diff options
Diffstat (limited to 'deps/uber-graph')
24 files changed, 6150 insertions, 0 deletions
diff --git a/deps/uber-graph/README b/deps/uber-graph/README new file mode 100644 index 00000000..e9a95ab1 --- /dev/null +++ b/deps/uber-graph/README @@ -0,0 +1,39 @@ +This is Christian Hergert's "Uber-Graph" +after commit d31c8014d8cc9f293dfecfcb4bd6a7bf4d61c0be. +https://gitlab.gnome.org/chergert/uber-graph +File headers give LGPL2 as the license. + +Original README follows: + +Some of this code is good. Some of this code is very bad. It is a prototype, +nothing more, nothing less. + +Particularly bad/nasty/unreadable code is in main.c. It is also Linux specific. + +UberGraph - A realtime graph similar to that found in Gnome System Monitor. + However, it is much faster and smoother. It runs at a higher + framerate with less X bandwidth. + + It uses multiple pixmaps on the server-side and shifts data between + them to lower the X bandwidth. New data is rendered and clipped so + that the transfer is small. If frame movement is < 1 pixel, the + framerate is dynamically reduced. + +UberHeatMap - This is going to eventually be similar to UberGraph but as a + heat map. It's not very far yet, however. + +GRing - A small circular buffer meant for values in the realtime graphs. This + is most definitely not meant to be used as a byte buffer, so don't use + it as such. + + Example: + + GRing *ring = g_ring_sized_new(sizeof(gdouble), 60, NULL); + + or + + static void free_array_func (gpointer data) { + GArray **ar = data; + g_array_unref(*ar); + } + GRing *ring = g_ring_sized_new(sizeof(GArray*), 60, free_array_func); diff --git a/deps/uber-graph/g-ring.c b/deps/uber-graph/g-ring.c new file mode 100644 index 00000000..b014bf74 --- /dev/null +++ b/deps/uber-graph/g-ring.c @@ -0,0 +1,227 @@ +/* g-ring.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This file is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This file is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <string.h> + +#include "g-ring.h" + +#ifndef g_malloc0_n +#define g_malloc0_n(x,y) g_malloc0((gsize)x * y) +#endif + +#define get_element(r,i) ((r)->data + ((r)->elt_size * i)) + +typedef struct _GRingImpl GRingImpl; + +struct _GRingImpl +{ + guint8 *data; /* Pointer to real data. */ + guint len; /* Length of data allocation. */ + guint pos; /* Position in ring. */ + guint elt_size; /* Size of each element. */ + gboolean looped; /* Have we wrapped around at least once. */ + GDestroyNotify destroy; /* Destroy element callback. */ + volatile gint ref_count; /* Reference count. */ +}; + +/** + * g_ring_sized_new: + * @element_size: (in): The size per element. + * @reserved_size: (in): The number of elements to allocate. + * @element_destroy: (in): Notification called when removing an element. + * + * Creates a new instance of #GRing with the given number of elements. + * + * Returns: A new #GRing. + * Side effects: None. + */ +GRing* +g_ring_sized_new (guint element_size, + guint reserved_size, + GDestroyNotify element_destroy) +{ + GRingImpl *ring_impl; + + ring_impl = g_slice_new0(GRingImpl); + ring_impl->elt_size = element_size; + ring_impl->len = reserved_size; + ring_impl->data = g_malloc0_n(reserved_size, element_size); + ring_impl->destroy = element_destroy; + ring_impl->ref_count = 1; + + return (GRing *)ring_impl; +} + +/** + * g_ring_append_vals: + * @ring: (in): A #GRing. + * @data: (in): A pointer to the array of values. + * @len: (in): The number of values. + * + * Appends @len values located at @data. + * + * Returns: None. + * Side effects: None. + */ +void +g_ring_append_vals (GRing *ring, + gconstpointer data, + guint len) +{ + GRingImpl *ring_impl = (GRingImpl *)ring; + gpointer idx; + gint x; + guint i; + + g_return_if_fail(ring_impl != NULL); + + for (i = 0; i < len; i++) { + x = (int)ring->pos - i; + if (x < 0) x += ring->len; + idx = ring->data + (ring_impl->elt_size * x); + if (ring_impl->destroy && ring_impl->looped == TRUE) { + ring_impl->destroy(idx); + } + memcpy(idx, data, ring_impl->elt_size); + ring->pos++; + if (ring->pos >= ring->len) { + ring_impl->looped = TRUE; + } + ring->pos %= ring->len; + data += ring_impl->elt_size; + } +} + +/** + * g_ring_foreach: + * @ring: (in): A #GRing. + * @func: (in): A #GFunc to call for each element. + * @user_data: (in): user data for @func. + * + * Calls @func for every item in the #GRing starting from the most recently + * inserted element to the least recently inserted. + * + * Returns: None. + * Side effects: None. + */ +void +g_ring_foreach (GRing *ring, + GFunc func, + gpointer user_data) +{ + GRingImpl *ring_impl = (GRingImpl *)ring; + gint i; + + g_return_if_fail(ring_impl != NULL); + g_return_if_fail(func != NULL); + + for (i = ring_impl->pos - 1; i >= 0; i--) { + func(get_element(ring_impl, i), user_data); + } + for (i = ring->len - 1; i >= (int)ring_impl->pos; i--) { + func(get_element(ring_impl, i), user_data); + } +} + +/** + * g_ring_destroy: + * @ring: (in): A #GRing. + * + * Cleans up after a #GRing that is no longer in use. + * + * Returns: None. + * Side effects: None. + */ +void +g_ring_destroy (GRing *ring) +{ + GRingImpl *ring_impl = (GRingImpl *)ring; + + g_return_if_fail(ring != NULL); + g_return_if_fail(ring_impl->ref_count == 0); + + g_free(ring_impl->data); + g_slice_free(GRingImpl, ring_impl); +} + +/** + * g_ring_ref: + * @ring: (in): A #GRing. + * + * Atomically increments the reference count of @ring by one. + * + * Returns: The @ring pointer. + * Side effects: None. + */ +GRing* +g_ring_ref (GRing *ring) +{ + GRingImpl *ring_impl = (GRingImpl *)ring; + + g_return_val_if_fail(ring != NULL, NULL); + g_return_val_if_fail(ring_impl->ref_count > 0, NULL); + + g_atomic_int_inc(&ring_impl->ref_count); + return ring; +} + +/** + * g_ring_unref: + * @ring: (in): A #GRing. + * + * Atomically decrements the reference count of @ring by one. When the + * reference count reaches zero, the structure is freed. + * + * Returns: None. + * Side effects: None. + */ +void +g_ring_unref (GRing *ring) +{ + GRingImpl *ring_impl = (GRingImpl *)ring; + + g_return_if_fail(ring != NULL); + g_return_if_fail(ring_impl->ref_count > 0); + + if (g_atomic_int_dec_and_test(&ring_impl->ref_count)) { + g_ring_destroy(ring); + } +} + +/** + * g_ring_get_type: + * + * Retrieves the #GType identifier for #GRing. + * + * Returns: The #GType for #GRing. + * Side effects: The type is registered on first call. + */ +GType +g_ring_get_type (void) +{ + static gsize initialized = FALSE; + static GType type_id = 0; + + if (g_once_init_enter(&initialized)) { + type_id = g_boxed_type_register_static("GRing", + (GBoxedCopyFunc)g_ring_ref, + (GBoxedFreeFunc)g_ring_unref); + g_once_init_leave(&initialized, TRUE); + } + return type_id; +} diff --git a/deps/uber-graph/g-ring.h b/deps/uber-graph/g-ring.h new file mode 100644 index 00000000..a4943878 --- /dev/null +++ b/deps/uber-graph/g-ring.h @@ -0,0 +1,84 @@ +/* g-ring.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This file is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This file is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __G_RING_H__ +#define __G_RING_H__ + +#include <glib-object.h> + +G_BEGIN_DECLS + +/** + * g_ring_append_val: + * @ring: A #GRing. + * @val: A value to append to the #GRing. + * + * Appends a value to the ring buffer. @val must be a variable as it is + * referenced to. + * + * Returns: None. + * Side effects: None. + */ +#define g_ring_append_val(ring, val) g_ring_append_vals(ring, &(val), 1) + +/** + * g_ring_get_index: + * @ring: A #GRing. + * @type: The type to extract. + * @i: The index within the #GRing relative to the current position. + * + * Retrieves the value at the given index from the #GRing. The value + * is cast to @type. You may retrieve a pointer to the value within the + * array by using &. + * + * [[ + * gdouble *v = &g_ring_get_index(ring, gdouble, 0); + * gdouble v = g_ring_get_index(ring, gdouble, 0); + * ]] + * + * Returns: The value at the given index. + * Side effects: None. + */ +#define g_ring_get_index(ring, type, i) \ + (((type*)(ring)->data)[(((gint)(ring)->pos - 1 - (i)) >= 0) ? \ + ((ring)->pos - 1 - (i)) : \ + ((ring)->len + ((ring)->pos - 1 - (i)))]) + +typedef struct +{ + guint8 *data; + guint len; + guint pos; +} GRing; + +GType g_ring_get_type (void) G_GNUC_CONST; +GRing* g_ring_sized_new (guint element_size, + guint reserved_size, + GDestroyNotify element_destroy); +void g_ring_append_vals (GRing *ring, + gconstpointer data, + guint len); +void g_ring_foreach (GRing *ring, + GFunc func, + gpointer user_data); +GRing* g_ring_ref (GRing *ring); +void g_ring_unref (GRing *ring); + +G_END_DECLS + +#endif /* __G_RING_H__ */ diff --git a/deps/uber-graph/uber-frame-source.c b/deps/uber-graph/uber-frame-source.c new file mode 100644 index 00000000..3de4d537 --- /dev/null +++ b/deps/uber-graph/uber-frame-source.c @@ -0,0 +1,177 @@ +/* + * Clutter. + * + * An OpenGL based 'interactive canvas' library. + * + * Authored By Neil Roberts <neil@linux.intel.com> + * + * Copyright (C) 2008 OpenedHand + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + * + * + */ + +/* Modified by Christian Hergert for use in Uber Graph. */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "uber-frame-source.h" +#include "uber-timeout-interval.h" + +typedef struct _UberFrameSource UberFrameSource; + +struct _UberFrameSource +{ + GSource source; + + UberTimeoutInterval timeout; +}; + +static gboolean uber_frame_source_prepare (GSource *source, + gint *timeout); +static gboolean uber_frame_source_check (GSource *source); +static gboolean uber_frame_source_dispatch (GSource *source, + GSourceFunc callback, + gpointer user_data); + +static GSourceFuncs uber_frame_source_funcs = +{ + uber_frame_source_prepare, + uber_frame_source_check, + uber_frame_source_dispatch, + NULL +}; + +/** + * uber_frame_source_add_full: + * @priority: the priority of the frame source. Typically this will be in the + * range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH. + * @fps: the number of times per second to call the function + * @func: function to call + * @data: data to pass to the function + * @notify: function to call when the timeout source is removed + * + * Sets a function to be called at regular intervals with the given + * priority. The function is called repeatedly until it returns + * %FALSE, at which point the timeout is automatically destroyed and + * the function will not be called again. The @notify function is + * called when the timeout is destroyed. The first call to the + * function will be at the end of the first @interval. + * + * This function is similar to g_timeout_add_full() except that it + * will try to compensate for delays. For example, if @func takes half + * the interval time to execute then the function will be called again + * half the interval time after it finished. In contrast + * g_timeout_add_full() would not fire until a full interval after the + * function completes so the delay between calls would be 1.0 / @fps * + * 1.5. This function does not however try to invoke the function + * multiple times to catch up missing frames if @func takes more than + * @interval ms to execute. + * + * Return value: the ID (greater than 0) of the event source. + * + * Since: 0.8 + */ +guint +uber_frame_source_add_full (gint priority, + guint fps, + GSourceFunc func, + gpointer data, + GDestroyNotify notify) +{ + guint ret; + GSource *source = g_source_new (&uber_frame_source_funcs, + sizeof (UberFrameSource)); + UberFrameSource *frame_source = (UberFrameSource *) source; + + _uber_timeout_interval_init (&frame_source->timeout, fps); + + if (priority != G_PRIORITY_DEFAULT) + g_source_set_priority (source, priority); + +#if GLIB_CHECK_VERSION (2, 25, 8) + g_source_set_name (source, "Uber frame timeout"); +#endif + + g_source_set_callback (source, func, data, notify); + + ret = g_source_attach (source, NULL); + + g_source_unref (source); + + return ret; +} + +/** + * uber_frame_source_add: + * @fps: the number of times per second to call the function + * @func: function to call + * @data: data to pass to the function + * + * Simple wrapper around uber_frame_source_add_full(). + * + * Return value: the ID (greater than 0) of the event source. + * + * Since: 0.8 + */ +guint +uber_frame_source_add (guint fps, + GSourceFunc func, + gpointer data) +{ + return uber_frame_source_add_full (G_PRIORITY_DEFAULT, + fps, func, data, NULL); +} + +static gboolean +uber_frame_source_prepare (GSource *source, + gint *delay) +{ + UberFrameSource *frame_source = (UberFrameSource *) source; + gint64 current_time; + +#if GLIB_CHECK_VERSION (2, 27, 3) + current_time = g_source_get_time (source) / 1000; +#else + { + GTimeVal source_time; + g_source_get_current_time (source, &source_time); + current_time = source_time.tv_sec * 1000 + source_time.tv_usec / 1000; + } +#endif + + return _uber_timeout_interval_prepare (current_time, + &frame_source->timeout, + delay); +} + +static gboolean +uber_frame_source_check (GSource *source) +{ + return uber_frame_source_prepare (source, NULL); +} + +static gboolean +uber_frame_source_dispatch (GSource *source, + GSourceFunc callback, + gpointer user_data) +{ + UberFrameSource *frame_source = (UberFrameSource *) source; + + return _uber_timeout_interval_dispatch (&frame_source->timeout, + callback, user_data); +} diff --git a/deps/uber-graph/uber-frame-source.h b/deps/uber-graph/uber-frame-source.h new file mode 100644 index 00000000..8976beaa --- /dev/null +++ b/deps/uber-graph/uber-frame-source.h @@ -0,0 +1,43 @@ +/* + * Clutter. + * + * An OpenGL based 'interactive canvas' library. + * + * Authored By Matthew Allum <mallum@openedhand.com> + * + * Copyright (C) 2008 OpenedHand + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_FRAME_SOURCE_H__ +#define __UBER_FRAME_SOURCE_H__ + +#include <glib.h> + +G_BEGIN_DECLS + +guint uber_frame_source_add (guint fps, + GSourceFunc func, + gpointer data); + +guint uber_frame_source_add_full (gint priority, + guint fps, + GSourceFunc func, + gpointer data, + GDestroyNotify notify); + +G_END_DECLS + +#endif /* __UBER_FRAME_SOURCE_H__ */ diff --git a/deps/uber-graph/uber-graph.c b/deps/uber-graph/uber-graph.c new file mode 100644 index 00000000..9118f263 --- /dev/null +++ b/deps/uber-graph/uber-graph.c @@ -0,0 +1,2166 @@ +/* uber-graph.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <glib/gi18n.h> +#include <gdk/gdk.h> +#include <math.h> +#include <string.h> + +#include "uber-graph.h" +#include "uber-scale.h" +#include "uber-frame-source.h" + +#define WIDGET_CLASS (GTK_WIDGET_CLASS(uber_graph_parent_class)) +#define RECT_RIGHT(r) ((r).x + (r).width) +#define RECT_BOTTOM(r) ((r).y + (r).height) +#define UNSET_SURFACE(p) \ + G_STMT_START { \ + if (p) { \ + cairo_surface_destroy (p); \ + p = NULL; \ + } \ + } G_STMT_END +#define CLEAR_CAIRO(c, a) \ + G_STMT_START { \ + cairo_save(c); \ + cairo_rectangle(c, 0, 0, a.width, a.height); \ + cairo_set_operator(c, CAIRO_OPERATOR_CLEAR); \ + cairo_fill(c); \ + cairo_restore(c); \ + } G_STMT_END + +/** + * SECTION:uber-graph.h + * @title: UberGraph + * @short_description: Graphing of realtime data. + * + * #UberGraph is an abstract base class for building realtime graphs. It + * handles scrolling the graph based on the required time intervals and tries + * to render as little data as possible. + * + * Subclasses are responsible for acquiring data when #UberGraph notifies them + * of their next data sample. Additionally, there are two rendering methods. + * UberGraph::render is a render of the full scene. UberGraph::render_fast is + * a rendering of just a new data sample. Ideally, UberGraph::render_fast is + * going to be called. + * + * #UberGraph uses a #cairo_surface_t as a ring buffer to store the contents of the + * graph. Upon destructive changes to the widget such as allocation changed + * or a new #GtkStyle set, a full rendering of the graph will be required. + */ + + +struct _UberGraphPrivate +{ + cairo_surface_t *fg_surface; + cairo_surface_t *bg_surface; + + GdkRectangle content_rect; /* Content area rectangle. */ + GdkRectangle nonvis_rect; /* Non-visible drawing area larger than + * content rect. Used to draw over larger + * area so we can scroll and not fall out + * of view. + */ + UberGraphFormat format; /* Data type format. */ + gboolean paused; /* Is the graph paused. */ + gboolean have_rgba; /* Do we support 32-bit RGBA colormaps. */ + gint x_slots; /* Number of data points on x axis. */ + gint fps; /* Desired frames per second. */ + gint fps_real; /* Milleseconds between FPS callbacks. */ + gfloat fps_each; /* How far to move in each FPS tick. */ + guint fps_handler; /* Timeout for moving the content. */ + gfloat dps; /* Desired data points per second. */ + gint dps_slot; /* Which slot in the surface buffer. */ + gfloat dps_each; /* How many pixels between data points. */ + GTimeVal dps_tv; /* Timeval of last data point. */ + guint dps_handler; /* Timeout for getting new data. */ + guint dps_downscale; /* Count since last downscale. */ + gboolean fg_dirty; /* Does the foreground need to be redrawn. */ + gboolean bg_dirty; /* Does the background need to be redrawn. */ + guint tick_len; /* How long should axis-ticks be. */ + gboolean show_xlines; /* Show X axis lines. */ + gboolean show_xlabels; /* Show X axis labels. */ + gboolean show_ylines; /* Show Y axis lines. */ + gboolean full_draw; /* Do we need to redraw all foreground content. + * If false, draws will try to only add new + * content to the back buffer. + */ + GtkWidget *labels; /* Container for graph labels. */ + GtkWidget *align; /* Alignment for labels. */ + gint fps_count; /* Track actual FPS. */ +}; + +G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(UberGraph, uber_graph, GTK_TYPE_DRAWING_AREA) + +static gboolean show_fps = FALSE; + +enum +{ + PROP_0, + PROP_FORMAT, +}; + +/** + * uber_graph_new: + * + * Creates a new instance of #UberGraph. + * + * Returns: the newly created instance of #UberGraph. + * Side effects: None. + */ +GtkWidget* +uber_graph_new (void) +{ + UberGraph *graph; + + graph = g_object_new(UBER_TYPE_GRAPH, NULL); + return GTK_WIDGET(graph); +} + +/** + * uber_graph_fps_timeout: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: %TRUE always. + * Side effects: None. + */ +static gboolean +uber_graph_fps_timeout (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_val_if_fail(UBER_IS_GRAPH(graph), FALSE); + + priv = graph->priv; + gtk_widget_queue_draw_area(GTK_WIDGET(graph), + priv->content_rect.x, + priv->content_rect.y, + priv->content_rect.width, + priv->content_rect.height); + return TRUE; +} + +/** + * uber_graph_get_content_area: + * @graph: A #UberGraph. + * + * Retrieves the content area of the graph. + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_get_content_area (UberGraph *graph, /* IN */ + GdkRectangle *rect) /* OUT */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + g_return_if_fail(rect != NULL); + + priv = graph->priv; + *rect = priv->content_rect; +} + +/** + * uber_graph_get_show_xlines: + * @graph: A #UberGraph. + * + * Retrieves if the X grid lines should be shown. + * + * Returns: None. + * Side effects: None. + */ +gboolean +uber_graph_get_show_xlines (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_val_if_fail(UBER_IS_GRAPH(graph), FALSE); + + priv = graph->priv; + return priv->show_xlines; +} + +/** + * uber_graph_set_show_xlines: + * @graph: A #UberGraph. + * @show_xlines: Show x lines. + * + * Sets if the x lines should be shown. + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_set_show_xlines (UberGraph *graph, /* IN */ + gboolean show_xlines) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + priv->show_xlines = show_xlines; + priv->bg_dirty = TRUE; + gtk_widget_queue_draw(GTK_WIDGET(graph)); +} + +/** + * uber_graph_get_show_ylines: + * @graph: A #UberGraph. + * + * Retrieves if the X grid lines should be shown. + * + * Returns: None. + * Side effects: None. + */ +gboolean +uber_graph_get_show_ylines (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_val_if_fail(UBER_IS_GRAPH(graph), FALSE); + + priv = graph->priv; + return priv->show_ylines; +} + +/** + * uber_graph_set_show_ylines: + * @graph: A #UberGraph. + * @show_ylines: Show x lines. + * + * Sets if the x lines should be shown. + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_set_show_ylines (UberGraph *graph, /* IN */ + gboolean show_ylines) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + priv->show_ylines = show_ylines; + priv->bg_dirty = TRUE; + gtk_widget_queue_draw(GTK_WIDGET(graph)); +} + +/** + * uber_graph_get_labels: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +GtkWidget* +uber_graph_get_labels (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_val_if_fail(UBER_IS_GRAPH(graph), NULL); + + priv = graph->priv; + return priv->align; +} + +/** + * uber_graph_scale_changed: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_scale_changed (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + GtkAllocation alloc; + GdkRectangle rect; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + if (!priv->paused) { + priv->fg_dirty = TRUE; + priv->bg_dirty = TRUE; + priv->full_draw = TRUE; + gtk_widget_get_allocation(GTK_WIDGET(graph), &alloc); + rect.x = 0; + rect.y = 0; + rect.width = alloc.width; + rect.height = alloc.height; + gdk_window_invalidate_rect(gtk_widget_get_window(GTK_WIDGET(graph)), + &rect, TRUE); + } +} + +/** + * uber_graph_get_next_data: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static inline gboolean +uber_graph_get_next_data (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + gboolean ret = TRUE; + + g_return_val_if_fail(UBER_IS_GRAPH(graph), FALSE); + + /* + * Get the current time for this data point. This is used to calculate + * the proper offset in the FPS callback. + */ + priv = graph->priv; + g_get_current_time(&priv->dps_tv); + /* + * Notify the subclass to retrieve the data point. + */ + if (UBER_GRAPH_GET_CLASS(graph)->get_next_data) { + ret = UBER_GRAPH_GET_CLASS(graph)->get_next_data(graph); + } + return ret; +} + +/** + * uber_graph_init_texture: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_init_texture (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + GtkAllocation alloc; + GdkWindow *window; + cairo_t *cr; + gint width; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + gtk_widget_get_allocation(GTK_WIDGET(graph), &alloc); + window = gtk_widget_get_window(GTK_WIDGET(graph)); + /* + * Get drawable to base surface upon. + */ + if (!window) { + g_critical("%s() called before GdkWindow is allocated.", G_STRFUNC); + return; + } + /* + * Initialize foreground and background surface. + */ + width = MAX(priv->nonvis_rect.x + priv->nonvis_rect.width, alloc.width); + priv->fg_surface = gdk_window_create_similar_surface(window, CAIRO_CONTENT_COLOR_ALPHA, width, alloc.height); + /* + * Clear foreground contents. + */ + cr = cairo_create(priv->fg_surface); + CLEAR_CAIRO(cr, alloc); + cairo_destroy(cr); +} + +/** + * uber_graph_init_bg: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_init_bg (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + GtkAllocation alloc; + GdkWindow *window; + cairo_t *cr; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + gtk_widget_get_allocation(GTK_WIDGET(graph), &alloc); + window = gtk_widget_get_window(GTK_WIDGET(graph)); + /* + * Get drawable for surface. + */ + if (!window) { + g_critical("%s() called before GdkWindow is allocated.", G_STRFUNC); + return; + } + /* + * Create the server-side surface. + */ + priv->bg_surface = gdk_window_create_similar_surface(window, CAIRO_CONTENT_COLOR_ALPHA, alloc.width, alloc.height); + /* + * Clear background contents. + */ + cr = cairo_create(priv->bg_surface); + CLEAR_CAIRO(cr, alloc); + cairo_destroy(cr); +} + +/** + * uber_graph_calculate_rects: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_calculate_rects (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + GtkAllocation alloc; + PangoLayout *layout; + PangoFontDescription *font_desc; + GdkWindow *window; + gint pango_width; + gint pango_height; + cairo_t *cr; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + gtk_widget_get_allocation(GTK_WIDGET(graph), &alloc); + window = gtk_widget_get_window(GTK_WIDGET(graph)); + /* + * We can't calculate rectangles before we have a GdkWindow. + */ + if (!window) { + return; + } + /* + * Determine the pixels required for labels. + */ + cr = gdk_cairo_create(window); + layout = pango_cairo_create_layout(cr); + font_desc = pango_font_description_new(); + pango_font_description_set_family_static(font_desc, "Monospace"); + pango_font_description_set_size(font_desc, 6 * PANGO_SCALE); + pango_layout_set_font_description(layout, font_desc); + pango_layout_set_text(layout, "XXXXXXXXXX", -1); + pango_layout_get_pixel_size(layout, &pango_width, &pango_height); + pango_font_description_free(font_desc); + g_object_unref(layout); + cairo_destroy(cr); + /* + * Calculate content area rectangle. + */ + priv->content_rect.x = priv->tick_len + pango_width + 1.5; + priv->content_rect.y = (pango_height / 2.) + 1.5; + priv->content_rect.width = alloc.width - priv->content_rect.x - 3.0; + priv->content_rect.height = alloc.height - priv->tick_len - pango_height + - (pango_height / 2.) - 3.0; + if (!priv->show_xlabels) { + priv->content_rect.height += pango_height; + } + /* + * Adjust label offset. + */ + /* + * Calculate FPS/DPS adjustments. + */ + priv->dps_each = ceil((gfloat)priv->content_rect.width + / (gfloat)(priv->x_slots - 1)); + priv->fps_each = priv->dps_each + / ((gfloat)priv->fps / (gfloat)priv->dps); + /* + * XXX: Small hack to make things a bit smoother at small scales. + */ + if (priv->fps_each < .5) { + priv->fps_each = 1; + priv->fps_real = (1000. / priv->dps_each) / 2.; + } else { + priv->fps_real = 1000. / priv->fps; + } + /* + * Update FPS callback. + */ + if (priv->fps_handler) { + g_source_remove(priv->fps_handler); + priv->fps_handler = uber_frame_source_add(priv->fps, + (GSourceFunc)uber_graph_fps_timeout, + graph); + } + /* + * Calculate the non-visible area that drawing should happen within. + */ + priv->nonvis_rect = priv->content_rect; + priv->nonvis_rect.width = priv->dps_each * priv->x_slots; + /* + * Update positioning for label alignment. + */ + gtk_widget_set_margin_top(GTK_WIDGET(priv->align), 6); + gtk_widget_set_margin_bottom(GTK_WIDGET(priv->align), 6); + gtk_widget_set_margin_start(GTK_WIDGET(priv->align), priv->content_rect.x); + gtk_widget_set_margin_end(GTK_WIDGET(priv->align), 0); +} + +/** + * uber_graph_get_show_xlabels: + * @graph: A #UberGraph. + * + * Retrieves if the X grid labels should be shown. + * + * Returns: None. + * Side effects: None. + */ +gboolean +uber_graph_get_show_xlabels (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_val_if_fail(UBER_IS_GRAPH(graph), FALSE); + + priv = graph->priv; + return priv->show_xlabels; +} + +/** + * uber_graph_set_show_xlabels: + * @graph: A #UberGraph. + * @show_xlabels: Show x labels. + * + * Sets if the x labels should be shown. + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_set_show_xlabels (UberGraph *graph, /* IN */ + gboolean show_xlabels) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + priv->show_xlabels = show_xlabels; + priv->bg_dirty = TRUE; + uber_graph_calculate_rects(graph); + gtk_widget_queue_draw(GTK_WIDGET(graph)); +} + +/** + * uber_graph_dps_timeout: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: %TRUE always. + * Side effects: None. + */ +static gboolean +uber_graph_dps_timeout (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_val_if_fail(UBER_IS_GRAPH(graph), FALSE); + + priv = graph->priv; + if (!uber_graph_get_next_data(graph)) { + /* + * XXX: How should we handle failed data retrieval. + */ + } + if (G_UNLIKELY(show_fps)) { + g_print("UberGraph[%p] %02d FPS\n", graph, priv->fps_count); + priv->fps_count = 0; + } + /* + * Make sure the content is re-rendered. + */ + if (!priv->paused) { + priv->fg_dirty = TRUE; + /* + * We do not queue a draw here since the next FPS callback will happen + * when it is the right time to show the frame. + */ + } + /* + * Try to downscale the graph. We do this whether or not we are paused + * as redrawing is deferred if we are in a paused state. + */ + priv->dps_downscale++; + if (priv->dps_downscale >= 5) { + if (UBER_GRAPH_GET_CLASS(graph)->downscale) { + if (UBER_GRAPH_GET_CLASS(graph)->downscale(graph)) { + if (!priv->paused) { + uber_graph_redraw(graph); + } + } + } + priv->dps_downscale = 0; + } + return TRUE; +} + +/** + * uber_graph_register_dps_handler: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_register_dps_handler (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + guint dps_freq; + gboolean do_now = TRUE; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + if (priv->dps_handler) { + g_source_remove(priv->dps_handler); + do_now = FALSE; + } + /* + * Calculate the update frequency. + */ + dps_freq = 1000 / priv->dps; + /* + * Install the data handler. + */ + priv->dps_handler = g_timeout_add(dps_freq, + (GSourceFunc)uber_graph_dps_timeout, + graph); + /* + * Call immediately. + */ + if (do_now) { + uber_graph_dps_timeout(graph); + } +} + +/** + * uber_graph_register_fps_handler: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_register_fps_handler (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + /* + * Remove any existing FPS handler. + */ + if (priv->fps_handler) { + g_source_remove(priv->fps_handler); + } + /* + * Install the FPS timeout. + */ + priv->fps_handler = uber_frame_source_add(priv->fps, + (GSourceFunc)uber_graph_fps_timeout, + graph); +} + +/** + * uber_graph_set_dps: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_set_dps (UberGraph *graph, /* IN */ + gfloat dps) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + priv->dps = dps; + /* + * TODO: Does this belong somewhere else? + */ + if (UBER_GRAPH_GET_CLASS(graph)->set_stride) { + UBER_GRAPH_GET_CLASS(graph)->set_stride(graph, priv->x_slots); + } + /* + * Recalculate frame rates and timeouts. + */ + uber_graph_calculate_rects(graph); + uber_graph_register_dps_handler(graph); + uber_graph_register_fps_handler(graph); +} + +/** + * uber_graph_set_fps: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_set_fps (UberGraph *graph, /* IN */ + guint fps) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + priv->fps = fps; + uber_graph_register_fps_handler(graph); +} + +/** + * uber_graph_realize: + * @widget: A #GtkWidget. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_realize (GtkWidget *widget) /* IN */ +{ + UberGraph *graph; + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(widget)); + + graph = UBER_GRAPH(widget); + priv = graph->priv; + WIDGET_CLASS->realize(widget); + /* + * Calculate new layout based on allocation. + */ + uber_graph_calculate_rects(graph); + /* + * Re-initialize textures for updated sizes. + */ + UNSET_SURFACE(priv->bg_surface); + UNSET_SURFACE(priv->fg_surface); + uber_graph_init_bg(graph); + uber_graph_init_texture(graph); + /* + * Notify subclass of current data stride (points per graph). + */ + if (UBER_GRAPH_GET_CLASS(widget)->set_stride) { + UBER_GRAPH_GET_CLASS(widget)->set_stride(UBER_GRAPH(widget), + priv->x_slots); + } + /* + * Install the data collector. + */ + uber_graph_register_dps_handler(graph); +} + +/** + * uber_graph_unrealize: + * @widget: A #GtkWidget. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_unrealize (GtkWidget *widget) /* IN */ +{ + UberGraph *graph; + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(widget)); + + graph = UBER_GRAPH(widget); + priv = graph->priv; + /* + * Unregister any data acquisition handlers. + */ + if (priv->dps_handler) { + g_source_remove(priv->dps_handler); + priv->dps_handler = 0; + } + /* + * Destroy textures. + */ + UNSET_SURFACE(priv->bg_surface); + UNSET_SURFACE(priv->fg_surface); +} + +/** + * uber_graph_screen_changed: + * @widget: A #GtkWidget. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_screen_changed (GtkWidget *widget, /* IN */ + GdkScreen *old_screen) /* IN */ +{ + UberGraphPrivate *priv; + GdkScreen *screen; + GdkVisual *visual; + + g_return_if_fail(UBER_IS_GRAPH(widget)); + + screen = gtk_widget_get_screen (GTK_WIDGET (widget)); + visual = gdk_screen_get_rgba_visual (screen); + + priv = UBER_GRAPH(widget)->priv; + /* + * Check if we have RGBA colormaps available. + */ + priv->have_rgba = visual != NULL; +} + +/** + * uber_graph_show: + * @widget: A #GtkWidget. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_show (GtkWidget *widget) /* IN */ +{ + g_return_if_fail(UBER_IS_GRAPH(widget)); + + WIDGET_CLASS->show(widget); + /* + * Only run the FPS timeout when we are visible. + */ + uber_graph_register_fps_handler(UBER_GRAPH(widget)); +} + +/** + * uber_graph_hide: + * @widget: A #GtkWIdget. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_hide (GtkWidget *widget) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(widget)); + + priv = UBER_GRAPH(widget)->priv; + /* + * Disable the FPS timeout when we are not visible. + */ + if (priv->fps_handler) { + g_source_remove(priv->fps_handler); + priv->fps_handler = 0; + } +} + +static inline void +uber_graph_get_pixmap_rect (UberGraph *graph, /* IN */ + GdkRectangle *rect) /* OUT */ +{ + UberGraphPrivate *priv; + GtkAllocation alloc; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + gtk_widget_get_allocation(GTK_WIDGET(graph), &alloc); + rect->x = 0; + rect->y = 0; + rect->width = MAX(alloc.width, + priv->nonvis_rect.x + priv->nonvis_rect.width); + rect->height = alloc.height; +} + +/** + * uber_graph_render_fg: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_render_fg (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + GtkAllocation alloc; + GdkRectangle rect; + cairo_t *cr; + gfloat each; + gfloat x_epoch; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + /* + * Acquire resources. + */ + priv = graph->priv; + gtk_widget_get_allocation(GTK_WIDGET(graph), &alloc); + uber_graph_get_pixmap_rect(graph, &rect); + cr = cairo_create(priv->fg_surface); + /* + * Render to texture if needed. + */ + if (priv->fg_dirty) { + /* + * Caclulate relative positionings for use in renderers. + */ + each = priv->content_rect.width / (gfloat)(priv->x_slots - 1); + x_epoch = RECT_RIGHT(priv->nonvis_rect); + /* + * If we are in a fast draw, lets copy the content from the other + * buffer at the next offset. + */ + if (!priv->full_draw && UBER_GRAPH_GET_CLASS(graph)->render_fast) { + /* + * Determine next rendering slot. + */ + rect.x = priv->content_rect.x + + (priv->dps_each * priv->dps_slot); + rect.width = priv->dps_each; + rect.y = priv->content_rect.y; + rect.height = priv->content_rect.height; + priv->dps_slot = (priv->dps_slot + 1) % priv->x_slots; + x_epoch = RECT_RIGHT(rect); + /* + * Clear content area. + */ + cairo_save(cr); + cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); + gdk_cairo_rectangle(cr, &rect); + cairo_fill(cr); + cairo_restore(cr); + +#if 0 + /* + * XXX: Draw line helper for debugging. + */ + cairo_save(cr); + cairo_set_source_rgb(cr, .3, .3, .3); + cairo_rectangle(cr, + rect.x, + rect.y + (rect.height / (gfloat)priv->x_slots * priv->dps_slot), + rect.width, + rect.height / priv->x_slots); + cairo_fill(cr); + cairo_restore(cr); +#endif + + /* + * Render new content clipped. + */ + cairo_save(cr); + cairo_reset_clip(cr); + gdk_cairo_rectangle(cr, &rect); + cairo_clip(cr); + /* + * Determine area for this draw. + */ + UBER_GRAPH_GET_CLASS(graph)->render_fast(graph, + cr, + &rect, + x_epoch, + each + .5); + cairo_restore(cr); + } else { + /* + * Clear content area. + */ + cairo_save(cr); + cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); + gdk_cairo_rectangle(cr, &rect); + cairo_fill(cr); + cairo_restore(cr); + /* + * Draw the entire foreground. + */ + if (UBER_GRAPH_GET_CLASS(graph)->render) { + priv->dps_slot = 0; + cairo_save(cr); + gdk_cairo_rectangle(cr, &priv->nonvis_rect); + cairo_clip(cr); + UBER_GRAPH_GET_CLASS(graph)->render(graph, + cr, + &priv->nonvis_rect, + x_epoch, + each); + cairo_restore(cr); + } + } + } + /* + * Foreground is no longer dirty. + */ + priv->fg_dirty = FALSE; + priv->full_draw = FALSE; + /* + * Cleanup. + */ + cairo_destroy(cr); +} + +/** + * uber_graph_redraw: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_redraw (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + priv->fg_dirty = TRUE; + priv->bg_dirty = TRUE; + priv->full_draw = TRUE; + gtk_widget_queue_draw(GTK_WIDGET(graph)); +} + +/** + * uber_graph_get_yrange: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static inline void +uber_graph_get_yrange (UberGraph *graph, /* IN */ + UberRange *range) /* OUT */ +{ + g_return_if_fail(UBER_IS_GRAPH(graph)); + g_return_if_fail(range != NULL); + + memset(range, 0, sizeof(*range)); + if (UBER_GRAPH_GET_CLASS(graph)->get_yrange) { + UBER_GRAPH_GET_CLASS(graph)->get_yrange(graph, range); + } +} + +/** + * uber_graph_set_format: + * @graph: A UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_set_format (UberGraph *graph, /* IN */ + UberGraphFormat format) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + priv->format = format; + priv->bg_dirty = TRUE; + gtk_widget_queue_draw(GTK_WIDGET(graph)); +} + +static void +uber_graph_render_x_axis (UberGraph *graph, /* IN */ + cairo_t *cr) /* IN */ +{ + UberGraphPrivate *priv; + const gdouble dashes[] = { 1.0, 2.0 }; + PangoFontDescription *fd; + PangoLayout *pl; + GtkStyleContext *style; + GdkRGBA fg_color; + gfloat each; + gfloat x; + gfloat y; + gfloat h; + gchar text[16] = { 0 }; + gint count; + gint wi; + gint hi; + gint i; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + style = gtk_widget_get_style_context(GTK_WIDGET(graph)); + gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &fg_color); + + count = priv->x_slots / 10; + each = priv->content_rect.width / (gfloat)count; + /* + * Draw ticks. + */ + cairo_save(cr); + pl = pango_cairo_create_layout(cr); + fd = pango_font_description_new(); + pango_font_description_set_family_static(fd, "Monospace"); + pango_font_description_set_size(fd, 6 * PANGO_SCALE); + pango_layout_set_font_description(pl, fd); + gdk_cairo_set_source_rgba(cr, &fg_color); + cairo_set_line_width(cr, 1.0); + cairo_set_dash(cr, dashes, G_N_ELEMENTS(dashes), 0); + for (i = 0; i <= count; i++) { + x = RECT_RIGHT(priv->content_rect) - (gint)(i * each) + .5; + if (priv->show_xlines && (i != 0 && i != count)) { + y = priv->content_rect.y; + h = priv->content_rect.height + priv->tick_len; + } else { + y = priv->content_rect.y + priv->content_rect.height; + h = priv->tick_len; + } + if (i != 0 && i != count) { + cairo_move_to(cr, x, y); + cairo_line_to(cr, x, y + h); + cairo_stroke(cr); + } + /* + * Render the label. + */ + if (priv->show_xlabels) { + g_snprintf(text, sizeof(text), "%d", i * 10); + pango_layout_set_text(pl, text, -1); + pango_layout_get_pixel_size(pl, &wi, &hi); + if (i != 0 && i != count) { + cairo_move_to(cr, x - (wi / 2), y + h); + } else if (i == 0) { + cairo_move_to(cr, + RECT_RIGHT(priv->content_rect) - (wi / 2), + RECT_BOTTOM(priv->content_rect) + priv->tick_len); + } else if (i == count) { + cairo_move_to(cr, + priv->content_rect.x - (wi / 2), + RECT_BOTTOM(priv->content_rect) + priv->tick_len); + } + pango_cairo_show_layout(cr, pl); + } + } + g_object_unref(pl); + pango_font_description_free(fd); + cairo_restore(cr); +} + +static void G_GNUC_PRINTF(6, 7) +uber_graph_render_y_line (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + gint y, /* IN */ + gboolean tick_only, /* IN */ + gboolean no_label, /* IN */ + const gchar *format, /* IN */ + ...) /* IN */ +{ + UberGraphPrivate *priv; + const gdouble dashes[] = { 1.0, 2.0 }; + PangoFontDescription *fd; + PangoLayout *pl; + GtkStyleContext *style; + GdkRGBA fg_color; + va_list args; + gchar *text; + gint width; + gint height; + gfloat real_y = y + .5; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + g_return_if_fail(cr != NULL); + g_return_if_fail(format != NULL); + + priv = graph->priv; + style = gtk_widget_get_style_context(GTK_WIDGET(graph)); + gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &fg_color); + /* + * Draw grid line. + */ + cairo_save(cr); + cairo_set_dash(cr, dashes, G_N_ELEMENTS(dashes), 0); + cairo_set_line_width(cr, 1.0); + gdk_cairo_set_source_rgba(cr, &fg_color); + cairo_move_to(cr, priv->content_rect.x - priv->tick_len, real_y); + if (tick_only) { + cairo_line_to(cr, priv->content_rect.x, real_y); + } else { + cairo_line_to(cr, RECT_RIGHT(priv->content_rect), real_y); + } + cairo_stroke(cr); + cairo_restore(cr); + /* + * Show label. + */ + if (!no_label) { + cairo_save(cr); + gdk_cairo_set_source_rgba(cr, &fg_color); + /* + * Format text. + */ + va_start(args, format); + text = g_strdup_vprintf(format, args); + va_end(args); + /* + * Render pango layout. + */ + pl = pango_cairo_create_layout(cr); + fd = pango_font_description_new(); + pango_font_description_set_family_static(fd, "Monospace"); + pango_font_description_set_size(fd, 6 * PANGO_SCALE); + pango_layout_set_font_description(pl, fd); + pango_layout_set_text(pl, text, -1); + pango_layout_get_pixel_size(pl, &width, &height); + cairo_move_to(cr, priv->content_rect.x - priv->tick_len - width - 3, + real_y - height / 2); + pango_cairo_show_layout(cr, pl); + /* + * Cleanup resources. + */ + g_free(text); + pango_font_description_free(fd); + g_object_unref(pl); + cairo_restore(cr); + } +} + +static void +uber_graph_render_y_axis_percent (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + UberRange *range, /* IN */ + UberRange *pixel_range, /* IN */ + gint n_lines) /* IN */ +{ + static const gchar format[] = "%0.0f %%"; + UberGraphPrivate *priv; + gdouble value; + gdouble y; + gint i; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + g_return_if_fail(range != NULL); + g_return_if_fail(pixel_range != NULL); + g_return_if_fail(n_lines >= 0); + g_return_if_fail(n_lines < 6); + + priv = graph->priv; + /* + * Render top and bottom lines. + */ + uber_graph_render_y_line(graph, cr, + priv->content_rect.y - 1, + TRUE, FALSE, format, 100.); + uber_graph_render_y_line(graph, cr, + RECT_BOTTOM(priv->content_rect), + TRUE, FALSE, format, 0.); + /* + * Render lines between the edges. + */ + for (i = 1; i < n_lines; i++) { + value = (n_lines - i) / (gfloat)n_lines; + y = pixel_range->end - (pixel_range->range * value); + value *= 100.; + uber_graph_render_y_line(graph, cr, y, + !priv->show_ylines, FALSE, + format, value); + } +} + +/** + * uber_graph_render_y_axis_direct: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_render_y_axis_direct (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + UberRange *range, /* IN */ + UberRange *pixel_range, /* IN */ + gint n_lines, /* IN */ + gboolean kibi) /* IN */ +{ + static const gchar format[] = "%0.1f%s"; + const gchar *modifier = ""; + UberGraphPrivate *priv; + gdouble value; + gdouble y; + gint i; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + +#define CONDENSE(v) \ +G_STMT_START { \ + if (kibi) { \ + if ((v) >= 1073741824.) { \ + (v) /= 1073741824.; \ + modifier = " Gi"; \ + } else if ((v) >= 1048576.) { \ + (v) /= 1048576.; \ + modifier = " Mi"; \ + } else if ((v) >= 1024.) { \ + (v) /= 1024.; \ + modifier = " Ki"; \ + } else { \ + modifier = ""; \ + } \ + } else { \ + if ((v) >= 1000000000.) { \ + (v) /= 1000000000.; \ + modifier = " G"; \ + } else if ((v) >= 1000000.) { \ + (v) /= 1000000.; \ + modifier = " M"; \ + } else if ((v) >= 1000.) { \ + (v) /= 1000.; \ + modifier = " K"; \ + } else { \ + modifier = ""; \ + } \ + } \ +} G_STMT_END + + priv = graph->priv; + /* + * Render top and bottom lines. + */ + value = range->end; + CONDENSE(value); + uber_graph_render_y_line(graph, cr, + priv->content_rect.y - 1, + TRUE, FALSE, format, value, modifier); + value = range->begin; + CONDENSE(value); + uber_graph_render_y_line(graph, cr, + RECT_BOTTOM(priv->content_rect), + TRUE, FALSE, format, value, modifier); + /* + * Render lines between the edges. + */ + for (i = 1; i < n_lines; i++) { + y = value = range->range / (gfloat)(n_lines) * (gfloat)i; + /* + * TODO: Use proper scale. + */ + uber_scale_linear(range, pixel_range, &y, NULL); + if (y == 0 || y == pixel_range->begin || y == pixel_range->end) { + continue; + } + y = pixel_range->end - y; + CONDENSE(value); + uber_graph_render_y_line(graph, cr, y, + !priv->show_ylines, + (range->begin == range->end), + format, value, modifier); + } +} + +/** + * uber_graph_render_y_axis: + * @graph: A #UberGraph. + * + * Render the Y axis grid lines and labels. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_render_y_axis (UberGraph *graph, /* IN */ + cairo_t *cr) /* IN */ +{ + UberGraphPrivate *priv; + UberRange pixel_range; + UberRange range; + gint n_lines; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + /* + * Calculate ranges. + */ + uber_graph_get_yrange(graph, &range); + pixel_range.begin = priv->content_rect.y; + pixel_range.end = priv->content_rect.y + priv->content_rect.height; + pixel_range.range = pixel_range.end - pixel_range.begin; + /* + * Render grid lines for given format. + */ + n_lines = MIN(priv->content_rect.height / 25, 5); + switch (priv->format) { + case UBER_GRAPH_FORMAT_PERCENT: + uber_graph_render_y_axis_percent(graph, cr, &range, &pixel_range, + n_lines); + break; + case UBER_GRAPH_FORMAT_DIRECT: + uber_graph_render_y_axis_direct(graph, cr, &range, &pixel_range, + n_lines, FALSE); + break; + case UBER_GRAPH_FORMAT_DIRECT1024: + uber_graph_render_y_axis_direct(graph, cr, &range, &pixel_range, + n_lines, TRUE); + break; + default: + g_assert_not_reached(); + } +} + +/** + * uber_graph_render_bg: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_render_bg (UberGraph *graph) /* IN */ +{ + const gdouble dashes[] = { 1.0, 2.0 }; + UberGraphPrivate *priv; + GtkAllocation alloc; + GtkStyleContext *style; + GdkRGBA fg_color; + GdkRGBA light_color; + cairo_t *cr; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + /* + * Acquire resources. + */ + priv = graph->priv; + gtk_widget_get_allocation(GTK_WIDGET(graph), &alloc); + style = gtk_widget_get_style_context(GTK_WIDGET(graph)); + gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &fg_color); + gtk_style_context_get_color(style, GTK_STATE_FLAG_SELECTED, &light_color); + cr = cairo_create(priv->bg_surface); + /* + * Ensure valid resources. + */ + g_assert(style); + g_assert(priv->bg_surface); + /* + * Clear entire background. Hopefully this looks okay for RGBA themes + * that are translucent. + */ + cairo_save(cr); + cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); + cairo_rectangle(cr, 0, 0, alloc.width, alloc.height); + cairo_fill(cr); + cairo_restore(cr); + /* + * Paint the content area background. + */ + cairo_save(cr); + gdk_cairo_set_source_rgba(cr, &light_color); + gdk_cairo_rectangle(cr, &priv->content_rect); + cairo_fill(cr); + cairo_restore(cr); + /* + * Stroke the border around the content area. + */ + cairo_save(cr); + gdk_cairo_set_source_rgba(cr, &fg_color); + cairo_set_line_width(cr, 1.0); + cairo_set_dash(cr, dashes, G_N_ELEMENTS(dashes), 0); + cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE); + cairo_rectangle(cr, + priv->content_rect.x - .5, + priv->content_rect.y - .5, + priv->content_rect.width + 1.0, + priv->content_rect.height + 1.0); + cairo_stroke(cr); + cairo_restore(cr); + /* + * Render the axis ticks. + */ + uber_graph_render_y_axis(graph, cr); + uber_graph_render_x_axis(graph, cr); + /* + * Background is no longer dirty. + */ + priv->bg_dirty = FALSE; + /* + * Cleanup. + */ + cairo_destroy(cr); +} + +static inline void +g_time_val_subtract (GTimeVal *a, /* IN */ + GTimeVal *b, /* IN */ + GTimeVal *c) /* OUT */ +{ + g_return_if_fail(a != NULL); + g_return_if_fail(b != NULL); + g_return_if_fail(c != NULL); + + c->tv_sec = a->tv_sec - b->tv_sec; + c->tv_usec = a->tv_usec - b->tv_usec; + if (c->tv_usec < 0) { + c->tv_usec += G_USEC_PER_SEC; + c->tv_sec -= 1; + } +} + +/** + * uber_graph_get_fps_offset: + * @graph: A #UberGraph. + * + * Calculates the number of pixels that the foreground should be rendered + * from the origin. + * + * Returns: The pixel offset to render the foreground. + * Side effects: None. + */ +static gfloat +uber_graph_get_fps_offset (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + GTimeVal rel = { 0 }; + GTimeVal tv; + gfloat f; + + g_return_val_if_fail(UBER_IS_GRAPH(graph), 0.); + + priv = graph->priv; + g_get_current_time(&tv); + g_time_val_subtract(&tv, &priv->dps_tv, &rel); + f = ((rel.tv_sec * 1000) + (rel.tv_usec / 1000)) + / (1000. / priv->dps) /* MSec Per Data Point */ + * priv->dps_each; /* Pixels Per Data Point */ + return MIN(f, (priv->dps_each - priv->fps_each)); +} + +/** + * uber_graph_draw: + * @widget: A #GtkWidget. + * + * XXX + * + * Returns: %FALSE always. + * Side effects: None. + */ +static gboolean +uber_graph_draw (GtkWidget *widget, /* IN */ + cairo_t *cr) /* IN */ +{ + UberGraphPrivate *priv; + GtkAllocation alloc; +// cairo_t *cr; + gfloat offset; + gint x; + + g_return_val_if_fail(UBER_IS_GRAPH(widget), FALSE); + + priv = UBER_GRAPH(widget)->priv; + gtk_widget_get_allocation(widget, &alloc); + priv->fps_count++; + /* + * Ensure that the texture is initialized. + */ + g_assert(priv->fg_surface); + g_assert(priv->bg_surface); + /* + * Clear window background. + */ +#if 0 + gdk_window_clear_area(expose->window, + expose->area.x, + expose->area.y, + expose->area.width, + expose->area.height); + /* + * Allocate resources. + */ + cr = gdk_cairo_create(expose->window); + /* + * Clip to exposure area. + */ + gdk_cairo_rectangle(cr, &expose->area); + cairo_clip(cr); +#endif + /* + * Render background or foreground if needed. + */ + if (priv->bg_dirty) { + uber_graph_render_bg(UBER_GRAPH(widget)); + } + if (priv->fg_dirty) { + uber_graph_render_fg(UBER_GRAPH(widget)); + } + /* + * Paint the background to the exposure area. + */ + cairo_save(cr); + cairo_set_source_surface(cr, priv->bg_surface, 0, 0); + cairo_rectangle(cr, 0, 0, alloc.width, alloc.height); + cairo_fill(cr); + cairo_restore(cr); + /* + * Draw the foreground. + */ + offset = uber_graph_get_fps_offset(UBER_GRAPH(widget)); + if (priv->have_rgba) { + cairo_save(cr); + /* + * Clip exposure to the content area. + */ + cairo_reset_clip(cr); + gdk_cairo_rectangle(cr, &priv->content_rect); + cairo_clip(cr); + /* + * Data in the fg surface is a ring bufer. Render the first portion + * at its given offset. + */ + x = ((priv->x_slots - priv->dps_slot) * priv->dps_each) - offset; + cairo_set_source_surface(cr, priv->fg_surface, (gint)x, 0); + gdk_cairo_rectangle(cr, &priv->content_rect); + cairo_fill(cr); + /* + * Render the second part of the ring surface buffer. + */ + x = (priv->dps_each * -priv->dps_slot) - offset; + cairo_set_source_surface(cr, priv->fg_surface, (gint)x, 0); + gdk_cairo_rectangle(cr, &priv->content_rect); + cairo_fill(cr); + /* + * Cleanup. + */ + cairo_restore(cr); + } else { + /* + * TODO: Use XOR command for fallback. + */ + g_warn_if_reached(); + } + /* + * Cleanup resources. + */ + //cairo_destroy(cr); + return FALSE; +} + +/** + * uber_graph_style_set: + * @widget: A #GtkWidget. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_style_set (GtkWidget *widget, /* IN */ + GtkStyle *old_style) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(widget)); + + priv = UBER_GRAPH(widget)->priv; + WIDGET_CLASS->style_set(widget, old_style); + priv->fg_dirty = TRUE; + priv->bg_dirty = TRUE; + gtk_widget_queue_draw(widget); +} + +/** + * uber_graph_size_allocate: + * @widget: A #GtkWidget. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_size_allocate (GtkWidget *widget, /* IN */ + GtkAllocation *alloc) /* IN */ +{ + UberGraph *graph; + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(widget)); + + graph = UBER_GRAPH(widget); + priv = graph->priv; + WIDGET_CLASS->size_allocate(widget, alloc); + /* + * If there is no window yet, we can defer setup. + */ + if (!gtk_widget_get_window(widget)) { + return; + } + /* + * Recalculate rectangles. + */ + uber_graph_calculate_rects(graph); + /* + * Recreate server side surface. + */ + UNSET_SURFACE(priv->bg_surface); + UNSET_SURFACE(priv->fg_surface); + uber_graph_init_bg(graph); + uber_graph_init_texture(graph); + /* + * Mark foreground and background as dirty. + */ + priv->fg_dirty = TRUE; + priv->bg_dirty = TRUE; + priv->full_draw = TRUE; + gtk_widget_queue_draw(widget); +} + +static void +uber_graph_size_request (GtkWidget *widget, /* IN */ + GtkRequisition *req) /* OUT */ +{ + g_return_if_fail(req != NULL); + + req->width = 150; + req->height = 50; +} + +static void +uber_graph_get_preferred_width (GtkWidget *widget, /* IN */ + gint *minimal_width, + gint *natural_width) +{ + GtkRequisition requisition; + uber_graph_size_request(widget, &requisition); + *minimal_width = * natural_width = requisition.width; +} + +static void +uber_graph_get_preferred_height (GtkWidget *widget, /* IN */ + gint *minimal_height, + gint *natural_height) +{ + GtkRequisition requisition; + uber_graph_size_request(widget, &requisition); + *minimal_height = * natural_height = requisition.height; +} + +/** + * uber_graph_add_label: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_graph_add_label (UberGraph *graph, /* IN */ + UberLabel *label) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + g_return_if_fail(UBER_IS_LABEL(label)); + + priv = graph->priv; + gtk_box_pack_start(GTK_BOX(priv->labels), GTK_WIDGET(label), + TRUE, TRUE, 0); + gtk_widget_show(GTK_WIDGET(label)); +} + +/** + * uber_graph_take_screenshot: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_take_screenshot (UberGraph *graph) /* IN */ +{ + GtkWidget *widget; + GtkWidget *dialog; + GtkAllocation alloc; + const gchar *filename; + cairo_status_t status; + cairo_surface_t *surface; + cairo_t *cr; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + widget = GTK_WIDGET(graph); + gtk_widget_get_allocation(widget, &alloc); + + /* + * Create save dialog and ask user for filename. + */ + dialog = gtk_file_chooser_dialog_new(_("Save As"), + GTK_WINDOW(gtk_widget_get_toplevel(widget)), + GTK_FILE_CHOOSER_ACTION_SAVE, + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_Save"), GTK_RESPONSE_ACCEPT, + NULL); + if (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) { + /* + * Create surface and cairo context. + */ + surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, + alloc.width, alloc.height); + cr = cairo_create(surface); + cairo_rectangle(cr, 0, 0, alloc.width, alloc.height); + cairo_clip(cr); + + /* Paint to the image surface instead of the screen */ + uber_graph_draw(widget, cr); + + /* + * Save surface to png. + */ + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + status = cairo_surface_write_to_png(surface, filename); + if (status != CAIRO_STATUS_SUCCESS) { + g_critical("Failed to save pixmap to file."); + goto cleanup; + } + /* + * Cleanup resources. + */ + cleanup: + cairo_destroy(cr); + cairo_surface_destroy(surface); + } + gtk_widget_destroy(dialog); +} + +/** + * uber_graph_toggle_paused: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_toggle_paused (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = graph->priv; + priv->paused = !priv->paused; + if (priv->fps_handler) { + g_source_remove(priv->fps_handler); + priv->fps_handler = 0; + } else { + if (!priv->paused) { + uber_graph_redraw(graph); + } + uber_graph_register_fps_handler(graph); + } +} + +/** + * uber_graph_button_press: + * @widget: A #GtkWidget. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static gboolean +uber_graph_button_press_event (GtkWidget *widget, /* IN */ + GdkEventButton *button) /* IN */ +{ + g_return_val_if_fail(UBER_IS_GRAPH(widget), FALSE); + + switch (button->button) { + case 2: /* Middle Click */ + if (button->state & GDK_CONTROL_MASK) { + uber_graph_take_screenshot(UBER_GRAPH(widget)); + } else { + uber_graph_toggle_paused(UBER_GRAPH(widget)); + } + break; + default: + break; + } + return FALSE; +} + +/** + * uber_graph_finalize: + * @object: A #UberGraph. + * + * Finalizer for a #UberGraph instance. Frees any resources held by + * the instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_finalize (GObject *object) /* IN */ +{ + G_OBJECT_CLASS(uber_graph_parent_class)->finalize(object); +} + +/** + * uber_graph_dispose: + * @object: A #GObject. + * + * Dispose callback for @object. This method releases references held + * by the #GObject instance. + * + * Returns: None. + * Side effects: Plenty. + */ +static void +uber_graph_dispose (GObject *object) /* IN */ +{ + UberGraph *graph; + UberGraphPrivate *priv; + + graph = UBER_GRAPH(object); + priv = graph->priv; + /* + * Stop any timeout handlers. + */ + if (priv->fps_handler) { + g_source_remove(priv->fps_handler); + } + if (priv->dps_handler) { + g_source_remove(priv->dps_handler); + } + /* + * Destroy textures. + */ + UNSET_SURFACE(priv->bg_surface); + UNSET_SURFACE(priv->fg_surface); + /* + * Call base class. + */ + G_OBJECT_CLASS(uber_graph_parent_class)->dispose(object); +} + +/** + * uber_graph_set_property: + * @object: (in): A #GObject. + * @prop_id: (in): The property identifier. + * @value: (out): The given property. + * @pspec: (in): A #ParamSpec. + * + * Get a given #GObject property. + */ +static void +uber_graph_get_property (GObject *object, /* IN */ + guint prop_id, /* IN */ + GValue *value, /* OUT */ + GParamSpec *pspec) /* IN */ +{ + UberGraph *graph = UBER_GRAPH(object); + + switch (prop_id) { + case PROP_FORMAT: + g_value_set_uint(value, graph->priv->format); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + } +} + +/** + * uber_graph_set_property: + * @object: (in): A #GObject. + * @prop_id: (in): The property identifier. + * @value: (in): The given property. + * @pspec: (in): A #ParamSpec. + * + * Set a given #GObject property. + */ +static void +uber_graph_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + UberGraph *graph = UBER_GRAPH(object); + + switch (prop_id) { + case PROP_FORMAT: + uber_graph_set_format(graph, g_value_get_uint(value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + } +} + +/** + * uber_graph_class_init: + * @klass: A #UberGraphClass. + * + * Initializes the #UberGraphClass and prepares the vtable. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_class_init (UberGraphClass *klass) /* IN */ +{ + GObjectClass *object_class; + GtkWidgetClass *widget_class; + + object_class = G_OBJECT_CLASS(klass); + object_class->dispose = uber_graph_dispose; + object_class->finalize = uber_graph_finalize; + object_class->get_property = uber_graph_get_property; + object_class->set_property = uber_graph_set_property; + + widget_class = GTK_WIDGET_CLASS(klass); + widget_class->draw = uber_graph_draw; + widget_class->hide = uber_graph_hide; + widget_class->realize = uber_graph_realize; + widget_class->screen_changed = uber_graph_screen_changed; + widget_class->show = uber_graph_show; + widget_class->size_allocate = uber_graph_size_allocate; + widget_class->style_set = uber_graph_style_set; + widget_class->unrealize = uber_graph_unrealize; + widget_class->get_preferred_width = uber_graph_get_preferred_width; + widget_class->get_preferred_height = uber_graph_get_preferred_height; + widget_class->button_press_event = uber_graph_button_press_event; + + show_fps = !!g_getenv("UBER_SHOW_FPS"); + + /* + * FIXME: Use enum. + */ + g_object_class_install_property(object_class, + PROP_FORMAT, + g_param_spec_uint("format", + "format", + "format", + 0, + UBER_GRAPH_FORMAT_PERCENT, + 0, + G_PARAM_READWRITE)); +} + +/** + * uber_graph_init: + * @graph: A #UberGraph. + * + * Initializes the newly created #UberGraph instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_graph_init (UberGraph *graph) /* IN */ +{ + UberGraphPrivate *priv; + + /* + * Store pointer to private data allocation. + */ + graph->priv = uber_graph_get_instance_private(graph); + + priv = graph->priv; + /* + * Enable required events. + */ + gtk_widget_set_events(GTK_WIDGET(graph), GDK_BUTTON_PRESS_MASK); + /* + * Prepare default values. + */ + priv->tick_len = 10; + priv->fps = 20; + priv->fps_real = 1000. / priv->fps; + priv->dps = 1.; + priv->x_slots = 60; + priv->fg_dirty = TRUE; + priv->bg_dirty = TRUE; + priv->full_draw = TRUE; + priv->show_xlines = TRUE; + priv->show_ylines = TRUE; + /* + * TODO: Support labels in a grid. + */ + priv->labels = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); + gtk_box_set_homogeneous (GTK_BOX(priv->labels), TRUE); + priv->align = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); + gtk_container_add(GTK_CONTAINER(priv->align), priv->labels); + gtk_widget_show(priv->labels); +} diff --git a/deps/uber-graph/uber-graph.h b/deps/uber-graph/uber-graph.h new file mode 100644 index 00000000..2c452d25 --- /dev/null +++ b/deps/uber-graph/uber-graph.h @@ -0,0 +1,104 @@ +/* uber-graph.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_GRAPH_H__ +#define __UBER_GRAPH_H__ + +#include <gtk/gtk.h> + +#include "uber-range.h" +#include "uber-label.h" + +G_BEGIN_DECLS + +#define UBER_TYPE_GRAPH (uber_graph_get_type()) +#define UBER_GRAPH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_GRAPH, UberGraph)) +#define UBER_GRAPH_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_GRAPH, UberGraph const)) +#define UBER_GRAPH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UBER_TYPE_GRAPH, UberGraphClass)) +#define UBER_IS_GRAPH(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UBER_TYPE_GRAPH)) +#define UBER_IS_GRAPH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UBER_TYPE_GRAPH)) +#define UBER_GRAPH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UBER_TYPE_GRAPH, UberGraphClass)) + +typedef enum +{ + UBER_GRAPH_FORMAT_DIRECT, + UBER_GRAPH_FORMAT_DIRECT1024, + UBER_GRAPH_FORMAT_PERCENT, +} UberGraphFormat; + +typedef struct _UberGraph UberGraph; +typedef struct _UberGraphClass UberGraphClass; +typedef struct _UberGraphPrivate UberGraphPrivate; + +struct _UberGraph +{ + GtkDrawingArea parent; + + /*< private >*/ + UberGraphPrivate *priv; +}; + +struct _UberGraphClass +{ + GtkDrawingAreaClass parent_class; + + gboolean (*downscale) (UberGraph *graph); + gboolean (*get_next_data) (UberGraph *graph); + void (*get_yrange) (UberGraph *graph, + UberRange *range); + void (*render) (UberGraph *graph, + cairo_t *cairo, + GdkRectangle *content_area, + guint epoch, + gfloat each); + void (*render_fast) (UberGraph *graph, + cairo_t *cairo, + GdkRectangle *content_area, + guint epoch, + gfloat each); + void (*set_stride) (UberGraph *graph, + guint stride); +}; + +GType uber_graph_get_type (void) G_GNUC_CONST; +void uber_graph_set_dps (UberGraph *graph, + gfloat dps); +void uber_graph_set_fps (UberGraph *graph, + guint fps); +void uber_graph_redraw (UberGraph *graph); +void uber_graph_set_format (UberGraph *graph, + UberGraphFormat format); +GtkWidget* uber_graph_get_labels (UberGraph *graph); +void uber_graph_get_content_area (UberGraph *graph, + GdkRectangle *rect); +void uber_graph_add_label (UberGraph *graph, + UberLabel *label); +gboolean uber_graph_get_show_xlines (UberGraph *graph); +void uber_graph_set_show_xlines (UberGraph *graph, + gboolean show_xlines); +gboolean uber_graph_get_show_xlabels (UberGraph *graph); +void uber_graph_set_show_xlabels (UberGraph *graph, + gboolean show_xlabels); +gboolean uber_graph_get_show_ylines (UberGraph *graph); +void uber_graph_set_show_ylines (UberGraph *graph, + gboolean show_ylines); +void uber_graph_scale_changed (UberGraph *graph); + +G_END_DECLS + +#endif /* __UBER_GRAPH_H__ */ diff --git a/deps/uber-graph/uber-heat-map.c b/deps/uber-graph/uber-heat-map.c new file mode 100644 index 00000000..6c2caa3b --- /dev/null +++ b/deps/uber-graph/uber-heat-map.c @@ -0,0 +1,347 @@ +/* uber-heat-map.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <string.h> + +#include "uber-heat-map.h" +#include "g-ring.h" + +/** + * SECTION:uber-heat-map.h + * @title: UberHeatMap + * @short_description: + * + * Section overview. + */ + +struct _UberHeatMapPrivate +{ + GRing *raw_data; + gboolean fg_color_set; + GdkRGBA fg_color; + UberHeatMapFunc func; + GDestroyNotify func_destroy; + gpointer func_user_data; +}; + +G_DEFINE_TYPE_WITH_PRIVATE(UberHeatMap, uber_heat_map, UBER_TYPE_GRAPH) + + +/** + * uber_heat_map_new: + * + * Creates a new instance of #UberHeatMap. + * + * Returns: the newly created instance of #UberHeatMap. + * Side effects: None. + */ +GtkWidget* +uber_heat_map_new (void) +{ + UberHeatMap *map; + + map = g_object_new(UBER_TYPE_HEAT_MAP, NULL); + return GTK_WIDGET(map); +} + +/** + * uber_heat_map_destroy_array: + * @array: A #GArray. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_heat_map_destroy_array (gpointer data) /* IN */ +{ + GArray **ar = data; + + if (ar) { + g_array_unref(*ar); + } +} + +/** + * uber_heat_map_set_stride: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_heat_map_set_stride (UberGraph *graph, /* IN */ + guint stride) /* IN */ +{ + UberHeatMapPrivate *priv; + + g_return_if_fail(UBER_IS_HEAT_MAP(graph)); + + priv = UBER_HEAT_MAP(graph)->priv; + if (priv->raw_data) { + g_ring_unref(priv->raw_data); + } + priv->raw_data = g_ring_sized_new(sizeof(GArray*), stride, + uber_heat_map_destroy_array); +} + +/** + * uber_heat_map_set_data_func: + * @map: A #UberHeatMap. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_heat_map_set_data_func (UberHeatMap *map, /* IN */ + UberHeatMapFunc func, /* IN */ + gpointer user_data, /* IN */ + GDestroyNotify destroy) /* IN */ +{ + UberHeatMapPrivate *priv; + + g_return_if_fail(UBER_IS_HEAT_MAP(map)); + + priv = map->priv; + if (priv->func_destroy) { + priv->func_destroy(priv->func_user_data); + } + priv->func = func; + priv->func_destroy = destroy; + priv->func_user_data = user_data; +} + +/** + * uber_heat_map_render: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_heat_map_render (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + GdkRectangle *area, /* IN */ + guint epoch, /* IN */ + gfloat each) /* IN */ +{ +#if 0 + UberGraphPrivate *priv; + cairo_pattern_t *cp; + + g_return_if_fail(UBER_IS_HEAT_MAP(graph)); + + priv = graph->priv; + /* + * XXX: Temporarily draw a nice little gradient to test sliding. + */ + cp = cairo_pattern_create_linear(0, 0, area->width, 0); + cairo_pattern_add_color_stop_rgb(cp, 0, .1, .1, .1); + cairo_pattern_add_color_stop_rgb(cp, .2, .3, .3, .5); + cairo_pattern_add_color_stop_rgb(cp, .4, .2, .7, .4); + cairo_pattern_add_color_stop_rgb(cp, .7, .6, .2, .1); + cairo_pattern_add_color_stop_rgb(cp, .8, .6, .8, .1); + cairo_pattern_add_color_stop_rgb(cp, 1., .3, .8, .5); + gdk_cairo_rectangle(cr, area); + cairo_set_source(cr, cp); + cairo_fill(cr); + cairo_pattern_destroy(cp); +#endif +} + +/** + * uber_heat_map_render_fast: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_heat_map_render_fast (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + GdkRectangle *area, /* IN */ + guint epoch, /* IN */ + gfloat each) /* IN */ +{ + UberHeatMapPrivate *priv; + GtkStyleContext *style; + GdkRGBA color; + gfloat height; + gint i; + + g_return_if_fail(UBER_IS_HEAT_MAP(graph)); + + priv = UBER_HEAT_MAP(graph)->priv; + color = priv->fg_color; + if (!priv->fg_color_set) { + style = gtk_widget_get_style_context(GTK_WIDGET(graph)); + gtk_style_context_get_color(style, GTK_STATE_FLAG_SELECTED, &color); + } + /* + * XXX: Temporarily draw nice little squares. + */ + #define COUNT 10 + height = area->height / (gfloat)COUNT; + for (i = 0; i < COUNT; i++) { + cairo_rectangle(cr, + area->x + area->width - each, + area->y + (i * height), + each, + height); + cairo_set_source_rgba(cr, + color.red, + color.green, + color.blue, + g_random_double_range(0., 1.)); + cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE); + cairo_fill(cr); + } +} + +/** + * uber_heat_map_get_next_data: + * @graph: A #UberGraph. + * + * Retrieve the next data point for the graph. + * + * Returns: None. + * Side effects: None. + */ +static gboolean +uber_heat_map_get_next_data (UberGraph *graph) /* IN */ +{ + UberHeatMapPrivate *priv; + GArray *array = NULL; + + g_return_val_if_fail(UBER_IS_HEAT_MAP(graph), FALSE); + + priv = UBER_HEAT_MAP(graph)->priv; + if (!priv->func) { + return FALSE; + } + /* + * Retrieve the next data point. + */ + if (!priv->func(UBER_HEAT_MAP(graph), &array, priv->func_user_data)) { + return FALSE; + } + /* + * Store data points. + */ + g_ring_append_val(priv->raw_data, array); +// for (int i = 0; i < array->len; i++) { +// g_print("==> %f\n", g_array_index(array, gdouble, i)); +// } + return TRUE; +} + +/** + * uber_heat_map_set_fg_color: + * @map: A #UberHeatMap. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_heat_map_set_fg_color (UberHeatMap *map, /* IN */ + const GdkRGBA *color) /* IN */ +{ + UberHeatMapPrivate *priv; + + g_return_if_fail(UBER_IS_HEAT_MAP(map)); + + priv = map->priv; + if (!color) { + priv->fg_color_set = FALSE; + memset(&priv->fg_color, 0, sizeof(priv->fg_color)); + } else { + priv->fg_color = *color; + priv->fg_color_set = TRUE; + } +} + +/** + * uber_heat_map_finalize: + * @object: A #UberHeatMap. + * + * Finalizer for a #UberHeatMap instance. Frees any resources held by + * the instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_heat_map_finalize (GObject *object) /* IN */ +{ + G_OBJECT_CLASS(uber_heat_map_parent_class)->finalize(object); +} + +/** + * uber_heat_map_class_init: + * @klass: A #UberHeatMapClass. + * + * Initializes the #UberHeatMapClass and prepares the vtable. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_heat_map_class_init (UberHeatMapClass *klass) /* IN */ +{ + GObjectClass *object_class; + UberGraphClass *graph_class; + + object_class = G_OBJECT_CLASS(klass); + object_class->finalize = uber_heat_map_finalize; + + graph_class = UBER_GRAPH_CLASS(klass); + graph_class->render = uber_heat_map_render; + graph_class->render_fast = uber_heat_map_render_fast; + graph_class->set_stride = uber_heat_map_set_stride; + graph_class->get_next_data = uber_heat_map_get_next_data; +} + +/** + * uber_heat_map_init: + * @map: A #UberHeatMap. + * + * Initializes the newly created #UberHeatMap instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_heat_map_init (UberHeatMap *map) /* IN */ +{ + map->priv = uber_heat_map_get_instance_private(map); +} diff --git a/deps/uber-graph/uber-heat-map.h b/deps/uber-graph/uber-heat-map.h new file mode 100644 index 00000000..fb1bd2bd --- /dev/null +++ b/deps/uber-graph/uber-heat-map.h @@ -0,0 +1,66 @@ +/* uber-heat-map.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_HEAT_MAP_H__ +#define __UBER_HEAT_MAP_H__ + +#include "uber-graph.h" + +G_BEGIN_DECLS + +#define UBER_TYPE_HEAT_MAP (uber_heat_map_get_type()) +#define UBER_HEAT_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_HEAT_MAP, UberHeatMap)) +#define UBER_HEAT_MAP_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_HEAT_MAP, UberHeatMap const)) +#define UBER_HEAT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UBER_TYPE_HEAT_MAP, UberHeatMapClass)) +#define UBER_IS_HEAT_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UBER_TYPE_HEAT_MAP)) +#define UBER_IS_HEAT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UBER_TYPE_HEAT_MAP)) +#define UBER_HEAT_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UBER_TYPE_HEAT_MAP, UberHeatMapClass)) + +typedef struct _UberHeatMap UberHeatMap; +typedef struct _UberHeatMapClass UberHeatMapClass; +typedef struct _UberHeatMapPrivate UberHeatMapPrivate; + +typedef gboolean (*UberHeatMapFunc) (UberHeatMap *map, + GArray **values, + gpointer user_data); + +struct _UberHeatMap +{ + UberGraph parent; + + /*< private >*/ + UberHeatMapPrivate *priv; +}; + +struct _UberHeatMapClass +{ + UberGraphClass parent_class; +}; + +GType uber_heat_map_get_type (void) G_GNUC_CONST; +GtkWidget* uber_heat_map_new (void); +void uber_heat_map_set_fg_color (UberHeatMap *map, + const GdkRGBA *color); +void uber_heat_map_set_data_func (UberHeatMap *map, + UberHeatMapFunc func, + gpointer user_data, + GDestroyNotify destroy); + +G_END_DECLS + +#endif /* __UBER_HEAT_MAP_H__ */ diff --git a/deps/uber-graph/uber-label.c b/deps/uber-graph/uber-label.c new file mode 100644 index 00000000..abc865fc --- /dev/null +++ b/deps/uber-graph/uber-label.c @@ -0,0 +1,395 @@ +/* uber-label.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <glib/gi18n.h> + +#include "uber-label.h" + +/** + * SECTION:uber-label.h + * @title: UberLabel + * @short_description: + * + * Section overview. + */ + + +struct _UberLabelPrivate +{ + GtkWidget *hbox; + GtkWidget *block; + GtkWidget *label; + GdkRGBA color; + gboolean in_block; +}; + +G_DEFINE_TYPE_WITH_PRIVATE(UberLabel, uber_label, GTK_TYPE_WIDGET) + +enum +{ + COLOR_CHANGED, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_COLOR, + PROP_TEXT, +}; + +static guint signals[LAST_SIGNAL] = { 0 }; + +/** + * uber_label_new: + * + * Creates a new instance of #UberLabel. + * + * Returns: the newly created instance of #UberLabel. + * Side effects: None. + */ +GtkWidget* +uber_label_new (void) +{ + UberLabel *label; + + label = g_object_new(UBER_TYPE_LABEL, NULL); + return GTK_WIDGET(label); +} + +/** + * uber_label_set_text: + * @label: A #UberLabel. + * @text: The label text. + * + * Sets the text for the label. + * + * Returns: None. + * Side effects: None. + */ +void +uber_label_set_text (UberLabel *label, /* IN */ + const gchar *text) /* IN */ +{ + UberLabelPrivate *priv; + + g_return_if_fail(UBER_IS_LABEL(label)); + + priv = label->priv; + gtk_label_set_text(GTK_LABEL(priv->label), text); +} + +/** + * uber_label_set_color: + * @label: A #UberLabel. + * @color: A #GdkRGBA. + * + * Sets the color of the label. + * + * Returns: None. + * Side effects: None. + */ +void +uber_label_set_color (UberLabel *label, /* IN */ + const GdkRGBA *color) /* IN */ +{ + UberLabelPrivate *priv; + + g_return_if_fail(UBER_IS_LABEL(label)); + + priv = label->priv; + priv->color = *color; +} + +static void +uber_label_block_draw (GtkWidget *block, /* IN */ + cairo_t *cr, /* IN */ + UberLabel *label) /* IN */ +{ + UberLabelPrivate *priv; + GtkAllocation alloc; + + g_return_if_fail(UBER_IS_LABEL(label)); + + priv = label->priv; + gtk_widget_get_allocation(block, &alloc); + /* + * Draw background. + */ + gdk_cairo_set_source_rgba(cr, &priv->color); + cairo_rectangle(cr, .5, .5, alloc.width - 1., alloc.height - 1.); + cairo_fill_preserve(cr); + /* + * Add highlight if mouse is in the block. + */ + if (priv->in_block) { + cairo_set_source_rgba(cr, 1., 1., 1., .3); + cairo_fill_preserve(cr); + } + /* + * Stroke the edge of the block. + */ + cairo_set_line_width(cr, 1.0); + cairo_set_source_rgba(cr, 0., 0., 0., .5); + cairo_stroke(cr); + /* + * Stroke the highlight of the block. + */ + cairo_rectangle(cr, 1.5, 1.5, alloc.width - 3., alloc.height - 3.); + cairo_set_source_rgba(cr, 1., 1., 1., .5); + cairo_stroke(cr); +} + +/** + * uber_label_block_enter_notify_event: + * @label: A #UberLabel. + * + * Tracks the mouse entering the block widget. + * + * Returns: %FALSE to allow further callbacks. + * Side effects: None. + */ +static gboolean +uber_label_block_enter_notify_event (GtkWidget *widget, /* IN */ + GdkEventCrossing *event, /* IN */ + UberLabel *label) /* IN */ +{ + UberLabelPrivate *priv; + + priv = label->priv; + priv->in_block = TRUE; + gtk_widget_queue_draw(widget); + return FALSE; +} + +/** + * uber_label_block_leave_notify_event: + * @label: A #UberLabel. + * + * Tracks the mouse leaving the block widget. + * + * Returns: %FALSE to allow further callbacks. + * Side effects: None. + */ +static gboolean +uber_label_block_leave_notify_event (GtkWidget *widget, /* IN */ + GdkEventCrossing *event, /* IN */ + UberLabel *label) /* IN */ +{ + UberLabelPrivate *priv; + + priv = label->priv; + priv->in_block = FALSE; + gtk_widget_queue_draw(widget); + return FALSE; +} + +/** + * uber_label_block_button_press_event: + * @widget: A #GtkWidget. + * @event: A #GdkEventButton. + * @label: An #UberLabel. + * + * Callback to handle a button press event within the colored block. + * + * Returns: %FALSE always to allow further signal emission. + * Side effects: None. + */ +static gboolean +uber_label_block_button_press_event (GtkWidget *widget, /* IN */ + GdkEventButton *event, /* IN */ + UberLabel *label) /* IN */ +{ + UberLabelPrivate *priv; + GtkWidget *dialog; + + g_return_val_if_fail(UBER_IS_LABEL(label), FALSE); + + priv = label->priv; + dialog = gtk_color_chooser_dialog_new("", GTK_WINDOW(gtk_widget_get_toplevel(widget))); + gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(dialog), TRUE); + gtk_color_chooser_set_rgba( + GTK_COLOR_CHOOSER(dialog), + &priv->color); + if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { + gtk_color_chooser_get_rgba( + GTK_COLOR_CHOOSER(dialog), + &priv->color); + gtk_widget_queue_draw(widget); + g_signal_emit(label, signals[COLOR_CHANGED], + 0, &priv->color); + } + gtk_widget_destroy(dialog); + return FALSE; +} + +/** + * uber_label_set_property: + * @object: (in): A #GObject. + * @prop_id: (in): The property identifier. + * @value: (in): The given property. + * @pspec: (in): A #ParamSpec. + * + * Set a given #GObject property. + */ +static void +uber_label_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + UberLabel *label = UBER_LABEL(object); + + switch (prop_id) { + case PROP_COLOR: + uber_label_set_color(label, g_value_get_boxed(value)); + break; + case PROP_TEXT: + uber_label_set_text(label, g_value_get_string(value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + } +} + +/** + * uber_label_finalize: + * @object: A #UberLabel. + * + * Finalizer for a #UberLabel instance. Frees any resources held by + * the instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_label_finalize (GObject *object) /* IN */ +{ + G_OBJECT_CLASS(uber_label_parent_class)->finalize(object); +} + +/** + * uber_label_class_init: + * @klass: A #UberLabelClass. + * + * Initializes the #UberLabelClass and prepares the vtable. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_label_class_init (UberLabelClass *klass) /* IN */ +{ + GObjectClass *object_class; + + object_class = G_OBJECT_CLASS(klass); + object_class->finalize = uber_label_finalize; + object_class->set_property = uber_label_set_property; + + g_object_class_install_property(object_class, + PROP_COLOR, + g_param_spec_boxed("color", + "color", + "color", + GDK_TYPE_RGBA, + G_PARAM_WRITABLE)); + + g_object_class_install_property(object_class, + PROP_TEXT, + g_param_spec_string("text", + "text", + "text", + NULL, + G_PARAM_WRITABLE)); + + /** + * UberLabel::color-changed: + * @label: An #UberLabel. + * @color: A #GdkRGBA. + * + * Signal emitted when the color is changed. + */ + signals[COLOR_CHANGED] = g_signal_new("color-changed", + UBER_TYPE_LABEL, + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + g_cclosure_marshal_VOID__POINTER, + G_TYPE_NONE, + 1, + G_TYPE_POINTER); +} + +/** + * uber_label_init: + * @label: A #UberLabel. + * + * Initializes the newly created #UberLabel instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_label_init (UberLabel *label) /* IN */ +{ + UberLabelPrivate *priv; + + label->priv = uber_label_get_instance_private(label); + + priv = label->priv; + priv->hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); + priv->block = gtk_drawing_area_new(); + priv->label = gtk_label_new(NULL); + gdk_rgba_parse(&priv->color, "#cc0000"); + gtk_widget_set_halign(GTK_WIDGET(priv->label), GTK_ALIGN_START); + gtk_widget_set_valign(GTK_WIDGET(priv->label), GTK_ALIGN_CENTER); + gtk_widget_set_size_request(priv->block, 32, 17); + gtk_container_add(GTK_CONTAINER(label), priv->hbox); + gtk_box_pack_start(GTK_BOX(priv->hbox), priv->block, FALSE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(priv->hbox), priv->label, TRUE, TRUE, 0); + gtk_widget_add_events(priv->block, + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK | + GDK_BUTTON_PRESS_MASK); + g_signal_connect(priv->block, + "draw", + G_CALLBACK(uber_label_block_draw), + label); + g_signal_connect(priv->block, + "enter-notify-event", + G_CALLBACK(uber_label_block_enter_notify_event), + label); + g_signal_connect(priv->block, + "leave-notify-event", + G_CALLBACK(uber_label_block_leave_notify_event), + label); + g_signal_connect(priv->block, + "button-press-event", + G_CALLBACK(uber_label_block_button_press_event), + label); + gtk_widget_set_tooltip_text(GTK_WIDGET(priv->block), + _("Click to select color")); + gtk_widget_show(priv->hbox); + gtk_widget_show(priv->block); + gtk_widget_show(priv->label); +} diff --git a/deps/uber-graph/uber-label.h b/deps/uber-graph/uber-label.h new file mode 100644 index 00000000..8c4c74f5 --- /dev/null +++ b/deps/uber-graph/uber-label.h @@ -0,0 +1,60 @@ +/* uber-label.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_LABEL_H__ +#define __UBER_LABEL_H__ + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define UBER_TYPE_LABEL (uber_label_get_type()) +#define UBER_LABEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_LABEL, UberLabel)) +#define UBER_LABEL_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_LABEL, UberLabel const)) +#define UBER_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UBER_TYPE_LABEL, UberLabelClass)) +#define UBER_IS_LABEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UBER_TYPE_LABEL)) +#define UBER_IS_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UBER_TYPE_LABEL)) +#define UBER_LABEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UBER_TYPE_LABEL, UberLabelClass)) + +typedef struct _UberLabel UberLabel; +typedef struct _UberLabelClass UberLabelClass; +typedef struct _UberLabelPrivate UberLabelPrivate; + +struct _UberLabel +{ + GtkAlignment parent; + + /*< private >*/ + UberLabelPrivate *priv; +}; + +struct _UberLabelClass +{ + GtkAlignmentClass parent_class; +}; + +GType uber_label_get_type (void) G_GNUC_CONST; +GtkWidget* uber_label_new (void); +void uber_label_set_color (UberLabel *label, + const GdkRGBA *color); +void uber_label_set_text (UberLabel *label, + const gchar *text); + +G_END_DECLS + +#endif /* __UBER_LABEL_H__ */ diff --git a/deps/uber-graph/uber-line-graph.c b/deps/uber-graph/uber-line-graph.c new file mode 100644 index 00000000..776f5363 --- /dev/null +++ b/deps/uber-graph/uber-line-graph.c @@ -0,0 +1,1028 @@ +/* uber-line-graph.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <math.h> +#include <string.h> + +#include "uber-line-graph.h" +#include "uber-range.h" +#include "uber-scale.h" +#include "g-ring.h" + +#define RECT_BOTTOM(r) ((r).y + (r).height) +#define RECT_RIGHT(r) ((r).x + (r).width) +#define SCALE_FACTOR (0.2) + +/** + * SECTION:uber-line-graph.h + * @title: UberLineGraph + * @short_description: + * + * Section overview. + */ + + +typedef struct +{ + GRing *raw_data; + GdkRGBA color; + gdouble width; + gdouble *dashes; + gint num_dashes; + gdouble dash_offset; + UberLabel *label; + guint label_id; +} LineInfo; + +struct _UberLineGraphPrivate +{ + GArray *lines; + cairo_antialias_t antialias; + guint stride; + gboolean autoscale; + UberRange range; + UberScale scale; + gpointer scale_data; + GDestroyNotify scale_notify; + UberLineGraphFunc func; + gpointer func_data; + GDestroyNotify func_notify; +}; + +G_DEFINE_TYPE_WITH_PRIVATE(UberLineGraph, uber_line_graph, UBER_TYPE_GRAPH) + + +enum +{ + PROP_0, + PROP_AUTOSCALE, + PROP_RANGE, +}; + +/** + * uber_line_graph_init_ring: + * @ring: A #GRing. + * + * Initialize the #GRing to default values (UBER_LINE_GRAPH_NO_VALUE). + * + * Returns: None. + * Side effects: None. + */ +static inline void +uber_line_graph_init_ring (GRing *ring) /* IN */ +{ + gdouble val = UBER_LINE_GRAPH_NO_VALUE; + guint i; + + g_return_if_fail(ring != NULL); + + for (i = 0; i < ring->len; i++) { + g_ring_append_val(ring, val); + } +} + +/** + * uber_line_graph_new: + * + * Creates a new instance of #UberLineGraph. + * + * Returns: the newly created instance of #UberLineGraph. + * Side effects: None. + */ +GtkWidget* +uber_line_graph_new (void) +{ + UberLineGraph *graph; + + graph = g_object_new(UBER_TYPE_LINE_GRAPH, NULL); + return GTK_WIDGET(graph); +} + +/** + * uber_line_graph_color: + * @graph: A #UberLineGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_color_changed (UberLabel *label, /* IN */ + GdkRGBA *color, /* IN */ + UberLineGraph *graph) /* IN */ +{ + UberLineGraphPrivate *priv; + LineInfo *info; + guint i; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + g_return_if_fail(color != NULL); + + priv = graph->priv; + for (i = 0; i < priv->lines->len; i++) { + info = &g_array_index(priv->lines, LineInfo, i); + if (info->label == label) { + info->color = *color; + } + } + uber_graph_redraw(UBER_GRAPH(graph)); +} + +void +uber_line_graph_bind_label (UberLineGraph *graph, /* IN */ + guint line, /* IN */ + UberLabel *label) /* IN */ +{ + UberLineGraphPrivate *priv; + LineInfo *info; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + g_return_if_fail(UBER_IS_LABEL(label)); + g_return_if_fail(line > 0); + g_return_if_fail(line <= graph->priv->lines->len); + + priv = graph->priv; + info = &g_array_index(priv->lines, LineInfo, line - 1); + if (info->label_id) { + g_signal_handler_disconnect(info->label, info->label_id); + } + info->label = label; + info->label_id = g_signal_connect(label, + "color-changed", + G_CALLBACK(uber_line_graph_color_changed), + graph); +} + +/** + * uber_line_graph_set_autoscale: + * @graph: A #UberLineGraph. + * @autoscale: Should we autoscale. + * + * Sets if we should autoscale the range of the graph when a new input + * value is outside the visible range. + * + * Returns: None. + * Side effects: None. + */ +void +uber_line_graph_set_autoscale (UberLineGraph *graph, /* IN */ + gboolean autoscale) /* IN */ +{ + UberLineGraphPrivate *priv; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + + priv = graph->priv; + priv->autoscale = autoscale; +} + +/** + * uber_line_graph_get_autoscale: + * @graph: A #UberLineGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +gboolean +uber_line_graph_get_autoscale (UberLineGraph *graph) /* IN */ +{ + g_return_val_if_fail(UBER_IS_LINE_GRAPH(graph), FALSE); + return graph->priv->autoscale; +} + +/** + * uber_line_graph_add_line: + * @graph: A #UberLineGraph. + * @color: A #GdkRGBA for the line or %NULL. + * + * Adds a new line to the graph. If color is %NULL, the next value + * in the default color list will be used. + * + * See uber_line_graph_remove_line(). + * + * Returns: The line identifier. + * Side effects: None. + */ +gint +uber_line_graph_add_line (UberLineGraph *graph, /* IN */ + const GdkRGBA *color, /* IN */ + UberLabel *label) /* IN */ +{ + UberLineGraphPrivate *priv; + LineInfo info = { 0 }; + + g_return_val_if_fail(UBER_IS_LINE_GRAPH(graph), 0); + + priv = graph->priv; + info.width = 1.0; + /* + * Retrieve the lines color. + */ + if (color) { + info.color = *color; + } else { + gdk_rgba_parse(&info.color, "#729fcf"); + } + /* + * Allocate buffers for data points. + */ + info.raw_data = g_ring_sized_new(sizeof(gdouble), priv->stride, NULL); + uber_line_graph_init_ring(info.raw_data); + /* + * Store the newly crated line. + */ + g_array_append_val(priv->lines, info); + /* + * Mark the graph for full redraw. + */ + uber_graph_redraw(UBER_GRAPH(graph)); + /* + * Attach label. + */ + if (label) { + uber_line_graph_bind_label(graph, priv->lines->len, label); + uber_graph_add_label(UBER_GRAPH(graph), label); + uber_label_set_color(label, &info.color); + } + /* + * Line indexes start from 1. + */ + return priv->lines->len; +} + +/** + * uber_line_graph_set_antialias: + * @graph: A #UberLineGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_line_graph_set_antialias (UberLineGraph *graph, /* IN */ + cairo_antialias_t antialias) /* IN */ +{ + UberLineGraphPrivate *priv; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + + priv = graph->priv; + priv->antialias = antialias; + uber_graph_redraw(UBER_GRAPH(graph)); +} + +/** + * uber_line_graph_get_antialias: + * @graph: A #UberLineGraph. + * + * Retrieves the antialias mode for the graph. + * + * Returns: A cairo_antialias_t. + * Side effects: None. + */ +cairo_antialias_t +uber_line_graph_get_antialias (UberLineGraph *graph) /* IN */ +{ + g_return_val_if_fail(UBER_IS_LINE_GRAPH(graph), 0); + + return graph->priv->antialias; +} + +/** + * uber_line_graph_get_next_data: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static gboolean +uber_line_graph_get_next_data (UberGraph *graph) /* IN */ +{ + UberLineGraphPrivate *priv; + gboolean scale_changed = FALSE; + gboolean ret = FALSE; + LineInfo *line; + gdouble val; + guint i; + + g_return_val_if_fail(UBER_IS_LINE_GRAPH(graph), FALSE); + + priv = UBER_LINE_GRAPH(graph)->priv; + /* + * Retrieve the next data point. + */ + if (priv->func) { + for (i = 0; i < priv->lines->len; i++) { + line = &g_array_index(priv->lines, LineInfo, i); + val = priv->func(UBER_LINE_GRAPH(graph), i + 1, priv->func_data); + g_ring_append_val(line->raw_data, val); + if (priv->autoscale) { + if (val < priv->range.begin) { + priv->range.begin = val - (val * SCALE_FACTOR); + priv->range.range = priv->range.end - priv->range.begin; + scale_changed = TRUE; + } else if (val > priv->range.end) { + priv->range.end = val + (val * SCALE_FACTOR); + priv->range.range = priv->range.end - priv->range.begin; + scale_changed = TRUE; + } + } + } + } + if (scale_changed) { + uber_graph_scale_changed(graph); + } + return ret; +} + +/** + * uber_line_graph_set_data_func: + * @graph: A #UberLineGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_line_graph_set_data_func (UberLineGraph *graph, /* IN */ + UberLineGraphFunc func, /* IN */ + gpointer user_data, /* IN */ + GDestroyNotify notify) /* IN */ +{ + UberLineGraphPrivate *priv; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + + priv = graph->priv; + /* + * Free existing data func if neccessary. + */ + if (priv->func_notify) { + priv->func_notify(priv->func_data); + } + /* + * Store data func. + */ + priv->func = func; + priv->func_data = user_data; + priv->func_notify = notify; +} + +/** + * uber_line_graph_stylize_line: + * @graph: A #UberLineGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_stylize_line (UberLineGraph *graph, /* IN */ + LineInfo *info, /* IN */ + cairo_t *cr) /* IN */ +{ + UberLineGraphPrivate *priv; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + g_return_if_fail(info != NULL); + + priv = graph->priv; + if (info->dashes) { + cairo_set_dash(cr, info->dashes, info->num_dashes, info->dash_offset); + } else { + cairo_set_dash(cr, NULL, 0, 0); + } + cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND); + cairo_set_line_width(cr, info->width); + cairo_set_antialias(cr, priv->antialias); + cairo_set_source_rgba(cr, + info->color.red, + info->color.green, + info->color.blue, + info->color.alpha); +} + +/** + * uber_line_graph_render: + * @graph: A #UberGraph. + * @cr: A #cairo_t context. + * @area: Full area to render contents within. + * @line: The line to render. + * + * Render a particular line to the graph. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_render_line (UberLineGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + GdkRectangle *area, /* IN */ + LineInfo *line, /* IN */ + guint epoch, /* IN */ + gfloat each) /* IN */ +{ + UberLineGraphPrivate *priv; + UberRange pixel_range; + GdkRectangle vis; + guint x; + guint last_x; + gdouble y; + gdouble last_y; + gdouble val; + guint i; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + + priv = graph->priv; + uber_graph_get_content_area(UBER_GRAPH(graph), &vis); + pixel_range.begin = area->y + 1; + pixel_range.end = area->y + area->height; + pixel_range.range = pixel_range.end - pixel_range.begin; + /* + * Prepare cairo settings. + */ + uber_line_graph_stylize_line(graph, line, cr); + /* + * Force a new path. + */ + cairo_new_path(cr); + /* + * Draw the line contents as bezier curves. + */ + for (i = 0; i < line->raw_data->len; i++) { + /* + * Retrieve data point. + */ + val = g_ring_get_index(line->raw_data, gdouble, (int)i); + /* + * Once we get to UBER_LINE_GRAPH_NO_VALUE, we must be at the end of the data + * sequence. This may not always be true in the future. + */ + if (val == UBER_LINE_GRAPH_NO_VALUE) { + break; + } + /* + * Translate value to coordinate system. + */ + if (!priv->scale(&priv->range, &pixel_range, &val, priv->scale_data)) { + break; + } + /* + * Calculate X/Y coordinate. + */ + y = (gint)(RECT_BOTTOM(*area) - val) - .5; + x = epoch - (each * i); + if (i == 0) { + /* + * Just move to the right position on first entry. + */ + cairo_move_to(cr, x, y); + goto next; + } else { + /* + * Draw curve to data point using the last X/Y positions as + * control points. + */ + cairo_curve_to(cr, + last_x - (each / 2.), + last_y, + last_x - (each / 2.), + y, x, y); + } + next: + last_y = y; + last_x = x; + } + /* + * Stroke the line content. + */ + cairo_stroke(cr); +} + +/** + * uber_line_graph_render: + * @graph: A #UberGraph. + * + * Render the entire contents of the graph. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_render (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + GdkRectangle *rect, /* IN */ + guint epoch, /* IN */ + gfloat each) /* IN */ +{ + UberLineGraphPrivate *priv; + LineInfo *line; + guint i; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + + priv = UBER_LINE_GRAPH(graph)->priv; + /* + * Render each line to the graph. + */ + for (i = 0; i < priv->lines->len; i++) { + line = &g_array_index(priv->lines, LineInfo, i); + uber_line_graph_render_line(UBER_LINE_GRAPH(graph), cr, rect, + line, epoch, each); + } +} + +/** + * uber_line_graph_render_fast: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_render_fast (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + GdkRectangle *rect, /* IN */ + guint epoch, /* IN */ + gfloat each) /* IN */ +{ + UberLineGraphPrivate *priv; + UberRange pixel_range; + LineInfo *line; + gdouble last_y; + gdouble y; + guint i; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + g_return_if_fail(cr != NULL); + g_return_if_fail(rect != NULL); + + priv = UBER_LINE_GRAPH(graph)->priv; + pixel_range.begin = rect->y + 1; + pixel_range.end = rect->y + rect->height; + pixel_range.range = pixel_range.end - pixel_range.begin; + /* + * Render most recent data point for each line. + */ + for (i = 0; i < priv->lines->len; i++) { + line = &g_array_index(priv->lines, LineInfo, i); + uber_line_graph_stylize_line(UBER_LINE_GRAPH(graph), line, cr); + /* + * Calculate positions. + */ + y = g_ring_get_index(line->raw_data, gdouble, 0); + last_y = g_ring_get_index(line->raw_data, gdouble, 1); + /* + * Don't try to draw before we have real values. + */ + if ((isnan(y) || isinf(y)) || (isnan(last_y) || isinf(last_y))) { + continue; + } + /* + * Translate to coordinate scale. + */ + if (!priv->scale(&priv->range, &pixel_range, &y, priv->scale_data) || + !priv->scale(&priv->range, &pixel_range, &last_y, priv->scale_data)) { + continue; + } + /* + * Translate position from bottom right corner. + */ + y = (gint)(RECT_BOTTOM(*rect) - y) - .5; + last_y = (gint)(RECT_BOTTOM(*rect) - last_y) - .5; + /* + * Convert relative position to fixed from bottom pixel. + */ + cairo_new_path(cr); + cairo_move_to(cr, epoch, y); + cairo_curve_to(cr, + epoch - (each / 2.), + y, + epoch - (each / 2.), + last_y, + epoch - each, + last_y); + cairo_stroke(cr); + } +} + +/** + * uber_line_graph_set_stride: + * @graph: A #UberGraph. + * @stride: The number of data points within the graph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_set_stride (UberGraph *graph, /* IN */ + guint stride) /* IN */ +{ + UberLineGraphPrivate *priv; + LineInfo *line; + guint i; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + + priv = UBER_LINE_GRAPH(graph)->priv; + priv->stride = stride; + /* + * TODO: Support changing stride after lines have been added. + */ + if (priv->lines->len) { + for (i = 0; i < priv->lines->len; i++) { + line = &g_array_index(priv->lines, LineInfo, i); + g_ring_unref(line->raw_data); + line->raw_data = g_ring_sized_new(sizeof(gdouble), + priv->stride, NULL); + uber_line_graph_init_ring(line->raw_data); + } + return; + } +} + +/** + * uber_line_graph_get_range: + * @graph: (in): A #UberLineGraph. + * + * XXX + * + * Returns: An #UberRange which should not be modified or freed. + * Side effects: None. + */ +const UberRange* +uber_line_graph_get_range (UberLineGraph *graph) /* IN */ +{ + g_return_val_if_fail(UBER_IS_LINE_GRAPH(graph), NULL); + return &graph->priv->range; +} + +/** + * uber_line_graph_set_range: + * @graph: A #UberLineGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_line_graph_set_range (UberLineGraph *graph, /* IN */ + const UberRange *range) /* IN */ +{ + UberLineGraphPrivate *priv; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + g_return_if_fail(range != NULL); + + priv = graph->priv; + priv->range = *range; +} + +/** + * uber_line_graph_get_yrange: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_get_yrange (UberGraph *graph, /* IN */ + UberRange *range) /* OUT */ +{ + UberLineGraphPrivate *priv; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + g_return_if_fail(range != NULL); + + priv = UBER_LINE_GRAPH(graph)->priv; + *range = priv->range; +} + +/** + * uber_line_graph_set_line_dash: + * @graph: A #UberLineGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_line_graph_set_line_dash (UberLineGraph *graph, /* IN */ + guint line, /* IN */ + const gdouble *dashes, /* IN */ + gint num_dashes, /* IN */ + gdouble offset) /* IN */ +{ + UberLineGraphPrivate *priv; + LineInfo *info; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + g_return_if_fail(dashes != NULL); + g_return_if_fail(num_dashes > 0); + g_return_if_fail(line > 0); + g_return_if_fail(line <= graph->priv->lines->len); + + priv = graph->priv; + info = &g_array_index(priv->lines, LineInfo, line - 1); + if (info->dashes) { + g_free(info->dashes); + info->dashes = NULL; + info->num_dashes = 0; + info->dash_offset = 0; + } + if (dashes) { + info->dashes = g_new0(gdouble, num_dashes); + memcpy(info->dashes, dashes, sizeof(gdouble) * num_dashes); + info->num_dashes = num_dashes; + info->dash_offset = offset; + } +} + +/** + * uber_line_graph_set_line_width: + * @graph: A #UberLineGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_line_graph_set_line_width (UberLineGraph *graph, /* IN */ + gint line, /* IN */ + gdouble width) /* IN */ +{ + LineInfo *info; + + g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); + g_return_if_fail(line > 0); + g_return_if_fail(line <= (int)graph->priv->lines->len); + + info = &g_array_index(graph->priv->lines, LineInfo, line - 1); + info->width = width; + uber_graph_redraw(UBER_GRAPH(graph)); +} + +/** + * uber_line_graph_downscale: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static gboolean +uber_line_graph_downscale (UberGraph *graph) /* IN */ +{ + UberLineGraphPrivate *priv; + gboolean ret = FALSE; + gdouble val = 0; + gdouble cur; + LineInfo *line; + guint i; + guint j; + + g_return_val_if_fail(UBER_IS_LINE_GRAPH(graph), FALSE); + + priv = UBER_LINE_GRAPH(graph)->priv; + /* + * If we are set to autoscale, ignore request. + */ + if (!priv->autoscale) { + return FALSE; + } + /* + * Determine the largest value available. + */ + for (i = 0; i < priv->lines->len; i++) { + line = &g_array_index(priv->lines, LineInfo, i); + for (j = 0; j < line->raw_data->len; j++) { + cur = g_ring_get_index(line->raw_data, gdouble, (int)j); + val = (cur > val) ? cur : val; + } + } + /* + * Downscale if we can. + */ + if (val != priv->range.begin) { + if ((val * (1. + SCALE_FACTOR)) < priv->range.end) { + priv->range.end = val * (1. + SCALE_FACTOR); + priv->range.range = priv->range.end - priv->range.begin; + ret = TRUE; + } + } + return ret; +} + +/** + * uber_line_graph_finalize: + * @object: A #UberLineGraph. + * + * Finalizer for a #UberLineGraph instance. Frees any resources held by + * the instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_finalize (GObject *object) /* IN */ +{ + UberLineGraphPrivate *priv; + LineInfo *line; + guint i; + + priv = UBER_LINE_GRAPH(object)->priv; + /* + * Clean up after cached values. + */ + for (i = 0; i < priv->lines->len; i++) { + line = &g_array_index(priv->lines, LineInfo, i); + g_ring_unref(line->raw_data); + g_free(line->dashes); + } + G_OBJECT_CLASS(uber_line_graph_parent_class)->finalize(object); +} + +/** + * uber_line_graph_set_property: + * @object: (in): A #GObject. + * @prop_id: (in): The property identifier. + * @value: (out): The given property. + * @pspec: (in): A #ParamSpec. + * + * Get a given #GObject property. + */ +static void +uber_line_graph_get_property (GObject *object, /* IN */ + guint prop_id, /* IN */ + GValue *value, /* OUT */ + GParamSpec *pspec) /* IN */ +{ + UberLineGraph *graph = UBER_LINE_GRAPH(object); + + switch (prop_id) { + case PROP_AUTOSCALE: + g_value_set_boolean(value, uber_line_graph_get_autoscale(graph)); + break; + case PROP_RANGE: + g_value_set_boxed(value, uber_line_graph_get_range(graph)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + } +} + +/** + * uber_line_graph_set_property: + * @object: (in): A #GObject. + * @prop_id: (in): The property identifier. + * @value: (in): The given property. + * @pspec: (in): A #ParamSpec. + * + * Set a given #GObject property. + */ +static void +uber_line_graph_set_property (GObject *object, /* IN */ + guint prop_id, /* IN */ + const GValue *value, /* IN */ + GParamSpec *pspec) /* IN */ +{ + UberLineGraph *graph = UBER_LINE_GRAPH(object); + + switch (prop_id) { + case PROP_AUTOSCALE: + uber_line_graph_set_autoscale(graph, g_value_get_boolean(value)); + break; + case PROP_RANGE: + uber_line_graph_set_range(graph, g_value_get_boxed(value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + } +} + +/** + * uber_line_graph_class_init: + * @klass: A #UberLineGraphClass. + * + * Initializes the #UberLineGraphClass and prepares the vtable. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_class_init (UberLineGraphClass *klass) /* IN */ +{ + GObjectClass *object_class; + UberGraphClass *graph_class; + + object_class = G_OBJECT_CLASS(klass); + object_class->finalize = uber_line_graph_finalize; + object_class->get_property = uber_line_graph_get_property; + object_class->set_property = uber_line_graph_set_property; + + graph_class = UBER_GRAPH_CLASS(klass); + graph_class->downscale = uber_line_graph_downscale; + graph_class->get_next_data = uber_line_graph_get_next_data; + graph_class->get_yrange = uber_line_graph_get_yrange; + graph_class->render = uber_line_graph_render; + graph_class->render_fast = uber_line_graph_render_fast; + graph_class->set_stride = uber_line_graph_set_stride; + + g_object_class_install_property(object_class, + PROP_AUTOSCALE, + g_param_spec_boolean("autoscale", + "autoscale", + "autoscale", + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property(object_class, + PROP_RANGE, + g_param_spec_boxed("range", + "range", + "range", + UBER_TYPE_RANGE, + G_PARAM_READWRITE)); +} + +/** + * uber_line_graph_init: + * @graph: A #UberLineGraph. + * + * Initializes the newly created #UberLineGraph instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_line_graph_init (UberLineGraph *graph) /* IN */ +{ + UberLineGraphPrivate *priv; + + /* + * Keep pointer to private data. + */ + graph->priv = uber_line_graph_get_instance_private(graph); + + priv = graph->priv; + /* + * Initialize defaults. + */ + priv->stride = 60; + priv->antialias = CAIRO_ANTIALIAS_DEFAULT; + priv->lines = g_array_sized_new(FALSE, FALSE, sizeof(LineInfo), 2); + priv->scale = uber_scale_linear; + priv->autoscale = TRUE; +} + +void +uber_line_graph_clear (UberLineGraph *graph) /* IN */ +{ + UberLineGraphPrivate *priv = graph->priv; + LineInfo *line; + guint i; + + for (i = 0; i < priv->lines->len; i++) { + line = &g_array_index(priv->lines, LineInfo, i); + uber_line_graph_init_ring(line->raw_data); + } +} diff --git a/deps/uber-graph/uber-line-graph.h b/deps/uber-graph/uber-line-graph.h new file mode 100644 index 00000000..22a01681 --- /dev/null +++ b/deps/uber-graph/uber-line-graph.h @@ -0,0 +1,100 @@ +/* uber-line-graph.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_LINE_GRAPH_H__ +#define __UBER_LINE_GRAPH_H__ + +#include <math.h> + +#include "uber-graph.h" +#include "uber-range.h" +#include "uber-label.h" + +G_BEGIN_DECLS + +#define UBER_TYPE_LINE_GRAPH (uber_line_graph_get_type()) +#define UBER_LINE_GRAPH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_LINE_GRAPH, UberLineGraph)) +#define UBER_LINE_GRAPH_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_LINE_GRAPH, UberLineGraph const)) +#define UBER_LINE_GRAPH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UBER_TYPE_LINE_GRAPH, UberLineGraphClass)) +#define UBER_IS_LINE_GRAPH(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UBER_TYPE_LINE_GRAPH)) +#define UBER_IS_LINE_GRAPH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UBER_TYPE_LINE_GRAPH)) +#define UBER_LINE_GRAPH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UBER_TYPE_LINE_GRAPH, UberLineGraphClass)) + +#define UBER_LINE_GRAPH_NO_VALUE (NAN) + +typedef struct _UberLineGraph UberLineGraph; +typedef struct _UberLineGraphClass UberLineGraphClass; +typedef struct _UberLineGraphPrivate UberLineGraphPrivate; + +/** + * UberLineGraphFunc: + * @graph: A #UberLineGraph. + * @user_data: User data supplied to uber_line_graph_set_data_func(). + * + * Callback prototype for retrieving the next data point in the graph. + * + * Returns: a value if successful, otherwise %UBER_LINE_GRAPH_NO_VALUE + * Side effects: Implementation dependent. + */ +typedef gdouble (*UberLineGraphFunc) (UberLineGraph *graph, + guint line, + gpointer user_data); + +struct _UberLineGraph +{ + UberGraph parent; + + /*< private >*/ + UberLineGraphPrivate *priv; +}; + +struct _UberLineGraphClass +{ + UberGraphClass parent_class; +}; + +gint uber_line_graph_add_line (UberLineGraph *graph, + const GdkRGBA *color, + UberLabel *label); +cairo_antialias_t uber_line_graph_get_antialias (UberLineGraph *graph); +GType uber_line_graph_get_type (void) G_GNUC_CONST; +GtkWidget* uber_line_graph_new (void); +void uber_line_graph_set_antialias (UberLineGraph *graph, + cairo_antialias_t antialias); +void uber_line_graph_set_data_func (UberLineGraph *graph, + UberLineGraphFunc func, + gpointer user_data, + GDestroyNotify notify); +gboolean uber_line_graph_get_autoscale (UberLineGraph *graph); +void uber_line_graph_set_autoscale (UberLineGraph *graph, + gboolean autoscale); +const UberRange* uber_line_graph_get_range (UberLineGraph *graph); +void uber_line_graph_set_range (UberLineGraph *graph, + const UberRange *range); +void uber_line_graph_set_line_dash (UberLineGraph *graph, + guint line, + const gdouble *dashes, + gint num_dashes, + gdouble offset); +void uber_line_graph_set_line_width (UberLineGraph *graph, + gint line, + gdouble width); +void uber_line_graph_clear (UberLineGraph *graph); +G_END_DECLS + +#endif /* __UBER_LINE_GRAPH_H__ */ diff --git a/deps/uber-graph/uber-range.c b/deps/uber-graph/uber-range.c new file mode 100644 index 00000000..e8afc0de --- /dev/null +++ b/deps/uber-graph/uber-range.c @@ -0,0 +1,64 @@ +/* uber-range.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <string.h> + +#include "uber-range.h" + +UberRange* +uber_range_copy (UberRange *src) +{ + UberRange *dst = g_new0(UberRange, 1); + memcpy(dst, src, sizeof(UberRange)); + return dst; +} + +void +uber_range_free (UberRange *range) +{ + g_free(range); +} + +UberRange* +uber_range_new (gdouble begin, + gdouble end) +{ + UberRange *range; + + range = g_new0(UberRange, 1); + range->begin = begin; + range->end = end; + range->range = range->end - range->begin; + return range; +} + +GType +uber_range_get_type (void) +{ + static gsize initialized = FALSE; + GType type_id = 0; + + if (G_UNLIKELY(g_once_init_enter(&initialized))) { + type_id = g_boxed_type_register_static("UberRange", + (GBoxedCopyFunc)uber_range_copy, + (GBoxedFreeFunc)uber_range_free); + g_once_init_leave(&initialized, TRUE); + } + + return type_id; +} diff --git a/deps/uber-graph/uber-range.h b/deps/uber-graph/uber-range.h new file mode 100644 index 00000000..166a1313 --- /dev/null +++ b/deps/uber-graph/uber-range.h @@ -0,0 +1,50 @@ +/* uber-range.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_RANGE_H__ +#define __UBER_RANGE_H__ + +#include <glib-object.h> + +G_BEGIN_DECLS + +#define UBER_TYPE_RANGE (uber_range_get_type()) + +/** + * UberRange: + * + * #UberRange is a structure that encapsulates the range of a particular + * scale. It contains the beginning value, ending value, and a pre-calculated + * range between the values. + */ +typedef struct +{ + gdouble begin; + gdouble end; + gdouble range; +} UberRange; + +GType uber_range_get_type (void) G_GNUC_CONST; +void uber_range_free (UberRange *range); +UberRange* uber_range_copy (UberRange *range); +UberRange* uber_range_new (gdouble begin, + gdouble end); + +G_END_DECLS + +#endif /* __UBER_RANGE_H__ */ diff --git a/deps/uber-graph/uber-scale.c b/deps/uber-graph/uber-scale.c new file mode 100644 index 00000000..ead9f988 --- /dev/null +++ b/deps/uber-graph/uber-scale.c @@ -0,0 +1,54 @@ +/* uber-scale.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "uber-scale.h" + +/** + * uber_scale_linear: + * @range: An #UberRange. + * @pixel_range: An #UberRange. + * @value: A pointer to the value to translate. + * @user_data: user data for scale. + * + * An #UberScale function to translate a value to the coordinate system in + * a linear fashion. + * + * Returns: %TRUE if successful; otherwise %FALSE. + * Side effects: None. + */ +gboolean +uber_scale_linear (const UberRange *range, /* IN */ + const UberRange *pixel_range, /* IN */ + gdouble *value, /* IN/OUT */ + gpointer user_data) /* IN */ +{ + #define A (range->range) + #define B (pixel_range->range) + #define C (*value) + if (*value != 0.) { + *value = C * B / A; + } + #undef A + #undef B + #undef C + return TRUE; +} diff --git a/deps/uber-graph/uber-scale.h b/deps/uber-graph/uber-scale.h new file mode 100644 index 00000000..5101275b --- /dev/null +++ b/deps/uber-graph/uber-scale.h @@ -0,0 +1,38 @@ +/* uber-scale.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_SCALE_H__ +#define __UBER_SCALE_H__ + +#include "uber-range.h" + +G_BEGIN_DECLS + +typedef gboolean (*UberScale) (const UberRange *range, + const UberRange *pixel_range, + gdouble *value, + gpointer user_data); + +gboolean uber_scale_linear (const UberRange *range, + const UberRange *pixel_range, + gdouble *value, + gpointer user_data); + +G_END_DECLS + +#endif /* __UBER_SCALE_H__ */ diff --git a/deps/uber-graph/uber-scatter.c b/deps/uber-graph/uber-scatter.c new file mode 100644 index 00000000..56c7b00d --- /dev/null +++ b/deps/uber-graph/uber-scatter.c @@ -0,0 +1,421 @@ +/* uber-scatter.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <math.h> +#include <string.h> + +#include "uber-scatter.h" +#include "uber-scale.h" +#include "uber-range.h" +#include "g-ring.h" + +#define RADIUS 3 + +/** + * SECTION:uber-scatter.h + * @title: UberScatter + * @short_description: + * + * Section overview. + */ + + +struct _UberScatterPrivate +{ + GRing *raw_data; + UberRange range; + guint stride; + GdkRGBA fg_color; + gboolean fg_color_set; + UberScatterFunc func; + gpointer func_user_data; + GDestroyNotify func_destroy; +}; + +G_DEFINE_TYPE_WITH_PRIVATE(UberScatter, uber_scatter, UBER_TYPE_GRAPH) + +/** + * uber_scatter_new: + * + * Creates a new instance of #UberScatter. + * + * Returns: the newly created instance of #UberScatter. + * Side effects: None. + */ +GtkWidget* +uber_scatter_new (void) +{ + UberScatter *scatter; + + scatter = g_object_new(UBER_TYPE_SCATTER, NULL); + return GTK_WIDGET(scatter); +} + +/** + * uber_scatter_set_data_func: + * @scatter: A #UberScatter. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_scatter_set_data_func (UberScatter *scatter, /* IN */ + UberScatterFunc func, /* IN */ + gpointer user_data, /* IN */ + GDestroyNotify destroy) /* IN */ +{ + UberScatterPrivate *priv; + + g_return_if_fail(UBER_IS_SCATTER(scatter)); + g_return_if_fail(func != NULL); + + priv = scatter->priv; + /* + * Cleanup previous data func if necessary. + */ + if (priv->func_destroy) { + priv->func_destroy(priv->func_user_data); + } + priv->func = func; + priv->func_destroy = destroy; + priv->func_user_data = user_data; +} + +/** + * uber_scatter_destroy_array: + * @array: A #GArray. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_scatter_destroy_array (gpointer data) /* IN */ +{ + GArray **ar = data; + + if (ar) { + g_array_unref(*ar); + } +} + +/** + * uber_scatter_set_stride: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_scatter_set_stride (UberGraph *graph, /* IN */ + guint stride) /* IN */ +{ + UberScatterPrivate *priv; + + g_return_if_fail(UBER_IS_SCATTER(graph)); + + priv = UBER_SCATTER(graph)->priv; + if (priv->stride == stride) { + return; + } + priv->stride = stride; + if (priv->raw_data) { + g_ring_unref(priv->raw_data); + } + priv->raw_data = g_ring_sized_new(sizeof(GArray*), stride, + uber_scatter_destroy_array); +} + +/** + * uber_scatter_render: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_scatter_render (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + GdkRectangle *area, /* IN */ + guint epoch, /* IN */ + gfloat each) /* IN */ +{ + UberScatterPrivate *priv; + UberRange pixel_range; + GtkStyleContext *style; + GdkRGBA color; + GArray *ar; + gdouble x; + gdouble y; + guint i; + guint j; + + g_return_if_fail(UBER_IS_SCATTER(graph)); + + priv = UBER_SCATTER(graph)->priv; + color = priv->fg_color; + if (!priv->fg_color_set) { + style = gtk_widget_get_style_context(GTK_WIDGET(graph)); + gtk_style_context_get_color(style, GTK_STATE_FLAG_SELECTED, &color); + } + /* + * Calculate ranges. + */ + pixel_range.begin = area->y + (RADIUS / 2.); + pixel_range.end = area->y + area->height - RADIUS; + pixel_range.range = pixel_range.end - pixel_range.begin; + /* + * Retrieve the current data set. + */ + for (i = 0; i < priv->raw_data->len; i++) { + if (!(ar = g_ring_get_index(priv->raw_data, GArray*, (int)i))) { + continue; + } + x = epoch - (i * each) - (each / 2.); + for (j = 0; j < ar->len; j++) { + y = g_array_index(ar, gdouble, j); +// g_debug("Raw ==> %f", y); + uber_scale_linear(&priv->range, &pixel_range, &y, NULL); + /* + * Shadow. + */ + cairo_arc(cr, x + .5, y + .5, RADIUS, 0, 2 * M_PI); + cairo_set_source_rgb(cr, .1, .1, .1); + cairo_fill(cr); + /* + * Foreground. + */ + cairo_arc(cr, x, y, RADIUS, 0, 2 * M_PI); + cairo_set_source_rgb(cr, + color.red, + color.green, + color.blue); + cairo_fill(cr); + } + } +} + +/** + * uber_scatter_render_fast: + * @graph: A #UberGraph. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +static void +uber_scatter_render_fast (UberGraph *graph, /* IN */ + cairo_t *cr, /* IN */ + GdkRectangle *area, /* IN */ + guint epoch, /* IN */ + gfloat each) /* IN */ +{ + UberScatterPrivate *priv; + UberRange pixel_range; + GtkStyleContext *style; + GdkRGBA color; + GArray *ar; + gdouble x; + gdouble y; + guint i; + + g_return_if_fail(UBER_IS_SCATTER(graph)); + + priv = UBER_SCATTER(graph)->priv; + color = priv->fg_color; + if (!priv->fg_color_set) { + style = gtk_widget_get_style_context(GTK_WIDGET(graph)); + gtk_style_context_get_color(style, GTK_STATE_FLAG_SELECTED, &color); + } + /* + * Calculate ranges. + */ + pixel_range.begin = area->y + (RADIUS / 2.); + pixel_range.end = area->y + area->height - RADIUS; + pixel_range.range = pixel_range.end - pixel_range.begin; + /* + * Retrieve the current data set. + */ + ar = g_ring_get_index(priv->raw_data, GArray*, 0); + if (!ar) { + return; + } + /* + * Calculate X position (Center of this chunk). + */ + x = epoch - (each / 2.); + /* + * Draw scatter dots. + */ + for (i = 0; i < ar->len; i++) { + /* + * Scale the value to our graph coordinates. + */ + y = g_array_index(ar, gdouble, i); + /* + * XXX: Support multiple scales. + */ + uber_scale_linear(&priv->range, &pixel_range, &y, NULL); + /* + * Shadow. + */ + cairo_arc(cr, x + .5, y + .5, RADIUS, 0, 2 * M_PI); + cairo_set_source_rgb(cr, .1, .1, .1); + cairo_fill(cr); + /* + * Foreground. + */ + cairo_arc(cr, x, y, RADIUS, 0, 2 * M_PI); + cairo_set_source_rgb(cr, + color.red, + color.green, + color.blue); + cairo_fill(cr); + } +} + +/** + * uber_scatter_get_next_data: + * @graph: A #UberGraph. + * + * Retrieve the next data point for the graph. + * + * Returns: None. + * Side effects: None. + */ +static gboolean +uber_scatter_get_next_data (UberGraph *graph) /* IN */ +{ + UberScatterPrivate *priv; + GArray *array = NULL; + + g_return_val_if_fail(UBER_IS_SCATTER(graph), FALSE); + + priv = UBER_SCATTER(graph)->priv; + if (priv->func) { + if (!priv->func(UBER_SCATTER(graph), &array, priv->func_user_data)) { + array = NULL; + } + g_ring_append_val(priv->raw_data, array); + return TRUE; + } + return FALSE; +} + +/** + * uber_scatter_set_fg_color: + * @scatter: A #UberScatter. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_scatter_set_fg_color (UberScatter *scatter, /* IN */ + const GdkRGBA *color) /* IN */ +{ + UberScatterPrivate *priv; + + g_return_if_fail(UBER_IS_SCATTER(scatter)); + + priv = scatter->priv; + if (color) { + priv->fg_color = *color; + priv->fg_color_set = TRUE; + } else { + memset(&priv->fg_color, 0, sizeof(priv->fg_color)); + priv->fg_color_set = FALSE; + } +} + +/** + * uber_scatter_finalize: + * @object: A #UberScatter. + * + * Finalizer for a #UberScatter instance. Frees any resources held by + * the instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_scatter_finalize (GObject *object) /* IN */ +{ + G_OBJECT_CLASS(uber_scatter_parent_class)->finalize(object); +} + +/** + * uber_scatter_class_init: + * @klass: A #UberScatterClass. + * + * Initializes the #UberScatterClass and prepares the vtable. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_scatter_class_init (UberScatterClass *klass) /* IN */ +{ + GObjectClass *object_class; + UberGraphClass *graph_class; + + object_class = G_OBJECT_CLASS(klass); + object_class->finalize = uber_scatter_finalize; + + graph_class = UBER_GRAPH_CLASS(klass); + graph_class->render = uber_scatter_render; + graph_class->render_fast = uber_scatter_render_fast; + graph_class->set_stride = uber_scatter_set_stride; + graph_class->get_next_data = uber_scatter_get_next_data; +} + +/** + * uber_scatter_init: + * @scatter: A #UberScatter. + * + * Initializes the newly created #UberScatter instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_scatter_init (UberScatter *scatter) /* IN */ +{ + UberScatterPrivate *priv; + + scatter->priv = uber_scatter_get_instance_private(scatter); + + priv = scatter->priv; + + priv->range.begin = 0.; + priv->range.end = 15000.; + priv->range.range = priv->range.end - priv->range.begin; +} diff --git a/deps/uber-graph/uber-scatter.h b/deps/uber-graph/uber-scatter.h new file mode 100644 index 00000000..ef111456 --- /dev/null +++ b/deps/uber-graph/uber-scatter.h @@ -0,0 +1,66 @@ +/* uber-scatter.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_SCATTER_H__ +#define __UBER_SCATTER_H__ + +#include "uber-graph.h" + +G_BEGIN_DECLS + +#define UBER_TYPE_SCATTER (uber_scatter_get_type()) +#define UBER_SCATTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_SCATTER, UberScatter)) +#define UBER_SCATTER_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_SCATTER, UberScatter const)) +#define UBER_SCATTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UBER_TYPE_SCATTER, UberScatterClass)) +#define UBER_IS_SCATTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UBER_TYPE_SCATTER)) +#define UBER_IS_SCATTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UBER_TYPE_SCATTER)) +#define UBER_SCATTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UBER_TYPE_SCATTER, UberScatterClass)) + +typedef struct _UberScatter UberScatter; +typedef struct _UberScatterClass UberScatterClass; +typedef struct _UberScatterPrivate UberScatterPrivate; + +typedef gboolean (*UberScatterFunc) (UberScatter *scatter, + GArray **values, + gpointer user_data); + +struct _UberScatter +{ + UberGraph parent; + + /*< private >*/ + UberScatterPrivate *priv; +}; + +struct _UberScatterClass +{ + UberGraphClass parent_class; +}; + +GType uber_scatter_get_type (void) G_GNUC_CONST; +GtkWidget* uber_scatter_new (void); +void uber_scatter_set_fg_color (UberScatter *scatter, + const GdkRGBA *color); +void uber_scatter_set_data_func (UberScatter *scatter, + UberScatterFunc func, + gpointer user_data, + GDestroyNotify destroy); + +G_END_DECLS + +#endif /* __UBER_SCATTER_H__ */ diff --git a/deps/uber-graph/uber-timeout-interval.c b/deps/uber-graph/uber-timeout-interval.c new file mode 100644 index 00000000..baabbcca --- /dev/null +++ b/deps/uber-graph/uber-timeout-interval.c @@ -0,0 +1,140 @@ +/* + * Clutter. + * + * An OpenGL based 'interactive canvas' library. + * + * Authored By Neil Roberts <neil@linux.intel.com> + * + * Copyright (C) 2009 Intel Corporation. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +/* This file contains the common code to check whether an interval has + expired used in uber-frame-source and uber-timeout-pool. */ + +#include "uber-timeout-interval.h" + +void +_uber_timeout_interval_init (UberTimeoutInterval *interval, + guint fps) +{ +#if GLIB_CHECK_VERSION (2, 27, 3) + interval->start_time = g_get_monotonic_time () / 1000; +#else + { + GTimeVal start_time; + g_get_current_time (&start_time); + interval->start_time = start_time.tv_sec * 1000 + + start_time.tv_usec / 1000; + } +#endif + + interval->fps = fps; + interval->frame_count = 0; +} + +static gint64 +_uber_timeout_interval_get_ticks (gint64 current_time, + UberTimeoutInterval *interval) +{ + return MAX (current_time - interval->start_time, 0); +} + +gboolean +_uber_timeout_interval_prepare (gint64 current_time, + UberTimeoutInterval *interval, + gint *delay) +{ + guint elapsed_time, new_frame_num; + + elapsed_time = _uber_timeout_interval_get_ticks (current_time, interval); + new_frame_num = elapsed_time * interval->fps / 1000; + + /* If time has gone backwards or the time since the last frame is + greater than the two frames worth then reset the time and do a + frame now */ + if (new_frame_num < interval->frame_count || + new_frame_num - interval->frame_count > 2) + { + /* Get the frame time rounded up to the nearest ms */ + guint frame_time = (1000 + interval->fps - 1) / interval->fps; + + /* Reset the start time */ + interval->start_time = current_time; + + /* Move the start time as if one whole frame has elapsed */ + interval->start_time -= frame_time; + + interval->frame_count = 0; + + if (delay) + *delay = 0; + + return TRUE; + } + else if (new_frame_num > interval->frame_count) + { + if (delay) + *delay = 0; + + return TRUE; + } + else + { + if (delay) + *delay = ((interval->frame_count + 1) * 1000 / interval->fps + - elapsed_time); + + return FALSE; + } +} + +gboolean +_uber_timeout_interval_dispatch (UberTimeoutInterval *interval, + GSourceFunc callback, + gpointer user_data) +{ + if ((* callback) (user_data)) + { + interval->frame_count++; + + return TRUE; + } + + return FALSE; +} + +gint +_uber_timeout_interval_compare_expiration (const UberTimeoutInterval *a, + const UberTimeoutInterval *b) +{ + guint a_delay = 1000 / a->fps; + guint b_delay = 1000 / b->fps; + gint64 b_difference; + gint comparison; + + b_difference = a->start_time - b->start_time; + + comparison = ((gint) (((gint64)a->frame_count + 1) * a_delay) + - (gint) (((gint64)b->frame_count + 1) * b_delay + b_difference)); + + return (comparison < 0 ? -1 + : comparison > 0 ? 1 + : 0); +} diff --git a/deps/uber-graph/uber-timeout-interval.h b/deps/uber-graph/uber-timeout-interval.h new file mode 100644 index 00000000..c1b8b892 --- /dev/null +++ b/deps/uber-graph/uber-timeout-interval.h @@ -0,0 +1,56 @@ +/* + * Clutter. + * + * An OpenGL based 'interactive canvas' library. + * + * Authored By Neil Roberts <neil@linux.intel.com> + * + * Copyright (C) 2009 Intel Corporation. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_TIMEOUT_INTERVAL_H__ +#define __UBER_TIMEOUT_INTERVAL_H__ + +#include <glib.h> + +G_BEGIN_DECLS + +typedef struct _UberTimeoutInterval UberTimeoutInterval; + +struct _UberTimeoutInterval +{ + gint64 start_time; + guint frame_count, fps; +}; + +void _uber_timeout_interval_init (UberTimeoutInterval *interval, + guint fps); + +gboolean _uber_timeout_interval_prepare (gint64 current_time, + UberTimeoutInterval *interval, + gint *delay); + +gboolean _uber_timeout_interval_dispatch (UberTimeoutInterval *interval, + GSourceFunc callback, + gpointer user_data); + +gint _uber_timeout_interval_compare_expiration + (const UberTimeoutInterval *a, + const UberTimeoutInterval *b); + +G_END_DECLS + +#endif /* __UBER_TIMEOUT_INTERVAL_H__ */ diff --git a/deps/uber-graph/uber-window.c b/deps/uber-graph/uber-window.c new file mode 100644 index 00000000..989f3374 --- /dev/null +++ b/deps/uber-graph/uber-window.c @@ -0,0 +1,330 @@ +/* uber-window.c + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "uber-window.h" + +/** + * SECTION:uber-window.h + * @title: UberWindow + * @short_description: + * + * Section overview. + */ + + +struct _UberWindowPrivate +{ + gint graph_count; + GList *graphs; + GtkWidget *notebook; + GtkWidget *table; +}; +G_DEFINE_TYPE_WITH_PRIVATE(UberWindow, uber_window, GTK_TYPE_WINDOW) + +/** + * uber_window_new: + * + * Creates a new instance of #UberWindow. + * + * Returns: the newly created instance of #UberWindow. + * Side effects: None. + */ +GtkWidget* +uber_window_new (void) +{ + UberWindow *window; + + window = g_object_new(UBER_TYPE_WINDOW, NULL); + return GTK_WIDGET(window); +} + +/** + * uber_window_show_labels: + * @window: A #UberWindow. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_window_show_labels (UberWindow *window, /* IN */ + UberGraph *graph) /* IN */ +{ + UberWindowPrivate *priv; + GtkWidget *labels; + GtkWidget *align; + GList *list; + gboolean show; + + g_return_if_fail(UBER_IS_WINDOW(window)); + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = window->priv; + /* + * Get the widgets labels. + */ + labels = uber_graph_get_labels(graph); + /* + * Show/hide ticks and labels. + */ + show = !!labels; + if (labels) { + align = gtk_bin_get_child(GTK_BIN(labels)); + list = gtk_container_get_children(GTK_CONTAINER(align)); + if (list) { + gtk_widget_show(labels); + } else { + gtk_widget_hide(labels); + show = FALSE; + } + g_list_free(list); + } + if (graph == (gpointer)g_list_last(priv->graphs)) { + show = TRUE; + } + uber_graph_set_show_xlabels(graph, show); + /* + * Hide labels/xlabels for other graphs. + */ + for (list = priv->graphs; list && list->next; list = list->next) { + if (list->data != graph) { + uber_graph_set_show_xlabels(list->data, FALSE); + labels = uber_graph_get_labels(list->data); + if (labels) { + gtk_widget_hide(labels); + } + } + } + /* + * Ensure the last graph always has labels. + */ + if (list) { + uber_graph_set_show_xlabels(UBER_GRAPH(list->data), TRUE); + } +} + +/** + * uber_window_hide_labels: + * @window: A #UberWindow. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_window_hide_labels (UberWindow *window, /* IN */ + UberGraph *graph) /* IN */ +{ + UberWindowPrivate *priv; + GtkWidget *labels; + gboolean show; + + g_return_if_fail(UBER_IS_WINDOW(window)); + g_return_if_fail(UBER_IS_GRAPH(graph)); + + priv = window->priv; + labels = uber_graph_get_labels(graph); + if (labels) { + gtk_widget_hide(labels); + } + show = g_list_last(priv->graphs) == (gpointer)graph; + uber_graph_set_show_xlabels(graph, show); +} + +static gboolean +uber_window_graph_button_press_event (GtkWidget *widget, /* IN */ + GdkEventButton *button, /* IN */ + UberWindow *window) /* IN */ +{ + GtkWidget *labels; + + g_return_val_if_fail(UBER_IS_WINDOW(window), FALSE); + g_return_val_if_fail(UBER_IS_GRAPH(widget), FALSE); + + switch (button->button) { + case 1: /* Left click */ + labels = uber_graph_get_labels(UBER_GRAPH(widget)); + if (gtk_widget_get_visible(labels)) { + uber_window_hide_labels(window, UBER_GRAPH(widget)); + } else { + uber_window_show_labels(window, UBER_GRAPH(widget)); + } + break; + default: + break; + } + return FALSE; +} + +/** + * uber_window_add_graph: + * @window: A #UberWindow. + * + * XXX + * + * Returns: None. + * Side effects: None. + */ +void +uber_window_add_graph (UberWindow *window, /* IN */ + UberGraph *graph, /* IN */ + const gchar *title) /* IN */ +{ + UberWindowPrivate *priv; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *label; + GtkWidget *labels; + gchar *formatted; + gint left_attach; + gint top_attach; + + g_return_if_fail(UBER_IS_WINDOW(window)); + + priv = window->priv; + /* + * Format title string. + */ + formatted = g_markup_printf_escaped("<b>%s</b>", title); + /* + * Create container for graph. + */ + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); + label = gtk_label_new(NULL); + labels = uber_graph_get_labels(graph); + gtk_label_set_markup(GTK_LABEL(label), formatted); + gtk_label_set_angle(GTK_LABEL(label), -270.); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(graph), TRUE, TRUE, 0); + gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0); + if (labels) { + gtk_box_pack_start(GTK_BOX(vbox), labels, FALSE, TRUE, 0); + } + gtk_widget_show(label); + gtk_widget_show(hbox); + gtk_widget_show(vbox); + /* + * Append graph to table. + */ + left_attach = 0; + top_attach = priv->graph_count; // % 4; + gtk_grid_attach(GTK_GRID(priv->table), hbox, + left_attach, + top_attach, + 1, + 1); + /* + * Attach signal to show ticks when label is shown. + */ + g_signal_connect_after(graph, + "button-press-event", + G_CALLBACK(uber_window_graph_button_press_event), + window); + priv->graphs = g_list_append(priv->graphs, graph); + /* + * Cleanup. + */ + g_free(formatted); + priv->graph_count++; +} + +/** + * uber_window_finalize: + * @object: A #UberWindow. + * + * Finalizer for a #UberWindow instance. Frees any resources held by + * the instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_window_finalize (GObject *object) /* IN */ +{ + UberWindowPrivate *priv; + + priv = UBER_WINDOW(object)->priv; + g_list_free(priv->graphs); + G_OBJECT_CLASS(uber_window_parent_class)->finalize(object); +} + +/** + * uber_window_class_init: + * @klass: A #UberWindowClass. + * + * Initializes the #UberWindowClass and prepares the vtable. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_window_class_init (UberWindowClass *klass) /* IN */ +{ + GObjectClass *object_class; + + object_class = G_OBJECT_CLASS(klass); + object_class->finalize = uber_window_finalize; +} + +/** + * uber_window_init: + * @window: A #UberWindow. + * + * Initializes the newly created #UberWindow instance. + * + * Returns: None. + * Side effects: None. + */ +static void +uber_window_init (UberWindow *window) /* IN */ +{ + UberWindowPrivate *priv; + + window->priv = uber_window_get_instance_private(window); + + /* + * Initialize defaults. + */ + priv = window->priv; + gtk_window_set_title(GTK_WINDOW(window), "Uber Graph"); + gtk_window_set_default_size(GTK_WINDOW(window), 750, 550); + gtk_container_set_border_width(GTK_CONTAINER(window), 12); + /* + * Create notebook container for pages. + */ + priv->notebook = gtk_notebook_new(); + gtk_notebook_set_show_border(GTK_NOTEBOOK(priv->notebook), FALSE); + gtk_notebook_set_show_tabs(GTK_NOTEBOOK(priv->notebook), FALSE); + gtk_container_add(GTK_CONTAINER(window), priv->notebook); + gtk_widget_show(priv->notebook); + /* + * Create table for graphs. + */ + priv->table = gtk_grid_new(); + gtk_grid_set_row_homogeneous(GTK_GRID(priv->table), TRUE); + gtk_grid_set_column_homogeneous(GTK_GRID(priv->table), TRUE); + gtk_notebook_append_page(GTK_NOTEBOOK(priv->notebook), priv->table, NULL); + gtk_widget_show(priv->table); +} diff --git a/deps/uber-graph/uber-window.h b/deps/uber-graph/uber-window.h new file mode 100644 index 00000000..e913e852 --- /dev/null +++ b/deps/uber-graph/uber-window.h @@ -0,0 +1,65 @@ +/* uber-window.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_WINDOW_H__ +#define __UBER_WINDOW_H__ + +#include <gtk/gtk.h> + +#include "uber-graph.h" + +G_BEGIN_DECLS + +#define UBER_TYPE_WINDOW (uber_window_get_type()) +#define UBER_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_WINDOW, UberWindow)) +#define UBER_WINDOW_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UBER_TYPE_WINDOW, UberWindow const)) +#define UBER_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UBER_TYPE_WINDOW, UberWindowClass)) +#define UBER_IS_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UBER_TYPE_WINDOW)) +#define UBER_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UBER_TYPE_WINDOW)) +#define UBER_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UBER_TYPE_WINDOW, UberWindowClass)) + +typedef struct _UberWindow UberWindow; +typedef struct _UberWindowClass UberWindowClass; +typedef struct _UberWindowPrivate UberWindowPrivate; + +struct _UberWindow +{ + GtkWindow parent; + + /*< private >*/ + UberWindowPrivate *priv; +}; + +struct _UberWindowClass +{ + GtkWindowClass parent_class; +}; + +GType uber_window_get_type (void) G_GNUC_CONST; +GtkWidget* uber_window_new (void); +void uber_window_add_graph (UberWindow *window, + UberGraph *graph, + const gchar *title); +void uber_window_show_labels (UberWindow *window, + UberGraph *graph); +void uber_window_hide_labels (UberWindow *window, + UberGraph *graph); + +G_END_DECLS + +#endif /* __UBER_WINDOW_H__ */ diff --git a/deps/uber-graph/uber.h b/deps/uber-graph/uber.h new file mode 100644 index 00000000..b101dfd7 --- /dev/null +++ b/deps/uber-graph/uber.h @@ -0,0 +1,30 @@ +/* uber.h + * + * Copyright (C) 2010 Christian Hergert <chris@dronelabs.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __UBER_H__ +#define __UBER_H__ + +#include "uber-graph.h" +#include "uber-line-graph.h" +#include "uber-heat-map.h" +#include "uber-range.h" +#include "uber-scatter.h" +#include "uber-scale.h" +#include "uber-window.h" + +#endif /* __UBER_H__ */ |