Moved from Mate-Extra repository

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);
+}