[baobab/wip/vala: 7/45] clean up BaobabChart API
- From: Paolo Borelli <pborelli src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [baobab/wip/vala: 7/45] clean up BaobabChart API
- Date: Sun, 29 Jan 2012 14:44:10 +0000 (UTC)
commit 526033fbeacb4fef12d58fb748e661500244d0f2
Author: Ryan Lortie <desrt desrt ca>
Date: Thu Jan 5 14:15:48 2012 -0500
clean up BaobabChart API
Use BaobabChart* where appropriate instead of GtkWidget*.
Clean up the whitespace.
src/baobab-chart.c | 796 ++++++++++++++++++++---------------------------
src/baobab-chart.h | 154 +++++-----
src/baobab-ringschart.c | 96 +++---
src/baobab-ringschart.h | 10 +-
src/baobab-treemap.c | 58 ++--
src/baobab-treemap.h | 5 +-
6 files changed, 495 insertions(+), 624 deletions(-)
---
diff --git a/src/baobab-chart.c b/src/baobab-chart.c
index 2d9ec77..54b29cb 100644
--- a/src/baobab-chart.c
+++ b/src/baobab-chart.c
@@ -39,10 +39,6 @@
#include <gtk/gtk.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);
@@ -119,31 +115,11 @@ 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_chart (GtkWidget *chart,
+static void baobab_chart_free_items (BaobabChart *chart);
+static void baobab_chart_draw_chart (BaobabChart *chart,
cairo_t *cr);
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_draw (GtkWidget *chart,
cairo_t *cr);
static void baobab_chart_interpolate_colors (BaobabChartColor *color,
@@ -158,11 +134,11 @@ 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 void baobab_chart_disconnect_signals (BaobabChart *chart,
+ GtkTreeModel *model);
+static void baobab_chart_connect_signals (BaobabChart *chart,
+ GtkTreeModel *model);
+static void baobab_chart_get_items (BaobabChart *chart, GtkTreePath *root);
static gboolean baobab_chart_query_tooltip (GtkWidget *widget,
gint x,
gint y,
@@ -170,7 +146,6 @@ static gboolean baobab_chart_query_tooltip (GtkWidget *widget,
GtkTooltip *tooltip,
gpointer user_data);
-
static void
baobab_chart_class_init (BaobabChartClass *class)
{
@@ -243,52 +218,45 @@ baobab_chart_class_init (BaobabChartClass *class)
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;
+ chart->priv = G_TYPE_INSTANCE_GET_PRIVATE (chart, BAOBAB_TYPE_CHART, BaobabChartPrivate);
+
+ chart->priv->model = NULL;
+ chart->priv->max_depth = BAOBAB_CHART_MAX_DEPTH;
+ chart->priv->name_column = 0;
+ chart->priv->size_column = 0;
+ chart->priv->info_column = 0;
+ chart->priv->percentage_column = 0;
+ chart->priv->valid_column = 0;
+ chart->priv->button_pressed = FALSE;
+ chart->priv->is_frozen = FALSE;
+ chart->priv->memento = NULL;
+ chart->priv->root = NULL;
+
+ chart->priv->first_item = NULL;
+ chart->priv->last_item = NULL;
+ chart->priv->highlighted_item = NULL;
}
static void
baobab_chart_dispose (GObject *object)
{
- BaobabChartPrivate *priv;
+ BaobabChart *chart;
- baobab_chart_free_items (GTK_WIDGET (object));
+ chart = BAOBAB_CHART (object);
- priv = BAOBAB_CHART (object)->priv;
+ baobab_chart_free_items (chart);
- if (priv->model)
+ if (chart->priv->model)
{
- baobab_chart_disconnect_signals (GTK_WIDGET (object),
- priv->model);
-
- g_object_unref (priv->model);
-
- priv->model = NULL;
+ baobab_chart_disconnect_signals (chart, chart->priv->model);
+ g_object_unref (chart->priv->model);
+ chart->priv->model = NULL;
}
- if (priv->root)
+ if (chart->priv->root)
{
- gtk_tree_row_reference_free (priv->root);
-
- priv->root = NULL;
+ gtk_tree_row_reference_free (chart->priv->root);
+ chart->priv->root = NULL;
}
G_OBJECT_CLASS (baobab_chart_parent_class)->dispose (object);
@@ -338,10 +306,10 @@ baobab_chart_realize (GtkWidget *widget)
}
static void
-baobab_chart_size_allocate (GtkWidget *widget,
+baobab_chart_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
- BaobabChartPrivate *priv;
+ BaobabChart *chart;
BaobabChartClass *class;
BaobabChartItem *item;
GList *node;
@@ -349,8 +317,8 @@ baobab_chart_size_allocate (GtkWidget *widget,
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);
+ chart = BAOBAB_CHART (widget);
+ class = BAOBAB_CHART_GET_CLASS (chart);
gtk_widget_set_allocation (widget, allocation);
@@ -360,15 +328,12 @@ baobab_chart_size_allocate (GtkWidget *widget,
allocation->x, allocation->y,
allocation->width, allocation->height);
- node = priv->first_item;
- while (node != NULL)
+ for (node = chart->priv->first_item; node != NULL; node = node->next)
{
item = (BaobabChartItem *) node->data;
item->has_visible_children = FALSE;
item->visible = FALSE;
- class->calculate_item_geometry (widget, item);
-
- node = node->next;
+ class->calculate_item_geometry (chart, item);
}
}
}
@@ -379,20 +344,18 @@ baobab_chart_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec)
{
- BaobabChart *chart;
-
- chart = BAOBAB_CHART (object);
+ BaobabChart *chart = BAOBAB_CHART (object);
switch (prop_id)
{
case PROP_MAX_DEPTH:
- baobab_chart_set_max_depth (GTK_WIDGET (chart), g_value_get_int (value));
+ baobab_chart_set_max_depth (chart, g_value_get_int (value));
break;
case PROP_MODEL:
- baobab_chart_set_model (GTK_WIDGET (chart), g_value_get_object (value));
+ baobab_chart_set_model (chart, g_value_get_object (value));
break;
case PROP_ROOT:
- baobab_chart_set_root (GTK_WIDGET (chart), g_value_get_object (value));
+ baobab_chart_set_root (chart, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -406,20 +369,18 @@ baobab_chart_get_property (GObject *object,
GValue *value,
GParamSpec *pspec)
{
- BaobabChartPrivate *priv;
-
- priv = BAOBAB_CHART (object)->priv;
+ BaobabChart *chart = BAOBAB_CHART (object);
switch (prop_id)
{
case PROP_MAX_DEPTH:
- g_value_set_int (value, priv->max_depth);
+ g_value_set_int (value, chart->priv->max_depth);
break;
case PROP_MODEL:
- g_value_set_object (value, priv->model);
+ g_value_set_object (value, chart->priv->model);
break;
case PROP_ROOT:
- g_value_set_object (value, priv->root);
+ g_value_set_object (value, chart->priv->root);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -427,25 +388,21 @@ baobab_chart_get_property (GObject *object,
}
}
-static GList
-*baobab_chart_add_item (GtkWidget *chart,
- guint depth,
- gdouble rel_start,
- gdouble rel_size,
- GtkTreeIter iter)
+static GList *
+baobab_chart_add_item (BaobabChart *chart,
+ guint depth,
+ gdouble rel_start,
+ gdouble rel_size,
+ GtkTreeIter iter)
{
- BaobabChartPrivate *priv;
BaobabChartItem *item;
-
gchar *name;
guint64 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);
+ gtk_tree_model_get (chart->priv->model, &iter,
+ chart->priv->name_column, &name,
+ chart->priv->size_column, &size,
+ -1);
item = g_new (BaobabChartItem, 1);
item->name = name;
@@ -462,22 +419,20 @@ static GList
item->parent = NULL;
item->data = NULL;
- priv->last_item = g_list_prepend (priv->last_item, item);
+ chart->priv->last_item = g_list_prepend (chart->priv->last_item, item);
- return priv->last_item;
+ return chart->priv->last_item;
}
static void
-baobab_chart_free_items (GtkWidget *chart)
+baobab_chart_free_items (BaobabChart *chart)
{
- BaobabChartPrivate *priv;
BaobabChartItem *item;
GList *node;
GList *next;
- priv = BAOBAB_CHART_GET_PRIVATE (chart);
+ node = chart->priv->first_item;
- node = priv->first_item;
while (node != NULL)
{
next = node->next;
@@ -496,49 +451,43 @@ baobab_chart_free_items (GtkWidget *chart)
node = next;
}
- priv->first_item = NULL;
- priv->last_item = NULL;
- priv->highlighted_item = NULL;
+ chart->priv->first_item = NULL;
+ chart->priv->last_item = NULL;
+ chart->priv->highlighted_item = NULL;
}
static void
-baobab_chart_get_items (GtkWidget *chart, GtkTreePath *root)
+baobab_chart_get_items (BaobabChart *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))
+ if (!gtk_tree_model_get_iter (chart->priv->model, &initial_iter, root))
{
- priv->model_changed = FALSE;
+ chart->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_model_get_iter (chart->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);
+ gtk_tree_model_get (chart->priv->model, &model_root_iter,
+ chart->priv->percentage_column, &size, -1);
/* Create first item */
node = baobab_chart_add_item (chart, 0, 0, 100, initial_iter);
@@ -549,9 +498,7 @@ baobab_chart_get_items (GtkWidget *chart, GtkTreePath *root)
do
{
item = (BaobabChartItem *) node->data;
- item->has_any_child = gtk_tree_model_iter_children (priv->model,
- &child_iter,
- &(item->iter));
+ item->has_any_child = gtk_tree_model_iter_children (chart->priv->model, &child_iter, &(item->iter));
/* Calculate item geometry */
class->calculate_item_geometry (chart, item);
@@ -563,14 +510,13 @@ baobab_chart_get_items (GtkWidget *chart, GtkTreePath *root)
}
/* Get item's children and add them to the list */
- if ((item->has_any_child) && (item->depth < priv->max_depth + 1))
+ if ((item->has_any_child) && (item->depth < chart->priv->max_depth + 1))
{
rel_start = 0;
do
{
- gtk_tree_model_get (priv->model, &child_iter,
- priv->percentage_column, &size, -1);
+ gtk_tree_model_get (chart->priv->model, &child_iter, chart->priv->percentage_column, &size, -1);
child_node = baobab_chart_add_item (chart,
item->depth + 1,
@@ -581,7 +527,7 @@ baobab_chart_get_items (GtkWidget *chart, GtkTreePath *root)
child->parent = node;
rel_start += size;
}
- while (gtk_tree_model_iter_next (priv->model, &child_iter));
+ while (gtk_tree_model_iter_next (chart->priv->model, &child_iter));
}
node = node->prev;
@@ -589,20 +535,18 @@ baobab_chart_get_items (GtkWidget *chart, GtkTreePath *root)
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);
+ chart->priv->first_item = g_list_reverse (chart->priv->last_item);
- priv->model_changed = FALSE;
+ chart->priv->model_changed = FALSE;
}
static void
-baobab_chart_draw_chart (GtkWidget *chart,
- cairo_t *cr)
+baobab_chart_draw_chart (BaobabChart *chart,
+ cairo_t *cr)
{
- BaobabChartPrivate *priv;
BaobabChartClass *class;
GList *node;
- priv = BAOBAB_CHART_GET_PRIVATE (chart);
class = BAOBAB_CHART_GET_CLASS (chart);
/* call pre-draw abstract method */
@@ -611,8 +555,7 @@ baobab_chart_draw_chart (GtkWidget *chart,
cairo_save (cr);
- node = priv->first_item;
- while (node != NULL)
+ for (node = chart->priv->first_item; node != NULL; node = node->next)
{
BaobabChartItem *item;
GdkRectangle clip;
@@ -622,16 +565,13 @@ baobab_chart_draw_chart (GtkWidget *chart,
if (gdk_cairo_get_clip_rectangle (cr, &clip) &&
(item->visible) &&
(gdk_rectangle_intersect (&clip, &item->rect, NULL)) &&
- (item->depth <= priv->max_depth))
+ (item->depth <= chart->priv->max_depth))
{
gboolean highlighted;
- highlighted = (node == priv->highlighted_item);
-
+ highlighted = (node == chart->priv->highlighted_item);
class->draw_item (chart, cr, item, highlighted);
}
-
- node = node->next;
}
cairo_restore (cr);
@@ -645,34 +585,31 @@ 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)
+ if (chart->priv->root != NULL)
{
- root_path = gtk_tree_row_reference_get_path (priv->root);
+ root_path = gtk_tree_row_reference_get_path (chart->priv->root);
if (root_path == NULL)
{
- gtk_tree_row_reference_free (priv->root);
- priv->root = NULL;
+ gtk_tree_row_reference_free (chart->priv->root);
+ chart->priv->root = NULL;
}
}
- if (priv->root == NULL)
+ if (chart->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)&&
+ if (((node_depth-root_depth)<=chart->priv->max_depth)&&
((gtk_tree_path_is_ancestor (root_path, path))||
(gtk_tree_path_compare (root_path, path) == 0)))
{
@@ -683,101 +620,90 @@ baobab_chart_update_draw (BaobabChart* chart,
}
static void
-baobab_chart_row_changed (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer data)
+baobab_chart_row_changed (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ BaobabChart *chart)
{
- 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);
+ chart->priv->model_changed = TRUE;
+ baobab_chart_update_draw (chart, path);
}
static void
-baobab_chart_row_inserted (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer data)
+baobab_chart_row_inserted (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ BaobabChart *chart)
{
- 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);
+ chart->priv->model_changed = TRUE;
+ baobab_chart_update_draw (chart, path);
}
static void
-baobab_chart_row_has_child_toggled (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer data)
+baobab_chart_row_has_child_toggled (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ BaobabChart *chart)
{
- 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);
+ chart->priv->model_changed = TRUE;
+ baobab_chart_update_draw (chart, path);
}
static void
-baobab_chart_row_deleted (GtkTreeModel *model,
- GtkTreePath *path,
- gpointer data)
+baobab_chart_row_deleted (GtkTreeModel *model,
+ GtkTreePath *path,
+ BaobabChart *chart)
{
- 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);
-
+ chart->priv->model_changed = TRUE;
+ baobab_chart_update_draw (chart, path);
}
static void
-baobab_chart_rows_reordered (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gint *new_order,
- gpointer data)
+baobab_chart_rows_reordered (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gint *new_order,
+ BaobabChart *chart)
{
- 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);
-
+ chart->priv->model_changed = TRUE;
+ baobab_chart_update_draw (chart, path);
}
static gboolean
-baobab_chart_draw (GtkWidget *chart, cairo_t *cr)
+baobab_chart_draw (GtkWidget *widget,
+ cairo_t *cr)
{
- BaobabChartPrivate *priv;
+ BaobabChart *chart;
- priv = BAOBAB_CHART (chart)->priv;
+ chart = BAOBAB_CHART (widget);
/* the columns are not set we paint nothing */
- if (priv->name_column == priv->percentage_column)
+ if (chart->priv->name_column == chart->priv->percentage_column)
return FALSE;
/* there is no model we can not paint */
- if ((priv->is_frozen) || (priv->model == NULL))
+ if ((chart->priv->is_frozen) || (chart->priv->model == NULL))
{
- if (priv->memento != NULL)
+ if (chart->priv->memento != NULL)
{
gint w, h, aw, ah;
gdouble p, sx, sy;
- w = cairo_image_surface_get_width (priv->memento);
- h = cairo_image_surface_get_height (priv->memento);
+ w = cairo_image_surface_get_width (chart->priv->memento);
+ h = cairo_image_surface_get_height (chart->priv->memento);
- aw = gtk_widget_get_allocated_width (chart);
- ah = gtk_widget_get_allocated_height (chart);
+ aw = gtk_widget_get_allocated_width (widget);
+ ah = gtk_widget_get_allocated_height (widget);
if (w > 0 && h > 0 && !(aw == w && aw == h))
{
@@ -791,9 +717,7 @@ baobab_chart_draw (GtkWidget *chart, cairo_t *cr)
cairo_scale (cr, p, p);
}
- cairo_set_source_surface (cr,
- priv->memento,
- 0, 0);
+ cairo_set_source_surface (cr, chart->priv->memento, 0, 0);
cairo_paint (cr);
}
}
@@ -804,18 +728,17 @@ baobab_chart_draw (GtkWidget *chart, cairo_t *cr)
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_fill_preserve (cr);
- if (priv->root != NULL)
- root_path = gtk_tree_row_reference_get_path (priv->root);
+ if (chart->priv->root != NULL)
+ root_path = gtk_tree_row_reference_get_path (chart->priv->root);
if (root_path == NULL)
{
root_path = gtk_tree_path_new_first ();
- priv->root = NULL;
+ chart->priv->root = NULL;
}
/* Check if tree model was modified in any way */
- if ((priv->model_changed) ||
- (priv->first_item == NULL))
+ if ((chart->priv->model_changed) || (chart->priv->first_item == NULL))
{
baobab_chart_get_items (chart, root_path);
}
@@ -824,8 +747,8 @@ baobab_chart_draw (GtkWidget *chart, cairo_t *cr)
GtkTreePath *current_path;
/* Check if root was changed */
- current_path = gtk_tree_model_get_path (priv->model,
- &((BaobabChartItem*) priv->first_item->data)->iter);
+ current_path = gtk_tree_model_get_path (chart->priv->model,
+ &((BaobabChartItem*) chart->priv->first_item->data)->iter);
if (gtk_tree_path_compare (root_path, current_path) != 0)
baobab_chart_get_items (chart, root_path);
@@ -907,30 +830,27 @@ baobab_chart_get_item_color (BaobabChartColor *color,
}
static gint
-baobab_chart_button_release (GtkWidget *widget,
+baobab_chart_button_release (GtkWidget *widget,
GdkEventButton *event)
{
- BaobabChartPrivate *priv;
+ BaobabChart *chart = BAOBAB_CHART (widget);
- priv = BAOBAB_CHART (widget)->priv;
-
- if (priv->is_frozen)
+ if (chart->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);
+ if (chart->priv->highlighted_item != NULL)
+ g_signal_emit (BAOBAB_CHART (widget), baobab_chart_signals[ITEM_ACTIVATED], 0,
+ &((BaobabChartItem*) chart->priv->highlighted_item->data)->iter);
break;
case MIDDLE_BUTTON:
/* Go back to the parent dir */
- baobab_chart_move_up_root (widget);
+ baobab_chart_move_up_root (BAOBAB_CHART (widget));
break;
}
@@ -941,20 +861,22 @@ static gint
baobab_chart_scroll (GtkWidget *widget,
GdkEventScroll *event)
{
+ BaobabChart *chart = BAOBAB_CHART (widget);
+
switch (event->direction)
{
case GDK_SCROLL_LEFT :
case GDK_SCROLL_UP :
- if (baobab_chart_can_zoom_out (widget))
- baobab_chart_zoom_out (widget);
+ if (baobab_chart_can_zoom_out (chart))
+ baobab_chart_zoom_out (chart);
/* 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);
+ if (baobab_chart_can_zoom_in (chart))
+ baobab_chart_zoom_in (chart);
break;
}
@@ -962,70 +884,67 @@ baobab_chart_scroll (GtkWidget *widget,
}
static void
-baobab_chart_set_item_highlight (GtkWidget *chart,
- GList *node,
- gboolean highlighted)
+baobab_chart_set_item_highlight (BaobabChart *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;
+ chart->priv->highlighted_item = node;
else
- priv->highlighted_item = NULL;
+ chart->priv->highlighted_item = NULL;
- gdk_window_invalidate_rect (gtk_widget_get_window ( GTK_WIDGET (chart)),
+ gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET (chart)),
&item->rect, TRUE);
}
static gint
-baobab_chart_motion_notify (GtkWidget *widget,
+baobab_chart_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
+ BaobabChart *chart;
BaobabChartPrivate *priv;
BaobabChartClass *class;
GList *node;
BaobabChartItem *item;
gboolean found = FALSE;
- priv = BAOBAB_CHART_GET_PRIVATE (widget);
+ chart = BAOBAB_CHART (widget);
+ priv = chart->priv;
+
class = BAOBAB_CHART_GET_CLASS (widget);
/* Check if the pointer is over an item */
- node = priv->last_item;
- while (node != NULL)
+ for (node = priv->last_item; node != NULL; node = node->prev)
{
item = (BaobabChartItem *) node->data;
- if ((item->visible) && (class->is_point_over_item (widget, item, event->x, event->y)))
+ if ((item->visible) && (class->is_point_over_item (chart, item, event->x, event->y)))
{
- if (priv->highlighted_item != node)
+ if (chart->priv->highlighted_item != node)
{
- baobab_chart_set_item_highlight (widget, priv->highlighted_item, FALSE);
+ baobab_chart_set_item_highlight (chart, priv->highlighted_item, FALSE);
gtk_widget_set_has_tooltip (widget, TRUE);
- baobab_chart_set_item_highlight (widget, node, TRUE);
+ baobab_chart_set_item_highlight (chart, 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);
+ baobab_chart_set_item_highlight (chart, priv->highlighted_item, FALSE);
gtk_widget_set_has_tooltip (widget, FALSE);
}
@@ -1036,19 +955,20 @@ baobab_chart_motion_notify (GtkWidget *widget,
}
static gint
-baobab_chart_leave_notify (GtkWidget *widget,
+baobab_chart_leave_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
- BaobabChartPrivate *priv;
+ BaobabChart *chart;
- priv = BAOBAB_CHART_GET_PRIVATE (widget);
- baobab_chart_set_item_highlight (widget, priv->highlighted_item, FALSE);
+ chart = BAOBAB_CHART (widget);
+
+ baobab_chart_set_item_highlight (chart, chart->priv->highlighted_item, FALSE);
return FALSE;
}
-static inline void
-baobab_chart_connect_signals (GtkWidget *chart,
+static void
+baobab_chart_connect_signals (BaobabChart *chart,
GtkTreeModel *model)
{
g_signal_connect (model,
@@ -1089,8 +1009,8 @@ baobab_chart_connect_signals (GtkWidget *chart,
chart);
}
-static inline void
-baobab_chart_disconnect_signals (GtkWidget *chart,
+static void
+baobab_chart_disconnect_signals (BaobabChart *chart,
GtkTreeModel *model)
{
g_signal_handlers_disconnect_by_func (model,
@@ -1130,16 +1050,14 @@ baobab_chart_query_tooltip (GtkWidget *widget,
GtkTooltip *tooltip,
gpointer user_data)
{
- BaobabChartPrivate *priv;
+ BaobabChart *chart = BAOBAB_CHART (widget);
BaobabChartItem *item;
char *markup;
- priv = BAOBAB_CHART_GET_PRIVATE (widget);
-
- if (priv->highlighted_item == NULL)
+ if (chart->priv->highlighted_item == NULL)
return FALSE;
- item = (BaobabChartItem *) priv->highlighted_item->data;
+ item = (BaobabChartItem *) chart->priv->highlighted_item->data;
if ( (item->name == NULL) || (item->size == NULL) )
return FALSE;
@@ -1156,19 +1074,17 @@ baobab_chart_query_tooltip (GtkWidget *widget,
return TRUE;
}
-GdkPixbuf*
-baobab_chart_get_pixbuf (GtkWidget *widget)
+static GdkPixbuf *
+baobab_chart_get_pixbuf (BaobabChart *chart)
{
gint w, h;
GdkPixbuf *pixbuf;
- g_return_val_if_fail (BAOBAB_IS_CHART (widget), NULL);
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), NULL);
- w = gtk_widget_get_allocated_width (widget);
- h = gtk_widget_get_allocated_height (widget);
- pixbuf = gdk_pixbuf_get_from_window (gtk_widget_get_window (widget),
- 0, 0,
- w, h);
+ w = gtk_widget_get_allocated_width (GTK_WIDGET (chart));
+ h = gtk_widget_get_allocated_height (GTK_WIDGET (chart));
+ pixbuf = gdk_pixbuf_get_from_window (gtk_widget_get_window (GTK_WIDGET (chart)), 0, 0, w, h);
return pixbuf;
}
@@ -1181,12 +1097,11 @@ baobab_chart_get_pixbuf (GtkWidget *widget)
* Constructor for the baobab_chart class
*
* Returns: a new #BaobabChart object
- *
**/
-GtkWidget *
-baobab_chart_new ()
+BaobabChart *
+baobab_chart_new (void)
{
- return g_object_new (BAOBAB_CHART_TYPE, NULL);
+ return g_object_new (BAOBAB_TYPE_CHART, NULL);
}
/**
@@ -1225,35 +1140,32 @@ baobab_chart_new ()
* #GtkTreeModel.
**/
void
-baobab_chart_set_model_with_columns (GtkWidget *chart,
+baobab_chart_set_model_with_columns (BaobabChart *chart,
GtkTreeModel *model,
- guint name_column,
- guint size_column,
- guint info_column,
- guint percentage_column,
- guint valid_column,
- GtkTreePath *root)
+ 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);
+ chart->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;
+ chart->priv->name_column = name_column;
+ chart->priv->size_column = size_column;
+ chart->priv->info_column = info_column;
+ chart->priv->percentage_column = percentage_column;
+ chart->priv->valid_column = valid_column;
}
/**
@@ -1273,42 +1185,36 @@ baobab_chart_set_model_with_columns (GtkWidget *chart,
* #GtkTreeModel.
**/
void
-baobab_chart_set_model (GtkWidget *chart,
- GtkTreeModel *model)
+baobab_chart_set_model (BaobabChart *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)
+ if (model == chart->priv->model)
return;
- if (priv->model)
+ if (chart->priv->model)
{
- if (! priv->is_frozen)
- baobab_chart_disconnect_signals (chart,
- priv->model);
- g_object_unref (priv->model);
+ if (! chart->priv->is_frozen)
+ baobab_chart_disconnect_signals (chart, chart->priv->model);
+ g_object_unref (chart->priv->model);
}
- priv->model = model;
- g_object_ref (priv->model);
+ chart->priv->model = model;
+ g_object_ref (chart->priv->model);
- if (! priv->is_frozen)
- baobab_chart_connect_signals (chart,
- priv->model);
+ if (! chart->priv->is_frozen)
+ baobab_chart_connect_signals (chart, chart->priv->model);
- if (priv->root)
- gtk_tree_row_reference_free (priv->root);
+ if (chart->priv->root)
+ gtk_tree_row_reference_free (chart->priv->root);
- priv->root = NULL;
+ chart->priv->root = NULL;
g_object_notify (G_OBJECT (chart), "model");
- gtk_widget_queue_draw (chart);
+ gtk_widget_queue_draw (GTK_WIDGET (chart));
}
/**
@@ -1320,11 +1226,11 @@ baobab_chart_set_model (GtkWidget *chart,
* Returns: %NULL if @chart is not a #BaobabChart.
**/
GtkTreeModel *
-baobab_chart_get_model (GtkWidget *chart)
+baobab_chart_get_model (BaobabChart *chart)
{
g_return_val_if_fail (BAOBAB_IS_CHART (chart), NULL);
- return BAOBAB_CHART (chart)->priv->model;
+ return chart->priv->model;
}
/**
@@ -1339,27 +1245,23 @@ baobab_chart_get_model (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
void
-baobab_chart_set_max_depth (GtkWidget *chart,
- guint max_depth)
+baobab_chart_set_max_depth (BaobabChart *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)
+ if (max_depth == chart->priv->max_depth)
return;
- priv->max_depth = max_depth;
+ chart->priv->max_depth = max_depth;
g_object_notify (G_OBJECT (chart), "max-depth");
- priv->model_changed = TRUE;
+ chart->priv->model_changed = TRUE;
- gtk_widget_queue_draw (chart);
+ gtk_widget_queue_draw (GTK_WIDGET (chart));
}
/**
@@ -1372,11 +1274,11 @@ baobab_chart_set_max_depth (GtkWidget *chart,
* Fails if @chart is not a #BaobabChart.
**/
guint
-baobab_chart_get_max_depth (GtkWidget *chart)
+baobab_chart_get_max_depth (BaobabChart *chart)
{
g_return_val_if_fail (BAOBAB_IS_CHART (chart), 0);
- return BAOBAB_CHART (chart)->priv->max_depth;
+ return chart->priv->max_depth;
}
/**
@@ -1392,33 +1294,30 @@ baobab_chart_get_max_depth (GtkWidget *chart)
* a #GtkTreeModel set.
**/
void
-baobab_chart_set_root (GtkWidget *chart,
+baobab_chart_set_root (BaobabChart *chart,
GtkTreePath *root)
{
- BaobabChartPrivate *priv;
- GtkTreePath *current_root;
-
g_return_if_fail (BAOBAB_IS_CHART (chart));
+ g_return_if_fail (chart->priv->model != NULL);
- 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;
+ if (chart->priv->root)
+ {
+ /* Check that given root is different from current */
+ GtkTreePath *current_root = gtk_tree_row_reference_get_path (chart->priv->root);
+ if (current_root && (gtk_tree_path_compare (current_root, root) == 0))
+ return;
- /* Free current root */
- gtk_tree_row_reference_free (priv->root);
- }
+ /* Free current root */
+ gtk_tree_row_reference_free (chart->priv->root);
+ }
+ else if (!root)
+ return;
- priv->root = gtk_tree_row_reference_new (priv->model, root);
+ chart->priv->root = root ? gtk_tree_row_reference_new (chart->priv->model, root) : NULL;
g_object_notify (G_OBJECT (chart), "root");
- gtk_widget_queue_draw (chart);
+ gtk_widget_queue_draw (GTK_WIDGET (chart));
}
/**
@@ -1432,13 +1331,13 @@ baobab_chart_set_root (GtkWidget *chart,
*
* Fails if @chart is not a #BaobabChart.
**/
-GtkTreePath*
-baobab_chart_get_root (GtkWidget *chart)
+GtkTreePath *
+baobab_chart_get_root (BaobabChart *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);
+ if (chart->priv->root)
+ return gtk_tree_row_reference_get_path (chart->priv->root);
else
return NULL;
}
@@ -1456,22 +1355,18 @@ baobab_chart_get_root (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
void
-baobab_chart_freeze_updates (GtkWidget *chart)
+baobab_chart_freeze_updates (BaobabChart *chart)
{
- BaobabChartPrivate *priv;
cairo_surface_t *surface = NULL;
GtkAllocation allocation;
g_return_if_fail (BAOBAB_IS_CHART (chart));
- priv = BAOBAB_CHART_GET_PRIVATE (chart);
-
- if (priv->is_frozen)
+ if (chart->priv->is_frozen)
return;
- if (priv->model)
- baobab_chart_disconnect_signals (chart,
- priv->model);
+ if (chart->priv->model)
+ baobab_chart_disconnect_signals (chart, chart->priv->model);
gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
@@ -1496,14 +1391,14 @@ baobab_chart_freeze_updates (GtkWidget *chart)
cairo_clip (cr);
- priv->memento = surface;
+ chart->priv->memento = surface;
cairo_destroy (cr);
}
- priv->is_frozen = TRUE;
+ chart->priv->is_frozen = TRUE;
- gtk_widget_queue_draw (chart);
+ gtk_widget_queue_draw (GTK_WIDGET (chart));
}
/**
@@ -1518,30 +1413,25 @@ baobab_chart_freeze_updates (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
void
-baobab_chart_thaw_updates (GtkWidget *chart)
+baobab_chart_thaw_updates (BaobabChart *chart)
{
- BaobabChartPrivate *priv;
-
g_return_if_fail (BAOBAB_IS_CHART (chart));
- priv = BAOBAB_CHART_GET_PRIVATE (chart);
-
- if (priv->is_frozen)
+ if (chart->priv->is_frozen)
{
- if (priv->model)
- baobab_chart_connect_signals (chart,
- priv->model);
+ if (chart->priv->model)
+ baobab_chart_connect_signals (chart, chart->priv->model);
- if (priv->memento)
+ if (chart->priv->memento)
{
- cairo_surface_destroy (priv->memento);
- priv->memento = NULL;
+ cairo_surface_destroy (chart->priv->memento);
+ chart->priv->memento = NULL;
}
- priv->is_frozen = FALSE;
+ chart->priv->is_frozen = FALSE;
- priv->model_changed = TRUE;
- gtk_widget_queue_draw (chart);
+ chart->priv->model_changed = TRUE;
+ gtk_widget_queue_draw (GTK_WIDGET (chart));
}
}
@@ -1554,21 +1444,19 @@ baobab_chart_thaw_updates (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
void
-baobab_chart_zoom_in (GtkWidget *chart)
+baobab_chart_zoom_in (BaobabChart *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;
+ new_max_depth = chart->priv->max_depth - 1;
baobab_chart_set_max_depth (chart, new_max_depth);
}
@@ -1582,12 +1470,59 @@ baobab_chart_zoom_in (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
void
-baobab_chart_zoom_out (GtkWidget *chart)
+baobab_chart_zoom_out (BaobabChart *chart)
{
g_return_if_fail (BAOBAB_IS_CHART (chart));
- baobab_chart_set_max_depth (chart,
- baobab_chart_get_max_depth (chart) + 1);
+ baobab_chart_set_max_depth (chart, baobab_chart_get_max_depth (chart) + 1);
+}
+
+/**
+ * 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 (BaobabChart *chart)
+{
+ BaobabChartClass *class;
+
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), FALSE);
+
+ class = BAOBAB_CHART_GET_CLASS (chart);
+
+ if (class->can_zoom_in != NULL)
+ return class->can_zoom_in (chart) > 0;
+ else
+ return chart->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 (BaobabChart *chart)
+{
+ BaobabChartClass *class;
+
+ g_return_val_if_fail (BAOBAB_IS_CHART (chart), FALSE);
+
+ class = BAOBAB_CHART_GET_CLASS (chart);
+
+ if (class->can_zoom_out != NULL)
+ return class->can_zoom_out (chart) > 0;
+ else
+ return (chart->priv->max_depth < BAOBAB_CHART_MAX_DEPTH);
}
/**
@@ -1599,10 +1534,8 @@ baobab_chart_zoom_out (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
void
-baobab_chart_move_up_root (GtkWidget *chart)
+baobab_chart_move_up_root (BaobabChart *chart)
{
- BaobabChartPrivate *priv;
-
GtkTreeIter parent_iter;
GtkTreePath *path;
GtkTreeIter root_iter;
@@ -1612,36 +1545,34 @@ baobab_chart_move_up_root (GtkWidget *chart)
g_return_if_fail (BAOBAB_IS_CHART (chart));
- priv = BAOBAB_CHART_GET_PRIVATE (chart);
-
- if (priv->root == NULL)
+ if (chart->priv->root == NULL)
return;
- path = gtk_tree_row_reference_get_path (priv->root);
+ path = gtk_tree_row_reference_get_path (chart->priv->root);
if (path != NULL)
- gtk_tree_model_get_iter (priv->model, &root_iter, path);
+ gtk_tree_model_get_iter (chart->priv->model, &root_iter, path);
else
return;
- if (gtk_tree_model_iter_parent (priv->model, &parent_iter, &root_iter))
+ if (gtk_tree_model_iter_parent (chart->priv->model, &parent_iter, &root_iter))
{
- gtk_tree_model_get (priv->model, &parent_iter, priv->valid_column,
+ gtk_tree_model_get (chart->priv->model, &parent_iter, chart->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_row_reference_free (chart->priv->root);
+ parent_path = gtk_tree_model_get_path (chart->priv->model, &parent_iter);
+ chart->priv->root = gtk_tree_row_reference_new (chart->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_widget_queue_draw (GTK_WIDGET (chart));
}
gtk_tree_path_free (path);
@@ -1657,12 +1588,9 @@ baobab_chart_move_up_root (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
void
-baobab_chart_save_snapshot (GtkWidget *chart)
+baobab_chart_save_snapshot (BaobabChart *chart)
{
- BaobabChartPrivate *priv;
-
GdkPixbuf *pixbuf;
-
GtkWidget *fs_dlg;
GtkWidget *vbox;
GtkWidget *hbox;
@@ -1695,8 +1623,6 @@ baobab_chart_save_snapshot (GtkWidget *chart)
return;
}
- priv = BAOBAB_CHART (chart)->priv;
-
/* Popup the File chooser dialog */
fs_dlg = gtk_file_chooser_dialog_new (_("Save Snapshot"),
NULL,
@@ -1706,7 +1632,7 @@ baobab_chart_save_snapshot (GtkWidget *chart)
GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT, NULL);
- item = (BaobabChartItem *) priv->first_item->data;
+ item = (BaobabChartItem *) chart->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);
@@ -1771,14 +1697,11 @@ baobab_chart_save_snapshot (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
gboolean
-baobab_chart_is_frozen (GtkWidget *chart)
+baobab_chart_is_frozen (BaobabChart *chart)
{
- BaobabChartPrivate *priv;
-
g_return_val_if_fail (BAOBAB_IS_CHART (chart), FALSE);
- priv = BAOBAB_CHART_GET_PRIVATE (chart);
- return priv->is_frozen;
+ return chart->priv->is_frozen;
}
/**
@@ -1791,67 +1714,10 @@ baobab_chart_is_frozen (GtkWidget *chart)
* Fails if @chart is not a #BaobabChart.
**/
BaobabChartItem *
-baobab_chart_get_highlighted_item (GtkWidget *chart)
+baobab_chart_get_highlighted_item (BaobabChart *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;
+ return (chart->priv->highlighted_item ?
+ (BaobabChartItem *) chart->priv->highlighted_item->data : NULL);
}
-
-/**
- * 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);
-}
-
-/* ex:set ts=8 noet: */
diff --git a/src/baobab-chart.h b/src/baobab-chart.h
index 1977302..f813fc6 100644
--- a/src/baobab-chart.h
+++ b/src/baobab-chart.h
@@ -5,18 +5,18 @@
*
* 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.
+ * the Free Software Foundation; either version 2 of the licence, 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.
+ * 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
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+ * USA
*
* Authors:
* Felipe Erias <femorandeira igalia com>
@@ -38,24 +38,27 @@
G_BEGIN_DECLS
-#define BAOBAB_CHART_TYPE (baobab_chart_get_type ())
-#define BAOBAB_CHART(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BAOBAB_CHART_TYPE, BaobabChart))
-#define BAOBAB_CHART_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), BAOBAB_CHART_TYPE, BaobabChartClass))
-#define BAOBAB_IS_CHART(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BAOBAB_CHART_TYPE))
-#define BAOBAB_IS_CHART_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE ((obj), BAOBAB_CHART_TYPE))
-#define BAOBAB_CHART_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), BAOBAB_CHART_TYPE, BaobabChartClass))
-
-typedef struct _BaobabChart BaobabChart;
-typedef struct _BaobabChartClass BaobabChartClass;
-typedef struct _BaobabChartPrivate BaobabChartPrivate;
-typedef struct _BaobabChartColor BaobabChartColor;
-typedef struct _BaobabChartItem BaobabChartItem;
+#define BAOBAB_TYPE_CHART (baobab_chart_get_type ())
+#define BAOBAB_CHART(inst) (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
+ BAOBAB_TYPE_CHART, BaobabChart))
+#define BAOBAB_CHART_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), \
+ BAOBAB_TYPE_CHART, BaobabChartClass))
+#define BAOBAB_IS_CHART(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst), BAOBAB_TYPE_CHART))
+#define BAOBAB_IS_CHART_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), BAOBAB_TYPE_CHART))
+#define BAOBAB_CHART_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), \
+ BAOBAB_TYPE_CHART, BaobabChartClass))
+
+typedef struct _BaobabChart BaobabChart;
+typedef struct _BaobabChartClass BaobabChartClass;
+typedef struct _BaobabChartPrivate BaobabChartPrivate;
+typedef struct _BaobabChartColor BaobabChartColor;
+typedef struct _BaobabChartItem BaobabChartItem;
struct _BaobabChart
{
GtkWidget parent;
- /* < private > */
+ /*< private >*/
BaobabChartPrivate *priv;
};
@@ -89,71 +92,70 @@ struct _BaobabChartClass
GtkWidgetClass parent_class;
/* Signal prototypes */
- void (* item_activated) (BaobabChart *chart,
- GtkTreeIter *iter);
+ void (* item_activated) (BaobabChart *chart,
+ GtkTreeIter *iter);
/* Abstract methods */
- void (* draw_item) (GtkWidget *chart,
- cairo_t *cr,
- BaobabChartItem *item,
- gboolean highlighted);
+ void (* draw_item) (BaobabChart *chart,
+ cairo_t *cr,
+ BaobabChartItem *item,
+ gboolean highlighted);
- void (* pre_draw) (GtkWidget *chart,
- cairo_t *cr);
+ void (* pre_draw) (BaobabChart *chart,
+ cairo_t *cr);
- void (* post_draw) (GtkWidget *chart,
- cairo_t *cr);
+ void (* post_draw) (BaobabChart *chart,
+ cairo_t *cr);
- void (* calculate_item_geometry) (GtkWidget *chart,
- BaobabChartItem *item);
+ void (* calculate_item_geometry) (BaobabChart *chart,
+ BaobabChartItem *item);
- gboolean (* is_point_over_item) (GtkWidget *chart,
- BaobabChartItem *item,
- gdouble x,
- gdouble y);
+ gboolean (* is_point_over_item) (BaobabChart *chart,
+ BaobabChartItem *item,
+ gdouble x,
+ gdouble y);
- void (* get_item_rectangle) (GtkWidget *chart,
- BaobabChartItem *item);
+ void (* get_item_rectangle) (BaobabChart *chart,
+ BaobabChartItem *item);
- guint (* can_zoom_in) (GtkWidget *chart);
- guint (* can_zoom_out) (GtkWidget *chart);
+ guint (* can_zoom_in) (BaobabChart *chart);
+ guint (* can_zoom_out) (BaobabChart *chart);
};
-GType baobab_chart_get_type (void) G_GNUC_CONST;
-GtkWidget* baobab_chart_new (void);
-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);
-void baobab_chart_set_model (GtkWidget *chart,
- GtkTreeModel *model);
-GtkTreeModel* baobab_chart_get_model (GtkWidget *chart);
-void baobab_chart_set_max_depth (GtkWidget *chart,
- guint max_depth);
-guint baobab_chart_get_max_depth (GtkWidget *chart);
-void baobab_chart_set_root (GtkWidget *chart,
- GtkTreePath *root);
-GtkTreePath *baobab_chart_get_root (GtkWidget *chart);
-void baobab_chart_freeze_updates (GtkWidget *chart);
-void baobab_chart_thaw_updates (GtkWidget *chart);
-void baobab_chart_get_item_color (BaobabChartColor *color,
- gdouble position,
- gint depth,
- gboolean highlighted);
-void baobab_chart_move_up_root (GtkWidget *chart);
-void baobab_chart_zoom_in (GtkWidget *chart);
-void baobab_chart_zoom_out (GtkWidget *chart);
-void baobab_chart_save_snapshot (GtkWidget *chart);
-gboolean baobab_chart_is_frozen (GtkWidget *chart);
-BaobabChartItem *baobab_chart_get_highlighted_item (GtkWidget *chart);
-
-gboolean baobab_chart_can_zoom_in (GtkWidget *chart);
-gboolean baobab_chart_can_zoom_out (GtkWidget *chart);
+GType baobab_chart_get_type (void) G_GNUC_CONST;
+BaobabChart * baobab_chart_new (void);
+void baobab_chart_set_model_with_columns (BaobabChart *chart,
+ GtkTreeModel *model,
+ guint name_column,
+ guint size_column,
+ guint info_column,
+ guint percentage_column,
+ guint valid_column,
+ GtkTreePath *root);
+void baobab_chart_set_model (BaobabChart *chart,
+ GtkTreeModel *model);
+GtkTreeModel * baobab_chart_get_model (BaobabChart *chart);
+void baobab_chart_set_max_depth (BaobabChart *chart,
+ guint max_depth);
+guint baobab_chart_get_max_depth (BaobabChart *chart);
+void baobab_chart_set_root (BaobabChart *chart,
+ GtkTreePath *root);
+GtkTreePath * baobab_chart_get_root (BaobabChart *chart);
+void baobab_chart_freeze_updates (BaobabChart *chart);
+void baobab_chart_thaw_updates (BaobabChart *chart);
+void baobab_chart_get_item_color (BaobabChartColor *color,
+ gdouble position,
+ gint depth,
+ gboolean highlighted);
+void baobab_chart_move_up_root (BaobabChart *chart);
+void baobab_chart_zoom_in (BaobabChart *chart);
+void baobab_chart_zoom_out (BaobabChart *chart);
+gboolean baobab_chart_can_zoom_in (BaobabChart *chart);
+gboolean baobab_chart_can_zoom_out (BaobabChart *chart);
+void baobab_chart_save_snapshot (BaobabChart *chart);
+gboolean baobab_chart_is_frozen (BaobabChart *chart);
+BaobabChartItem * baobab_chart_get_highlighted_item (BaobabChart *chart);
G_END_DECLS
-#endif
+#endif /* __BAOBAB_CHART_H__ */
diff --git a/src/baobab-ringschart.c b/src/baobab-ringschart.c
index ab604f5..f801862 100644
--- a/src/baobab-ringschart.c
+++ b/src/baobab-ringschart.c
@@ -53,7 +53,7 @@
#define SUBFOLDER_TIP_PADDING 3
-G_DEFINE_TYPE (BaobabRingschart, baobab_ringschart, BAOBAB_CHART_TYPE);
+G_DEFINE_TYPE (BaobabRingschart, baobab_ringschart, BAOBAB_TYPE_CHART);
typedef struct _BaobabRingschartItem BaobabRingschartItem;
@@ -84,23 +84,23 @@ static void baobab_ringschart_draw_sector (cairo_t *cr,
gdouble init_angle, gdouble final_angle,
BaobabChartColor fill_color,
gboolean continued, guint border);
-static void baobab_ringschart_draw_item (GtkWidget *chart,
+static void baobab_ringschart_draw_item (BaobabChart *chart,
cairo_t *cr,
BaobabChartItem *item,
gboolean highlighted);
-static void baobab_ringschart_calculate_item_geometry (GtkWidget *chart,
+static void baobab_ringschart_calculate_item_geometry (BaobabChart *chart,
BaobabChartItem *item);
-static gboolean baobab_ringschart_is_point_over_item (GtkWidget *chart,
+static gboolean baobab_ringschart_is_point_over_item (BaobabChart *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,
+static void baobab_ringschart_get_item_rectangle (BaobabChart *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_pre_draw (BaobabChart *chart, cairo_t *cr);
+static void baobab_ringschart_post_draw (BaobabChart *chart, cairo_t *cr);
static void
@@ -126,21 +126,20 @@ baobab_ringschart_class_init (BaobabRingschartClass *class)
static void
baobab_ringschart_init (BaobabRingschart *chart)
{
- BaobabRingschartPrivate *priv;
GtkSettings* settings;
gint timeout;
- priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+ chart->priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
- priv->subfoldertips_enabled = TRUE;
- priv->highlighted_item = NULL;
- priv->tips_timeout_event = 0;
- priv->subtip_items = NULL;
- priv->drawing_subtips = FALSE;
+ chart->priv->subfoldertips_enabled = TRUE;
+ chart->priv->highlighted_item = NULL;
+ chart->priv->tips_timeout_event = 0;
+ chart->priv->subtip_items = NULL;
+ chart->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;
+ chart->priv->subtip_timeout = 2 * timeout;
}
static void
@@ -177,17 +176,17 @@ baobab_ringschart_draw_sector (cairo_t *cr,
}
static void
-baobab_ringschart_draw_item (GtkWidget *chart,
- cairo_t *cr,
+baobab_ringschart_draw_item (BaobabChart *chart,
+ cairo_t *cr,
BaobabChartItem *item,
- gboolean highlighted)
+ gboolean highlighted)
{
BaobabRingschartPrivate *priv;
BaobabRingschartItem *data;
BaobabChartColor fill_color;
GtkAllocation allocation;
- priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+ priv = BAOBAB_RINGSCHART (chart)->priv;
data = (BaobabRingschartItem *) item->data;
@@ -210,7 +209,8 @@ baobab_ringschart_draw_item (GtkWidget *chart,
item->depth,
highlighted);
- gtk_widget_get_allocation (chart, &allocation);
+ gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
+
baobab_ringschart_draw_sector (cr,
allocation.width / 2,
allocation.height / 2,
@@ -224,7 +224,7 @@ baobab_ringschart_draw_item (GtkWidget *chart,
}
static void
-baobab_ringschart_calculate_item_geometry (GtkWidget *chart,
+baobab_ringschart_calculate_item_geometry (BaobabChart *chart,
BaobabChartItem *item)
{
BaobabRingschartItem *data;
@@ -246,7 +246,7 @@ baobab_ringschart_calculate_item_geometry (GtkWidget *chart,
data->continued = FALSE;
item->visible = FALSE;
- gtk_widget_get_allocation (chart, &allocation);
+ gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
max_radius = MIN (allocation.width / 2, allocation.height / 2) - CHART_PADDING;
thickness = max_radius / (max_depth + 1);
@@ -285,7 +285,7 @@ baobab_ringschart_calculate_item_geometry (GtkWidget *chart,
}
static gboolean
-baobab_ringschart_is_point_over_item (GtkWidget *chart,
+baobab_ringschart_is_point_over_item (BaobabChart *chart,
BaobabChartItem *item,
gdouble x,
gdouble y)
@@ -295,7 +295,7 @@ baobab_ringschart_is_point_over_item (GtkWidget *chart,
GtkAllocation allocation;
data = (BaobabRingschartItem *) item->data;
- gtk_widget_get_allocation (chart, &allocation);
+ gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
x = x - allocation.width / 2;
y = y - allocation.height / 2;
@@ -328,8 +328,8 @@ baobab_ringschart_get_point_min_rect (gdouble cx,
}
static void
-baobab_ringschart_get_item_rectangle (GtkWidget *chart,
- BaobabChartItem *item)
+baobab_ringschart_get_item_rectangle (BaobabChart *chart,
+ BaobabChartItem *item)
{
BaobabRingschartItem *data;
GdkRectangle rect;
@@ -338,7 +338,7 @@ baobab_ringschart_get_item_rectangle (GtkWidget *chart,
data = (BaobabRingschartItem *) item->data;
- gtk_widget_get_allocation (chart, &allocation);
+ gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
cx = allocation.width / 2;
cy = allocation.height / 2;
r1 = data->min_radius;
@@ -374,12 +374,12 @@ baobab_ringschart_get_item_rectangle (GtkWidget *chart,
item->rect = rect;
}
-gboolean
+static gboolean
baobab_ringschart_subfolder_tips_timeout (gpointer data)
{
BaobabRingschartPrivate *priv;
- priv = BAOBAB_RINGSCHART_GET_PRIVATE (data);
+ priv = BAOBAB_RINGSCHART (data)->priv;
priv->drawing_subtips = TRUE;
@@ -389,15 +389,15 @@ baobab_ringschart_subfolder_tips_timeout (gpointer data)
}
void
-baobab_ringschart_clean_subforlder_tips_state (GtkWidget *chart)
+baobab_ringschart_clean_subforlder_tips_state (BaobabRingschart *chart)
{
BaobabRingschartPrivate *priv;
GList *node;
- priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+ priv = chart->priv;
if (priv->drawing_subtips)
- gtk_widget_queue_draw (chart);
+ gtk_widget_queue_draw (GTK_WIDGET (chart));
priv->drawing_subtips = FALSE;
@@ -431,24 +431,20 @@ baobab_ringschart_draw_subfolder_tips (GtkWidget *chart, cairo_t *cr)
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);
+ priv = BAOBAB_RINGSCHART (chart)->priv;
gtk_widget_get_allocation (chart, &allocation);
q_width = allocation.width / 2;
@@ -589,25 +585,25 @@ baobab_ringschart_draw_subfolder_tips (GtkWidget *chart, cairo_t *cr)
}
static void
-baobab_ringschart_pre_draw (GtkWidget *chart, cairo_t *cr)
+baobab_ringschart_pre_draw (BaobabChart *chart,
+ cairo_t *cr)
{
BaobabRingschartPrivate *priv;
BaobabChartItem *hl_item;
- priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+ priv = BAOBAB_RINGSCHART (chart)->priv;
hl_item = baobab_chart_get_highlighted_item (chart);
- if ( (hl_item == NULL) || (! hl_item->has_visible_children) )
+ if ((hl_item == NULL) || (! hl_item->has_visible_children))
{
- baobab_ringschart_clean_subforlder_tips_state (chart);
-
+ baobab_ringschart_clean_subforlder_tips_state (BAOBAB_RINGSCHART (chart));
return;
}
if (hl_item != priv->highlighted_item)
{
- baobab_ringschart_clean_subforlder_tips_state (chart);
+ baobab_ringschart_clean_subforlder_tips_state (BAOBAB_RINGSCHART (chart));
priv->highlighted_item = hl_item;
@@ -619,18 +615,19 @@ baobab_ringschart_pre_draw (GtkWidget *chart, cairo_t *cr)
}
static void
-baobab_ringschart_post_draw (GtkWidget *chart, cairo_t *cr)
+baobab_ringschart_post_draw (BaobabChart *chart,
+ cairo_t *cr)
{
BaobabRingschartPrivate *priv;
- priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+ priv = BAOBAB_RINGSCHART (chart)->priv;
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);
+ baobab_ringschart_draw_subfolder_tips (GTK_WIDGET (chart), cr);
}
}
@@ -661,15 +658,16 @@ baobab_ringschart_new (void)
*
**/
void
-baobab_ringschart_set_subfoldertips_enabled (GtkWidget *chart, gboolean enabled)
+baobab_ringschart_set_subfoldertips_enabled (BaobabRingschart *chart,
+ gboolean enabled)
{
BaobabRingschartPrivate *priv;
- priv = BAOBAB_RINGSCHART_GET_PRIVATE (chart);
+ priv = chart->priv;
priv->subfoldertips_enabled = enabled;
- if ( (! enabled) && (priv->drawing_subtips) )
+ if (!enabled && priv->drawing_subtips)
{
/* Turn off currently drawn tips */
baobab_ringschart_clean_subforlder_tips_state (chart);
diff --git a/src/baobab-ringschart.h b/src/baobab-ringschart.h
index 276bd7f..7552f09 100644
--- a/src/baobab-ringschart.h
+++ b/src/baobab-ringschart.h
@@ -62,10 +62,12 @@ struct _BaobabRingschartClass
BaobabChartClass parent_class;
};
-GType baobab_ringschart_get_type (void) G_GNUC_CONST;
-GtkWidget *baobab_ringschart_new (void);
-void baobab_ringschart_set_subfoldertips_enabled (GtkWidget *chart,
- gboolean enabled);
+GType baobab_ringschart_get_type (void) G_GNUC_CONST;
+
+GtkWidget *baobab_ringschart_new (void);
+
+void baobab_ringschart_set_subfoldertips_enabled (BaobabRingschart *chart,
+ gboolean enabled);
G_END_DECLS
diff --git a/src/baobab-treemap.c b/src/baobab-treemap.c
index 30fd446..1a84539 100644
--- a/src/baobab-treemap.c
+++ b/src/baobab-treemap.c
@@ -48,7 +48,7 @@
#define ITEM_SHOW_LABEL TRUE
-G_DEFINE_TYPE (BaobabTreemap, baobab_treemap, BAOBAB_CHART_TYPE);
+G_DEFINE_TYPE (BaobabTreemap, baobab_treemap, BAOBAB_TYPE_CHART);
struct _BaobabTreemapPrivate
{
@@ -64,20 +64,20 @@ static void baobab_treemap_draw_rectangle (GtkWidget *chart,
BaobabChartColor fill_color,
const char *text,
gboolean show_text);
-static void baobab_treemap_draw_item (GtkWidget *chart,
+static void baobab_treemap_draw_item (BaobabChart *chart,
cairo_t *cr,
BaobabChartItem *item,
gboolean highlighted);
-static void baobab_treemap_calculate_item_geometry (GtkWidget *chart,
+static void baobab_treemap_calculate_item_geometry (BaobabChart *chart,
BaobabChartItem *item);
-static gboolean baobab_treemap_is_point_over_item (GtkWidget *chart,
+static gboolean baobab_treemap_is_point_over_item (BaobabChart *chart,
BaobabChartItem *item,
gdouble x,
gdouble y);
-static void baobab_treemap_get_item_rectangle (GtkWidget *chart,
+static void baobab_treemap_get_item_rectangle (BaobabChart *chart,
BaobabChartItem *item);
-guint baobab_treemap_can_zoom_in (GtkWidget *chart);
-guint baobab_treemap_can_zoom_out (GtkWidget *chart);
+guint baobab_treemap_can_zoom_in (BaobabChart *chart);
+guint baobab_treemap_can_zoom_out (BaobabChart *chart);
static void
baobab_treemap_class_init (BaobabTreemapClass *class)
@@ -93,8 +93,8 @@ baobab_treemap_class_init (BaobabTreemapClass *class)
chart_class->calculate_item_geometry = baobab_treemap_calculate_item_geometry;
chart_class->is_point_over_item = baobab_treemap_is_point_over_item;
chart_class->get_item_rectangle = baobab_treemap_get_item_rectangle;
- chart_class->can_zoom_in = baobab_treemap_can_zoom_in;
- chart_class->can_zoom_out = baobab_treemap_can_zoom_out;
+ chart_class->can_zoom_in = baobab_treemap_can_zoom_in;
+ chart_class->can_zoom_out = baobab_treemap_can_zoom_out;
g_type_class_add_private (obj_class, sizeof (BaobabTreemapPrivate));
}
@@ -110,12 +110,15 @@ baobab_treemap_init (BaobabTreemap *chart)
}
static void
-baobab_treemap_draw_rectangle (GtkWidget *chart,
- cairo_t *cr,
- gdouble x, gdouble y, gdouble width, gdouble height,
- BaobabChartColor fill_color,
- const char *text,
- gboolean show_text)
+baobab_treemap_draw_rectangle (GtkWidget *chart,
+ cairo_t *cr,
+ gdouble x,
+ gdouble y,
+ gdouble width,
+ gdouble height,
+ BaobabChartColor fill_color,
+ const char *text,
+ gboolean show_text)
{
guint border = ITEM_BORDER_WIDTH;
PangoRectangle rect;
@@ -151,19 +154,19 @@ baobab_treemap_draw_rectangle (GtkWidget *chart,
}
static void
-baobab_treemap_draw_item (GtkWidget *chart,
+baobab_treemap_draw_item (BaobabChart *chart,
cairo_t *cr,
BaobabChartItem *item,
gboolean highlighted)
{
- cairo_rectangle_t * rect;
+ cairo_rectangle_t *rect;
BaobabChartColor fill_color;
GtkAllocation allocation;
gdouble width, height;
rect = (cairo_rectangle_t *) item->data;
- gtk_widget_get_allocation (chart, &allocation);
+ gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
if (item->depth % 2 != 0)
{
@@ -180,7 +183,7 @@ baobab_treemap_draw_item (GtkWidget *chart,
height = rect->height - ITEM_PADDING;
}
- baobab_treemap_draw_rectangle (chart,
+ baobab_treemap_draw_rectangle (GTK_WIDGET (chart),
cr,
rect->x,
rect->y,
@@ -188,11 +191,11 @@ baobab_treemap_draw_item (GtkWidget *chart,
height,
fill_color,
item->name,
- (! item->has_visible_children) );
+ (!item->has_visible_children) );
}
static void
-baobab_treemap_calculate_item_geometry (GtkWidget *chart,
+baobab_treemap_calculate_item_geometry (BaobabChart *chart,
BaobabChartItem *item)
{
BaobabTreemapPrivate *priv;
@@ -214,7 +217,7 @@ baobab_treemap_calculate_item_geometry (GtkWidget *chart,
if (item->parent == NULL)
{
- gtk_widget_get_allocation (chart, &allocation);
+ gtk_widget_get_allocation (GTK_WIDGET (chart), &allocation);
p_area.x = 0 - ITEM_PADDING/2;
p_area.y = 0 - ITEM_PADDING/2;
p_area.width = allocation.width + ITEM_PADDING * 2;
@@ -266,14 +269,14 @@ baobab_treemap_calculate_item_geometry (GtkWidget *chart,
baobab_treemap_get_item_rectangle (chart, item);
- if (item->depth == baobab_chart_get_max_depth (chart) + 1)
+ if (item->depth == baobab_chart_get_max_depth (BAOBAB_CHART (chart)) + 1)
priv->more_visible_childs = TRUE;
else
priv->max_visible_depth = MAX (priv->max_visible_depth, item->depth);
}
static gboolean
-baobab_treemap_is_point_over_item (GtkWidget *chart,
+baobab_treemap_is_point_over_item (BaobabChart *chart,
BaobabChartItem *item,
gdouble x,
gdouble y)
@@ -286,7 +289,7 @@ baobab_treemap_is_point_over_item (GtkWidget *chart,
}
static void
-baobab_treemap_get_item_rectangle (GtkWidget *chart,
+baobab_treemap_get_item_rectangle (BaobabChart *chart,
BaobabChartItem *item)
{
cairo_rectangle_t *_rect;
@@ -305,11 +308,10 @@ baobab_treemap_get_item_rectangle (GtkWidget *chart,
item->rect.width = _rect->width;
item->rect.height = _rect->height - ITEM_PADDING;
}
-
}
guint
-baobab_treemap_can_zoom_in (GtkWidget *chart)
+baobab_treemap_can_zoom_in (BaobabChart *chart)
{
BaobabTreemapPrivate *priv;
@@ -319,7 +321,7 @@ baobab_treemap_can_zoom_in (GtkWidget *chart)
}
guint
-baobab_treemap_can_zoom_out (GtkWidget *chart)
+baobab_treemap_can_zoom_out (BaobabChart *chart)
{
BaobabTreemapPrivate *priv;
diff --git a/src/baobab-treemap.h b/src/baobab-treemap.h
index 734bc27..f6bbf98 100644
--- a/src/baobab-treemap.h
+++ b/src/baobab-treemap.h
@@ -56,8 +56,9 @@ struct _BaobabTreemapClass
BaobabChartClass parent_class;
};
-GType baobab_treemap_get_type (void) G_GNUC_CONST;
-GtkWidget* baobab_treemap_new (void);
+GType baobab_treemap_get_type (void) G_GNUC_CONST;
+
+GtkWidget *baobab_treemap_new (void);
G_END_DECLS
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
