gtkdatabox  1.0.0
About: GtkDatabox is a Gtk+-widget for live display of large amounts of fluctuating numerical data.
  Fossies Dox: gtkdatabox-1.0.0.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

gtkdatabox_graph.c
Go to the documentation of this file.
1 /* $Id: gtkdatabox_graph.c 4 2008-06-22 09:19:11Z rbock $ */
2 /* GtkDatabox - An extension to the gtk+ library
3  * Copyright (C) 1998 - 2008 Dr. Roland Bock
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public License
7  * as published by the Free Software Foundation; either version 2.1
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19 
20 #include <gtkdatabox_graph.h>
21 #include <gtk/gtk.h>
22 
23 static void gtk_databox_graph_real_draw (GtkDataboxGraph * graph,
24  GtkDatabox * draw);
26  gfloat * min_x,
27  gfloat * max_x,
28  gfloat * min_y,
29  gfloat * max_y);
30 
31 /* IDs of properties */
32 enum
33 {
37 };
38 
39 /**
40  * GtkDataboxGraphPrivate
41  *
42  * A private data structure used by the #GtkDataboxGraph. It shields all internal things
43  * from developers who are just using the object.
44  *
45  **/
47 
49 {
50  GdkRGBA color;
51  gint size;
52  gboolean hide;
53  GdkRGBA rgba;
54 };
55 
57  G_TYPE_OBJECT)
58 
59 static void
60 gtk_databox_graph_set_property (GObject * object,
61  guint property_id,
62  const GValue * value, GParamSpec * pspec)
63 {
64  GtkDataboxGraph *graph = GTK_DATABOX_GRAPH (object);
65 
66  switch (property_id)
67  {
68  case GRAPH_COLOR:
69  {
71  (GdkRGBA *)
72  g_value_get_pointer (value));
73  }
74  break;
75  case GRAPH_SIZE:
76  {
77  gtk_databox_graph_set_size (graph, g_value_get_int (value));
78  }
79  break;
80  case GRAPH_HIDE:
81  {
82  gtk_databox_graph_set_hide (graph, g_value_get_boolean (value));
83  }
84  break;
85  default:
86  /* We don't have any other property... */
87  G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
88  break;
89  }
90 }
91 
92 static void
94  guint property_id,
95  GValue * value, GParamSpec * pspec)
96 {
97  GtkDataboxGraph *graph = GTK_DATABOX_GRAPH (object);
98 
99  switch (property_id)
100  {
101  case GRAPH_COLOR:
102  {
103  g_value_set_pointer (value, gtk_databox_graph_get_color (graph));
104  }
105  break;
106  case GRAPH_SIZE:
107  {
108  g_value_set_int (value, gtk_databox_graph_get_size (graph));
109  }
110  break;
111  case GRAPH_HIDE:
112  {
113  g_value_set_boolean (value, gtk_databox_graph_get_hide (graph));
114  }
115  break;
116  default:
117  /* We don't have any other property... */
118  G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
119  break;
120  }
121 }
122 
123 /**
124  * gtk_databox_graph_create_gc:
125  * @graph: A #GtkDataboxGraph object
126  * @box: A #GtkDatabox object
127  *
128  * Virtual function which creates a graphics context for the @graph.
129  *
130  * Typically called by derived graph objects when the graphics context is needed for the first time.
131  *
132  * Return value: The new graphics context.
133  */
134 cairo_t*
136  GtkDatabox* box)
137 {
138  return GTK_DATABOX_GRAPH_GET_CLASS (graph)->create_gc (graph, box);
139 }
140 
141 static cairo_t *
143  GtkDatabox* box)
144 {
145  GtkDataboxGraphPrivate *priv = gtk_databox_graph_get_instance_private(graph);
146  cairo_t *cr;
147 
148  g_return_val_if_fail (GTK_DATABOX_IS_GRAPH (graph), NULL);
149 
150  cr = cairo_create (gtk_databox_get_backing_surface (box));
151  gdk_cairo_set_source_rgba (cr, &priv->color);
152  cairo_set_line_width (cr, (priv->size > 1) ? priv->size : 1);
153 
154  return cr;
155 }
156 
157 static void
159 {
160  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
161  GParamSpec *graph_param_spec;
162 
163  gobject_class->set_property = gtk_databox_graph_set_property;
164  gobject_class->get_property = gtk_databox_graph_get_property;
165 
166  graph_param_spec = g_param_spec_pointer ("color",
167  "Graph color",
168  "Color of graph",
169  G_PARAM_READWRITE);
170 
171  g_object_class_install_property (gobject_class,
172  GRAPH_COLOR, graph_param_spec);
173 
174  graph_param_spec = g_param_spec_int ("size", "Graph size", "Size of displayed items", G_MININT, G_MAXINT, 0, /* default value */
175  G_PARAM_READWRITE);
176 
177  g_object_class_install_property (gobject_class,
178  GRAPH_SIZE, graph_param_spec);
179 
180  graph_param_spec = g_param_spec_boolean ("hide", "Graph hidden", "Determine if graph is hidden or not", FALSE, /* default value */
181  G_PARAM_READWRITE);
182 
183  g_object_class_install_property (gobject_class,
184  GRAPH_HIDE, graph_param_spec);
185 
189 }
190 
191 static void
193 {
194  if (graph == NULL) g_warning ("graph_init with NULL");
195 }
196 
197 /**
198  * gtk_databox_graph_draw:
199  * @graph: A #GtkDataboxGraph object
200  * @box: A #GtkDatabox object
201  *
202  * Virtual function which draws the #GtkDataboxGraph on the drawing area of the GtkDatabox object.
203  *
204  * Typically this function is called by #GtkDatabox objects.
205  *
206  */
207 void
209 {
210  GtkDataboxGraphPrivate *priv = gtk_databox_graph_get_instance_private(graph);
211  if (!priv->hide)
212  GTK_DATABOX_GRAPH_GET_CLASS (graph)->draw (graph, box);
213 }
214 
215 /**
216  * gtk_databox_graph_calculate_extrema:
217  * @graph: A #GtkDataboxGraph object
218  * @min_x: Will be filled with the lowest x value of the dataset
219  * @max_x: Will be filled with the highest x value of the dataset
220  * @min_y: Will be filled with the lowest y value of the dataset
221  * @max_y: Will be filled with the highest y value of the dataset
222  *
223  * Virtual function which determines the minimum and maximum x and y values of the values of this
224  * #GtkDataboxGraph object if applicable (there are graphs which do
225  * not contain data).
226  *
227  * Return value: 0 on success,
228  * -1 if no data is available,
229  *
230  */
231 gint
233  gfloat * min_x, gfloat * max_x,
234  gfloat * min_y, gfloat * max_y)
235 {
236  return
237  GTK_DATABOX_GRAPH_GET_CLASS (graph)->calculate_extrema (graph, min_x,
238  max_x, min_y,
239  max_y);
240 }
241 
242 static void
244  GtkDatabox* box)
245 {
246  g_return_if_fail (graph);
247  g_return_if_fail (box);
248 
249  /* We have no data... */
250  return;
251 }
252 
253 
254 static gint
256  gfloat * min_x, gfloat * max_x,
257  gfloat * min_y, gfloat * max_y)
258 {
259  g_return_val_if_fail (graph, -1);
260  g_return_val_if_fail (min_x, -1);
261  g_return_val_if_fail (max_x, -1);
262  g_return_val_if_fail (min_y, -1);
263  g_return_val_if_fail (max_y, -1);
264 
265  /* We have no data... */
266  return -1;
267 }
268 
269 /**
270  * gtk_databox_graph_set_color:
271  * @graph: A #GtkDataboxGraph object
272  * @color: Color which is to be used by the graph object
273  *
274  * Sets the color which the #GtkDataboxGraph object is supposed to be using when drawing itself.
275  *
276  */
277 void
279 {
280  GtkDataboxGraphPrivate *priv = gtk_databox_graph_get_instance_private(graph);
281 
282  g_return_if_fail (GTK_DATABOX_IS_GRAPH (graph));
283 
284  priv->color = *color;
285 
286  g_object_notify (G_OBJECT (graph), "color");
287 }
288 
289 /**
290  * gtk_databox_graph_get_color:
291  * @graph: A #GtkDataboxGraph object
292  *
293  * Gets the current color of the graph elements (e.g. points).
294  *
295  * Return value: The color of the graph.
296  *
297  */
298 GdkRGBA *
300 {
301  GtkDataboxGraphPrivate *priv = gtk_databox_graph_get_instance_private(graph);
302  return &priv->color;
303 }
304 
305 /**
306  * gtk_databox_graph_set_size:
307  * @graph: A #GtkDataboxGraph object
308  * @size: Size of graph elements for the graph object
309  *
310  * Sets the size (e.g. line width) which the #GtkDataboxGraph object is supposed to be using when drawing itself.
311  *
312  */
313 void
315 {
316  g_return_if_fail (GTK_DATABOX_IS_GRAPH (graph));
317  GtkDataboxGraphPrivate *priv = gtk_databox_graph_get_instance_private(graph);
318  priv->size = MAX (1, size);;
319 
320  g_object_notify (G_OBJECT (graph), "size");
321 }
322 
323 /**
324  * gtk_databox_graph_get_size:
325  * @graph: A #GtkDataboxGraph object
326  *
327  * Gets the size of the graph elements (e.g. the line width).
328  *
329  * Return value: size of the graph elements
330  *
331  */
332 gint
334 {
335  g_return_val_if_fail (GTK_DATABOX_IS_GRAPH (graph), -1);
336  GtkDataboxGraphPrivate *priv = gtk_databox_graph_get_instance_private(graph);
337  return priv->size;
338 }
339 
340 /**
341  * gtk_databox_graph_set_hide:
342  * @graph: A #GtkDataboxGraph object
343  * @hide: Declares whether should be hidden (true) or not (false).
344  *
345  * Hidden graphs are not shown, when the #GtkDatabox containing them is redrawn.
346  *
347  */
348 void
350 {
351  g_return_if_fail (GTK_DATABOX_IS_GRAPH (graph));
352  GtkDataboxGraphPrivate *priv = gtk_databox_graph_get_instance_private(graph);
353  priv->hide = hide;
354 
355  g_object_notify (G_OBJECT (graph), "hide");
356 }
357 
358 /**
359  * gtk_databox_graph_get_hide:
360  * @graph: A #GtkDataboxGraph object
361  *
362  * Gets the current "hide" status.
363  *
364  * Return value: Whether the graph is hidden (true) or not (false).
365  *
366  */
367 gboolean
369 {
370  g_return_val_if_fail (GTK_DATABOX_IS_GRAPH (graph), -1);
371  GtkDataboxGraphPrivate *priv = gtk_databox_graph_get_instance_private(graph);
372  return priv->hide;
373 }
cairo_surface_t * gtk_databox_get_backing_surface(GtkDatabox *box)
Definition: gtkdatabox.c:1229
gint gtk_databox_graph_get_size(GtkDataboxGraph *graph)
static void gtk_databox_graph_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
void gtk_databox_graph_set_hide(GtkDataboxGraph *graph, gboolean hide)
GdkRGBA * gtk_databox_graph_get_color(GtkDataboxGraph *graph)
void gtk_databox_graph_set_size(GtkDataboxGraph *graph, gint size)
static void gtk_databox_graph_class_init(GtkDataboxGraphClass *klass)
G_DEFINE_TYPE_WITH_PRIVATE(GtkDataboxGraph, gtk_databox_graph, G_TYPE_OBJECT)
@ GRAPH_SIZE
@ GRAPH_COLOR
@ GRAPH_HIDE
static void gtk_databox_graph_real_draw(GtkDataboxGraph *graph, GtkDatabox *draw)
cairo_t * gtk_databox_graph_create_gc(GtkDataboxGraph *graph, GtkDatabox *box)
void gtk_databox_graph_set_color(GtkDataboxGraph *graph, GdkRGBA *color)
void gtk_databox_graph_draw(GtkDataboxGraph *graph, GtkDatabox *box)
static gint gtk_databox_graph_real_calculate_extrema(GtkDataboxGraph *graph, gfloat *min_x, gfloat *max_x, gfloat *min_y, gfloat *max_y)
gint gtk_databox_graph_calculate_extrema(GtkDataboxGraph *graph, gfloat *min_x, gfloat *max_x, gfloat *min_y, gfloat *max_y)
static cairo_t * gtk_databox_graph_real_create_gc(GtkDataboxGraph *graph, GtkDatabox *box)
static void gtk_databox_graph_init(GtkDataboxGraph *graph)
gboolean gtk_databox_graph_get_hide(GtkDataboxGraph *graph)
#define GTK_DATABOX_GRAPH_GET_CLASS(obj)
#define GTK_DATABOX_GRAPH(obj)
#define GTK_DATABOX_IS_GRAPH(obj)
typedefG_BEGIN_DECLS struct _GtkDatabox GtkDatabox
void(* draw)(GtkDataboxGraph *graph, GtkDatabox *box)
cairo_t *(* create_gc)(GtkDataboxGraph *graph, GtkDatabox *box)
gint(* calculate_extrema)(GtkDataboxGraph *graph, gfloat *min_x, gfloat *max_x, gfloat *min_y, gfloat *max_y)