GtkPlot

## GtkPlot GtkPlot |

## Synopsis

    #include <gtkextra.h>

    #define             GTK_PLOT_AXIS                       (obj)
    #define             GTK_TYPE_PLOT_AXIS
    #define             GTK_IS_PLOT_AXIS                    (obj)
                        GtkPlotText;
                        GtkPlotLine;
                        GtkPlotSymbol;
                        GtkPlotTick;
                        GtkPlotTicks;
                        GtkPlotVector;
                        GtkPlotMarker;
    gdouble             (*GtkPlotFunc)                      (GtkPlot *plot,
                                                             GtkPlotData *data,
                                                             gdouble x,
                                                             gboolean *error);
    gdouble             (*GtkPlotFunc3D)                    (GtkPlot *plot,
                                                             GtkPlotData *data,
                                                             gdouble x,
                                                             gdouble y,
                                                             gboolean *error);
    void                (*GtkPlotIterator)                  (GtkPlot *plot,
                                                             GtkPlotData *data,
                                                             gint iter,
                                                             gdouble *x,
                                                             gdouble *y,
                                                             gdouble *z,
                                                             gdouble *a,
                                                             gdouble *dx,
                                                             gdouble *dy,
                                                             gdouble *dz,
                                                             gdouble *da,
                                                             gchar **label,
                                                             gboolean *error);
    enum                GtkPlotScale;
    enum                GtkPlotSymbolType;
    enum                GtkPlotSymbolStyle;
    enum                GtkPlotBorderStyle;
    enum                GtkPlotLineStyle;
    enum                GtkPlotConnector;
    enum                GtkPlotLabelPos;
    enum                GtkPlotError;
    enum                GtkPlotOrientation;
    enum                GtkPlotAxisPos;
    enum                GtkPlotLabelStyle;
    enum                GtkPlotTicksPos;
    GtkWidget*          gtk_plot_new                        (GdkDrawable *drawable);
    GtkWidget*          gtk_plot_new_with_size              (GdkDrawable *drawable,
                                                             gdouble width,
                                                             gdouble height);
    void                gtk_plot_construct                  (GtkPlot *plot,
                                                             GdkDrawable *drawable);
    void                gtk_plot_construct_with_size        (GtkPlot *plot,
                                                             GdkDrawable *drawable,
                                                             gdouble width,
                                                             gdouble height);
    void                gtk_plot_set_drawable               (GtkPlot *plot,
                                                             GdkDrawable *drawable);
    GdkDrawable *       gtk_plot_get_drawable               (GtkPlot *plot);
    void                gtk_plot_set_pc                     (GtkPlot *plot,
                                                             GtkPlotPC *pc);
    void                gtk_plot_set_background_pixmap      (GtkPlot *plot,
                                                             GdkPixmap *pixmap);
    void                gtk_plot_set_transparent            (GtkPlot *plot,
                                                             gboolean transparent);
    gboolean            gtk_plot_is_transparent             (GtkPlot *plot);
    void                gtk_plot_get_position               (GtkPlot *plot,
                                                             gdouble *x,
                                                             gdouble *y);
    void                gtk_plot_get_size                   (GtkPlot *plot,
                                                             gdouble *width,
                                                             gdouble *height);
    GtkAllocation       gtk_plot_get_internal_allocation    (GtkPlot *plot);
    void                gtk_plot_set_background             (GtkPlot *plot,
                                                             const GdkColor *background);
    void                gtk_plot_paint                      (GtkPlot *plot);
    void                gtk_plot_refresh                    (GtkPlot *plot,
                                                             GdkRectangle *area);
    void                gtk_plot_move                       (GtkPlot *plot,
                                                             gdouble x,
                                                             gdouble y);
    void                gtk_plot_resize                     (GtkPlot *plot,
                                                             gdouble width,
                                                             gdouble height);
    void                gtk_plot_set_magnification          (GtkPlot *plot,
                                                             gdouble magnification);
    void                gtk_plot_move_resize                (GtkPlot *plot,
                                                             gdouble x,
                                                             gdouble y,
                                                             gdouble width,
                                                             gdouble height);
    void                gtk_plot_get_pixel                  (GtkPlot *plot,
                                                             gdouble xx,
                                                             gdouble yy,
                                                             gdouble *x,
                                                             gdouble *y);
    void                gtk_plot_get_point                  (GtkPlot *plot,
                                                             gint x,
                                                             gint y,
                                                             gdouble *xx,
                                                             gdouble *yy);
    void                gtk_plot_clip_data                  (GtkPlot *plot,
                                                             gboolean clip);
    void                gtk_plot_set_xrange                 (GtkPlot *plot,
                                                             gdouble xmin,
                                                             gdouble xmax);
    void                gtk_plot_set_yrange                 (GtkPlot *plot,
                                                             gdouble ymin,
                                                             gdouble ymax);
    void                gtk_plot_set_range                  (GtkPlot *plot,
                                                             gdouble xmin,
                                                             gdouble xmax,
                                                             gdouble ymin,
                                                             gdouble ymax);
    void                gtk_plot_autoscale                  (GtkPlot *plot);
    void                gtk_plot_get_xrange                 (GtkPlot *plot,
                                                             gdouble *xmin,
                                                             gdouble *xmax);
    void                gtk_plot_get_yrange                 (GtkPlot *plot,
                                                             gdouble *ymin,
                                                             gdouble *ymax);
    void                gtk_plot_set_xscale                 (GtkPlot *plot,
                                                             GtkPlotScale scale_type);
    void                gtk_plot_set_yscale                 (GtkPlot *plot,
                                                             GtkPlotScale scale_type);
    GtkPlotScale        gtk_plot_get_xscale                 (GtkPlot *plot);
    GtkPlotScale        gtk_plot_get_yscale                 (GtkPlot *plot);
    void                gtk_plot_reflect_x                  (GtkPlot *plot,
                                                             gboolean reflect);
    void                gtk_plot_reflect_y                  (GtkPlot *plot,
                                                             gboolean reflect);
    gboolean            gtk_plot_is_x_reflected             (GtkPlot *plot);
    gboolean            gtk_plot_is_y_reflected             (GtkPlot *plot);
    GtkPlotText *       gtk_plot_put_text                   (GtkPlot *plot,
                                                             gdouble x,
                                                             gdouble y,
                                                             const gchar *font,
                                                             gint height,
                                                             gint angle,
                                                             const GdkColor *foreground,
                                                             const GdkColor *background,
                                                             gboolean transparent,
                                                             GtkJustification justification,
                                                             const gchar *text);
    gint                gtk_plot_remove_text                (GtkPlot *plot,
                                                             GtkPlotText *text);
    void                gtk_plot_text_get_size              (const gchar *text,
                                                             gint angle,
                                                             const gchar *font_name,
                                                             gint font_size,
                                                             gint *width,
                                                             gint *height,
                                                             gint *ascent,
                                                             gint *descent);
    void                gtk_plot_text_get_area              (const gchar *text,
                                                             gint angle,
                                                             GtkJustification just,
                                                             const gchar *font_name,
                                                             gint font_size,
                                                             gint *x,
                                                             gint *y,
                                                             gint *width,
                                                             gint *height);
    void                gtk_plot_text_set_attributes        (GtkPlotText *text_attr,
                                                             const gchar *font,
                                                             gint height,
                                                             gint angle,
                                                             const GdkColor *fg,
                                                             const GdkColor *bg,
                                                             gboolean transparent,
                                                             GtkJustification justification,
                                                             const gchar *text);
    void                gtk_plot_text_set_border            (GtkPlotText *text,
                                                             GtkPlotBorderStyle border,
                                                             gint border_space,
                                                             gint border_width,
                                                             gint shadow_width);
    void                gtk_plot_draw_line                  (GtkPlot *plot,
                                                             GtkPlotLine line,
                                                             gdouble x1,
                                                             gdouble y1,
                                                             gdouble x2,
                                                             gdouble y2);
    void                gtk_plot_draw_text                  (GtkPlot *plot,
                                                             GtkPlotText text);
    void                gtk_plot_set_ticks                  (GtkPlot *plot,
                                                             GtkPlotOrientation orientation,
                                                             gdouble major_step,
                                                             gint nminor);
    void                gtk_plot_set_major_ticks            (GtkPlot *plot,
                                                             GtkPlotOrientation orientation,
                                                             gdouble major_step);
    void                gtk_plot_set_minor_ticks            (GtkPlot *plot,
                                                             GtkPlotOrientation orientation,
                                                             gint nminor);
    void                gtk_plot_set_ticks_limits           (GtkPlot *plot,
                                                             GtkPlotOrientation orientation,
                                                             gdouble begin,
                                                             gdouble end);
    void                gtk_plot_unset_ticks_limits         (GtkPlot *plot,
                                                             GtkPlotOrientation orientation);
    void                gtk_plot_set_break                  (GtkPlot *plot,
                                                             GtkPlotOrientation orient,
                                                             gdouble min,
                                                             gdouble max,
                                                             gdouble step_after,
                                                             gint nminor_after,
                                                             GtkPlotScale scale_after,
                                                             gdouble pos);
    void                gtk_plot_remove_break               (GtkPlot *plot,
                                                             GtkPlotOrientation orient);
    GtkType             gtk_plot_axis_get_type              (void);
    GtkObject*          gtk_plot_axis_new                   (GtkPlotOrientation orientation);
    void                gtk_plot_axis_construct             (GtkPlotAxis *axis,
                                                             GtkPlotOrientation orientation);
    GtkPlotAxis *       gtk_plot_get_axis                   (GtkPlot *plot,
                                                             GtkPlotAxisPos axis);
    void                gtk_plot_axis_set_visible           (GtkPlotAxis *axis,
                                                             gboolean visible);
    gboolean            gtk_plot_axis_visible               (GtkPlotAxis *axis);
    void                gtk_plot_axis_set_title             (GtkPlotAxis *axis,
                                                             const gchar *title);
    void                gtk_plot_axis_show_title            (GtkPlotAxis *axis);
    void                gtk_plot_axis_hide_title            (GtkPlotAxis *axis);
    void                gtk_plot_axis_move_title            (GtkPlotAxis *axis,
                                                             gint angle,
                                                             gdouble x,
                                                             gdouble y);
    void                gtk_plot_axis_justify_title         (GtkPlotAxis *axis,
                                                             GtkJustification justification);
    void                gtk_plot_axis_set_attributes        (GtkPlotAxis *axis,
                                                             gfloat width,
                                                             const GdkColor *color);
    void                gtk_plot_axis_get_attributes        (GtkPlotAxis *axis,
                                                             gfloat *width,
                                                             GdkColor *color);
    void                gtk_plot_axis_set_ticks             (GtkPlotAxis *axis,
                                                             gdouble major_step,
                                                             gint nminor);
    void                gtk_plot_axis_set_major_ticks       (GtkPlotAxis *axis,
                                                             gdouble major_step);
    void                gtk_plot_axis_set_minor_ticks       (GtkPlotAxis *axis,
                                                             gint nminor);
    void                gtk_plot_axis_set_ticks_length      (GtkPlotAxis *axis,
                                                             gint length);
    void                gtk_plot_axis_set_ticks_width       (GtkPlotAxis *axis,
                                                             gfloat width);
    void                gtk_plot_axis_show_ticks            (GtkPlotAxis *axis,
                                                             gint major_mask,
                                                             gint minor_mask);
    void                gtk_plot_axis_set_ticks_limits      (GtkPlotAxis *axis,
                                                             gdouble begin,
                                                             gdouble end);
    void                gtk_plot_axis_unset_ticks_limits    (GtkPlotAxis *axis);
    void                gtk_plot_axis_set_tick_labels       (GtkPlotAxis *axis,
                                                             GtkPlotArray *array);
    void                gtk_plot_axis_set_break             (GtkPlotAxis *axis,
                                                             gdouble min,
                                                             gdouble max,
                                                             gdouble step_after,
                                                             gint nminor_after,
                                                             GtkPlotScale scale_after,
                                                             gdouble pos);
    void                gtk_plot_axis_remove_break          (GtkPlotAxis *axis);
    void                gtk_plot_axis_show_labels           (GtkPlotAxis *axis,
                                                             gint labels_mask);
    void                gtk_plot_axis_title_set_attributes  (GtkPlotAxis *axis,
                                                             const gchar *font,
                                                             gint height,
                                                             gint angle,
                                                             const GdkColor *foreground,
                                                             const GdkColor *background,
                                                             gboolean transparent,
                                                             GtkJustification justification);
    void                gtk_plot_axis_set_labels_attributes (GtkPlotAxis *axis,
                                                             const gchar *font,
                                                             gint height,
                                                             gint angle,
                                                             const GdkColor *foreground,
                                                             const GdkColor *background,
                                                             gboolean transparent,
                                                             GtkJustification justification);
    #define             gtk_plot_axis_set_labels_numbers
    void                gtk_plot_axis_set_labels_style      (GtkPlotAxis *axis,
                                                             GtkPlotLabelStyle style,
                                                             gint precision);
    void                gtk_plot_axis_set_labels_offset     (GtkPlotAxis *axis,
                                                             gint offset);
    gint                gtk_plot_axis_get_labels_offset     (GtkPlotAxis *axis);
    void                gtk_plot_axis_use_custom_tick_labels
                                                            (GtkPlotAxis *axis,
                                                             gboolean use);
    void                gtk_plot_axis_set_labels_suffix     (GtkPlotAxis *axis,
                                                             const gchar *text);
    void                gtk_plot_axis_set_labels_prefix     (GtkPlotAxis *axis,
                                                             const gchar *text);
    gchar *             gtk_plot_axis_get_labels_suffix     (GtkPlotAxis *axis);
    gchar *             gtk_plot_axis_get_labels_prefix     (GtkPlotAxis *axis);
    void                gtk_plot_axis_ticks_recalc          (GtkPlotAxis *axis);
    void                gtk_plot_axis_ticks_autoscale       (GtkPlotAxis *axis,
                                                             gdouble xmin,
                                                             gdouble xmax,
                                                             gint *precision);
    gdouble             gtk_plot_axis_ticks_transform       (GtkPlotAxis *axis,
                                                             gdouble y);
    gdouble             gtk_plot_axis_ticks_inverse         (GtkPlotAxis *axis,
                                                             gdouble x);
    void                gtk_plot_axis_parse_label           (GtkPlotAxis *axis,
                                                             gdouble val,
                                                             gint precision,
                                                             gint style,
                                                             gchar *label);
    void                gtk_plot_x0_set_visible             (GtkPlot *plot,
                                                             gboolean visible);
    gboolean            gtk_plot_x0_visible                 (GtkPlot *plot);
    void                gtk_plot_y0_set_visible             (GtkPlot *plot,
                                                             gboolean visible);
    gboolean            gtk_plot_y0_visible                 (GtkPlot *plot);
    void                gtk_plot_grids_set_on_top           (GtkPlot *plot,
                                                             gboolean on_top);
    gboolean            gtk_plot_grids_on_top               (GtkPlot *plot);
    void                gtk_plot_grids_set_visible          (GtkPlot *plot,
                                                             gboolean vmajor,
                                                             gboolean vminor,
                                                             gboolean hmajor,
                                                             gboolean hminor);
    void                gtk_plot_grids_visible              (GtkPlot *plot,
                                                             gboolean *vmajor,
                                                             gboolean *vminor,
                                                             gboolean *hmajor,
                                                             gboolean *hminor);
    void                gtk_plot_y0line_set_attributes      (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);
    void                gtk_plot_x0line_set_attributes      (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);
    void                gtk_plot_major_vgrid_set_attributes (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);
    void                gtk_plot_minor_vgrid_set_attributes (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);
    void                gtk_plot_major_hgrid_set_attributes (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);
    void                gtk_plot_minor_hgrid_set_attributes (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);
    void                gtk_plot_show_legends               (GtkPlot *plot);
    void                gtk_plot_hide_legends               (GtkPlot *plot);
    void                gtk_plot_set_legends_border         (GtkPlot *plot,
                                                             GtkPlotBorderStyle border,
                                                             gint shadow_width);
    void                gtk_plot_legends_move               (GtkPlot *plot,
                                                             gdouble x,
                                                             gdouble y);
    void                gtk_plot_legends_get_position       (GtkPlot *plot,
                                                             gdouble *x,
                                                             gdouble *y);
    GtkAllocation       gtk_plot_legends_get_allocation     (GtkPlot *plot);
    void                gtk_plot_legends_set_attributes     (GtkPlot *plot,
                                                             const gchar *font,
                                                             gint height,
                                                             const GdkColor *foreground,
                                                             const GdkColor *background);
    void                gtk_plot_set_line_attributes        (GtkPlot *plot,
                                                             GtkPlotLine line);
    void                gtk_plot_add_data                   (GtkPlot *plot,
                                                             GtkPlotData *data);
    gint                gtk_plot_remove_data                (GtkPlot *plot,
                                                             GtkPlotData *data);
    GtkPlotData *       gtk_plot_add_function               (GtkPlot *plot,
                                                             GtkPlotFunc function);

