gtk_databox_new ()

GtkWidget *
gtk_databox_new (void);

Creates a new GtkDatabox widget.

gtk_databox_get_graphs ()

GList *
gtk_databox_get_graphs (GtkDatabox *box);

Return a list of graphs that were previously added to box .

gtk_databox_graph_add ()

gint
gtk_databox_graph_add (GtkDatabox *box,
                       GtkDataboxGraph *graph);

Adds the graph to the box . The next time the box is re-drawn, the graph will be shown.

It might be becessary to modify the total_limits in order for the graph to be displayed properly (see gtk_databox_set_total_limits()).

gtk_databox_graph_add_front ()

gint
gtk_databox_graph_add_front (GtkDatabox *box,
                             GtkDataboxGraph *graph);

Adds the graph to the box and will be plotted on top. The next time the box is re-drawn, the graph will be shown.

It might be becessary to modify the total_limits in order for the graph to be displayed properly (see gtk_databox_set_total_limits()).

gtk_databox_graph_remove ()

gint
gtk_databox_graph_remove (GtkDatabox *box,
                          GtkDataboxGraph *graph);

Removes the graph from the box once. The next time the box is re-drawn, the graph will not be shown (unless it was added more than once).

gtk_databox_graph_remove_all ()

gint
gtk_databox_graph_remove_all (GtkDatabox *box);

Removes all graphs from the box . The next time the box is re-drawn, no graphs will be shown.

gtk_databox_auto_rescale ()

gint
gtk_databox_auto_rescale (GtkDatabox *box,
                          gfloat border);

This function is similar to gtk_databox_set_total_limits(). It sets the total limits to match the data extrema (see gtk_databox_calculate_extrema()). If you do not like data pixels exactly at the widget's border, you can add modify the limits using the border parameter: The limits are extended by border *(max-min) if max!=min. If max==min, they are extended by border *max (otherwise the data could not be scaled to the pixel realm).

After calling this function, x values grow from left to right, y values grow from bottom to top.

gtk_databox_calculate_extrema ()

gint
gtk_databox_calculate_extrema (GtkDatabox *box,
                               gfloat *min_x,
                               gfloat *max_x,
                               gfloat *min_y,
                               gfloat *max_y);

Determines the minimum and maximum x and y values of all GtkDataboxGraph objects which have been added to the GtkDatabox widget via gtk_databox_graph_add().

gtk_databox_set_total_limits ()

void
gtk_databox_set_total_limits (GtkDatabox *box,
                              gfloat left,
                              gfloat right,
                              gfloat top,
                              gfloat bottom);

This function is used to set the limits of the total display area of box . This function can be used to invert the orientation of the displayed graphs, e.g. top =-1000 and bottom =0.

Side effect: The box also internally calls gtk_databox_set_visible_limits() with the same values.

gtk_databox_set_visible_limits ()

void
gtk_databox_set_visible_limits (GtkDatabox *box,
                                gfloat left,
                                gfloat right,
                                gfloat top,
                                gfloat bottom);

This function is used to set the limits of the visible display area of box . The visible display area can be section of the total area, i.e. the box zooms in, showing only a part of the complete picture.

The orientation of the values have to be the same as in gtk_databox_set_total_limits() and the visible limits have to be within the total limits. The values will not be used otherwise.

Side effect: The box emits “zoomed”.

gtk_databox_get_total_limits ()

void
gtk_databox_get_total_limits (GtkDatabox *box,
                              gfloat *left,
                              gfloat *right,
                              gfloat *top,
                              gfloat *bottom);

Gives the total limits (as set by gtk_databox_auto_rescale() or gtk_databox_set_total_limits()).

gtk_databox_get_visible_limits ()

void
gtk_databox_get_visible_limits (GtkDatabox *box,
                                gfloat *left,
                                gfloat *right,
                                gfloat *top,
                                gfloat *bottom);

Gives the current visible limits. These differ from those given by gtk_databox_get_total_limits() if you zoomed into the data for instance by gtk_databox_zoom_to_selection() or gtk_databox_set_visible_limits() (these values can be changed by scrolling, of course).

