Moved from Mate-Extra repository

1 files changed, 675 insertions, 0 deletions

diff --git a/baobab/src/baobab-ringschart.c b/baobab/src/baobab-ringschart.c
new file mode 100644
index 00000000..4e51c01e
--- /dev/null
+++ b/baobab/src/baobab-ringschart.c
@@ -0,0 +1,675 @@
+/*
+ * baobab-ringschart.c
+ *
+ * Copyright (C) 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 <math.h>
+#include <string.h>
+
+#include <gtk/gtk.h>
+#include <pango/pangocairo.h>
+
+#include "baobab-chart.h"
+#include "baobab-ringschart.h"
+
+#define BAOBAB_RINGSCHART_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
+                                            BAOBAB_RINGSCHART_TYPE, \
+                                            BaobabRingschartPrivate))
+
+#define ITEM_BORDER_WIDTH  1
+#define CHART_PADDING     13
+#define ITEM_MIN_ANGLE     0.03
+#define EDGE_ANGLE         0.004
+
+#define SUBFOLDER_TIP_PADDING 3
+
+G_DEFINE_TYPE (BaobabRingschart, baobab_ringschart, BAOBAB_CHART_TYPE);
+
+typedef struct _BaobabRingschartItem BaobabRingschartItem;
+
+struct _BaobabRingschartItem
+{
+  gdouble min_radius;
+  gdouble max_radius;
+  gdouble start_angle;
+  gdouble angle;
+  gboolean continued;
+};
+
+struct _BaobabRingschartPrivate
+{
+  gboolean subfoldertips_enabled;
+  BaobabChartItem *highlighted_item;
+  guint tips_timeout_event;
+  GList *subtip_items;
+  gboolean drawing_subtips;
+  gint subtip_timeout;
+};
+
+static void baobab_ringschart_class_init (BaobabRingschartClass *class);
+static void baobab_ringschart_init (BaobabRingschart *object);
+static void baobab_ringschart_draw_sector (cairo_t *cr,
+                                           gdouble center_x, gdouble center_y,
+                                           gdouble radius, gdouble thickness,
+                                           gdouble init_angle, gdouble final_angle,
+                                           BaobabChartColor fill_color,
+                                           gboolean continued, guint border);
+static void baobab_ringschart_draw_item (GtkWidget *chart,
+                                         cairo_t *cr,
+                                         BaobabChartItem *item,
+                                         gboolean highlighted);
+static void baobab_ringschart_calculate_item_geometry (GtkWidget *chart,
+                                                       BaobabChartItem *item);
+static gboolean baobab_ringschart_is_point_over_item (GtkWidget *chart,
+                                                      BaobabChartItem *item,
+                                                      gdouble x,
+                                                      gdouble y);
+static void baobab_ringschart_get_point_min_rect (gdouble cx, gdouble cy,
+                                                  gdouble radius, gdouble angle,
+                                                  GdkRectangle *rect);
+static void baobab_ringschart_get_item_rectangle (GtkWidget *chart,
+                                                  BaobabChartItem *item);
+static void baobab_ringschart_pre_draw (GtkWidget *chart, cairo_t *cr);
+static void baobab_ringschart_post_draw (GtkWidget *chart, cairo_t *cr);
+
+
+static void
+baobab_ringschart_class_init (BaobabRingschartClass *class)
+{
+  GObjectClass *obj_class;
+  BaobabChartClass *chart_class;
+
+  obj_class = G_OBJECT_CLASS (class);
+  chart_class = BAOBAB_CHART_CLASS (class);
+
+  /* BaobabChart abstract methods */
+  chart_class->draw_item = baobab_ringschart_draw_item;
+  chart_class->calculate_item_geometry = baobab_ringschart_calculate_item_geometry;
+  chart_class->is_point_over_item = baobab_ringschart_is_point_over_item;
+  chart_class->get_item_rectangle = baobab_ringschart_get_item_rectangle;
+  chart_class->pre_draw = baobab_ringschart_pre_draw;
+  chart_class->post_draw = baobab_ringschart_post_draw;
+
+  g_type_class_add_private (obj_class, sizeof (BaobabRingschartPrivate));
+}
+
+static void
+baobab_ringschart_init (BaobabRingschart *chart)
+{
+  BaobabRingschartPrivate *priv;
+  GtkSettings* settings;
+  gint timeout;
+
+  priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+
+  priv->subfoldertips_enabled = FALSE;
+  priv->highlighted_item = NULL;
+  priv->tips_timeout_event = 0;
+  priv->subtip_items = NULL;
+  priv->drawing_subtips = FALSE;
+
+  settings = gtk_settings_get_default ();
+  g_object_get (G_OBJECT (settings), "gtk-tooltip-timeout", &timeout, NULL);
+  priv->subtip_timeout = 2 * timeout;
+}
+
+static void
+baobab_ringschart_draw_sector (cairo_t *cr,
+                               gdouble center_x,
+                               gdouble center_y,
+                               gdouble radius,
+                               gdouble thickness,
+                               gdouble init_angle,
+                               gdouble final_angle,
+                               BaobabChartColor fill_color,
+                               gboolean continued,
+                               guint border)
+{
+  cairo_set_line_width (cr, border);
+  if (radius > 0)
+    cairo_arc (cr, center_x, center_y, radius, init_angle, final_angle);
+  cairo_arc_negative (cr, center_x, center_y, radius+thickness,
+                      final_angle, init_angle);
+  cairo_close_path(cr);
+
+  cairo_set_source_rgb (cr, fill_color.red, fill_color.green, fill_color.blue);
+  cairo_fill_preserve (cr);
+  cairo_set_source_rgb (cr, 0, 0, 0);
+  cairo_stroke (cr);
+
+  if (continued)
+    {
+      cairo_set_line_width (cr, 3);
+      cairo_arc (cr, center_x, center_y, radius+thickness + 4,
+                 init_angle+EDGE_ANGLE, final_angle-EDGE_ANGLE);
+      cairo_stroke (cr);
+    }
+}
+
+static void
+baobab_ringschart_draw_item (GtkWidget *chart,
+                             cairo_t *cr,
+                             BaobabChartItem *item,
+                             gboolean highlighted)
+{
+  BaobabRingschartPrivate *priv;
+  BaobabRingschartItem *data;
+  BaobabChartColor fill_color;
+  GtkAllocation allocation;
+
+  priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+
+  data = (BaobabRingschartItem *) item->data;
+
+  if (priv->drawing_subtips)
+    if ( (priv->highlighted_item) && (item->parent) &&
+         (((BaobabChartItem *) item->parent->data) == priv->highlighted_item) )
+      {
+        GList *node;
+        node = g_new0 (GList, 1);
+        node->data = (gpointer) item;
+
+        node->next = priv->subtip_items;
+        if (priv->subtip_items)
+          priv->subtip_items->prev = node;
+        priv->subtip_items = node;
+      }
+
+  baobab_chart_get_item_color (&fill_color,
+                               data->start_angle / M_PI * 99,
+                               item->depth,
+                               highlighted);
+
+  gtk_widget_get_allocation (chart, &allocation);
+  baobab_ringschart_draw_sector (cr,
+                                 allocation.width / 2,
+                                 allocation.height / 2,
+                                 data->min_radius,
+                                 data->max_radius - data->min_radius,
+                                 data->start_angle,
+                                 data->start_angle + data->angle,
+                                 fill_color,
+                                 data->continued,
+                                 ITEM_BORDER_WIDTH);
+}
+
+static void
+baobab_ringschart_calculate_item_geometry (GtkWidget *chart,
+                                           BaobabChartItem *item)
+{
+  BaobabRingschartItem *data;
+  BaobabRingschartItem p_data;
+  BaobabChartItem *parent = NULL;
+  GtkAllocation allocation;
+
+  gdouble max_radius;
+  gdouble thickness;
+  guint max_depth;
+
+  max_depth = baobab_chart_get_max_depth (chart);
+
+  if (item->data == NULL)
+    item->data = g_new (BaobabRingschartItem, 1);
+
+  data = (BaobabRingschartItem *) item->data;
+
+  data->continued = FALSE;
+  item->visible = FALSE;
+
+  gtk_widget_get_allocation (chart, &allocation);
+  max_radius = MIN (allocation.width / 2, allocation.height / 2) - CHART_PADDING;
+  thickness = max_radius / (max_depth + 1);
+
+  if (item->parent == NULL)
+    {
+      data->min_radius = 0;
+      data->max_radius = thickness;
+      data->start_angle = 0;
+      data->angle = 2 * M_PI;
+    }
+  else
+    {
+      parent = (BaobabChartItem *) item->parent->data;
+      g_memmove (&p_data, parent->data, sizeof (BaobabRingschartItem));
+
+      data->min_radius = (item->depth) * thickness;
+
+      if (data->min_radius + thickness > max_radius)
+        return;
+      else
+        data->max_radius = data->min_radius + thickness;
+
+      data->angle = p_data.angle * item->rel_size / 100;
+      if (data->angle < ITEM_MIN_ANGLE)
+        return;
+
+      data->start_angle = p_data.start_angle + p_data.angle * item->rel_start / 100;
+
+      data->continued = (item->has_any_child) && (item->depth == max_depth);
+
+      parent->has_visible_children = TRUE;
+    }
+
+  item->visible = TRUE;
+  baobab_ringschart_get_item_rectangle (chart, item);
+}
+
+static gboolean
+baobab_ringschart_is_point_over_item (GtkWidget *chart,
+                                      BaobabChartItem *item,
+                                      gdouble x,
+                                      gdouble y)
+{
+  BaobabRingschartItem *data;
+  gdouble radius, angle;
+  GtkAllocation allocation;
+
+  data = (BaobabRingschartItem *) item->data;
+  gtk_widget_get_allocation (chart, &allocation);
+  x = x - allocation.width / 2;
+  y = y - allocation.height / 2;
+
+  radius = sqrt (x*x + y*y);
+  angle = atan2 (y, x);
+  angle = (angle > 0) ? angle : angle + 2*G_PI;
+
+  return (radius >= data->min_radius) &&
+         (radius <= data->max_radius) &&
+         (angle >= data->start_angle) &&
+         (angle <= data->start_angle + data->angle);
+}
+
+static void
+baobab_ringschart_get_point_min_rect (gdouble cx,
+                                      gdouble cy,
+                                      gdouble radius,
+                                      gdouble angle,
+                                      GdkRectangle *rect)
+{
+  gdouble x, y;
+
+  x = cx + cos (angle) * radius;
+  y = cy + sin (angle) * radius;
+
+  rect->x = MIN (rect->x, x);
+  rect->y = MIN (rect->y, y);
+  rect->width = MAX (rect->width, x);
+  rect->height = MAX (rect->height, y);
+}
+
+static void
+baobab_ringschart_get_item_rectangle (GtkWidget *chart,
+                                       BaobabChartItem *item)
+{
+  BaobabRingschartItem *data;
+  GdkRectangle rect;
+  gdouble cx, cy, r1, r2, a1, a2;
+  GtkAllocation allocation;
+
+  data = (BaobabRingschartItem *) item->data;
+
+  gtk_widget_get_allocation (chart, &allocation);
+  cx = allocation.width / 2;
+  cy = allocation.height / 2;
+  r1 = data->min_radius;
+  r2 = data->max_radius;
+  a1 = data->start_angle;
+  a2 = data->start_angle + data->angle;
+
+  rect.x = allocation.width;
+  rect.y = allocation.height;
+  rect.width = 0;
+  rect.height = 0;
+
+  baobab_ringschart_get_point_min_rect (cx, cy, r1, a1, &rect);
+  baobab_ringschart_get_point_min_rect (cx, cy, r2, a1, &rect);
+  baobab_ringschart_get_point_min_rect (cx, cy, r1, a2, &rect);
+  baobab_ringschart_get_point_min_rect (cx, cy, r2, a2, &rect);
+
+  if ( (a1 <= M_PI/2) && (a2 >= M_PI/2) )
+    rect.height = MAX (rect.height, cy + sin (M_PI/2) * r2);
+
+  if ( (a1 <= M_PI) && (a2 >= M_PI) )
+    rect.x = MIN (rect.x, cx + cos (M_PI) * r2);
+
+  if ( (a1 <= M_PI*1.5) && (a2 >= M_PI*1.5) )
+    rect.y = MIN (rect.y, cy + sin (M_PI*1.5) * r2);
+
+  if ( (a1 <= M_PI*2) && (a2 >= M_PI*2) )
+    rect.width = MAX (rect.width, cx + cos (M_PI*2) * r2);
+
+  rect.width -= rect.x;
+  rect.height -= rect.y;
+
+  item->rect = rect;
+}
+
+gboolean
+baobab_ringschart_subfolder_tips_timeout (gpointer data)
+{
+  BaobabRingschartPrivate *priv;
+
+  priv = BAOBAB_RINGSCHART_GET_PRIVATE (data);
+
+  priv->drawing_subtips = TRUE;
+
+  gtk_widget_queue_draw (GTK_WIDGET (data));
+
+  return FALSE;
+}
+
+void
+baobab_ringschart_clean_subforlder_tips_state (GtkWidget *chart)
+{
+  BaobabRingschartPrivate *priv;
+  GList *node;
+
+  priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+
+  if (priv->drawing_subtips)
+    gtk_widget_queue_draw (chart);
+
+  priv->drawing_subtips = FALSE;
+
+  if (priv->highlighted_item == NULL)
+    return;
+
+  if (priv->tips_timeout_event)
+    {
+      g_source_remove (priv->tips_timeout_event);
+      priv->tips_timeout_event = 0;
+    }
+
+  priv->highlighted_item = NULL;
+
+  /* Free subtip_items GList */
+  node = priv->subtip_items;
+  while (node != NULL)
+    {
+      priv->subtip_items = node->next;
+      g_free (node);
+
+      node = priv->subtip_items;
+    }
+  priv->subtip_items = NULL;
+}
+
+static void
+baobab_ringschart_draw_subfolder_tips (GtkWidget *chart, cairo_t *cr)
+{
+  BaobabRingschartPrivate *priv;
+  GList *node;
+  BaobabChartItem *item;
+  BaobabRingschartItem *data;
+
+  gdouble q_angle, q_width, q_height;
+
+  gdouble tip_x, tip_y;
+  gdouble middle_angle, middle_angle_n, middle_radius;
+  gdouble sector_center_x, sector_center_y;
+  gdouble a;
+  guint i;
+  GtkAllocation allocation;
+
+  PangoLayout *layout;
+  PangoRectangle layout_rect;
+  gchar *markup = NULL;
+
+  cairo_rectangle_t tooltip_rect;
+  GdkRectangle _rect, last_rect;
+
+  priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+
+  gtk_widget_get_allocation (chart, &allocation);
+  q_width = allocation.width / 2;
+  q_height = allocation.height / 2;
+  q_angle = atan2 (q_height, q_width);
+
+  memset (&last_rect, 0, sizeof (GdkRectangle));
+
+  cairo_save (cr);
+
+  node = priv->subtip_items;
+  while (node != NULL)
+    {
+      item = (BaobabChartItem *) node->data;
+      data = (BaobabRingschartItem *) item->data;
+
+      /* get the middle angle */
+      middle_angle = data->start_angle + data->angle / 2;
+
+      /* normalize the middle angle (take it to the first quadrant) */
+      middle_angle_n = middle_angle;
+      while (middle_angle_n > M_PI/2)
+        middle_angle_n -= M_PI;
+      middle_angle_n = ABS (middle_angle_n);
+
+      /* get the pango layout and its enclosing rectangle */
+      layout = gtk_widget_create_pango_layout (chart, NULL);
+      markup = g_strconcat ("<span size=\"small\">", item->name, "</span>", NULL);
+      pango_layout_set_markup (layout, markup, -1);
+      g_free (markup);
+      pango_layout_set_indent (layout, 0);
+      pango_layout_set_spacing (layout, 0);
+      pango_layout_get_pixel_extents (layout, NULL, &layout_rect);
+
+      /* get the center point of the tooltip rectangle */
+      if (middle_angle_n < q_angle)
+        {
+          tip_x = q_width - layout_rect.width/2 - SUBFOLDER_TIP_PADDING * 2;
+          tip_y = tan (middle_angle_n) * tip_x;
+        }
+      else
+        {
+          tip_y = q_height - layout_rect.height/2 - SUBFOLDER_TIP_PADDING * 2;
+          tip_x = tip_y / tan (middle_angle_n);
+        }
+
+      /* get the tooltip rectangle */
+      tooltip_rect.x = q_width + tip_x - layout_rect.width/2 - SUBFOLDER_TIP_PADDING;
+      tooltip_rect.y = q_height + tip_y - layout_rect.height/2 - SUBFOLDER_TIP_PADDING;
+      tooltip_rect.width = layout_rect.width + SUBFOLDER_TIP_PADDING * 2;
+      tooltip_rect.height = layout_rect.height + SUBFOLDER_TIP_PADDING * 2;
+
+      /* Check tooltip's width is not greater than half of the widget */
+      if (tooltip_rect.width > q_width)
+        {
+          g_object_unref (layout);
+          node = node->next;
+          continue;
+        }
+
+      /* translate tooltip rectangle and edge angles to the original quadrant */
+      a = middle_angle;
+      i = 0;
+      while (a > M_PI/2)
+        {
+          if (i % 2 == 0)
+            tooltip_rect.x = allocation.width - tooltip_rect.x
+                             - tooltip_rect.width;
+          else
+            tooltip_rect.y = allocation.height - tooltip_rect.y
+                             - tooltip_rect.height;
+
+          i++;
+          a -= M_PI/2;
+        }
+
+      /* get the GdkRectangle of the tooltip (with a little padding) */
+      _rect.x = tooltip_rect.x - 1;
+      _rect.y = tooltip_rect.y - 1;
+      _rect.width = tooltip_rect.width + 2;
+      _rect.height = tooltip_rect.height + 2;
+
+      /* Check if tooltip overlaps */
+      if (! gdk_rectangle_intersect (&_rect, &last_rect, NULL))
+        {
+          g_memmove (&last_rect, &_rect, sizeof (GdkRectangle));
+
+          /* Finally draw the tooltip to cairo! */
+
+          /* TODO: Do not hardcode colors */
+
+          /* avoid blurred lines */
+          tooltip_rect.x = floor (tooltip_rect.x) + 0.5;
+          tooltip_rect.y = floor (tooltip_rect.y) + 0.5;
+
+          middle_radius = data->min_radius + (data->max_radius - data->min_radius) / 2;
+          sector_center_x = q_width + middle_radius * cos (middle_angle);
+          sector_center_y = q_height + middle_radius * sin (middle_angle);
+
+          /* draw line from sector center to tooltip center */
+          cairo_set_line_width (cr, 1);
+          cairo_move_to (cr, sector_center_x, sector_center_y);
+          cairo_set_source_rgb (cr, 0.8275, 0.8431, 0.8118); /* tango: #d3d7cf */
+          cairo_line_to (cr, tooltip_rect.x + tooltip_rect.width / 2,
+                             tooltip_rect.y + tooltip_rect.height / 2);
+          cairo_stroke (cr);
+
+          /* draw a tiny circle in sector center */
+          cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.6666 );
+          cairo_arc (cr, sector_center_x, sector_center_y, 1.0, 0, 2 * G_PI );
+          cairo_stroke (cr);
+
+          /* draw tooltip box */
+          cairo_set_line_width (cr, 0.5);
+          cairo_rectangle (cr, tooltip_rect.x, tooltip_rect.y,
+                               tooltip_rect.width, tooltip_rect.height);
+          cairo_set_source_rgb (cr, 0.8275, 0.8431, 0.8118);  /* tango: #d3d7cf */
+          cairo_fill_preserve(cr);
+          cairo_set_source_rgb (cr, 0.5333, 0.5412, 0.5216);  /* tango: #888a85 */
+          cairo_stroke (cr);
+
+          /* draw the text inside the box */
+          cairo_set_source_rgb (cr, 0, 0, 0);
+          cairo_move_to (cr, tooltip_rect.x + SUBFOLDER_TIP_PADDING,
+                             tooltip_rect.y + SUBFOLDER_TIP_PADDING);
+          pango_cairo_show_layout (cr, layout);
+          cairo_set_line_width (cr, 1);
+          cairo_stroke (cr);
+        }
+
+      /* Free stuff */
+      g_object_unref (layout);
+
+      node = node->next;
+    }
+
+  cairo_restore (cr);
+}
+
+static void
+baobab_ringschart_pre_draw (GtkWidget *chart, cairo_t *cr)
+{
+  BaobabRingschartPrivate *priv;
+  BaobabChartItem *hl_item;
+
+  priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+
+  hl_item = baobab_chart_get_highlighted_item (chart);
+
+  if ( (hl_item == NULL) || (! hl_item->has_visible_children) )
+    {
+      baobab_ringschart_clean_subforlder_tips_state (chart);
+
+      return;
+    }
+
+  if (hl_item != priv->highlighted_item)
+    {
+      baobab_ringschart_clean_subforlder_tips_state (chart);
+
+      priv->highlighted_item = hl_item;
+
+      /* Launch timer to show subfolder tooltips */
+      priv->tips_timeout_event = g_timeout_add (priv->subtip_timeout,
+                        (GSourceFunc) baobab_ringschart_subfolder_tips_timeout,
+                        (gpointer) chart);
+    }
+}
+
+static void
+baobab_ringschart_post_draw (GtkWidget *chart, cairo_t *cr)
+{
+  BaobabRingschartPrivate *priv;
+
+  priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+
+  if (priv->drawing_subtips)
+    {
+      /* Reverse the glist, which was created from the tail */
+      priv->subtip_items = g_list_reverse (priv->subtip_items);
+
+      baobab_ringschart_draw_subfolder_tips (chart, cr);
+    }
+}
+
+/* Public functions start here */
+
+/**
+ * baobab_ringschart_new:
+ *
+ * Constructor for the baobab_ringschart class
+ *
+ * Returns: a new #BaobabRingschart object
+ *
+ **/
+GtkWidget *
+baobab_ringschart_new (void)
+{
+  return g_object_new (BAOBAB_RINGSCHART_TYPE, NULL);
+}
+
+/**
+ * baobab_ringschart_set_subfoldertips_enabled:
+ * @chart: the #BaobabRingschart to set the
+ * @enabled: boolean to determine whether to show sub-folder tips.
+ *
+ * Enables/disables drawing tooltips of sub-forlders of the highlighted sector.
+ *
+ * Fails if @chart is not a #BaobabRingschart.
+ *
+ **/
+void
+baobab_ringschart_set_subfoldertips_enabled (GtkWidget *chart, gboolean enabled)
+{
+  BaobabRingschartPrivate *priv;
+
+  priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+
+  priv->subfoldertips_enabled = enabled;
+
+  if ( (! enabled) && (priv->drawing_subtips) )
+    {
+      /* Turn off currently drawn tips */
+      baobab_ringschart_clean_subforlder_tips_state (chart);
+    }
+}