## Description

## Details

### GTK_PLOT_AXIS()

    #define GTK_PLOT_AXIS(obj)        GTK_CHECK_CAST (obj, gtk_plot_axis_get_type (), GtkPlotAxis)

`obj` : |

### GTK_TYPE_PLOT_AXIS

    #define GTK_TYPE_PLOT_AXIS   (gtk_plot_axis_get_type ())

### GTK_IS_PLOT_AXIS()

    #define GTK_IS_PLOT_AXIS(obj)     GTK_CHECK_TYPE (obj, gtk_plot_axis_get_type ())

`obj` : |

### GtkPlotText

    typedef struct {
      gdouble x, y;
      gint angle; /* 0, 90, 180, 270 */
      GdkColor fg;
      GdkColor bg;

      gboolean transparent;

      GtkPlotBorderStyle border;
      gint border_width;
      gint shadow_width;
      gint border_space;

      gchar *font;
      gint height;

      gchar *text;

      GtkJustification justification;
    } GtkPlotText;

### GtkPlotLine

    typedef struct {
      GtkPlotLineStyle line_style;
      GdkCapStyle cap_style;
      GdkJoinStyle join_style;

      gfloat line_width;
      GdkColor color;
    } GtkPlotLine;

### GtkPlotSymbol

    typedef struct {
      GtkPlotSymbolType symbol_type;
      GtkPlotSymbolStyle symbol_style;

      gint size;

      GdkColor color;
      GtkPlotLine border;
    } GtkPlotSymbol;