gtk_databox_set_adjustment_x ()

void
gtk_databox_set_adjustment_x (GtkDatabox *box,
                              GtkAdjustment *adj);

Setter function for the “adjustment-x” property. Normally, it should not be required to use this function, see property documentation.

gtk_databox_set_adjustment_y ()

void
gtk_databox_set_adjustment_y (GtkDatabox *box,
                              GtkAdjustment *adj);

Setter function for the “adjustment-y” property. Normally, it should not be required to use this function, see property documentation.

gtk_databox_get_adjustment_x ()

GtkAdjustment *
gtk_databox_get_adjustment_x (GtkDatabox *box);

Getter function for the “adjustment-x” property.

gtk_databox_get_adjustment_y ()

GtkAdjustment *
gtk_databox_get_adjustment_y (GtkDatabox *box);

Getter function for the “adjustment-y” property.

gtk_databox_set_ruler_x ()

void
gtk_databox_set_ruler_x (GtkDatabox *box,
                         GtkDataboxRuler *ruler);

Setter function for the “ruler-x” property.

gtk_databox_set_ruler_y ()

void
gtk_databox_set_ruler_y (GtkDatabox *box,
                         GtkDataboxRuler *ruler);

Setter function for the “ruler-y” property.

gtk_databox_get_ruler_x ()

GtkDataboxRuler *
gtk_databox_get_ruler_x (GtkDatabox *box);

Getter function for the “ruler-x” property.

gtk_databox_get_ruler_y ()

GtkDataboxRuler *
gtk_databox_get_ruler_y (GtkDatabox *box);

Getter function for the “ruler-y” property.

gtk_databox_set_scale_type_x ()

void
gtk_databox_set_scale_type_x (GtkDatabox *box,
                              GtkDataboxScaleType scale_type);

Setter function for the “scale-type-x” property.

gtk_databox_set_scale_type_y ()

void
gtk_databox_set_scale_type_y (GtkDatabox *box,
                              GtkDataboxScaleType scale_type);

Setter function for the “scale-type-y” property.

gtk_databox_get_scale_type_x ()

GtkDataboxScaleType
gtk_databox_get_scale_type_x (GtkDatabox *box);

Getter function for the “scale-type-x” property.

gtk_databox_get_scale_type_y ()

GtkDataboxScaleType
gtk_databox_get_scale_type_y (GtkDatabox *box);

Getter function for the “scale-type-y” property.

gtk_databox_set_enable_selection ()

void
gtk_databox_set_enable_selection (GtkDatabox *box,
                                  gboolean enable);

Setter function for the “enable-selection” property.

gtk_databox_set_enable_zoom ()

void
gtk_databox_set_enable_zoom (GtkDatabox *box,
                             gboolean enable);

Setter function for the “enable-zoom” property.

gtk_databox_set_box_shadow ()

void
gtk_databox_set_box_shadow (GtkDatabox *box,
                            GtkShadowType which_shadow);

Sets the shadow type when using gtk_paint_box. This will draw the desired edge shadow.

gtk_databox_set_bg_color ()

void
gtk_databox_set_bg_color (GtkDatabox *box,
                          gchar *bg_color);

Convenience function to override the background color of box , acording to bg_color .

gtk_databox_get_enable_selection ()

gboolean
gtk_databox_get_enable_selection (GtkDatabox *box);

Getter function for the “enable-selection” property.

gtk_databox_get_enable_zoom ()

gboolean
gtk_databox_get_enable_zoom (GtkDatabox *box);

Getter function for the “enable-zoom” property.

gtk_databox_get_box_shadow ()

GtkShadowType
gtk_databox_get_box_shadow (GtkDatabox *box);

Gets the type of shadow being rendered to the box (GTK_SHADOW_NONE, GTK_SHADOW_IN, GTK_SHADOW_OUT, GTK_SHADOW_ETCHED_IN, GTK_SHADOW_ETCHED_OUT).

gtk_databox_zoom_to_selection ()

void
gtk_databox_zoom_to_selection (GtkDatabox *box);

