/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* e-cell-tree.c - Tree cell object.
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
* Authors:
* Chris Toshok <toshok@ximian.com>
*
* A majority of code taken from:
*
* the ECellText renderer.
* Copyright 1998, The Free Software Foundation
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
#include <config.h>
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include <libgnomecanvas/libgnomecanvas.h>
#include "gal-a11y-e-cell-registry.h"
#include "gal-a11y-e-cell-tree.h"
#include "e-util/e-util.h"
#include "e-cell-tree.h"
#include "e-table-item.h"
#include "e-tree.h"
#include "e-tree-model.h"
#include "e-tree-table-adapter.h"
G_DEFINE_TYPE (ECellTree, e_cell_tree, E_TYPE_CELL)
typedef struct {
ECellView cell_view;
ECellView *subcell_view;
GnomeCanvas *canvas;
gboolean prelit;
gint animate_timeout;
} ECellTreeView;
#define INDENT_AMOUNT 16
ECellView *
e_cell_tree_view_get_subcell_view (ECellView *ect)
{
return ((ECellTreeView *)ect)->subcell_view;
}
static ETreePath
e_cell_tree_get_node (ETableModel *table_model, gint row)
{
return e_table_model_value_at (table_model, -1, row);
}
static ETreeModel*
e_cell_tree_get_tree_model (ETableModel *table_model, gint row)
{
return e_table_model_value_at (table_model, -2, row);
}
static ETreeTableAdapter *
e_cell_tree_get_tree_table_adapter (ETableModel *table_model, gint row)
{
return e_table_model_value_at (table_model, -3, row);
}
static gint
visible_depth_of_node (ETableModel *model, gint row)
{
ETreeModel *tree_model = e_cell_tree_get_tree_model (model, row);
ETreeTableAdapter *adapter = e_cell_tree_get_tree_table_adapter (model, row);
ETreePath path = e_cell_tree_get_node (model, row);
return (e_tree_model_node_depth (tree_model, path)
- (e_tree_table_adapter_root_node_is_visible (adapter) ? 0 : 1));
}
/* If this is changed to not include the width of the expansion pixmap
if the path is not expandable, then max_width needs to change as
well. */
static gint
offset_of_node (ETableModel *table_model, gint row)
{
ETreeModel *tree_model = e_cell_tree_get_tree_model (table_model, row);
ETreePath path = e_cell_tree_get_node (table_model, row);
if (visible_depth_of_node (table_model, row) >= 0 ||
e_tree_model_node_is_expandable (tree_model, path)) {
return (visible_depth_of_node (table_model, row) + 1) * INDENT_AMOUNT;
} else {
return 0;
}
}
/*
* ECell::new_view method
*/
static ECellView *
ect_new_view (ECell *ecell, ETableModel *table_model, gpointer e_table_item_view)
{
ECellTree *ect = E_CELL_TREE (ecell);
ECellTreeView *tree_view = g_new0 (ECellTreeView, 1);
GnomeCanvas *canvas = GNOME_CANVAS_ITEM (e_table_item_view)->canvas;
tree_view->cell_view.ecell = ecell;
tree_view->cell_view.e_table_model = table_model;
tree_view->cell_view.e_table_item_view = e_table_item_view;
tree_view->cell_view.kill_view_cb = NULL;
tree_view->cell_view.kill_view_cb_data = NULL;
/* create our subcell view */
tree_view->subcell_view = e_cell_new_view (ect->subcell, table_model, e_table_item_view /* XXX */);
tree_view->canvas = canvas;
return (ECellView *)tree_view;
}
/*
* ECell::kill_view method
*/
static void
ect_kill_view (ECellView *ecv)
{
ECellTreeView *tree_view = (ECellTreeView *) ecv;
if (tree_view->cell_view.kill_view_cb)
(tree_view->cell_view.kill_view_cb)(ecv, tree_view->cell_view.kill_view_cb_data);
if (tree_view->cell_view.kill_view_cb_data)
g_list_free (tree_view->cell_view.kill_view_cb_data);
/* kill our subcell view */
e_cell_kill_view (tree_view->subcell_view);
g_free (tree_view);
}
/*
* ECell::realize method
*/
static void
ect_realize (ECellView *ecell_view)
{
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
/* realize our subcell view */
e_cell_realize (tree_view->subcell_view);
if (E_CELL_CLASS (e_cell_tree_parent_class)->realize)
(* E_CELL_CLASS (e_cell_tree_parent_class)->realize) (ecell_view);
}
/*
* ECell::unrealize method
*/
static void
ect_unrealize (ECellView *ecv)
{
ECellTreeView *tree_view = (ECellTreeView *) ecv;
/* unrealize our subcell view. */
e_cell_unrealize (tree_view->subcell_view);
if (E_CELL_CLASS (e_cell_tree_parent_class)->unrealize)
(* E_CELL_CLASS (e_cell_tree_parent_class)->unrealize) (ecv);
}
static void
draw_expander (ECellTreeView *ectv,
cairo_t *cr,
GtkExpanderStyle expander_style,
GtkStateType state,
GdkRectangle *rect)
{
GtkStyle *style;
GtkWidget *tree;
gint exp_size;
tree = gtk_widget_get_parent (GTK_WIDGET (ectv->canvas));
style = gtk_widget_get_style (tree);
gtk_widget_style_get (tree, "expander_size", &exp_size, NULL);
gtk_paint_expander (
style, cr, state, tree, "treeview",
rect->x + rect->width - exp_size / 2,
rect->y + rect->height / 2, expander_style);
}
/*
* ECell::draw method
*/
static void
ect_draw (ECellView *ecell_view,
cairo_t *cr,
gint model_col,
gint view_col,
gint row,
ECellFlags flags,
gint x1,
gint y1,
gint x2,
gint y2)
{
ECellTreeView *tree_view = (ECellTreeView *)ecell_view;
ETreeModel *tree_model = e_cell_tree_get_tree_model (ecell_view->e_table_model, row);
ETreeTableAdapter *tree_table_adapter = e_cell_tree_get_tree_table_adapter (ecell_view->e_table_model, row);
ETreePath node;
GdkRectangle rect;
gint offset, subcell_offset;
cairo_save (cr);
/* only draw the tree effects if we're the active sort */
if (/* XXX */ TRUE) {
GdkPixbuf *node_image;
gint node_image_width = 0, node_image_height = 0;
tree_view->prelit = FALSE;
node = e_cell_tree_get_node (ecell_view->e_table_model, row);
offset = offset_of_node (ecell_view->e_table_model, row);
subcell_offset = offset;
node_image = e_tree_model_icon_at (tree_model, node);
if (node_image) {
node_image_width = gdk_pixbuf_get_width (node_image);
node_image_height = gdk_pixbuf_get_height (node_image);
}
/*
* Be a nice citizen: clip to the region we are supposed to draw on
*/
rect.x = x1;
rect.y = y1;
rect.width = subcell_offset + node_image_width;
rect.height = y2 - y1;
/* now draw our icon if we're expandable */
if (e_tree_model_node_is_expandable (tree_model, node)) {
gboolean expanded = e_tree_table_adapter_node_is_expanded (tree_table_adapter, node);
GdkRectangle r;
r = rect;
r.width -= node_image_width + 2;
draw_expander (tree_view, cr, expanded ? GTK_EXPANDER_EXPANDED : GTK_EXPANDER_COLLAPSED, GTK_STATE_NORMAL, &r);
}
if (node_image) {
gdk_cairo_set_source_pixbuf (cr, node_image,
x1 + subcell_offset,
y1 + (y2 - y1) / 2 - node_image_height / 2);
cairo_paint (cr);
subcell_offset += node_image_width;
}
}
/* Now cause our subcell to draw its contents, shifted by
subcell_offset pixels */
e_cell_draw (tree_view->subcell_view, cr,
model_col, view_col, row, flags,
x1 + subcell_offset, y1, x2, y2);
cairo_restore (cr);
}
static void
adjust_event_position (GdkEvent *event, gint offset)
{
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
event->button.x += offset;
break;
case GDK_MOTION_NOTIFY:
event->motion.x += offset;
break;
default:
break;
}
}
static gboolean
event_in_expander (GdkEvent *event, gint offset, gint height)
{
switch (event->type) {
case GDK_BUTTON_PRESS:
return (event->button.x > (offset - INDENT_AMOUNT) && event->button.x < offset);
case GDK_MOTION_NOTIFY:
return (event->motion.x > (offset - INDENT_AMOUNT) && event->motion.x < offset &&
event->motion.y > 2 && event->motion.y < (height - 2));
default:
break;
}
return FALSE;
}
/*
* ECell::height method
*/
static gint
ect_height (ECellView *ecell_view, gint model_col, gint view_col, gint row)
{
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
return (((e_cell_height (tree_view->subcell_view, model_col, view_col, row)) + 1) / 2) * 2;
}
typedef struct {
ECellTreeView *ectv;
ETreeTableAdapter *etta;
ETreePath node;
gboolean expanded;
gboolean finish;
GdkRectangle area;
} animate_closure_t;
static gboolean
animate_expander (gpointer data)
{
GtkLayout *layout;
GdkWindow *window;
animate_closure_t *closure = (animate_closure_t *) data;
cairo_t *cr;
if (closure->finish) {
e_tree_table_adapter_node_set_expanded (closure->etta, closure->node, !closure->expanded);
closure->ectv->animate_timeout = 0;
g_free (data);
return FALSE;
}
layout = GTK_LAYOUT (closure->ectv->canvas);
window = gtk_layout_get_bin_window (layout);
cr = gdk_cairo_create (window);
draw_expander (
closure->ectv, cr, closure->expanded ?
GTK_EXPANDER_SEMI_COLLAPSED :
GTK_EXPANDER_SEMI_EXPANDED,
GTK_STATE_NORMAL, &closure->area);
closure->finish = TRUE;
cairo_destroy (cr);
return TRUE;
}
/*
* ECell::event method
*/
static gint
ect_event (ECellView *ecell_view, GdkEvent *event, gint model_col, gint view_col, gint row, ECellFlags flags, ECellActions *actions)
{
GtkLayout *layout;
GdkWindow *window;
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
ETreeModel *tree_model = e_cell_tree_get_tree_model (ecell_view->e_table_model, row);
ETreeTableAdapter *etta = e_cell_tree_get_tree_table_adapter (ecell_view->e_table_model, row);
ETreePath node = e_cell_tree_get_node (ecell_view->e_table_model, row);
gint offset = offset_of_node (ecell_view->e_table_model, row);
gint result;
layout = GTK_LAYOUT (tree_view->canvas);
window = gtk_layout_get_bin_window (layout);
switch (event->type) {
case GDK_BUTTON_PRESS:
if (event_in_expander (event, offset, 0)) {
if (e_tree_model_node_is_expandable (tree_model, node)) {
gboolean expanded = e_tree_table_adapter_node_is_expanded (etta, node);
gint tmp_row = row;
GdkRectangle area;
animate_closure_t *closure = g_new0 (animate_closure_t, 1);
cairo_t *cr;
gint hgt;
e_table_item_get_cell_geometry (tree_view->cell_view.e_table_item_view,
&tmp_row, &view_col, &area.x, &area.y, NULL, &area.height);
area.width = offset - 2;
hgt = e_cell_height (ecell_view, model_col, view_col, row);
if (hgt != area.height) /* Composite cells */
area.height += hgt;
cr = gdk_cairo_create (window);
draw_expander (
tree_view, cr, expanded ?
GTK_EXPANDER_SEMI_EXPANDED :
GTK_EXPANDER_SEMI_COLLAPSED,
GTK_STATE_NORMAL, &area);
cairo_destroy (cr);
closure->ectv = tree_view;
closure->etta = etta;
closure->node = node;
closure->expanded = expanded;
closure->area = area;
tree_view->animate_timeout = g_timeout_add (50, animate_expander, closure);
return TRUE;
}
}
else if (event->button.x < (offset - INDENT_AMOUNT))
return FALSE;
break;
case GDK_MOTION_NOTIFY:
if (e_tree_model_node_is_expandable (tree_model, node)) {
gint height = ect_height (ecell_view, model_col, view_col, row);
GdkRectangle area;
gboolean in_expander = event_in_expander (event, offset, height);
if (tree_view->prelit ^ in_expander) {
gint tmp_row = row;
cairo_t *cr;
e_table_item_get_cell_geometry (tree_view->cell_view.e_table_item_view,
&tmp_row, &view_col, &area.x, &area.y, NULL, &area.height);
area.width = offset - 2;
cr = gdk_cairo_create (window);
draw_expander (
tree_view, cr,
e_tree_table_adapter_node_is_expanded (etta, node) ?
GTK_EXPANDER_EXPANDED : GTK_EXPANDER_COLLAPSED,
in_expander ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL, &area);
cairo_destroy (cr);
tree_view->prelit = in_expander;
return TRUE;
}
}
break;
case GDK_LEAVE_NOTIFY:
if (tree_view->prelit) {
gint tmp_row = row;
GdkRectangle area;
cairo_t *cr;
e_table_item_get_cell_geometry (tree_view->cell_view.e_table_item_view,
&tmp_row, &view_col, &area.x, &area.y, NULL, &area.height);
area.width = offset - 2;
cr = gdk_cairo_create (window);
draw_expander (
tree_view, cr,
e_tree_table_adapter_node_is_expanded (etta, node) ?
GTK_EXPANDER_EXPANDED : GTK_EXPANDER_COLLAPSED,
GTK_STATE_NORMAL, &area);
cairo_destroy (cr);
tree_view->prelit = FALSE;
}
return TRUE;
default:
break;
}
adjust_event_position (event, -offset);
result = e_cell_event (tree_view->subcell_view, event, model_col, view_col, row, flags, actions);
adjust_event_position (event, offset);
return result;
}
/*
* ECell::max_width method
*/
static gint
ect_max_width (ECellView *ecell_view, gint model_col, gint view_col)
{
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
gint row;
gint number_of_rows;
gint max_width = 0;
gint width = 0;
gint subcell_max_width = 0;
gboolean per_row = e_cell_max_width_by_row_implemented (tree_view->subcell_view);
number_of_rows = e_table_model_row_count (ecell_view->e_table_model);
if (!per_row)
subcell_max_width = e_cell_max_width (tree_view->subcell_view, model_col, view_col);
for (row = 0; row < number_of_rows; row++) {
ETreeModel *tree_model = e_cell_tree_get_tree_model (ecell_view->e_table_model, row);
ETreePath node;
GdkPixbuf *node_image;
gint node_image_width = 0;
gint offset, subcell_offset;
#if 0
gboolean expanded, expandable;
ETreeTableAdapter *tree_table_adapter = e_cell_tree_get_tree_table_adapter (ecell_view->e_table_model, row);
#endif
node = e_cell_tree_get_node (ecell_view->e_table_model, row);
offset = offset_of_node (ecell_view->e_table_model, row);
subcell_offset = offset;
node_image = e_tree_model_icon_at (tree_model, node);
if (node_image) {
node_image_width = gdk_pixbuf_get_width (node_image);
}
width = subcell_offset + node_image_width;
if (per_row)
width += e_cell_max_width_by_row (tree_view->subcell_view, model_col, view_col, row);
else
width += subcell_max_width;
#if 0
expandable = e_tree_model_node_is_expandable (tree_model, node);
expanded = e_tree_table_adapter_node_is_expanded (tree_table_adapter, node);
/* This is unnecessary since this is already handled
* by the offset_of_node function. If that changes,
* this will have to change too. */
if (expandable) {
GdkPixbuf *image;
image = (expanded
? E_CELL_TREE (tree_view->cell_view.ecell)->open_pixbuf
: E_CELL_TREE (tree_view->cell_view.ecell)->closed_pixbuf);
width += gdk_pixbuf_get_width (image);
}
#endif
max_width = MAX (max_width, width);
}
return max_width;
}
/*
* ECellView::get_bg_color method
*/
static gchar *
ect_get_bg_color (ECellView *ecell_view, gint row)
{
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
return e_cell_get_bg_color (tree_view->subcell_view, row);
}
/*
* ECellView::enter_edit method
*/
static gpointer
ect_enter_edit (ECellView *ecell_view, gint model_col, gint view_col, gint row)
{
/* just defer to our subcell's view */
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
return e_cell_enter_edit (tree_view->subcell_view, model_col, view_col, row);
}
/*
* ECellView::leave_edit method
*/
static void
ect_leave_edit (ECellView *ecell_view, gint model_col, gint view_col, gint row, gpointer edit_context)
{
/* just defer to our subcell's view */
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
e_cell_leave_edit (tree_view->subcell_view, model_col, view_col, row, edit_context);
}
static void
ect_print (ECellView *ecell_view, GtkPrintContext *context,
gint model_col, gint view_col, gint row,
gdouble width, gdouble height)
{
ECellTreeView *tree_view = (ECellTreeView *) ecell_view;
cairo_t *cr = gtk_print_context_get_cairo_context (context);
cairo_save (cr);
if (/* XXX only if we're the active sort */ TRUE) {
ETreeModel *tree_model = e_cell_tree_get_tree_model (ecell_view->e_table_model, row);
ETreeTableAdapter *tree_table_adapter = e_cell_tree_get_tree_table_adapter (ecell_view->e_table_model, row);
ETreePath node = e_cell_tree_get_node (ecell_view->e_table_model, row);
gint offset = offset_of_node (ecell_view->e_table_model, row);
gint subcell_offset = offset;
gboolean expandable = e_tree_model_node_is_expandable (tree_model, node);
/* draw our lines */
if (E_CELL_TREE (tree_view->cell_view.ecell)->draw_lines) {
gint depth;
if (!e_tree_model_node_is_root (tree_model, node)
|| e_tree_model_node_get_children (tree_model, node, NULL) > 0) {
cairo_move_to (cr,
offset - INDENT_AMOUNT / 2,
height / 2);
cairo_line_to (cr, offset, height / 2);
}
if (visible_depth_of_node (ecell_view->e_table_model, row) != 0) {
cairo_move_to (cr,
offset - INDENT_AMOUNT / 2, height);
cairo_line_to (cr,
offset - INDENT_AMOUNT / 2,
e_tree_table_adapter_node_get_next
(tree_table_adapter, node) ? 0 :
height / 2);
}
/* now traverse back up to the root of the tree, checking at
each level if the node has siblings, and drawing the
correct vertical pipe for it's configuration. */
node = e_tree_model_node_get_parent (tree_model, node);
depth = visible_depth_of_node (ecell_view->e_table_model, row) - 1;
offset -= INDENT_AMOUNT;
while (node && depth != 0) {
if (e_tree_table_adapter_node_get_next (tree_table_adapter, node)) {
cairo_move_to (cr,
offset - INDENT_AMOUNT / 2,
height);
cairo_line_to (cr,
offset - INDENT_AMOUNT / 2, 0);
}
node = e_tree_model_node_get_parent (tree_model, node);
depth--;
offset -= INDENT_AMOUNT;
}
}
/* now draw our icon if we're expandable */
if (expandable) {
#if GTK_CHECK_VERSION (3, 0, 0)
gboolean expanded = e_tree_table_adapter_node_is_expanded (tree_table_adapter, node);
#error Paint an expander here
#endif
}
cairo_stroke (cr);
cairo_translate (cr, subcell_offset, 0);
width -= subcell_offset;
}
cairo_restore (cr);
e_cell_print (tree_view->subcell_view, context, model_col, view_col, row, width, height);
}
static gdouble
ect_print_height (ECellView *ecell_view, GtkPrintContext *context,
gint model_col, gint view_col, gint row,
gdouble width)
{
return 12; /* XXX */
}
/*
* GObject::dispose method
*/
static void
ect_dispose (GObject *object)
{
ECellTree *ect = E_CELL_TREE (object);
/* destroy our subcell */
if (ect->subcell)
g_object_unref (ect->subcell);
ect->subcell = NULL;
G_OBJECT_CLASS (e_cell_tree_parent_class)->dispose (object);
}
static void
e_cell_tree_class_init (ECellTreeClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
ECellClass *ecc = E_CELL_CLASS (class);
object_class->dispose = ect_dispose;
ecc->new_view = ect_new_view;
ecc->kill_view = ect_kill_view;
ecc->realize = ect_realize;
ecc->unrealize = ect_unrealize;
ecc->draw = ect_draw;
ecc->event = ect_event;
ecc->height = ect_height;
ecc->enter_edit = ect_enter_edit;
ecc->leave_edit = ect_leave_edit;
ecc->print = ect_print;
ecc->print_height = ect_print_height;
ecc->max_width = ect_max_width;
ecc->get_bg_color = ect_get_bg_color;
gal_a11y_e_cell_registry_add_cell_type (NULL, E_TYPE_CELL_TREE, gal_a11y_e_cell_tree_new);
}
static void
e_cell_tree_init (ECellTree *ect)
{
/* nothing to do */
}
/**
* e_cell_tree_construct:
* @ect: the ECellTree we're constructing.
* @draw_lines: whether or not to draw the lines between parents/children/siblings.
* @subcell: the ECell to render to the right of the tree effects.
*
* Constructs an ECellTree. used by subclasses that need to
* initialize a nested ECellTree. See e_cell_tree_new() for more info.
*
**/
void
e_cell_tree_construct (ECellTree *ect,
gboolean draw_lines,
ECell *subcell)
{
ect->subcell = subcell;
if (subcell)
g_object_ref_sink (subcell);
ect->draw_lines = draw_lines;
}
/**
* e_cell_tree_new:
* @draw_lines: whether or not to draw the lines between parents/children/siblings.
* @subcell: the ECell to render to the right of the tree effects.
*
* Creates a new ECell renderer that can be used to render tree
* effects that come from an ETreeModel. Various assumptions are made
* as to the fact that the ETableModel the ETable this cell is
* associated with is in fact an ETreeModel. The cell uses special
* columns to get at structural information (needed to draw the
* lines/icons.
*
* Return value: an ECell object that can be used to render trees.
**/
ECell *
e_cell_tree_new (gboolean draw_lines,
ECell *subcell)
{
ECellTree *ect = g_object_new (E_TYPE_CELL_TREE, NULL);
e_cell_tree_construct (ect, draw_lines, subcell);
return (ECell *) ect;
}