### GtkPlotTick

    typedef struct {
      gdouble value;
      gboolean minor;
    } GtkPlotTick;

### GtkPlotTicks

    typedef struct {
      gdouble min;
      gdouble max;

      GtkPlotScale scale;

      gint nmajorticks;             /* Number of major ticks drawn */
      gint nminorticks;             /* Number of minor ticks drawn */
      gint nticks;			/* total number of ticks */

      gdouble step;		   	/* major ticks step */
      gint nminor;		  	/* number of minor ticks between major ticks */

      gboolean apply_break;
      GtkPlotScale break_scale;
      gdouble break_step;
      gint break_nminor;
      gdouble break_min;
      gdouble break_max;
      gdouble break_position;

      GtkPlotTick *values;

      gboolean set_limits;
      gdouble begin, end;
    } GtkPlotTicks;

### GtkPlotVector

    typedef struct {
      gdouble x, y, z;
    } GtkPlotVector;

### GtkPlotMarker

    typedef struct {
      GtkPlotData *data;
      gint point;
    } GtkPlotMarker;

### GtkPlotFunc ()

    gdouble             (*GtkPlotFunc)                      (GtkPlot *plot,
                                                             GtkPlotData *data,
                                                             gdouble x,
                                                             gboolean *error);

`plot` : |
`data` : |
`x` : |
`error` : |
Returns : |