This is equivalent to left-clicking into the selected area.

This function works, if the attribute enable-zoom is set to TRUE. Calling the function then zooms to the area selected with the mouse.

Side effect: The box emits “zoomed”.

gtk_databox_zoom_out ()

void
gtk_databox_zoom_out (GtkDatabox *box);

This is equivalent to right-clicking into the box .

This function works, if the attribute enable-zoom is set to TRUE. Calling the function then zooms out by a factor of 2 in both dimensions (the maximum is defined by the total limits, see gtk_databox_set_total_limits()).

Side effect: The box emits “zoomed”.

gtk_databox_zoom_home ()

void
gtk_databox_zoom_home (GtkDatabox *box);

This is equivalent to shift right-clicking into the box .

This function works, if the attribute enable-zoom is set to TRUE. It is equivalent to calling the gtk_databox_set_visible_limits() with the total limits.

gtk_databox_value_to_pixel_x ()

gint16
gtk_databox_value_to_pixel_x (GtkDatabox *box,
                              gfloat value);

Calculates the horizontal pixel coordinate which represents the x value . Pixel coordinates are relative to the top-left corner of the box which is equivalent to (0,0).

gtk_databox_value_to_pixel_y ()

gint16
gtk_databox_value_to_pixel_y (GtkDatabox *box,
                              gfloat value);

Calculates the vertical pixel coordinate which represents the y value . Pixel coordinates are relative to the top-left corner of the box which is equivalent to (0,0).

gtk_databox_pixel_to_value_x ()

gfloat
gtk_databox_pixel_to_value_x (GtkDatabox *box,
                              gint16 pixel);

Calculates the x value which is represented by the horizontal pixel coordinate. Pixel coordinates are relative to the top-left corner of the box which is equivalent to (0,0).

gtk_databox_pixel_to_value_y ()

gfloat
gtk_databox_pixel_to_value_y (GtkDatabox *box,
                              gint16 pixel);

Calculates the y value which is represented by the vertical pixel coordinate. Pixel coordinates are relative to the top-left corner of the box which is equivalent to (0,0).

gtk_databox_values_to_xpixels ()

void
gtk_databox_values_to_xpixels (GtkDatabox *box,
                               gint16 *pixels,
                               void *values,
                               GType vtype,
                               guint maxlen,
                               guint start,
                               guint stride,
                               guint len);

Calculates the horizontal coordinates for pixels which represents the x values . Pixel coordinates are relative to the left corner of the box which is equivalent to (0).

gtk_databox_values_to_ypixels ()

void
gtk_databox_values_to_ypixels (GtkDatabox *box,
                               gint16 *pixels,
                               void *values,
                               GType vtype,
                               guint maxlen,
                               guint start,
                               guint stride,
                               guint len);

Calculates the vertical coordinates for pixels which represents the y values . Pixel coordinates are relative to the top corner of the box which is equivalent to (0).

gtk_databox_create_box_with_scrollbars_and_rulers ()

void
gtk_databox_create_box_with_scrollbars_and_rulers
                               (GtkWidget **p_box,
                                GtkWidget **p_grid,
                                gboolean scrollbar_x,
                                gboolean scrollbar_y,
                                gboolean ruler_x,
                                gboolean ruler_y);

This is a convenience function which creates a GtkDatabox widget in a GtkGrid widget optionally accompanied by scrollbars and rulers. You only have to fill in the data (gtk_databox_graph_add()) and adjust the limits (gtk_databox_set_total_limits() or gtk_databox_auto_rescale()).

This function produces the default databox with rulers at the top left and scroll bars at the bottom right.

gtk_databox_create_box_with_scrollbars_and_rulers_positioned ()

void
gtk_databox_create_box_with_scrollbars_and_rulers_positioned
                               (GtkWidget **p_box,
                                GtkWidget **p_grid,
                                gboolean scrollbar_x,
                                gboolean scrollbar_y,
                                gboolean ruler_x,
                                gboolean ruler_y,
                                gboolean ruler_x_top,
                                gboolean ruler_y_left);

