1 files changed, 1876 insertions, 0 deletions
diff --git a/baobab/src/baobab-chart.c b/baobab/src/baobab-chart.c
new file mode 100644
index 00000000..dce8bfb6
--- /dev/null
+++ b/baobab/src/baobab-chart.c
@@ -0,0 +1,1876 @@
+/*
+ * baobab-chart.c
+ *
+ * Copyright (C) 2006, 2007, 2008 Igalia
+ *
+ * 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 2 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Felipe Erias <[email protected]>
+ * Pablo Santamaria <[email protected]>
+ * Jacobo Aragunde <[email protected]>
+ * Eduardo Lima <[email protected]>
+ * Mario Sanchez <[email protected]>
+ * Miguel Gomez <[email protected]>
+ * Henrique Ferreiro <[email protected]>
+ * Alejandro Pinheiro <[email protected]>
+ * Carlos Sanmartin <[email protected]>
+ * Alejandro Garcia <[email protected]>
+ */
+
+#include <config.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+
+#include "baobab-chart.h"
+
+#define BAOBAB_CHART_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
+ BAOBAB_CHART_TYPE, \
+ BaobabChartPrivate))
+
+#define SNAPSHOT_DEF_FILENAME_FORMAT "%s-disk-usage"
+
+G_DEFINE_ABSTRACT_TYPE (BaobabChart, baobab_chart, GTK_TYPE_WIDGET);
+
+#define BAOBAB_CHART_MAX_DEPTH 8
+#define BAOBAB_CHART_MIN_DEPTH 1
+
+enum
+{
+ LEFT_BUTTON = 1,
+ MIDDLE_BUTTON = 2,
+ RIGHT_BUTTON = 3
+};
+
+struct _BaobabChartPrivate
+{
+ guint name_column;
+ guint size_column;
+ guint info_column;
+ guint percentage_column;
+ guint valid_column;
+ gboolean button_pressed;
+ gboolean is_frozen;
+ cairo_surface_t *memento;
+
+ guint max_depth;
+ gboolean model_changed;
+
+ GtkTreeModel *model;
+ GtkTreeRowReference *root;
+
+ GList *first_item;
+ GList *last_item;
+ GList *highlighted_item;
+};
+
+/* Signals */
+enum
+{
+ ITEM_ACTIVATED,
+ LAST_SIGNAL
+};
+
+static guint baobab_chart_signals [LAST_SIGNAL] = { 0 };
+
+/* Properties */
+enum
+{
+ PROP_0,
+ PROP_MAX_DEPTH,
+ PROP_MODEL,
+ PROP_ROOT,
+};
+
+/* Colors */
+const BaobabChartColor baobab_chart_tango_colors[] = {{0.94, 0.16, 0.16}, /* tango: ef2929 */
+ {0.68, 0.49, 0.66}, /* tango: ad7fa8 */
+ {0.45, 0.62, 0.82}, /* tango: 729fcf */
+ {0.54, 0.89, 0.20}, /* tango: 8ae234 */
+ {0.91, 0.73, 0.43}, /* tango: e9b96e */
+ {0.99, 0.68, 0.25}}; /* tango: fcaf3e */
+
+static void baobab_chart_class_init (BaobabChartClass *class);
+static void baobab_chart_init (BaobabChart *object);
+static void baobab_chart_realize (GtkWidget *widget);
+static void baobab_chart_dispose (GObject *object);
+static void baobab_chart_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation);
+static void baobab_chart_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void baobab_chart_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void baobab_chart_free_items (GtkWidget *chart);
+static void baobab_chart_draw (GtkWidget *chart,
+ cairo_t *cr,
+ GdkRectangle area);
+static void baobab_chart_update_draw (BaobabChart *chart,
+ GtkTreePath *path);
+static void baobab_chart_row_changed (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data);
+static void baobab_chart_row_inserted (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data);
+static void baobab_chart_row_has_child_toggled (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data);
+static void baobab_chart_row_deleted (GtkTreeModel *model,
+ GtkTreePath *path,
+ gpointer data);
+static void baobab_chart_rows_reordered (GtkTreeModel *model,
+ GtkTreePath *parent,
+ GtkTreeIter *iter,
+ gint *new_order,
+ gpointer data);
+static gboolean baobab_chart_expose (GtkWidget *chart,
+ GdkEventExpose *event);
+static void baobab_chart_interpolate_colors (BaobabChartColor *color,
+ BaobabChartColor colora,
+ BaobabChartColor colorb,
+ gdouble percentage);
+static gint baobab_chart_button_release (GtkWidget *widget,
+ GdkEventButton *event);
+static gint baobab_chart_scroll (GtkWidget *widget,
+ GdkEventScroll *event);
+static gint baobab_chart_motion_notify (GtkWidget *widget,
+ GdkEventMotion *event);
+static gint baobab_chart_leave_notify (GtkWidget *widget,
+ GdkEventCrossing *event);
+static inline void baobab_chart_disconnect_signals (GtkWidget *chart,
+ GtkTreeModel *model);
+static inline void baobab_chart_connect_signals (GtkWidget *chart,
+ GtkTreeModel *model);
+static void baobab_chart_get_items (GtkWidget *chart, GtkTreePath *root);
+static gboolean baobab_chart_query_tooltip (GtkWidget *widget,
+ gint x,
+ gint y,
+ gboolean keyboard_mode,
+ GtkTooltip *tooltip,
+ gpointer user_data);
+
+
+static void
+baobab_chart_class_init (BaobabChartClass *class)
+{
+ GObjectClass *obj_class;
+ GtkWidgetClass *widget_class;
+
+ obj_class = G_OBJECT_CLASS (class);
+ widget_class = GTK_WIDGET_CLASS (class);
+
+ /* GtkObject signals */
+ obj_class->set_property = baobab_chart_set_property;
+ obj_class->get_property = baobab_chart_get_property;
+ obj_class->dispose = baobab_chart_dispose;
+
+ /* GtkWidget signals */
+ widget_class->realize = baobab_chart_realize;
+ widget_class->expose_event = baobab_chart_expose;
+ widget_class->size_allocate = baobab_chart_size_allocate;
+ widget_class->scroll_event = baobab_chart_scroll;
+
+ /* Baobab Chart abstract methods */
+ class->draw_item = NULL;
+ class->pre_draw = NULL;
+ class->post_draw = NULL;
+ class->calculate_item_geometry = NULL;
+ class->is_point_over_item = NULL;
+ class->get_item_rectangle = NULL;
+ class->can_zoom_in = NULL;
+ class->can_zoom_out = NULL;
+
+ g_object_class_install_property (obj_class,
+ PROP_MAX_DEPTH,
+ g_param_spec_int ("max-depth",
+ _("Maximum depth"),
+ _("The maximum depth drawn in the chart from the root"),
+ 1,
+ BAOBAB_CHART_MAX_DEPTH,
+ BAOBAB_CHART_MAX_DEPTH,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (obj_class,
+ PROP_MODEL,
+ g_param_spec_object ("model",
+ _("Chart model"),
+ _("Set the model of the chart"),
+ GTK_TYPE_TREE_MODEL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (obj_class,
+ PROP_ROOT,
+ g_param_spec_boxed ("root",
+ _("Chart root node"),
+ _("Set the root node from the model"),
+ GTK_TYPE_TREE_ITER,
+ G_PARAM_READWRITE));
+
+ baobab_chart_signals[ITEM_ACTIVATED] =
+ g_signal_new ("item_activated",
+ G_TYPE_FROM_CLASS (obj_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (BaobabChartClass, item_activated),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__BOXED,
+ G_TYPE_NONE, 1,
+ GTK_TYPE_TREE_ITER);
+
+ g_type_class_add_private (obj_class, sizeof (BaobabChartPrivate));
+}
+
+static void
+baobab_chart_init (BaobabChart *chart)
+{
+ BaobabChartPrivate *priv;
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+ chart->priv = priv;
+
+ priv->model = NULL;
+ priv->max_depth = BAOBAB_CHART_MAX_DEPTH;
+ priv->name_column = 0;
+ priv->size_column = 0;
+ priv->info_column = 0;
+ priv->percentage_column = 0;
+ priv->valid_column = 0;
+ priv->button_pressed = FALSE;
+ priv->is_frozen = FALSE;
+ priv->memento = NULL;
+ priv->root = NULL;
+
+ priv->first_item = NULL;
+ priv->last_item = NULL;
+ priv->highlighted_item = NULL;
+}
+
+static void
+baobab_chart_dispose (GObject *object)
+{
+ BaobabChartPrivate *priv;
+
+ baobab_chart_free_items (GTK_WIDGET (object));
+
+ priv = BAOBAB_CHART (object)->priv;
+
+ if (priv->model)
+ {
+ baobab_chart_disconnect_signals (GTK_WIDGET (object),
+ priv->model);
+
+ g_object_unref (priv->model);
+
+ priv->model = NULL;
+ }
+
+ if (priv->root)
+ {
+ gtk_tree_row_reference_free (priv->root);
+
+ priv->root = NULL;
+ }
+
+ G_OBJECT_CLASS (baobab_chart_parent_class)->dispose (object);
+}
+
+static void
+baobab_chart_realize (GtkWidget *widget)
+{
+ BaobabChart *chart;
+ GdkWindowAttr attributes;
+ gint attributes_mask;
+ GtkAllocation allocation;
+ GdkWindow *window;
+
+ g_return_if_fail (BAOBAB_IS_CHART (widget));
+
+ chart = BAOBAB_CHART (widget);
+ gtk_widget_set_realized (widget, TRUE);
+
+ gtk_widget_get_allocation (widget, &allocation);
+
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.x = allocation.x;
+ attributes.y = allocation.y;
+ attributes.width = allocation.width;
+ attributes.height = allocation.height;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.visual = gtk_widget_get_visual (widget);
+ attributes.colormap = gtk_widget_get_colormap (widget);
+ attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
+
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+ window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes,
+ attributes_mask);
+ gtk_widget_set_window (widget, window);
+ gdk_window_set_user_data (window, chart);
+
+ gtk_widget_style_attach (widget);
+ gtk_style_set_background (gtk_widget_get_style (widget),
+ window,
+ GTK_STATE_NORMAL);
+
+ gtk_widget_add_events (widget,
+ GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
+ GDK_POINTER_MOTION_HINT_MASK | GDK_LEAVE_NOTIFY_MASK);
+}
+
+static void
+baobab_chart_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartClass *class;
+ BaobabChartItem *item;
+ GList *node;
+
+ g_return_if_fail (BAOBAB_IS_CHART (widget));
+ g_return_if_fail (allocation != NULL);
+
+ priv = BAOBAB_CHART (widget)->priv;
+ class = BAOBAB_CHART_GET_CLASS (widget);
+
+ gtk_widget_set_allocation (widget, allocation);
+
+ if (gtk_widget_get_realized (widget))
+ {
+ gdk_window_move_resize (gtk_widget_get_window (widget),
+ allocation->x, allocation->y,
+ allocation->width, allocation->height);
+
+ node = priv->first_item;
+ while (node != NULL)
+ {
+ item = (BaobabChartItem *) node->data;
+ item->has_visible_children = FALSE;
+ item->visible = FALSE;
+ class->calculate_item_geometry (widget, item);
+
+ node = node->next;
+ }
+ }
+}
+
+static void
+baobab_chart_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ BaobabChart *chart;
+
+ chart = BAOBAB_CHART (object);
+
+ switch (prop_id)
+ {
+ case PROP_MAX_DEPTH:
+ baobab_chart_set_max_depth (GTK_WIDGET (chart), g_value_get_int (value));
+ break;
+ case PROP_MODEL:
+ baobab_chart_set_model (GTK_WIDGET (chart), g_value_get_object (value));
+ break;
+ case PROP_ROOT:
+ baobab_chart_set_root (GTK_WIDGET (chart), g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+baobab_chart_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ BaobabChartPrivate *priv;
+
+ priv = BAOBAB_CHART (object)->priv;
+
+ switch (prop_id)
+ {
+ case PROP_MAX_DEPTH:
+ g_value_set_int (value, priv->max_depth);
+ break;
+ case PROP_MODEL:
+ g_value_set_object (value, priv->model);
+ break;
+ case PROP_ROOT:
+ g_value_set_object (value, priv->root);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static GList
+*baobab_chart_add_item (GtkWidget *chart,
+ guint depth,
+ gdouble rel_start,
+ gdouble rel_size,
+ GtkTreeIter iter)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartItem *item;
+
+ gchar *name;
+ gchar *size;
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+
+ gtk_tree_model_get (priv->model, &iter,
+ priv->name_column, &name, -1);
+ gtk_tree_model_get (priv->model, &iter,
+ priv->size_column, &size, -1);
+
+ item = g_new (BaobabChartItem, 1);
+ item->name = name;
+ item->size = size;
+ item->depth = depth;
+ item->rel_start = rel_start;
+ item->rel_size = rel_size;
+ item->has_any_child = FALSE;
+ item->visible = FALSE;
+ item->has_visible_children = FALSE;
+
+ item->iter = iter;
+
+ item->parent = NULL;
+ item->data = NULL;
+
+ priv->last_item = g_list_prepend (priv->last_item, item);
+
+ return priv->last_item;
+}
+
+static void
+baobab_chart_free_items (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartItem *item;
+ GList *node;
+ GList *next;
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+
+ node = priv->first_item;
+ while (node != NULL)
+ {
+ next = node->next;
+
+ item = (BaobabChartItem *) node->data;
+
+ g_free (item->name);
+ g_free (item->size);
+
+ g_free (item->data);
+ item->data = NULL;
+
+ g_free (item);
+ g_list_free_1 (node);
+
+ node = next;
+ }
+
+ priv->first_item = NULL;
+ priv->last_item = NULL;
+ priv->highlighted_item = NULL;
+}
+
+static void
+baobab_chart_get_items (GtkWidget *chart, GtkTreePath *root)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartItem *item;
+
+ GList *node;
+ GtkTreeIter initial_iter = {0};
+ gdouble size;
+ GtkTreePath *model_root_path;
+ GtkTreeIter model_root_iter;
+
+ BaobabChartClass *class;
+ GtkTreeIter child_iter = {0};
+ GList *child_node;
+ BaobabChartItem *child;
+ gdouble rel_start;
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+
+ /* First we free current item list */
+ baobab_chart_free_items (chart);
+
+ /* Get the tree iteration corresponding to root */
+ if (!gtk_tree_model_get_iter (priv->model, &initial_iter, root))
+ {
+ priv->model_changed = FALSE;
+ return;
+ }
+
+
+
+ model_root_path = gtk_tree_path_new_first ();
+ gtk_tree_model_get_iter (priv->model, &model_root_iter, model_root_path);
+ gtk_tree_path_free (model_root_path);
+
+ gtk_tree_model_get (priv->model, &model_root_iter,
+ priv->percentage_column, &size, -1);
+
+ /* Create first item */
+ node = baobab_chart_add_item (chart, 0, 0, 100, initial_iter);
+
+ /* Iterate through childs building the list */
+ class = BAOBAB_CHART_GET_CLASS (chart);
+
+ do
+ {
+ item = (BaobabChartItem *) node->data;
+ item->has_any_child = gtk_tree_model_iter_children (priv->model,
+ &child_iter,
+ &(item->iter));
+
+ /* Calculate item geometry */
+ class->calculate_item_geometry (chart, item);
+
+ if (! item->visible)
+ {
+ node = node->prev;
+ continue;
+ }
+
+ /* Get item's children and add them to the list */
+ if ((item->has_any_child) && (item->depth < priv->max_depth + 1))
+ {
+ rel_start = 0;
+
+ do
+ {
+ gtk_tree_model_get (priv->model, &child_iter,
+ priv->percentage_column, &size, -1);
+
+ child_node = baobab_chart_add_item (chart,
+ item->depth + 1,
+ rel_start,
+ size,
+ child_iter);
+ child = (BaobabChartItem *) child_node->data;
+ child->parent = node;
+ rel_start += size;
+ }
+ while (gtk_tree_model_iter_next (priv->model, &child_iter));
+ }
+
+ node = node->prev;
+ }
+ while (node != NULL);
+
+ /* Reverse the list, 'cause we created it from the tail, for efficiency reasons */
+ priv->first_item = g_list_reverse (priv->last_item);
+
+ priv->model_changed = FALSE;
+}
+
+static void
+baobab_chart_draw (GtkWidget *chart,
+ cairo_t *cr,
+ GdkRectangle area)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartClass *class;
+
+ GList *node;
+ BaobabChartItem *item;
+ gboolean highlighted;
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+ class = BAOBAB_CHART_GET_CLASS (chart);
+
+ /* call pre-draw abstract method */
+ if (class->pre_draw)
+ class->pre_draw (chart, cr);
+
+ cairo_save (cr);
+
+ node = priv->first_item;
+ while (node != NULL)
+ {
+ item = (BaobabChartItem *) node->data;
+
+ if ((item->visible) && (gdk_rectangle_intersect (&area, &item->rect, NULL))
+ && (item->depth <= priv->max_depth))
+ {
+ highlighted = (node == priv->highlighted_item);
+
+ class->draw_item (chart, cr, item, highlighted);
+ }
+
+ node = node->next;
+ }
+
+ cairo_restore (cr);
+
+ /* call post-draw abstract method */
+ if (class->post_draw)
+ class->post_draw (chart, cr);
+}
+
+static void
+baobab_chart_update_draw (BaobabChart* chart,
+ GtkTreePath *path)
+{
+ BaobabChartPrivate *priv;
+ GtkTreePath *root_path = NULL;
+ gint root_depth, node_depth;
+
+ if (!gtk_widget_get_realized ( GTK_WIDGET (chart)))
+ return;
+
+ priv = BAOBAB_CHART (chart)->priv;
+
+ if (priv->root != NULL)
+ {
+ root_path = gtk_tree_row_reference_get_path (priv->root);
+
+ if (root_path == NULL)
+ {
+ gtk_tree_row_reference_free (priv->root);
+ priv->root = NULL;
+ }
+ }
+
+ if (priv->root == NULL)
+ root_path = gtk_tree_path_new_first ();
+
+
+ root_depth = gtk_tree_path_get_depth (root_path);
+ node_depth = gtk_tree_path_get_depth (path);
+
+ if (((node_depth-root_depth)<=priv->max_depth)&&
+ ((gtk_tree_path_is_ancestor (root_path, path))||
+ (gtk_tree_path_compare (root_path, path) == 0)))
+ {
+ gtk_widget_queue_draw (GTK_WIDGET (chart));
+ }
+
+ gtk_tree_path_free (root_path);
+}
+
+static void
+baobab_chart_row_changed (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
+{
+ g_return_if_fail (BAOBAB_IS_CHART (data));
+ g_return_if_fail (path != NULL || iter != NULL);
+
+ BAOBAB_CHART_GET_PRIVATE (data)->model_changed = TRUE;
+
+ baobab_chart_update_draw (BAOBAB_CHART (data), path);
+}
+
+static void
+baobab_chart_row_inserted (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
+{
+ g_return_if_fail (BAOBAB_IS_CHART (data));
+ g_return_if_fail (path != NULL || iter != NULL);
+
+ BAOBAB_CHART_GET_PRIVATE (data)->model_changed = TRUE;
+
+ baobab_chart_update_draw (BAOBAB_CHART (data), path);
+}
+
+static void
+baobab_chart_row_has_child_toggled (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
+{
+ g_return_if_fail (BAOBAB_IS_CHART (data));
+ g_return_if_fail (path != NULL || iter != NULL);
+
+ BAOBAB_CHART_GET_PRIVATE (data)->model_changed = TRUE;
+
+ baobab_chart_update_draw (BAOBAB_CHART (data), path);
+}
+
+static void
+baobab_chart_row_deleted (GtkTreeModel *model,
+ GtkTreePath *path,
+ gpointer data)
+{
+ g_return_if_fail (BAOBAB_IS_CHART (data));
+ g_return_if_fail (path != NULL);
+
+ BAOBAB_CHART_GET_PRIVATE (data)->model_changed = TRUE;
+
+ baobab_chart_update_draw (BAOBAB_CHART (data), path);
+
+}
+
+static void
+baobab_chart_rows_reordered (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gint *new_order,
+ gpointer data)
+{
+ g_return_if_fail (BAOBAB_IS_CHART (data));
+ g_return_if_fail (path != NULL || iter != NULL);
+
+ BAOBAB_CHART_GET_PRIVATE (data)->model_changed = TRUE;
+
+ baobab_chart_update_draw (BAOBAB_CHART (data), path);
+
+}
+
+static gboolean
+baobab_chart_expose (GtkWidget *chart, GdkEventExpose *event)
+{
+ cairo_t *cr;
+ BaobabChartPrivate *priv;
+ gint w, h;
+ gdouble p, sx, sy;
+ GtkTreePath *root_path = NULL;
+ GtkTreePath *current_path = NULL;
+ GtkAllocation allocation;
+
+ priv = BAOBAB_CHART (chart)->priv;
+
+ /* the columns are not set we paint nothing */
+ if (priv->name_column == priv->percentage_column)
+ return FALSE;
+
+ /* get a cairo_t */
+ cr = gdk_cairo_create (gtk_widget_get_window (chart));
+
+ cairo_rectangle (cr,
+ event->area.x, event->area.y,
+ event->area.width, event->area.height);
+
+ /* there is no model we can not paint */
+ if ((priv->is_frozen) || (priv->model == NULL))
+ {
+ if (priv->memento != NULL)
+ {
+ w = cairo_image_surface_get_width (priv->memento);
+ h = cairo_image_surface_get_height (priv->memento);
+
+ cairo_clip (cr);
+
+ gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
+ if (w > 0 && h > 0 &&
+ !(allocation.width == w && allocation.height == h))
+ {
+ /* minimal available proportion */
+ p = MIN (allocation.width / (1.0 * w),
+ allocation.height / (1.0 * h));
+
+ sx = (gdouble) (allocation.width - w * p) / 2.0;
+ sy = (gdouble) (allocation.height - h * p) / 2.0;
+
+ cairo_translate (cr, sx, sy);
+ cairo_scale (cr, p, p);
+ }
+
+ cairo_set_source_surface (cr,
+ priv->memento,
+ 0, 0);
+ cairo_paint (cr);
+ }
+ }
+ else
+ {
+ cairo_set_source_rgb (cr, 1, 1, 1);
+ cairo_fill_preserve (cr);
+
+ cairo_clip (cr);
+
+ if (priv->root != NULL)
+ root_path = gtk_tree_row_reference_get_path (priv->root);
+
+ if (root_path == NULL) {
+ root_path = gtk_tree_path_new_first ();
+ priv->root = NULL;
+ }
+
+ /* Check if tree model was modified in any way */
+ if ((priv->model_changed) ||
+ (priv->first_item == NULL))
+ baobab_chart_get_items (chart, root_path);
+ else
+ {
+ /* Check if root was changed */
+ current_path = gtk_tree_model_get_path (priv->model,
+ &((BaobabChartItem*) priv->first_item->data)->iter);
+
+ if (gtk_tree_path_compare (root_path, current_path) != 0)
+ baobab_chart_get_items (chart, root_path);
+
+ gtk_tree_path_free (current_path);
+ }
+
+ gtk_tree_path_free (root_path);
+
+ baobab_chart_draw (chart, cr, event->area);
+ }
+
+ cairo_destroy (cr);
+
+ return FALSE;
+}
+
+static void
+baobab_chart_interpolate_colors (BaobabChartColor *color,
+ BaobabChartColor colora,
+ BaobabChartColor colorb,
+ gdouble percentage)
+{
+ gdouble diff;
+
+ diff = colora.red - colorb.red;
+ color->red = colora.red-diff*percentage;
+
+ diff = colora.green - colorb.green;
+ color->green = colora.green-diff*percentage;
+
+ diff = colora.blue - colorb.blue;
+ color->blue = colora.blue-diff*percentage;
+}
+
+void
+baobab_chart_get_item_color (BaobabChartColor *color,
+ gdouble rel_position,
+ gint depth,
+ gboolean highlighted)
+{
+ gdouble intensity;
+ gint color_number;
+ gint next_color_number;
+ gdouble maximum;
+ static const BaobabChartColor level_color = {0.83, 0.84, 0.82};
+ static const BaobabChartColor level_color_hl = {0.88, 0.89, 0.87};
+
+ intensity = 1 - (((depth-1)*0.3) / BAOBAB_CHART_MAX_DEPTH);
+
+ if (depth == 0)
+ *color = level_color;
+ else
+ {
+ color_number = rel_position / (100/3);
+ next_color_number = (color_number + 1) % 6;
+
+ baobab_chart_interpolate_colors (color,
+ baobab_chart_tango_colors[color_number],
+ baobab_chart_tango_colors[next_color_number],
+ (rel_position - color_number * 100/3) / (100/3));
+ color->red = color->red * intensity;
+ color->green = color->green * intensity;
+ color->blue = color->blue * intensity;
+ }
+
+ if (highlighted)
+ {
+ if (depth == 0)
+ *color = level_color_hl;
+ else
+ {
+ maximum = MAX (color->red,
+ MAX (color->green,
+ color->blue));
+ color->red /= maximum;
+ color->green /= maximum;
+ color->blue /= maximum;
+ }
+ }
+}
+
+static gint
+baobab_chart_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ BaobabChartPrivate *priv;
+
+ priv = BAOBAB_CHART (widget)->priv;
+
+ if (priv->is_frozen)
+ return TRUE;
+
+ switch (event->button)
+ {
+ case LEFT_BUTTON:
+ /* Enter into a subdir */
+ if (priv->highlighted_item != NULL)
+ g_signal_emit (BAOBAB_CHART (widget),
+ baobab_chart_signals[ITEM_ACTIVATED],
+ 0, &((BaobabChartItem*) priv->highlighted_item->data)->iter);
+
+ break;
+
+ case MIDDLE_BUTTON:
+ /* Go back to the parent dir */
+ baobab_chart_move_up_root (widget);
+ break;
+ }
+
+ return FALSE;
+}
+
+static gint
+baobab_chart_scroll (GtkWidget *widget,
+ GdkEventScroll *event)
+{
+ switch (event->direction)
+ {
+ case GDK_SCROLL_LEFT :
+ case GDK_SCROLL_UP :
+ if (baobab_chart_can_zoom_out (widget))
+ baobab_chart_zoom_out (widget);
+ /* change the selected item when zooming */
+ baobab_chart_motion_notify (widget, (GdkEventMotion *)event);
+ break;
+
+ case GDK_SCROLL_RIGHT :
+ case GDK_SCROLL_DOWN :
+ if (baobab_chart_can_zoom_in (widget))
+ baobab_chart_zoom_in (widget);
+ break;
+ }
+
+ return FALSE;
+}
+
+static void
+baobab_chart_set_item_highlight (GtkWidget *chart,
+ GList *node,
+ gboolean highlighted)
+{
+ BaobabChartItem *item;
+ BaobabChartPrivate *priv;
+ BaobabChartClass *class;
+
+ if (node == NULL)
+ return;
+
+ item = (BaobabChartItem *) node->data;
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+ class = BAOBAB_CHART_GET_CLASS (chart);
+
+ if (highlighted)
+ priv->highlighted_item = node;
+ else
+ priv->highlighted_item = NULL;
+
+ gdk_window_invalidate_rect (gtk_widget_get_window ( GTK_WIDGET (chart)),
+ &item->rect, TRUE);
+}
+
+static gint
+baobab_chart_motion_notify (GtkWidget *widget,
+ GdkEventMotion *event)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartClass *class;
+ GList *node;
+ BaobabChartItem *item;
+ gboolean found = FALSE;
+
+ priv = BAOBAB_CHART_GET_PRIVATE (widget);
+ class = BAOBAB_CHART_GET_CLASS (widget);
+
+ /* Check if the pointer is over an item */
+ node = priv->last_item;
+ while (node != NULL)
+ {
+ item = (BaobabChartItem *) node->data;
+
+ if ((item->visible) && (class->is_point_over_item (widget, item, event->x, event->y)))
+ {
+ if (priv->highlighted_item != node)
+ {
+ baobab_chart_set_item_highlight (widget, priv->highlighted_item, FALSE);
+
+ gtk_widget_set_has_tooltip (widget, TRUE);
+ baobab_chart_set_item_highlight (widget, node, TRUE);
+ }
+
+ found = TRUE;
+ break;
+ }
+ node = node->prev;
+ }
+
+ /* If we never found a highlighted item, but there is an old highlighted item,
+ redraw it to turn it off */
+ if (! found)
+ {
+ baobab_chart_set_item_highlight (widget, priv->highlighted_item, FALSE);
+ gtk_widget_set_has_tooltip (widget, FALSE);
+ }
+
+ /* Continue receiving motion notifies */
+ gdk_event_request_motions (event);
+
+ return FALSE;
+}
+
+static gint
+baobab_chart_leave_notify (GtkWidget *widget,
+ GdkEventCrossing *event)
+{
+ BaobabChartPrivate *priv;
+
+ priv = BAOBAB_CHART_GET_PRIVATE (widget);
+ baobab_chart_set_item_highlight (widget, priv->highlighted_item, FALSE);
+
+ return FALSE;
+}
+
+static inline void
+baobab_chart_connect_signals (GtkWidget *chart,
+ GtkTreeModel *model)
+{
+ g_signal_connect (model,
+ "row_changed",
+ G_CALLBACK (baobab_chart_row_changed),
+ chart);
+ g_signal_connect (model,
+ "row_inserted",
+ G_CALLBACK (baobab_chart_row_inserted),
+ chart);
+ g_signal_connect (model,
+ "row_has_child_toggled",
+ G_CALLBACK (baobab_chart_row_has_child_toggled),
+ chart);
+ g_signal_connect (model,
+ "row_deleted",
+ G_CALLBACK (baobab_chart_row_deleted),
+ chart);
+ g_signal_connect (model,
+ "rows_reordered",
+ G_CALLBACK (baobab_chart_rows_reordered),
+ chart);
+ g_signal_connect (chart,
+ "query-tooltip",
+ G_CALLBACK (baobab_chart_query_tooltip),
+ chart);
+ g_signal_connect (chart,
+ "motion-notify-event",
+ G_CALLBACK (baobab_chart_motion_notify),
+ chart);
+ g_signal_connect (chart,
+ "leave-notify-event",
+ G_CALLBACK (baobab_chart_leave_notify),
+ chart);
+ g_signal_connect (chart,
+ "button-release-event",
+ G_CALLBACK (baobab_chart_button_release),
+ chart);
+}
+
+static inline void
+baobab_chart_disconnect_signals (GtkWidget *chart,
+ GtkTreeModel *model)
+{
+ g_signal_handlers_disconnect_by_func (model,
+ baobab_chart_row_changed,
+ chart);
+ g_signal_handlers_disconnect_by_func (model,
+ baobab_chart_row_inserted,
+ chart);
+ g_signal_handlers_disconnect_by_func (model,
+ baobab_chart_row_has_child_toggled,
+ chart);
+ g_signal_handlers_disconnect_by_func (model,
+ baobab_chart_row_deleted,
+ chart);
+ g_signal_handlers_disconnect_by_func (model,
+ baobab_chart_rows_reordered,
+ chart);
+ g_signal_handlers_disconnect_by_func (chart,
+ baobab_chart_query_tooltip,
+ chart);
+ g_signal_handlers_disconnect_by_func (chart,
+ baobab_chart_motion_notify,
+ chart);
+ g_signal_handlers_disconnect_by_func (chart,
+ baobab_chart_leave_notify,
+ chart);
+ g_signal_handlers_disconnect_by_func (chart,
+ baobab_chart_button_release,
+ chart);
+}
+
+static gboolean
+baobab_chart_query_tooltip (GtkWidget *widget,
+ gint x,
+ gint y,
+ gboolean keyboard_mode,
+ GtkTooltip *tooltip,
+ gpointer user_data)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartItem *item;
+ char *markup;
+
+ priv = BAOBAB_CHART_GET_PRIVATE (widget);
+
+ if (priv->highlighted_item == NULL)
+ return FALSE;
+
+ item = (BaobabChartItem *) priv->highlighted_item->data;
+
+ if ( (item->name == NULL) || (item->size == NULL) )
+ return FALSE;
+
+ gtk_tooltip_set_tip_area (tooltip, &item->rect);
+
+ markup = g_strconcat (item->name,
+ "\n",
+ item->size,
+ NULL);
+ gtk_tooltip_set_markup (tooltip, markup);
+ g_free (markup);
+
+ return TRUE;
+}
+
+GdkPixbuf*
+baobab_chart_get_pixbuf (GtkWidget *widget)
+{
+ gint w, h;
+ GdkPixbuf *pixbuf;
+
+ g_return_val_if_fail (BAOBAB_IS_CHART (widget), NULL);
+
+ #if GTK_CHECK_VERSION(3, 0, 0)
+ w = gdk_window_get_width(gtk_widget_get_window(widget));
+ h = gdk_window_get_height(gtk_widget_get_window(widget));
+ #else
+ gdk_drawable_get_size(gtk_widget_get_window(widget), &w, &h);
+ #endif
+
+ pixbuf = gdk_pixbuf_get_from_drawable (NULL,
+ gtk_widget_get_window (widget),
+ gdk_colormap_get_system (),
+ 0, 0,
+ 0, 0,
+ w, h);
+
+ return pixbuf;
+}
+
+/* Public functions start here */
+
+/**
+ * baobab_chart_new:
+ *
+ * Constructor for the baobab_chart class
+ *
+ * Returns: a new #BaobabChart object
+ *
+ **/
+GtkWidget *
+baobab_chart_new ()
+{
+ return g_object_new (BAOBAB_CHART_TYPE, NULL);
+}
+
+/**
+ * baobab_chart_set_model_with_columns:
+ * @chart: the #BaobabChart whose model is going to be set
+ * @model: the #GtkTreeModel which is going to set as the model of
+ * @chart
+ * @name_column: number of column inside @model where the file name is
+ * stored
+ * @size_column: number of column inside @model where the file size is
+ * stored
+ * @info_column: number of column inside @model where the percentage
+ * of disk usage is stored
+ * @percentage_column: number of column inside @model where the disk
+ * usage percentage is stored
+ * @valid_column: number of column inside @model where the flag indicating
+ * if the row data is right or not.
+ * @root: a #GtkTreePath indicating the node of @model which will be
+ * used as root.
+ *
+ * Sets @model as the #GtkTreeModel used by @chart. Indicates the
+ * columns inside @model where the values file name, file
+ * size, file information, disk usage percentage and data correction are stored, and
+ * the node which will be used as the root of @chart. Once
+ * the model has been successfully set, a redraw of the window is
+ * forced.
+ * This function is intended to be used the first time a #GtkTreeModel
+ * is assigned to @chart, or when the columns containing the needed data
+ * are going to change. In other cases, #baobab_chart_set_model should
+ * be used.
+ * This function does not change the state of the signals from the model, which
+ * is controlled by he #baobab_chart_freeze_updates and the
+ * #baobab_chart_thaw_updates functions.
+ *
+ * Fails if @chart is not a #BaobabChart or if @model is not a
+ * #GtkTreeModel.
+ **/
+void
+baobab_chart_set_model_with_columns (GtkWidget *chart,
+ GtkTreeModel *model,
+ guint name_column,
+ guint size_column,
+ guint info_column,
+ guint percentage_column,
+ guint valid_column,
+ GtkTreePath *root)
+{
+ BaobabChartPrivate *priv;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+ g_return_if_fail (GTK_IS_TREE_MODEL (model));
+
+ priv = BAOBAB_CHART (chart)->priv;
+
+ baobab_chart_set_model (chart, model);
+
+ if (root != NULL)
+ {
+ priv->root = gtk_tree_row_reference_new (model, root);
+ g_object_notify (G_OBJECT (chart), "root");
+ }
+
+ priv->name_column = name_column;
+ priv->size_column = size_column;
+ priv->info_column = info_column;
+ priv->percentage_column = percentage_column;
+ priv->valid_column = valid_column;
+}
+
+/**
+ * baobab_chart_set_model:
+ * @chart: the #BaobabChart whose model is going to be set
+ * @model: the #GtkTreeModel which is going to set as the model of
+ * @chart
+ *
+ * Sets @model as the #GtkTreeModel used by @chart, and takes the needed
+ * data from the columns especified in the last call to
+ * #baobab_chart_set_model_with_colums.
+ * This function does not change the state of the signals from the model, which
+ * is controlled by he #baobab_chart_freeze_updates and the
+ * #baobab_chart_thaw_updates functions.
+ *
+ * Fails if @chart is not a #BaobabChart or if @model is not a
+ * #GtkTreeModel.
+ **/
+void
+baobab_chart_set_model (GtkWidget *chart,
+ GtkTreeModel *model)
+{
+ BaobabChartPrivate *priv;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+ g_return_if_fail (GTK_IS_TREE_MODEL (model));
+
+ priv = BAOBAB_CHART (chart)->priv;
+
+ if (model == priv->model)
+ return;
+
+ if (priv->model)
+ {
+ if (! priv->is_frozen)
+ baobab_chart_disconnect_signals (chart,
+ priv->model);
+ g_object_unref (priv->model);
+ }
+
+ priv->model = model;
+ g_object_ref (priv->model);
+
+ if (! priv->is_frozen)
+ baobab_chart_connect_signals (chart,
+ priv->model);
+
+ if (priv->root)
+ gtk_tree_row_reference_free (priv->root);
+
+ priv->root = NULL;
+
+ g_object_notify (G_OBJECT (chart), "model");
+
+ gtk_widget_queue_draw (chart);
+}
+
+/**
+ * baobab_chart_get_model:
+ * @chart: a #BaobabChart whose model will be returned.
+ *
+ * Returns the #GtkTreeModel which is the model used by @chart.
+ *
+ * Returns: %NULL if @chart is not a #BaobabChart.
+ **/
+GtkTreeModel *
+baobab_chart_get_model (GtkWidget *chart)
+{
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), NULL);
+
+ return BAOBAB_CHART (chart)->priv->model;
+}
+
+/**
+ * baobab_chart_set_max_depth:
+ * @chart: a #BaobabChart
+ * @max_depth: the new maximum depth to show in the widget.
+ *
+ * Sets the maximum number of nested levels that are going to be show in the
+ * wigdet, and causes a redraw of the widget to show the new maximum
+ * depth. If max_depth is < 1 MAX_DRAWABLE_DEPTH is used.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+void
+baobab_chart_set_max_depth (GtkWidget *chart,
+ guint max_depth)
+{
+ BaobabChartPrivate *priv;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+
+ max_depth = MIN (max_depth, BAOBAB_CHART_MAX_DEPTH);
+ max_depth = MAX (max_depth, BAOBAB_CHART_MIN_DEPTH);
+
+ if (max_depth == priv->max_depth)
+ return;
+
+ priv->max_depth = max_depth;
+ g_object_notify (G_OBJECT (chart), "max-depth");
+
+ priv->model_changed = TRUE;
+
+ gtk_widget_queue_draw (chart);
+}
+
+/**
+ * baobab_chart_get_max_depth:
+ * @chart: a #BaobabChart.
+ *
+ * Returns the maximum number of levels that will be show in the
+ * widget.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+guint
+baobab_chart_get_max_depth (GtkWidget *chart)
+{
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), 0);
+
+ return BAOBAB_CHART (chart)->priv->max_depth;
+}
+
+/**
+ * baobab_chart_set_root:
+ * @chart: a #BaobabChart
+ * @root: a #GtkTreePath indicating the node which will be used as
+ * the widget root.
+ *
+ * Sets the node pointed by @root as the new root of the widget
+ * @chart.
+ *
+ * Fails if @chart is not a #BaobabChart or if @chart has not
+ * a #GtkTreeModel set.
+ **/
+void
+baobab_chart_set_root (GtkWidget *chart,
+ GtkTreePath *root)
+{
+ BaobabChartPrivate *priv;
+ GtkTreePath *current_root;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+
+ priv = BAOBAB_CHART (chart)->priv;
+
+ g_return_if_fail (priv->model != NULL);
+
+ if (priv->root) {
+ /* Check that given root is different from current */
+ current_root = gtk_tree_row_reference_get_path (priv->root);
+ if ( (current_root) && (gtk_tree_path_compare (current_root, root) == 0) )
+ return;
+
+ /* Free current root */
+ gtk_tree_row_reference_free (priv->root);
+ }
+
+ priv->root = gtk_tree_row_reference_new (priv->model, root);
+
+ g_object_notify (G_OBJECT (chart), "root");
+
+ gtk_widget_queue_draw (chart);
+}
+
+/**
+ * baobab_chart_get_root:
+ * @chart: a #BaobabChart.
+ *
+ * Returns a #GtkTreePath pointing to the root of the widget. The
+ * programmer has the responsability to free the used memory once
+ * finished with the returned value. It returns NULL if there is no
+ * root node defined
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+GtkTreePath*
+baobab_chart_get_root (GtkWidget *chart)
+{
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), NULL);
+
+ if (BAOBAB_CHART (chart)->priv->root)
+ return gtk_tree_row_reference_get_path (BAOBAB_CHART (chart)->priv->root);
+ else
+ return NULL;
+}
+
+/**
+ * baobab_chart_freeze_updates:
+ * @chart: the #BaobabChart whose model signals are going to be frozen.
+ *
+ * Disconnects @chart from the signals emitted by its model, and sets
+ * the window of @chart to a "processing" state, so that the window
+ * ignores changes in the chart's model and mouse events.
+ * In order to connect again the window to the model, a call to
+ * #baobab_chart_thaw_updates must be done.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+void
+baobab_chart_freeze_updates (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+ cairo_surface_t *surface = NULL;
+ cairo_t *cr = NULL;
+ GdkRectangle area;
+ GtkAllocation allocation;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+
+ if (priv->is_frozen)
+ return;
+
+ if (priv->model)
+ baobab_chart_disconnect_signals (chart,
+ priv->model);
+
+ gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
+ surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
+ allocation.width,
+ allocation.height);
+
+ if (cairo_surface_status (surface) == CAIRO_STATUS_SUCCESS)
+ {
+ cr = cairo_create (surface);
+
+ area.x = 0;
+ area.y = 0;
+ area.width = allocation.width;
+ area.height = allocation.height;
+ baobab_chart_draw (chart, cr, area);
+
+ cairo_rectangle (cr,
+ 0, 0,
+ allocation.width,
+ allocation.height);
+
+ cairo_set_source_rgba (cr, 0.93, 0.93, 0.93, 0.5); /* tango: eeeeec */
+ cairo_fill_preserve (cr);
+
+ cairo_clip (cr);
+
+ priv->memento = surface;
+
+ cairo_destroy (cr);
+ }
+
+ priv->is_frozen = TRUE;
+
+ gtk_widget_queue_draw (chart);
+}
+
+/**
+ * baobab_chart_thaw_updates:
+ * @chart: the #BaobabChart whose model signals are frozen.
+ *
+ * Reconnects @chart to the signals emitted by its model, which
+ * were disconnected through a call to #baobab_chart_freeze_updates.
+ * Takes the window out of its "processing" state and forces a redraw
+ * of the widget.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+void
+baobab_chart_thaw_updates (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+
+ if (priv->is_frozen)
+ {
+ if (priv->model)
+ baobab_chart_connect_signals (chart,
+ priv->model);
+
+ if (priv->memento)
+ {
+ cairo_surface_destroy (priv->memento);
+ priv->memento = NULL;
+ }
+
+ priv->is_frozen = FALSE;
+
+ priv->model_changed = TRUE;
+ gtk_widget_queue_draw (chart);
+ }
+}
+
+/**
+ * baobab_chart_zoom_in:
+ * @chart: the #BaobabChart requested to zoom in.
+ *
+ * Zooms in the chart by decreasing its maximun depth.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+void
+baobab_chart_zoom_in (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartClass *class;
+ guint new_max_depth;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+
+ priv = BAOBAB_CHART (chart)->priv;
+ class = BAOBAB_CHART_GET_CLASS (chart);
+
+ if (class->can_zoom_in != NULL)
+ new_max_depth = class->can_zoom_in (chart);
+ else
+ new_max_depth = priv->max_depth - 1;
+
+ baobab_chart_set_max_depth (chart, new_max_depth);
+}
+
+/**
+ * baobab_chart_zoom_out:
+ * @chart: the #BaobabChart requested to zoom out.
+ *
+ * Zooms out the chart by increasing its maximun depth.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+void
+baobab_chart_zoom_out (GtkWidget *chart)
+{
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+
+ baobab_chart_set_max_depth (chart,
+ baobab_chart_get_max_depth (chart) + 1);
+}
+
+/**
+ * baobab_chart_move_up_root:
+ * @chart: the #BaobabChart whose root is requested to move up one level.
+ *
+ * Move root to the inmediate parent of the current root item of @chart.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+void
+baobab_chart_move_up_root (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+
+ GtkTreeIter parent_iter;
+ GtkTreePath *path;
+ GtkTreeIter root_iter;
+
+ gint valid;
+ GtkTreePath *parent_path;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+
+ if (priv->root == NULL)
+ return;
+
+ path = gtk_tree_row_reference_get_path (priv->root);
+
+ if (path != NULL)
+ gtk_tree_model_get_iter (priv->model, &root_iter, path);
+ else
+ return;
+
+ if (gtk_tree_model_iter_parent (priv->model, &parent_iter, &root_iter))
+ {
+ gtk_tree_model_get (priv->model, &parent_iter, priv->valid_column,
+ &valid, -1);
+
+ if (valid == -1)
+ return;
+
+ gtk_tree_row_reference_free (priv->root);
+ parent_path = gtk_tree_model_get_path (priv->model, &parent_iter);
+ priv->root = gtk_tree_row_reference_new (priv->model, parent_path);
+ gtk_tree_path_free (parent_path);
+
+ g_signal_emit (BAOBAB_CHART (chart),
+ baobab_chart_signals[ITEM_ACTIVATED],
+ 0, &parent_iter);
+
+ gtk_widget_queue_draw (chart);
+ }
+
+ gtk_tree_path_free (path);
+}
+
+/**
+ * baobab_chart_save_snapshot:
+ * @chart: the #BaobabChart requested to be exported to image.
+ *
+ * Opens a dialog to allow saving the current chart's image as a PNG, JPEG or
+ * BMP image.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+void
+baobab_chart_save_snapshot (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+
+ GdkPixbuf *pixbuf;
+
+ GtkWidget *fs_dlg;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *label;
+ GtkWidget *opt_menu;
+ gchar *sel_type;
+ gchar *filename;
+ gchar *def_filename;
+
+ BaobabChartItem *item;
+
+ g_return_if_fail (BAOBAB_IS_CHART (chart));
+
+ while (gtk_events_pending ())
+ gtk_main_iteration ();
+
+ /* Get the chart's pixbuf */
+ pixbuf = baobab_chart_get_pixbuf (chart);
+ if (pixbuf == NULL)
+ {
+ GtkWidget *dialog;
+ dialog = gtk_message_dialog_new (NULL,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ _("Cannot create pixbuf image!"));
+ gtk_dialog_run (GTK_DIALOG (dialog));
+ gtk_widget_destroy (dialog);
+
+ return;
+ }
+
+ priv = BAOBAB_CHART (chart)->priv;
+
+ /* Popup the File chooser dialog */
+ fs_dlg = gtk_file_chooser_dialog_new (_("Save Snapshot"),
+ NULL,
+ GTK_FILE_CHOOSER_ACTION_SAVE,
+ GTK_STOCK_CANCEL,
+ GTK_RESPONSE_CANCEL,
+ GTK_STOCK_SAVE,
+ GTK_RESPONSE_ACCEPT, NULL);
+
+ item = (BaobabChartItem *) priv->first_item->data;
+ def_filename = g_strdup_printf (SNAPSHOT_DEF_FILENAME_FORMAT, item->name);
+
+ gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fs_dlg), def_filename);
+ g_free (def_filename);
+
+ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fs_dlg),
+ g_get_home_dir ());
+
+#if GTK_CHECK_VERSION(2,8,0)
+ gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fs_dlg), TRUE);
+#endif
+
+ /* extra widget */
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
+ gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (fs_dlg), vbox);
+
+ hbox = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 6);
+
+ label = gtk_label_new_with_mnemonic (_("_Image type:"));
+ gtk_box_pack_start (GTK_BOX (hbox),
+ label,
+ FALSE, FALSE, 0);
+
+ opt_menu = gtk_combo_box_new_text ();
+ gtk_combo_box_append_text (GTK_COMBO_BOX (opt_menu), "png");
+ gtk_combo_box_append_text (GTK_COMBO_BOX (opt_menu), "jpeg");
+ gtk_combo_box_append_text (GTK_COMBO_BOX (opt_menu), "bmp");
+ gtk_combo_box_set_active (GTK_COMBO_BOX (opt_menu), 0);
+ gtk_box_pack_start (GTK_BOX (hbox), opt_menu, TRUE, TRUE, 0);
+
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), opt_menu);
+ gtk_widget_show_all (vbox);
+
+ if (gtk_dialog_run (GTK_DIALOG (fs_dlg)) == GTK_RESPONSE_ACCEPT)
+ {
+ filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fs_dlg));
+ sel_type = gtk_combo_box_get_active_text (GTK_COMBO_BOX (opt_menu));
+ if (! g_str_has_suffix (filename, sel_type))
+ {
+ gchar *tmp;
+ tmp = filename;
+ filename = g_strjoin (".", filename, sel_type, NULL);
+ g_free (tmp);
+ }
+ gdk_pixbuf_save (pixbuf, filename, sel_type, NULL, NULL);
+
+ g_free (filename);
+ g_free (sel_type);
+ }
+
+ gtk_widget_destroy (fs_dlg);
+ g_object_unref (pixbuf);
+}
+
+/**
+ * baobab_chart_is_frozen:
+ * @chart: the #BaobabChart to ask if frozen.
+ *
+ * Returns a boolean telling whether the chart is in a frozen state, meanning
+ * that no actions should be taken uppon it.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+gboolean
+baobab_chart_is_frozen (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), FALSE);
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+ return priv->is_frozen;
+}
+
+/**
+ * baobab_chart_is_frozen:
+ * @chart: the #BaobabChart to obtain the highlighted it from.
+ *
+ * Returns a BaobabChartItem corresponding to the item that currently has mouse
+ * pointer over, or NULL if no item is highlighted.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+BaobabChartItem *
+baobab_chart_get_highlighted_item (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), NULL);
+
+ priv = BAOBAB_CHART_GET_PRIVATE (chart);
+ return (priv->highlighted_item ?
+ (BaobabChartItem *) priv->highlighted_item->data : NULL);
+}
+
+/**
+ * baobab_chart_can_zoom_in:
+ * @chart: the #BaobabChart to ask if can be zoomed in.
+ *
+ * Returns a boolean telling whether the chart can be zoomed in, given its current
+ * visualization conditions.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+gboolean
+baobab_chart_can_zoom_in (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartClass *class;
+
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), FALSE);
+
+ priv = BAOBAB_CHART (chart)->priv;
+ class = BAOBAB_CHART_GET_CLASS (chart);
+
+ if (class->can_zoom_in != NULL)
+ return class->can_zoom_in (chart) > 0;
+ else
+ return priv->max_depth > 1;
+}
+
+/**
+ * baobab_chart_can_zoom_out:
+ * @chart: the #BaobabChart to ask if can be zoomed out.
+ *
+ * Returns a boolean telling whether the chart can be zoomed out, given its current
+ * visualization conditions.
+ *
+ * Fails if @chart is not a #BaobabChart.
+ **/
+gboolean
+baobab_chart_can_zoom_out (GtkWidget *chart)
+{
+ BaobabChartPrivate *priv;
+ BaobabChartClass *class;
+
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), FALSE);
+
+ priv = BAOBAB_CHART (chart)->priv;
+ class = BAOBAB_CHART_GET_CLASS (chart);
+
+ if (class->can_zoom_out != NULL)
+ return class->can_zoom_out (chart) > 0;
+ else
+ return (priv->max_depth < BAOBAB_CHART_MAX_DEPTH);
+}