### GtkPlotFunc3D ()

    gdouble             (*GtkPlotFunc3D)                    (GtkPlot *plot,
                                                             GtkPlotData *data,
                                                             gdouble x,
                                                             gdouble y,
                                                             gboolean *error);

`plot` : |
`data` : |
`x` : |
`y` : |
`error` : |
Returns : |

### GtkPlotIterator ()

    void                (*GtkPlotIterator)                  (GtkPlot *plot,
                                                             GtkPlotData *data,
                                                             gint iter,
                                                             gdouble *x,
                                                             gdouble *y,
                                                             gdouble *z,
                                                             gdouble *a,
                                                             gdouble *dx,
                                                             gdouble *dy,
                                                             gdouble *dz,
                                                             gdouble *da,
                                                             gchar **label,
                                                             gboolean *error);

`plot` : |
`data` : |
`iter` : |
`x` : |
`y` : |
`z` : |
`a` : |
`dx` : |
`dy` : |
`dz` : |
`da` : |
`label` : |
`error` : |

### enum GtkPlotScale

    typedef enum
    {
      GTK_PLOT_SCALE_LINEAR	,
      GTK_PLOT_SCALE_LOG10
    } GtkPlotScale;

### enum GtkPlotSymbolType

    typedef enum
    {
      GTK_PLOT_SYMBOL_NONE		,
      GTK_PLOT_SYMBOL_SQUARE	,
      GTK_PLOT_SYMBOL_CIRCLE	,
      GTK_PLOT_SYMBOL_UP_TRIANGLE	,
      GTK_PLOT_SYMBOL_DOWN_TRIANGLE	,
      GTK_PLOT_SYMBOL_RIGHT_TRIANGLE	,
      GTK_PLOT_SYMBOL_LEFT_TRIANGLE	,
      GTK_PLOT_SYMBOL_DIAMOND	,
      GTK_PLOT_SYMBOL_PLUS		,
      GTK_PLOT_SYMBOL_CROSS		,
      GTK_PLOT_SYMBOL_STAR		,
      GTK_PLOT_SYMBOL_DOT	 	,
      GTK_PLOT_SYMBOL_IMPULSE 	,
    } GtkPlotSymbolType;

### enum GtkPlotSymbolStyle

    typedef enum
    {
      GTK_PLOT_SYMBOL_EMPTY		,
      GTK_PLOT_SYMBOL_FILLED	,
      GTK_PLOT_SYMBOL_OPAQUE
    } GtkPlotSymbolStyle;

### enum GtkPlotBorderStyle

    typedef enum
    {
      GTK_PLOT_BORDER_NONE		,
      GTK_PLOT_BORDER_LINE		,
      GTK_PLOT_BORDER_SHADOW	,
    } GtkPlotBorderStyle;

### enum GtkPlotLineStyle

    typedef enum
    {
      GTK_PLOT_LINE_NONE		,
      GTK_PLOT_LINE_SOLID		,
      GTK_PLOT_LINE_DOTTED		,
      GTK_PLOT_LINE_DASHED		,
      GTK_PLOT_LINE_DOT_DASH	,
      GTK_PLOT_LINE_DOT_DOT_DASH	,
      GTK_PLOT_LINE_DOT_DASH_DASH
    } GtkPlotLineStyle;

### enum GtkPlotConnector

    typedef enum
    {
      GTK_PLOT_CONNECT_NONE		,
      GTK_PLOT_CONNECT_STRAIGHT	,
      GTK_PLOT_CONNECT_SPLINE	,
      GTK_PLOT_CONNECT_HV_STEP	,
      GTK_PLOT_CONNECT_VH_STEP	,
      GTK_PLOT_CONNECT_MIDDLE_STEP
    } GtkPlotConnector;

### enum GtkPlotLabelPos

    typedef enum
    {
      GTK_PLOT_LABEL_NONE    	= 0,
      GTK_PLOT_LABEL_IN 	   	= 1 << 0,
      GTK_PLOT_LABEL_OUT    	= 1 << 1,
    }GtkPlotLabelPos;

### enum GtkPlotError

    typedef enum
    {
      GTK_PLOT_ERROR_DIV_ZERO,
      GTK_PLOT_ERROR_LOG_NEG
    } GtkPlotError;

### enum GtkPlotOrientation

    typedef enum
    {
      GTK_PLOT_AXIS_X	,
      GTK_PLOT_AXIS_Y	,
      GTK_PLOT_AXIS_Z	,
    } GtkPlotOrientation;

### enum GtkPlotAxisPos

    typedef enum
    {
      GTK_PLOT_AXIS_LEFT	,
      GTK_PLOT_AXIS_RIGHT	,
      GTK_PLOT_AXIS_TOP	,
      GTK_PLOT_AXIS_BOTTOM
    } GtkPlotAxisPos;

### enum GtkPlotLabelStyle

    typedef enum
    {
      GTK_PLOT_LABEL_FLOAT	,
      GTK_PLOT_LABEL_EXP	,
      GTK_PLOT_LABEL_POW
    } GtkPlotLabelStyle;

### enum GtkPlotTicksPos

    typedef enum
    {
      GTK_PLOT_TICKS_NONE		= 0,
      GTK_PLOT_TICKS_IN		= 1 << 0,
      GTK_PLOT_TICKS_OUT		= 1 << 1
    } GtkPlotTicksPos;

### gtk_plot_new ()

    GtkWidget*          gtk_plot_new                        (GdkDrawable *drawable);

`drawable` : |
Returns : |

### gtk_plot_new_with_size ()

    GtkWidget*          gtk_plot_new_with_size              (GdkDrawable *drawable,
                                                             gdouble width,
                                                             gdouble height);

`drawable` : |
`width` : |
`height` : |
Returns : |

