"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "gtk/gtkdatabox_grid.c" between
gtkdatabox-0.9.3.1.tar.gz and gtkdatabox-1.0.0.tar.gz

About: GtkDatabox is a Gtk+-widget for live display of large amounts of fluctuating numerical data.

gtkdatabox_grid.c  (gtkdatabox-0.9.3.1):gtkdatabox_grid.c  (gtkdatabox-1.0.0)
skipping to change at line 17 skipping to change at line 17
* as published by the Free Software Foundation; either version 2.1 * as published by the Free Software Foundation; either version 2.1
* of the License, or (at your option) any later version. * of the License, or (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details. * GNU Lesser General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include <gtkdatabox_grid.h> #include <gtkdatabox_grid.h>
#include <math.h> #include <math.h>
G_DEFINE_TYPE(GtkDataboxGrid, gtk_databox_grid,
GTK_DATABOX_TYPE_GRAPH)
static void gtk_databox_grid_real_draw (GtkDataboxGraph * grid, static void gtk_databox_grid_real_draw (GtkDataboxGraph * grid,
GtkDatabox* box); GtkDatabox* box);
static GdkGC* gtk_databox_grid_real_create_gc (GtkDataboxGraph * graph, static cairo_t* gtk_databox_grid_real_create_gc (GtkDataboxGraph * graph,
GtkDatabox* box); GtkDatabox* box);
/* IDs of properties */ /* IDs of properties */
enum enum
{ {
GRID_HLINES = 1, GRID_HLINES = 1,
GRID_VLINES, GRID_VLINES,
GRID_HLINE_VALS, GRID_HLINE_VALS,
GRID_VLINE_VALS, GRID_VLINE_VALS,
GRID_LINE_STYLE GRID_LINE_STYLE
skipping to change at line 59 skipping to change at line 56
struct _GtkDataboxGridPrivate struct _GtkDataboxGridPrivate
{ {
gint hlines; gint hlines;
gint vlines; gint vlines;
gfloat *hline_vals; gfloat *hline_vals;
gfloat *vline_vals; gfloat *vline_vals;
GtkDataboxGridLineStyle line_style; GtkDataboxGridLineStyle line_style;
}; };
G_DEFINE_TYPE_WITH_PRIVATE(GtkDataboxGrid, gtk_databox_grid,
GTK_DATABOX_TYPE_GRAPH)
static void static void
gtk_databox_grid_set_property (GObject * object, gtk_databox_grid_set_property (GObject * object,
guint property_id, guint property_id,
const GValue * value, GParamSpec * pspec) const GValue * value, GParamSpec * pspec)
{ {
GtkDataboxGrid *grid = GTK_DATABOX_GRID (object); GtkDataboxGrid *grid = GTK_DATABOX_GRID (object);
switch (property_id) switch (property_id)
{ {
case GRID_HLINES: case GRID_HLINES:
skipping to change at line 141 skipping to change at line 141
g_value_set_int (value, gtk_databox_grid_get_line_style (grid)); g_value_set_int (value, gtk_databox_grid_get_line_style (grid));
} }
break; break;
default: default:
/* We don't have any other property... */ /* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break; break;
} }
} }
static GdkGC* static cairo_t*
gtk_databox_grid_real_create_gc (GtkDataboxGraph * graph, gtk_databox_grid_real_create_gc (GtkDataboxGraph * graph,
GtkDatabox* box) GtkDatabox* box)
{ {
GdkGC *gc; cairo_t *cr;
GdkGCValues values;
g_return_val_if_fail (GTK_DATABOX_IS_GRID (graph), NULL); g_return_val_if_fail (GTK_DATABOX_IS_GRID (graph), NULL);
gc = GTK_DATABOX_GRAPH_CLASS (gtk_databox_grid_parent_class)->create_gc (grap h, box); cr = GTK_DATABOX_GRAPH_CLASS (gtk_databox_grid_parent_class)->create_gc (grap h, box);
if (gc) return cr;
{ }
values.line_style = GDK_LINE_ON_OFF_DASH;
values.cap_style = GDK_CAP_BUTT;
values.join_style = GDK_JOIN_MITER;
gdk_gc_set_values (gc, &values,
GDK_GC_LINE_STYLE |
GDK_GC_CAP_STYLE | GDK_GC_JOIN_STYLE);
}
return gc; static void
grid_finalize (GObject * object)
{
/* Chain up to the parent class */
G_OBJECT_CLASS (gtk_databox_grid_parent_class)->finalize (object);
} }
static void static void
gtk_databox_grid_class_init (GtkDataboxGridClass *klass) gtk_databox_grid_class_init (GtkDataboxGridClass *klass)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkDataboxGraphClass *graph_class = GTK_DATABOX_GRAPH_CLASS (klass); GtkDataboxGraphClass *graph_class = GTK_DATABOX_GRAPH_CLASS (klass);
GParamSpec *grid_param_spec; GParamSpec *grid_param_spec;
gobject_class->set_property = gtk_databox_grid_set_property; gobject_class->set_property = gtk_databox_grid_set_property;
gobject_class->get_property = gtk_databox_grid_get_property; gobject_class->get_property = gtk_databox_grid_get_property;
gobject_class->finalize = grid_finalize;
grid_param_spec = g_param_spec_int ("grid-hlines", "grid-hlines", "Number of horizontal lines", G_MININT, G_MAXINT, 0, /* default value */ grid_param_spec = g_param_spec_int ("grid-hlines", "grid-hlines", "Number of horizontal lines", G_MININT, G_MAXINT, 0, /* default value */
G_PARAM_READWRITE); G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, g_object_class_install_property (gobject_class,
GRID_HLINES, grid_param_spec); GRID_HLINES, grid_param_spec);
grid_param_spec = g_param_spec_int ("grid-vlines", "grid-vlines", "Number of vertical lines", G_MININT, G_MAXINT, 0, /* default value */ grid_param_spec = g_param_spec_int ("grid-vlines", "grid-vlines", "Number of vertical lines", G_MININT, G_MAXINT, 0, /* default value */
G_PARAM_READWRITE); G_PARAM_READWRITE);
skipping to change at line 207 skipping to change at line 204
grid_param_spec = g_param_spec_int ("line-style", "line-style", "Line style o f grid lines", grid_param_spec = g_param_spec_int ("line-style", "line-style", "Line style o f grid lines",
GTK_DATABOX_GRID_DASHED_LINES, GTK_DATABOX _GRID_DOTTED_LINES, GTK_DATABOX_GRID_DASHED_LINES, GTK_DATABOX _GRID_DOTTED_LINES,
GTK_DATABOX_GRID_DASHED_LINES, GTK_DATABOX_GRID_DASHED_LINES,
G_PARAM_READWRITE); G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, g_object_class_install_property (gobject_class,
GRID_LINE_STYLE, grid_param_spec); GRID_LINE_STYLE, grid_param_spec);
graph_class->draw = gtk_databox_grid_real_draw; graph_class->draw = gtk_databox_grid_real_draw;
graph_class->create_gc = gtk_databox_grid_real_create_gc; graph_class->create_gc = gtk_databox_grid_real_create_gc;
g_type_class_add_private (klass, sizeof (GtkDataboxGridPrivate));
} }
static void static void
gtk_databox_grid_init (GtkDataboxGrid *grid __attribute__((unused))) gtk_databox_grid_init (GtkDataboxGrid *grid)
{ {
if (grid == NULL) g_warning ("grid_init with NULL");
} }
/** /**
* gtk_databox_grid_new: * gtk_databox_grid_new:
* @hlines: number of horizontal lines in the grid * @hlines: number of horizontal lines in the grid
* @vlines: number of vertical lines in the grid * @vlines: number of vertical lines in the grid
* @color: color of the grid * @color: color of the grid
* @size: line width of the grid * @size: line width of the grid
* *
* Creates a new #GtkDataboxGrid object which can be added to a #GtkDatabox widg et as nice decoration for other graphs. * Creates a new #GtkDataboxGrid object which can be added to a #GtkDatabox widg et as nice decoration for other graphs.
* *
* Return value: A new #GtkDataboxGrid object * Return value: A new #GtkDataboxGrid object
**/ **/
GtkDataboxGraph * GtkDataboxGraph *
gtk_databox_grid_new (gint hlines, gint vlines, GdkColor * color, guint size) gtk_databox_grid_new (gint hlines, gint vlines, GdkRGBA * color, guint size)
{ {
GtkDataboxGrid *grid; GtkDataboxGrid *grid;
grid = g_object_new (GTK_DATABOX_TYPE_GRID, grid = g_object_new (GTK_DATABOX_TYPE_GRID,
"color", color, "color", color,
"size", size, "size", size,
"grid-hlines", hlines, "grid-vlines", vlines, "grid-hline -vals",NULL, "grid-vline-vals", NULL, NULL); "grid-hlines", hlines, "grid-vlines", vlines, "grid-hline -vals",NULL, "grid-vline-vals", NULL, NULL);
return GTK_DATABOX_GRAPH (grid); return GTK_DATABOX_GRAPH (grid);
} }
skipping to change at line 253 skipping to change at line 249
* @hline_vals: a pointer to an array of gfloat horizontal grid coordinate * @hline_vals: a pointer to an array of gfloat horizontal grid coordinate
* @vline_vals: a pointer to an array of gfloat vertical grid coordinate * @vline_vals: a pointer to an array of gfloat vertical grid coordinate
* @color: color of the grid * @color: color of the grid
* @size: line width of the grid * @size: line width of the grid
* *
* Creates a new #GtkDataboxGrid object which can be added to a #GtkDatabox widg et as nice decoration for other graphs. * Creates a new #GtkDataboxGrid object which can be added to a #GtkDatabox widg et as nice decoration for other graphs.
* *
* Return value: A new #GtkDataboxGrid object * Return value: A new #GtkDataboxGrid object
**/ **/
GtkDataboxGraph *gtk_databox_grid_array_new (gint hlines, gint vlines, gfloat * local_hline_vals, gfloat * local_vline_vals, GtkDataboxGraph *gtk_databox_grid_array_new (gint hlines, gint vlines, gfloat * local_hline_vals, gfloat * local_vline_vals,
GdkColor * color, guint size) GdkRGBA * color, guint size)
{ {
GtkDataboxGrid *grid; GtkDataboxGrid *grid;
grid = g_object_new (GTK_DATABOX_TYPE_GRID, grid = g_object_new (GTK_DATABOX_TYPE_GRID,
"color", color, "color", color,
"size", size, "size", size,
"grid-hlines", hlines, "grid-vlines", vlines, "grid-hline -vals", local_hline_vals, "grid-vline-vals", local_vline_vals, NULL); "grid-hlines", hlines, "grid-vlines", vlines, "grid-hline -vals", local_hline_vals, "grid-vline-vals", local_vline_vals, NULL);
return GTK_DATABOX_GRAPH (grid); return GTK_DATABOX_GRAPH (grid);
} }
static void static void
gtk_databox_grid_real_draw (GtkDataboxGraph * graph, gtk_databox_grid_real_draw (GtkDataboxGraph * graph,
GtkDatabox* box) GtkDatabox* box)
{ {
GtkWidget *widget; GtkWidget *widget;
GtkDataboxGrid *grid = GTK_DATABOX_GRID (graph); GtkDataboxGrid *grid = GTK_DATABOX_GRID (graph);
GtkDataboxGridPrivate *priv = GTK_DATABOX_GRID_GET_PRIVATE(grid); GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
GdkPixmap *pixmap;
gint i = 0; gint i = 0;
gfloat x; gfloat x;
gfloat y; gfloat y;
gint16 width; gint16 width;
gint16 height; gint16 height;
gfloat offset_x; gfloat offset_x;
gfloat offset_y; gfloat offset_y;
gfloat factor_x; gfloat factor_x;
gfloat factor_y; gfloat factor_y;
gint16 pixel_x; gint16 pixel_x;
gint16 pixel_y; gint16 pixel_y;
gfloat left, right, top, bottom; gfloat left, right, top, bottom;
double pixel_right, pixel_left, pixel_top, pixel_bottom; double pixel_right, pixel_left, pixel_top, pixel_bottom;
double target_spacing, grid_spacing; double target_spacing, grid_spacing;
double grid_dot[] = {0.0, 0.0}; double grid_dot[] = {0.0, 0.0};
cairo_t *cr; cairo_t *cr;
GdkColor *color;
uint lineSize;
GtkAllocation allocation; GtkAllocation allocation;
g_return_if_fail (GTK_DATABOX_IS_GRID (grid)); g_return_if_fail (GTK_DATABOX_IS_GRID (grid));
g_return_if_fail (GTK_IS_DATABOX (box)); g_return_if_fail (GTK_IS_DATABOX (box));
widget = GTK_WIDGET(box); widget = GTK_WIDGET(box);
gtk_widget_get_allocation(widget, &allocation); gtk_widget_get_allocation(widget, &allocation);
pixmap = gtk_databox_get_backing_pixmap (box);
gtk_databox_get_total_limits (box, &left, &right, &top, &bottom); gtk_databox_get_total_limits (box, &left, &right, &top, &bottom);
cr = gdk_cairo_create (pixmap); cr = gtk_databox_graph_create_gc (graph, box);
g_object_get (grid, "color", &color, "size", &lineSize, NULL);
cairo_set_source_rgb (cr, color->red/65535.,color->green/65535.,color->blue/6
5535.);
cairo_set_line_width (cr, (gfloat)lineSize);
width = allocation.width; width = allocation.width;
height = allocation.height; height = allocation.height;
offset_x = left; offset_x = left;
factor_x = factor_x =
(right - left) / (priv->vlines + 1); (right - left) / (priv->vlines + 1);
offset_y = top; offset_y = top;
factor_y = factor_y =
skipping to change at line 363 skipping to change at line 352
case GTK_DATABOX_GRID_SOLID_LINES: case GTK_DATABOX_GRID_SOLID_LINES:
break; break;
} }
if (priv->hline_vals == NULL) if (priv->hline_vals == NULL)
for (i = 0; i < priv->hlines; i++) for (i = 0; i < priv->hlines; i++)
{ {
y = offset_y + (i + 1) * factor_y; y = offset_y + (i + 1) * factor_y;
pixel_y = gtk_databox_value_to_pixel_y (box, y); pixel_y = gtk_databox_value_to_pixel_y (box, y);
cairo_move_to (cr, 0.0, pixel_y + 0.5); cairo_move_to (cr, 0.0, pixel_y + 0.5);
cairo_line_to (cr, width, pixel_y + 0.5); cairo_line_to (cr, width, pixel_y + 0.5);
} }
else else
for (i = 0; i < priv->hlines; i++) for (i = 0; i < priv->hlines; i++)
{ {
y = priv->hline_vals[i]; y = priv->hline_vals[i];
pixel_y = gtk_databox_value_to_pixel_y (box, y); pixel_y = gtk_databox_value_to_pixel_y (box, y);
cairo_move_to (cr, 0.0, pixel_y + 0.5); cairo_move_to (cr, 0.0, pixel_y + 0.5);
cairo_line_to (cr, width, pixel_y + 0.5); cairo_line_to (cr, width, pixel_y + 0.5);
} }
cairo_stroke(cr); cairo_stroke(cr);
pixel_bottom = gtk_databox_value_to_pixel_y (box, bottom); pixel_bottom = gtk_databox_value_to_pixel_y (box, bottom);
pixel_top = gtk_databox_value_to_pixel_y (box, top); pixel_top = gtk_databox_value_to_pixel_y (box, top);
grid_spacing = (pixel_bottom - pixel_top)/(priv->hlines+1); grid_spacing = (pixel_bottom - pixel_top)/(priv->hlines+1);
switch (priv->line_style) { switch (priv->line_style) {
case GTK_DATABOX_GRID_DASHED_LINES: case GTK_DATABOX_GRID_DASHED_LINES:
skipping to change at line 402 skipping to change at line 391
case GTK_DATABOX_GRID_SOLID_LINES: case GTK_DATABOX_GRID_SOLID_LINES:
break; break;
} }
if (priv->vline_vals == NULL) if (priv->vline_vals == NULL)
for (i = 0; i < priv->vlines; i++) for (i = 0; i < priv->vlines; i++)
{ {
x = offset_x + (i + 1) * factor_x; x = offset_x + (i + 1) * factor_x;
pixel_x = gtk_databox_value_to_pixel_x (box, x); pixel_x = gtk_databox_value_to_pixel_x (box, x);
cairo_move_to (cr, pixel_x + 0.5, 0.0); cairo_move_to (cr, pixel_x + 0.5, 0.0);
cairo_line_to (cr, pixel_x + 0.5, height); cairo_line_to (cr, pixel_x + 0.5, height);
} }
else else
for (i = 0; i < priv->vlines; i++) for (i = 0; i < priv->vlines; i++)
{ {
x = priv->vline_vals[i]; x = priv->vline_vals[i];
pixel_x = gtk_databox_value_to_pixel_x (box, x); pixel_x = gtk_databox_value_to_pixel_x (box, x);
cairo_move_to (cr, pixel_x + 0.5, 0.0); cairo_move_to (cr, pixel_x + 0.5, 0);
cairo_line_to (cr, pixel_x + 0.5, height); cairo_line_to (cr, pixel_x + 0.5, height);
} }
cairo_stroke(cr); cairo_stroke(cr);
cairo_destroy(cr); cairo_destroy(cr);
return; return;
} }
/** /**
* gtk_databox_grid_set_hlines: * gtk_databox_grid_set_hlines:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* @hlines: number of vertical lines in the grid * @hlines: number of vertical lines in the grid
* *
* Sets the number of horizontal lines in the @grid. * Sets the number of horizontal lines in the @grid.
**/ **/
void void
gtk_databox_grid_set_hlines (GtkDataboxGrid * grid, gint hlines) gtk_databox_grid_set_hlines (GtkDataboxGrid * grid, gint hlines)
{ {
g_return_if_fail (GTK_DATABOX_IS_GRID (grid)); g_return_if_fail (GTK_DATABOX_IS_GRID (grid));
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
GTK_DATABOX_GRID_GET_PRIVATE(grid)->hlines = MAX (1, hlines); priv->hlines = MAX (1, hlines);
g_object_notify (G_OBJECT (grid), "grid-hlines"); g_object_notify (G_OBJECT (grid), "grid-hlines");
} }
/** /**
* gtk_databox_grid_get_hlines: * gtk_databox_grid_get_hlines:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* *
* Gets the number of horizontal lines in the @grid. * Gets the number of horizontal lines in the @grid.
* *
* Return value: Number of horizontal lines in the @grid. * Return value: Number of horizontal lines in the @grid.
**/ **/
gint gint
gtk_databox_grid_get_hlines (GtkDataboxGrid * grid) gtk_databox_grid_get_hlines (GtkDataboxGrid * grid)
{ {
g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), -1); g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), -1);
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
return GTK_DATABOX_GRID_GET_PRIVATE(grid)->hlines; return priv->hlines;
} }
/** /**
* gtk_databox_grid_set_vlines: * gtk_databox_grid_set_vlines:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* @vlines: number of vertical lines in the grid * @vlines: number of vertical lines in the grid
* *
* Sets the number of vertical lines in the @grid. * Sets the number of vertical lines in the @grid.
**/ **/
void void
gtk_databox_grid_set_vlines (GtkDataboxGrid * grid, gint vlines) gtk_databox_grid_set_vlines (GtkDataboxGrid * grid, gint vlines)
{ {
g_return_if_fail (GTK_DATABOX_IS_GRID (grid)); g_return_if_fail (GTK_DATABOX_IS_GRID (grid));
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
GTK_DATABOX_GRID_GET_PRIVATE(grid)->vlines = MAX (1, vlines); priv->vlines = MAX (1, vlines);
g_object_notify (G_OBJECT (grid), "grid-vlines"); g_object_notify (G_OBJECT (grid), "grid-vlines");
} }
/** /**
* gtk_databox_grid_get_vlines: * gtk_databox_grid_get_vlines:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* *
* Gets the number of vertical lines in the @grid. * Gets the number of vertical lines in the @grid.
* *
* Return value: Number of vertical lines in the @grid. * Return value: Number of vertical lines in the @grid.
**/ **/
gint gint
gtk_databox_grid_get_vlines (GtkDataboxGrid * grid) gtk_databox_grid_get_vlines (GtkDataboxGrid * grid)
{ {
g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), -1); g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), -1);
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
return GTK_DATABOX_GRID_GET_PRIVATE(grid)->vlines; return priv->vlines;
} }
/** /**
* gtk_databox_grid_set_hline_vals: * gtk_databox_grid_set_hline_vals:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* @hline_vals: sets the pointer to the hline values for the grid * @hline_vals: sets the pointer to the hline values for the grid
* *
* Sets the pointer to the horizontal lines in the @grid. * Sets the pointer to the horizontal lines in the @grid.
**/ **/
void void
gtk_databox_grid_set_hline_vals (GtkDataboxGrid * grid, gfloat *hline_vals) gtk_databox_grid_set_hline_vals (GtkDataboxGrid * grid, gfloat *hline_vals)
{ {
g_return_if_fail (GTK_DATABOX_IS_GRID (grid)); g_return_if_fail (GTK_DATABOX_IS_GRID (grid));
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
GTK_DATABOX_GRID_GET_PRIVATE(grid)->hline_vals = hline_vals; priv->hline_vals = hline_vals;
g_object_notify (G_OBJECT (grid), "grid-hline-vals"); g_object_notify (G_OBJECT (grid), "grid-hline-vals");
} }
/** /**
* gtk_databox_grid_get_hline_vals: * gtk_databox_grid_get_hline_vals:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* *
* Gets the pointer to the horizontal line values for the @grid. * Gets the pointer to the horizontal line values for the @grid.
* *
* Return value: Pointer to the horizontal line values for the @grid. * Return value: Pointer to the horizontal line values for the @grid. (or NULL i f error)
**/ **/
gfloat* gfloat*
gtk_databox_grid_get_hline_vals (GtkDataboxGrid * grid) gtk_databox_grid_get_hline_vals (GtkDataboxGrid * grid)
{ {
g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), NULL); g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), NULL);
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
return GTK_DATABOX_GRID_GET_PRIVATE(grid)->hline_vals; return priv->hline_vals;
} }
/** /**
* gtk_databox_grid_set_vline_vals: * gtk_databox_grid_set_vline_vals:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* @vline_vals: sets the pointer to the vline values for the grid * @vline_vals: sets the pointer to the vline values for the grid
* *
* Sets the pointer to the vertical lines in the @grid. * Sets the pointer to the vertical lines in the @grid.
**/ **/
void void
gtk_databox_grid_set_vline_vals (GtkDataboxGrid * grid, gfloat *vline_vals) gtk_databox_grid_set_vline_vals (GtkDataboxGrid * grid, gfloat *vline_vals)
{ {
g_return_if_fail (GTK_DATABOX_IS_GRID (grid)); g_return_if_fail (GTK_DATABOX_IS_GRID (grid));
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
GTK_DATABOX_GRID_GET_PRIVATE(grid)->vline_vals = vline_vals; priv->vline_vals = vline_vals;
g_object_notify (G_OBJECT (grid), "grid-vline-vals"); g_object_notify (G_OBJECT (grid), "grid-vline-vals");
} }
/** /**
* gtk_databox_grid_get_vline_vals: * gtk_databox_grid_get_vline_vals:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* *
* Gets the pointer to the vertical line values for the @grid. * Gets the pointer to the vertical line values for the @grid.
* *
* Return value: Pointer to the vertical line values for the @grid. * Return value: Pointer to the vertical line values for the @grid. (or NULL if error)
**/ **/
gfloat* gfloat*
gtk_databox_grid_get_vline_vals (GtkDataboxGrid * grid) gtk_databox_grid_get_vline_vals (GtkDataboxGrid * grid)
{ {
g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), NULL); g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), NULL);
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
return GTK_DATABOX_GRID_GET_PRIVATE(grid)->vline_vals; return priv->vline_vals;
} }
/** /**
* gtk_databox_grid_set_line_style: * gtk_databox_grid_set_line_style:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* @line_style: GTK_DATABOX_GRID_DASHED_LINES, * @line_style: GTK_DATABOX_GRID_DASHED_LINES,
* GTK_DATABOX_GRID_SOLID_LINES, or GTK_DATABOX_GRID_DOTTED_LINES * GTK_DATABOX_GRID_SOLID_LINES, or GTK_DATABOX_GRID_DOTTED_LINES
* *
* Sets the line style to draw the lines in the @grid. * Sets the line style to draw the lines in the @grid.
**/ **/
void void
gtk_databox_grid_set_line_style (GtkDataboxGrid *grid, gint line_style) gtk_databox_grid_set_line_style (GtkDataboxGrid *grid, gint line_style)
{ {
g_return_if_fail (GTK_DATABOX_IS_GRID (grid)); g_return_if_fail (GTK_DATABOX_IS_GRID (grid));
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
GTK_DATABOX_GRID_GET_PRIVATE(grid)->line_style = line_style; priv->line_style = line_style;
g_object_notify (G_OBJECT (grid), "line-style"); g_object_notify (G_OBJECT (grid), "line-style");
} }
/** /**
* gtk_databox_grid_get_line_style: * gtk_databox_grid_get_line_style:
* @grid: a #GtkDataboxGrid graph object * @grid: a #GtkDataboxGrid graph object
* *
* Retrieve the line style to draw the lines in the @grid. * Retrieve the line style to draw the lines in the @grid.
* *
* Return value: GTK_DATABOX_GRID_DASHED_LINES, * Return value: GTK_DATABOX_GRID_DASHED_LINES,
* GTK_DATABOX_GRID_SOLID_LINES, or GTK_DATABOX_GRID_DOTTED_LINES * GTK_DATABOX_GRID_SOLID_LINES, or GTK_DATABOX_GRID_DOTTED_LINES
**/ **/
gint gint
gtk_databox_grid_get_line_style (GtkDataboxGrid *grid) gtk_databox_grid_get_line_style (GtkDataboxGrid *grid)
{ {
g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), -1); g_return_val_if_fail (GTK_DATABOX_IS_GRID (grid), -1);
GtkDataboxGridPrivate *priv = gtk_databox_grid_get_instance_private(grid);
return GTK_DATABOX_GRID_GET_PRIVATE(grid)->line_style; return priv->line_style;
} }
 End of changes. 36 change blocks. 
65 lines changed or deleted 52 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)