This is a convenience function which creates a GtkDatabox widget in a GtkGrid widget optionally accompanied by scrollbars and rulers. You only have to fill in the data (gtk_databox_graph_add()) and adjust the limits (gtk_databox_set_total_limits() or gtk_databox_auto_rescale()).

This function produces the default databox with rulers at the top left and scroll bars at the bottom right.

gtk_databox_get_backing_surface ()

cairo_surface_t *
gtk_databox_get_backing_surface (GtkDatabox *box);

This function returns the surface which is used by box and its GtkDataboxGraph objects for drawing operations before copying the result to the screen.

The function is typically called by the GtkDataboxGraph objects.

The “adjustment-x” property

  “adjustment-x”             GtkAdjustment *

GtkAdjustment for horizontal scrolling.

Owner: GtkDatabox

Flags: Read / Write / Construct

The “adjustment-y” property

  “adjustment-y”             GtkAdjustment *

GtkAdjustment for vertical scrolling.

Owner: GtkDatabox

Flags: Read / Write / Construct

The “box-shadow” property

  “box-shadow”               guint

Style of the box shadow: GTK_SHADOW_NONE, GTK_SHADOW_IN, GTK_SHADOW_OUT, GTK_SHADOW_ETCHED_IN, GTK_SHADOW_ETCHED_OUT.

Owner: GtkDatabox

Flags: Read / Write

Allowed values: <= 4

Default value: 0

The “enable-selection” property

  “enable-selection”         gboolean

Defines whether the user can select rectangular areas with the mouse (TRUE) or not (FALSE).

Owner: GtkDatabox

Flags: Read / Write / Construct

Default value: TRUE

The “enable-zoom” property

  “enable-zoom”              gboolean

Defines whether the user can use the mouse to zoom in or out (TRUE) or not (FALSE).

Owner: GtkDatabox

Flags: Read / Write / Construct

Default value: TRUE

The “ruler-x” property

  “ruler-x”                  GtkDataboxRuler *

A horizontal GtkDataboxRuler or NULL.

Owner: GtkDatabox

Flags: Read / Write / Construct

The “ruler-y” property

  “ruler-y”                  GtkDataboxRuler *

A vertical GtkDataboxRuler or NULL.

Owner: GtkDatabox

Flags: Read / Write / Construct

The “scale-type-x” property

  “scale-type-x”             GtkDataboxScaleType

Horizontal scale type (linear or logarithmic).

Owner: GtkDatabox

Flags: Read / Write / Construct

Default value: GTK_DATABOX_SCALE_LINEAR

The “scale-type-y” property

  “scale-type-y”             GtkDataboxScaleType

Vertical scale type (linear or logarithmic).

Owner: GtkDatabox

Flags: Read / Write / Construct

Default value: GTK_DATABOX_SCALE_LINEAR

The “selection-canceled” signal

void
user_function (GtkDatabox *box,
               gpointer    user_data)

This signal is emitted after a right click outside a selection rectangle.

Flags: Run First

The “selection-changed” signal

void
user_function (GtkDatabox *box,
               gpointer    selection_values,
               gpointer    user_data)

This signal is emitted when the mouse is moved with the left button pressed (and the “enable-selection” property is set). The corners of the selection rectangle are stored in selection_values .

Flags: Run First

The “selection-finalized” signal

void
user_function (GtkDatabox *box,
               gpointer    selection_values,
               gpointer    user_data)

This signal is emitted when the left mouse button is released after a selection was started before.

see_also : “selection-changed”

Flags: Run First

The “selection-started” signal

void
user_function (GtkDatabox *box,
               gpointer    selection_values,
               gpointer    user_data)

This signal is emitted when the mouse is firstmoved with the left button pressed after the mouse-down (and the “enable-selection” property is set). The corners of the selection rectangle are stored in selection_values .

see_also : “selection-changed”

Flags: Run First

The “zoomed” signal

void
user_function (GtkDatabox *box,
               gpointer    user_data)

This signal is emitted each time the zoom of the widget is changed, see for example gtk_databox_zoom_to_selection(), gtk_databox_set_visible_limits().

Flags: Run First