### gtk_plot_construct ()

    void                gtk_plot_construct                  (GtkPlot *plot,
                                                             GdkDrawable *drawable);

`plot` : |
`drawable` : |

### gtk_plot_construct_with_size ()

    void                gtk_plot_construct_with_size        (GtkPlot *plot,
                                                             GdkDrawable *drawable,
                                                             gdouble width,
                                                             gdouble height);

`plot` : |
`drawable` : |
`width` : |
`height` : |

### gtk_plot_set_drawable ()

    void                gtk_plot_set_drawable               (GtkPlot *plot,
                                                             GdkDrawable *drawable);

`plot` : |
`drawable` : |

### gtk_plot_get_drawable ()

    GdkDrawable *       gtk_plot_get_drawable               (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_set_pc ()

    void                gtk_plot_set_pc                     (GtkPlot *plot,
                                                             GtkPlotPC *pc);

`plot` : |
`pc` : |

### gtk_plot_set_background_pixmap ()

    void                gtk_plot_set_background_pixmap      (GtkPlot *plot,
                                                             GdkPixmap *pixmap);

`plot` : |
`pixmap` : |

### gtk_plot_set_transparent ()

    void                gtk_plot_set_transparent            (GtkPlot *plot,
                                                             gboolean transparent);

`plot` : |
`transparent` : |

### gtk_plot_is_transparent ()

    gboolean            gtk_plot_is_transparent             (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_get_position ()

    void                gtk_plot_get_position               (GtkPlot *plot,
                                                             gdouble *x,
                                                             gdouble *y);

`plot` : |
`x` : |
`y` : |

### gtk_plot_get_size ()

    void                gtk_plot_get_size                   (GtkPlot *plot,
                                                             gdouble *width,
                                                             gdouble *height);

`plot` : |
`width` : |
`height` : |

### gtk_plot_get_internal_allocation ()

    GtkAllocation       gtk_plot_get_internal_allocation    (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_set_background ()

    void                gtk_plot_set_background             (GtkPlot *plot,
                                                             const GdkColor *background);

`plot` : |
`background` : |

### gtk_plot_paint ()

    void                gtk_plot_paint                      (GtkPlot *plot);

`plot` : |

### gtk_plot_refresh ()

    void                gtk_plot_refresh                    (GtkPlot *plot,
                                                             GdkRectangle *area);

`plot` : |
`area` : |

### gtk_plot_move ()

    void                gtk_plot_move                       (GtkPlot *plot,
                                                             gdouble x,
                                                             gdouble y);

`plot` : |
`x` : |
`y` : |

### gtk_plot_resize ()

    void                gtk_plot_resize                     (GtkPlot *plot,
                                                             gdouble width,
                                                             gdouble height);

`plot` : |
`width` : |
`height` : |

### gtk_plot_set_magnification ()

    void                gtk_plot_set_magnification          (GtkPlot *plot,
                                                             gdouble magnification);

`plot` : |
`magnification` : |

### gtk_plot_move_resize ()

    void                gtk_plot_move_resize                (GtkPlot *plot,
                                                             gdouble x,
                                                             gdouble y,
                                                             gdouble width,
                                                             gdouble height);

`plot` : |
`x` : |
`y` : |
`width` : |
`height` : |

### gtk_plot_get_pixel ()

    void                gtk_plot_get_pixel                  (GtkPlot *plot,
                                                             gdouble xx,
                                                             gdouble yy,
                                                             gdouble *x,
                                                             gdouble *y);

`plot` : |
`xx` : |
`yy` : |
`x` : |
`y` : |

### gtk_plot_get_point ()

    void                gtk_plot_get_point                  (GtkPlot *plot,
                                                             gint x,
                                                             gint y,
                                                             gdouble *xx,
                                                             gdouble *yy);

`plot` : |
`x` : |
`y` : |
`xx` : |
`yy` : |

### gtk_plot_clip_data ()

    void                gtk_plot_clip_data                  (GtkPlot *plot,
                                                             gboolean clip);

`plot` : |
`clip` : |

### gtk_plot_set_xrange ()

    void                gtk_plot_set_xrange                 (GtkPlot *plot,
                                                             gdouble xmin,
                                                             gdouble xmax);

`plot` : |
`xmin` : |
`xmax` : |

### gtk_plot_set_yrange ()

    void                gtk_plot_set_yrange                 (GtkPlot *plot,
                                                             gdouble ymin,
                                                             gdouble ymax);

`plot` : |
`ymin` : |
`ymax` : |

### gtk_plot_set_range ()

    void                gtk_plot_set_range                  (GtkPlot *plot,
                                                             gdouble xmin,
                                                             gdouble xmax,
                                                             gdouble ymin,
                                                             gdouble ymax);

`plot` : |
`xmin` : |
`xmax` : |
`ymin` : |
`ymax` : |

### gtk_plot_autoscale ()

    void                gtk_plot_autoscale                  (GtkPlot *plot);

`plot` : |

### gtk_plot_get_xrange ()

    void                gtk_plot_get_xrange                 (GtkPlot *plot,
                                                             gdouble *xmin,
                                                             gdouble *xmax);

`plot` : |
`xmin` : |
`xmax` : |

### gtk_plot_get_yrange ()

    void                gtk_plot_get_yrange                 (GtkPlot *plot,
                                                             gdouble *ymin,
                                                             gdouble *ymax);

`plot` : |
`ymin` : |
`ymax` : |

### gtk_plot_set_xscale ()

    void                gtk_plot_set_xscale                 (GtkPlot *plot,
                                                             GtkPlotScale scale_type);

`plot` : |
`scale_type` : |

### gtk_plot_set_yscale ()

    void                gtk_plot_set_yscale                 (GtkPlot *plot,
                                                             GtkPlotScale scale_type);

`plot` : |
`scale_type` : |

### gtk_plot_get_xscale ()

    GtkPlotScale        gtk_plot_get_xscale                 (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_get_yscale ()

    GtkPlotScale        gtk_plot_get_yscale                 (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_reflect_x ()

    void                gtk_plot_reflect_x                  (GtkPlot *plot,
                                                             gboolean reflect);

`plot` : |
`reflect` : |

### gtk_plot_reflect_y ()

    void                gtk_plot_reflect_y                  (GtkPlot *plot,
                                                             gboolean reflect);

`plot` : |
`reflect` : |

### gtk_plot_is_x_reflected ()

    gboolean            gtk_plot_is_x_reflected             (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_is_y_reflected ()

    gboolean            gtk_plot_is_y_reflected             (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_put_text ()

    GtkPlotText *       gtk_plot_put_text                   (GtkPlot *plot,
                                                             gdouble x,
                                                             gdouble y,
                                                             const gchar *font,
                                                             gint height,
                                                             gint angle,
                                                             const GdkColor *foreground,
                                                             const GdkColor *background,
                                                             gboolean transparent,
                                                             GtkJustification justification,
                                                             const gchar *text);

`plot` : |
`x` : |
`y` : |
`font` : |
`height` : |
`angle` : |
`foreground` : |
`background` : |
`transparent` : |
`justification` : |
`text` : |
Returns : |

### gtk_plot_remove_text ()

    gint                gtk_plot_remove_text                (GtkPlot *plot,
                                                             GtkPlotText *text);

`plot` : |
`text` : |
Returns : |

### gtk_plot_text_get_size ()

    void                gtk_plot_text_get_size              (const gchar *text,
                                                             gint angle,
                                                             const gchar *font_name,
                                                             gint font_size,
                                                             gint *width,
                                                             gint *height,
                                                             gint *ascent,
                                                             gint *descent);

`text` : |
`angle` : |
`font_name` : |
`font_size` : |
`width` : |
`height` : |
`ascent` : |
`descent` : |

### gtk_plot_text_get_area ()

    void                gtk_plot_text_get_area              (const gchar *text,
                                                             gint angle,
                                                             GtkJustification just,
                                                             const gchar *font_name,
                                                             gint font_size,
                                                             gint *x,
                                                             gint *y,
                                                             gint *width,
                                                             gint *height);

`text` : |
`angle` : |
`just` : |
`font_name` : |
`font_size` : |
`x` : |
`y` : |
`width` : |
`height` : |

### gtk_plot_text_set_attributes ()

    void                gtk_plot_text_set_attributes        (GtkPlotText *text_attr,
                                                             const gchar *font,
                                                             gint height,
                                                             gint angle,
                                                             const GdkColor *fg,
                                                             const GdkColor *bg,
                                                             gboolean transparent,
                                                             GtkJustification justification,
                                                             const gchar *text);

`text_attr` : |
`font` : |
`height` : |
`angle` : |
`fg` : |
`bg` : |
`transparent` : |
`justification` : |
`text` : |

### gtk_plot_text_set_border ()

    void                gtk_plot_text_set_border            (GtkPlotText *text,
                                                             GtkPlotBorderStyle border,
                                                             gint border_space,
                                                             gint border_width,
                                                             gint shadow_width);

`text` : |
`border` : |
`border_space` : |
`border_width` : |
`shadow_width` : |

### gtk_plot_draw_line ()

    void                gtk_plot_draw_line                  (GtkPlot *plot,
                                                             GtkPlotLine line,
                                                             gdouble x1,
                                                             gdouble y1,
                                                             gdouble x2,
                                                             gdouble y2);

`plot` : |
`line` : |
`x1` : |
`y1` : |
`x2` : |
`y2` : |

### gtk_plot_draw_text ()

    void                gtk_plot_draw_text                  (GtkPlot *plot,
                                                             GtkPlotText text);

`plot` : |
`text` : |

### gtk_plot_set_ticks ()

    void                gtk_plot_set_ticks                  (GtkPlot *plot,
                                                             GtkPlotOrientation orientation,
                                                             gdouble major_step,
                                                             gint nminor);

`plot` : |
`orientation` : |
`major_step` : |
`nminor` : |

### gtk_plot_set_major_ticks ()

    void                gtk_plot_set_major_ticks            (GtkPlot *plot,
                                                             GtkPlotOrientation orientation,
                                                             gdouble major_step);

`plot` : |
`orientation` : |
`major_step` : |

### gtk_plot_set_minor_ticks ()

    void                gtk_plot_set_minor_ticks            (GtkPlot *plot,
                                                             GtkPlotOrientation orientation,
                                                             gint nminor);

`plot` : |
`orientation` : |
`nminor` : |

### gtk_plot_set_ticks_limits ()

    void                gtk_plot_set_ticks_limits           (GtkPlot *plot,
                                                             GtkPlotOrientation orientation,
                                                             gdouble begin,
                                                             gdouble end);

`plot` : |
`orientation` : |
`begin` : |
`end` : |

### gtk_plot_unset_ticks_limits ()

    void                gtk_plot_unset_ticks_limits         (GtkPlot *plot,
                                                             GtkPlotOrientation orientation);

`plot` : |
`orientation` : |

### gtk_plot_set_break ()

    void                gtk_plot_set_break                  (GtkPlot *plot,
                                                             GtkPlotOrientation orient,
                                                             gdouble min,
                                                             gdouble max,
                                                             gdouble step_after,
                                                             gint nminor_after,
                                                             GtkPlotScale scale_after,
                                                             gdouble pos);

`plot` : |
`orient` : |
`min` : |
`max` : |
`step_after` : |
`nminor_after` : |
`scale_after` : |
`pos` : |

### gtk_plot_remove_break ()

    void                gtk_plot_remove_break               (GtkPlot *plot,
                                                             GtkPlotOrientation orient);

`plot` : |
`orient` : |

### gtk_plot_axis_get_type ()

    GtkType             gtk_plot_axis_get_type              (void);

Returns : |

### gtk_plot_axis_new ()

    GtkObject*          gtk_plot_axis_new                   (GtkPlotOrientation orientation);

`orientation` : |
Returns : |

### gtk_plot_axis_construct ()

    void                gtk_plot_axis_construct             (GtkPlotAxis *axis,
                                                             GtkPlotOrientation orientation);

`axis` : |
`orientation` : |

### gtk_plot_get_axis ()

    GtkPlotAxis *       gtk_plot_get_axis                   (GtkPlot *plot,
                                                             GtkPlotAxisPos axis);

`plot` : |
`axis` : |
Returns : |

### gtk_plot_axis_set_visible ()

    void                gtk_plot_axis_set_visible           (GtkPlotAxis *axis,
                                                             gboolean visible);

`axis` : |
`visible` : |

### gtk_plot_axis_visible ()

    gboolean            gtk_plot_axis_visible               (GtkPlotAxis *axis);

`axis` : |
Returns : |

### gtk_plot_axis_set_title ()

    void                gtk_plot_axis_set_title             (GtkPlotAxis *axis,
                                                             const gchar *title);

`axis` : |
`title` : |

### gtk_plot_axis_show_title ()

    void                gtk_plot_axis_show_title            (GtkPlotAxis *axis);

`axis` : |

### gtk_plot_axis_hide_title ()

    void                gtk_plot_axis_hide_title            (GtkPlotAxis *axis);

`axis` : |

### gtk_plot_axis_move_title ()

    void                gtk_plot_axis_move_title            (GtkPlotAxis *axis,
                                                             gint angle,
                                                             gdouble x,
                                                             gdouble y);

`axis` : |
`angle` : |
`x` : |
`y` : |

### gtk_plot_axis_justify_title ()

    void                gtk_plot_axis_justify_title         (GtkPlotAxis *axis,
                                                             GtkJustification justification);

`axis` : |
`justification` : |

### gtk_plot_axis_set_attributes ()

    void                gtk_plot_axis_set_attributes        (GtkPlotAxis *axis,
                                                             gfloat width,
                                                             const GdkColor *color);

`axis` : |
`width` : |
`color` : |

### gtk_plot_axis_get_attributes ()

    void                gtk_plot_axis_get_attributes        (GtkPlotAxis *axis,
                                                             gfloat *width,
                                                             GdkColor *color);

`axis` : |
`width` : |
`color` : |

### gtk_plot_axis_set_ticks ()

    void                gtk_plot_axis_set_ticks             (GtkPlotAxis *axis,
                                                             gdouble major_step,
                                                             gint nminor);

`axis` : |
`major_step` : |
`nminor` : |

### gtk_plot_axis_set_major_ticks ()

    void                gtk_plot_axis_set_major_ticks       (GtkPlotAxis *axis,
                                                             gdouble major_step);

`axis` : |
`major_step` : |

### gtk_plot_axis_set_minor_ticks ()

    void                gtk_plot_axis_set_minor_ticks       (GtkPlotAxis *axis,
                                                             gint nminor);

`axis` : |
`nminor` : |

### gtk_plot_axis_set_ticks_length ()

    void                gtk_plot_axis_set_ticks_length      (GtkPlotAxis *axis,
                                                             gint length);

`axis` : |
`length` : |

### gtk_plot_axis_set_ticks_width ()

    void                gtk_plot_axis_set_ticks_width       (GtkPlotAxis *axis,
                                                             gfloat width);

`axis` : |
`width` : |

### gtk_plot_axis_show_ticks ()

    void                gtk_plot_axis_show_ticks            (GtkPlotAxis *axis,
                                                             gint major_mask,
                                                             gint minor_mask);

`axis` : |
`major_mask` : |
`minor_mask` : |

### gtk_plot_axis_set_ticks_limits ()

    void                gtk_plot_axis_set_ticks_limits      (GtkPlotAxis *axis,
                                                             gdouble begin,
                                                             gdouble end);

`axis` : |
`begin` : |
`end` : |

### gtk_plot_axis_unset_ticks_limits ()

    void                gtk_plot_axis_unset_ticks_limits    (GtkPlotAxis *axis);

`axis` : |

### gtk_plot_axis_set_tick_labels ()

    void                gtk_plot_axis_set_tick_labels       (GtkPlotAxis *axis,
                                                             GtkPlotArray *array);

`axis` : |
`array` : |

### gtk_plot_axis_set_break ()

    void                gtk_plot_axis_set_break             (GtkPlotAxis *axis,
                                                             gdouble min,
                                                             gdouble max,
                                                             gdouble step_after,
                                                             gint nminor_after,
                                                             GtkPlotScale scale_after,
                                                             gdouble pos);

`axis` : |
`min` : |
`max` : |
`step_after` : |
`nminor_after` : |
`scale_after` : |
`pos` : |

### gtk_plot_axis_remove_break ()

    void                gtk_plot_axis_remove_break          (GtkPlotAxis *axis);

`axis` : |

### gtk_plot_axis_show_labels ()

    void                gtk_plot_axis_show_labels           (GtkPlotAxis *axis,
                                                             gint labels_mask);

`axis` : |
`labels_mask` : |

### gtk_plot_axis_title_set_attributes ()

    void                gtk_plot_axis_title_set_attributes  (GtkPlotAxis *axis,
                                                             const gchar *font,
                                                             gint height,
                                                             gint angle,
                                                             const GdkColor *foreground,
                                                             const GdkColor *background,
                                                             gboolean transparent,
                                                             GtkJustification justification);

`axis` : |
`font` : |
`height` : |
`angle` : |
`foreground` : |
`background` : |
`transparent` : |
`justification` : |

### gtk_plot_axis_set_labels_attributes ()

    void                gtk_plot_axis_set_labels_attributes (GtkPlotAxis *axis,
                                                             const gchar *font,
                                                             gint height,
                                                             gint angle,
                                                             const GdkColor *foreground,
                                                             const GdkColor *background,
                                                             gboolean transparent,
                                                             GtkJustification justification);

`axis` : |
`font` : |
`height` : |
`angle` : |
`foreground` : |
`background` : |
`transparent` : |
`justification` : |

### gtk_plot_axis_set_labels_numbers

    #define gtk_plot_axis_set_labels_numbers gtk_plot_axis_set_labels_style

### gtk_plot_axis_set_labels_style ()

    void                gtk_plot_axis_set_labels_style      (GtkPlotAxis *axis,
                                                             GtkPlotLabelStyle style,
                                                             gint precision);

`axis` : |
`style` : |
`precision` : |

### gtk_plot_axis_set_labels_offset ()

    void                gtk_plot_axis_set_labels_offset     (GtkPlotAxis *axis,
                                                             gint offset);

`axis` : |
`offset` : |

### gtk_plot_axis_get_labels_offset ()

    gint                gtk_plot_axis_get_labels_offset     (GtkPlotAxis *axis);

`axis` : |
Returns : |

### gtk_plot_axis_use_custom_tick_labels ()

    void                gtk_plot_axis_use_custom_tick_labels
                                                            (GtkPlotAxis *axis,
                                                             gboolean use);

`axis` : |
`use` : |

### gtk_plot_axis_set_labels_suffix ()

    void                gtk_plot_axis_set_labels_suffix     (GtkPlotAxis *axis,
                                                             const gchar *text);

`axis` : |
`text` : |

### gtk_plot_axis_set_labels_prefix ()

    void                gtk_plot_axis_set_labels_prefix     (GtkPlotAxis *axis,
                                                             const gchar *text);

`axis` : |
`text` : |

### gtk_plot_axis_get_labels_suffix ()

    gchar *             gtk_plot_axis_get_labels_suffix     (GtkPlotAxis *axis);

`axis` : |
Returns : |

### gtk_plot_axis_get_labels_prefix ()

    gchar *             gtk_plot_axis_get_labels_prefix     (GtkPlotAxis *axis);

`axis` : |
Returns : |

### gtk_plot_axis_ticks_recalc ()

    void                gtk_plot_axis_ticks_recalc          (GtkPlotAxis *axis);

`axis` : |

### gtk_plot_axis_ticks_autoscale ()

    void                gtk_plot_axis_ticks_autoscale       (GtkPlotAxis *axis,
                                                             gdouble xmin,
                                                             gdouble xmax,
                                                             gint *precision);

`axis` : |
`xmin` : |
`xmax` : |
`precision` : |

### gtk_plot_axis_ticks_transform ()

    gdouble             gtk_plot_axis_ticks_transform       (GtkPlotAxis *axis,
                                                             gdouble y);

`axis` : |
`y` : |
Returns : |

### gtk_plot_axis_ticks_inverse ()

    gdouble             gtk_plot_axis_ticks_inverse         (GtkPlotAxis *axis,
                                                             gdouble x);

`axis` : |
`x` : |
Returns : |

### gtk_plot_axis_parse_label ()

    void                gtk_plot_axis_parse_label           (GtkPlotAxis *axis,
                                                             gdouble val,
                                                             gint precision,
                                                             gint style,
                                                             gchar *label);

`axis` : |
`val` : |
`precision` : |
`style` : |
`label` : |

### gtk_plot_x0_set_visible ()

    void                gtk_plot_x0_set_visible             (GtkPlot *plot,
                                                             gboolean visible);

`plot` : |
`visible` : |

### gtk_plot_x0_visible ()

    gboolean            gtk_plot_x0_visible                 (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_y0_set_visible ()

    void                gtk_plot_y0_set_visible             (GtkPlot *plot,
                                                             gboolean visible);

`plot` : |
`visible` : |

### gtk_plot_y0_visible ()

    gboolean            gtk_plot_y0_visible                 (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_grids_set_on_top ()

    void                gtk_plot_grids_set_on_top           (GtkPlot *plot,
                                                             gboolean on_top);

`plot` : |
`on_top` : |

### gtk_plot_grids_on_top ()

    gboolean            gtk_plot_grids_on_top               (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_grids_set_visible ()

    void                gtk_plot_grids_set_visible          (GtkPlot *plot,
                                                             gboolean vmajor,
                                                             gboolean vminor,
                                                             gboolean hmajor,
                                                             gboolean hminor);

`plot` : |
`vmajor` : |
`vminor` : |
`hmajor` : |
`hminor` : |

### gtk_plot_grids_visible ()

    void                gtk_plot_grids_visible              (GtkPlot *plot,
                                                             gboolean *vmajor,
                                                             gboolean *vminor,
                                                             gboolean *hmajor,
                                                             gboolean *hminor);

`plot` : |
`vmajor` : |
`vminor` : |
`hmajor` : |
`hminor` : |

### gtk_plot_y0line_set_attributes ()

    void                gtk_plot_y0line_set_attributes      (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);

`plot` : |
`style` : |
`width` : |
`color` : |

### gtk_plot_x0line_set_attributes ()

    void                gtk_plot_x0line_set_attributes      (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);

`plot` : |
`style` : |
`width` : |
`color` : |

### gtk_plot_major_vgrid_set_attributes ()

    void                gtk_plot_major_vgrid_set_attributes (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);

`plot` : |
`style` : |
`width` : |
`color` : |

### gtk_plot_minor_vgrid_set_attributes ()

    void                gtk_plot_minor_vgrid_set_attributes (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);

`plot` : |
`style` : |
`width` : |
`color` : |

### gtk_plot_major_hgrid_set_attributes ()

    void                gtk_plot_major_hgrid_set_attributes (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);

`plot` : |
`style` : |
`width` : |
`color` : |

### gtk_plot_minor_hgrid_set_attributes ()

    void                gtk_plot_minor_hgrid_set_attributes (GtkPlot *plot,
                                                             GtkPlotLineStyle style,
                                                             gfloat width,
                                                             const GdkColor *color);

`plot` : |
`style` : |
`width` : |
`color` : |

### gtk_plot_show_legends ()

    void                gtk_plot_show_legends               (GtkPlot *plot);

`plot` : |

### gtk_plot_hide_legends ()

    void                gtk_plot_hide_legends               (GtkPlot *plot);

`plot` : |

### gtk_plot_set_legends_border ()

    void                gtk_plot_set_legends_border         (GtkPlot *plot,
                                                             GtkPlotBorderStyle border,
                                                             gint shadow_width);

`plot` : |
`border` : |
`shadow_width` : |

### gtk_plot_legends_move ()

    void                gtk_plot_legends_move               (GtkPlot *plot,
                                                             gdouble x,
                                                             gdouble y);

`plot` : |
`x` : |
`y` : |

### gtk_plot_legends_get_position ()

    void                gtk_plot_legends_get_position       (GtkPlot *plot,
                                                             gdouble *x,
                                                             gdouble *y);

`plot` : |
`x` : |
`y` : |

### gtk_plot_legends_get_allocation ()

    GtkAllocation       gtk_plot_legends_get_allocation     (GtkPlot *plot);

`plot` : |
Returns : |

### gtk_plot_legends_set_attributes ()

    void                gtk_plot_legends_set_attributes     (GtkPlot *plot,
                                                             const gchar *font,
                                                             gint height,
                                                             const GdkColor *foreground,
                                                             const GdkColor *background);

`plot` : |
`font` : |
`height` : |
`foreground` : |
`background` : |

### gtk_plot_set_line_attributes ()

    void                gtk_plot_set_line_attributes        (GtkPlot *plot,
                                                             GtkPlotLine line);

`plot` : |
`line` : |

### gtk_plot_add_data ()

    void                gtk_plot_add_data                   (GtkPlot *plot,
                                                             GtkPlotData *data);

`plot` : |
`data` : |

### gtk_plot_remove_data ()

    gint                gtk_plot_remove_data                (GtkPlot *plot,
                                                             GtkPlotData *data);

`plot` : |
`data` : |
Returns : |

### gtk_plot_add_function ()

    GtkPlotData *       gtk_plot_add_function               (GtkPlot *plot,
                                                             GtkPlotFunc function);

`plot` : |
`function` : |
Returns : |