[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH 01/17] Import GtkTreeView from GTK+ 2.0-2.20.1 renamed as PsppShe
|
From: |
Ben Pfaff |
|
Subject: |
[PATCH 01/17] Import GtkTreeView from GTK+ 2.0-2.20.1 renamed as PsppSheetView. |
|
Date: |
Sun, 22 Apr 2012 11:12:19 -0700 |
This includes minimal modifications to make it compile and link
cleanly.
I used the following Perl script to do the bulk of the renaming:
for $pair (['tree_view_column', 'sheet_view_column'],
['tree_selection', 'sheet_selection'],
['tree_view', 'sheet_view'],
['rbtree', 'rbtree'],
['rbnode', 'rbnode']) {
my ($from, $to) = @$pair;
my ($tfrom) = join ('', map ("\u$_", split ('_', $from)));
my ($tto) = join ('', map ("\u$_", split ('_', $to)));
s/gtk_$from/pspp_$to/g;
s/\Ugtk_$from/\Upspp_$to/g;
s/GTK_TYPE_\U$from/PSPP_TYPE_\U$to/g;
s/GTK_IS_\U$from/PSPP_IS_\U$to/g;
s/Gtk$tfrom/Pspp$tto/g;
}
s/GtkTreeCellDataFunc/PsppSheetCellDataFunc/g;
s/GtkTreeDestroyCountFunc/PsppSheetDestroyCountFunc/g;
---
src/ui/gui/automake.mk | 8 +
src/ui/gui/marshaller-list | 4 +
src/ui/gui/pspp-rb-tree.c | 1753 ++++
src/ui/gui/pspp-rb-tree.h | 200 +
src/ui/gui/pspp-sheet-private.h | 480 ++
src/ui/gui/pspp-sheet-selection.c | 1486 ++++
src/ui/gui/pspp-sheet-selection.h | 137 +
src/ui/gui/pspp-sheet-view-column.c | 3948 +++++++++
src/ui/gui/pspp-sheet-view-column.h | 254 +
src/ui/gui/pspp-sheet-view.c |15740 +++++++++++++++++++++++++++++++++++
src/ui/gui/pspp-sheet-view.h | 451 +
11 files changed, 24461 insertions(+), 0 deletions(-)
create mode 100644 src/ui/gui/pspp-rb-tree.c
create mode 100644 src/ui/gui/pspp-rb-tree.h
create mode 100644 src/ui/gui/pspp-sheet-private.h
create mode 100644 src/ui/gui/pspp-sheet-selection.c
create mode 100644 src/ui/gui/pspp-sheet-selection.h
create mode 100644 src/ui/gui/pspp-sheet-view-column.c
create mode 100644 src/ui/gui/pspp-sheet-view-column.h
create mode 100644 src/ui/gui/pspp-sheet-view.c
create mode 100644 src/ui/gui/pspp-sheet-view.h
diff --git a/src/ui/gui/automake.mk b/src/ui/gui/automake.mk
index 3016723..664c0d6 100644
--- a/src/ui/gui/automake.mk
+++ b/src/ui/gui/automake.mk
@@ -133,6 +133,14 @@ dist_src_ui_gui_psppire_DATA = \
src_ui_gui_psppire_SOURCES = \
+ src/ui/gui/pspp-rb-tree.c \
+ src/ui/gui/pspp-rb-tree.h \
+ src/ui/gui/pspp-sheet-selection.c \
+ src/ui/gui/pspp-sheet-selection.h \
+ src/ui/gui/pspp-sheet-view-column.c \
+ src/ui/gui/pspp-sheet-view-column.h \
+ src/ui/gui/pspp-sheet-view.c \
+ src/ui/gui/pspp-sheet-view.h \
src/ui/gui/psppire-dialog.c \
src/ui/gui/psppire-keypad.c \
src/ui/gui/psppire-selector.c \
diff --git a/src/ui/gui/marshaller-list b/src/ui/gui/marshaller-list
index f21c407..02c7ff6 100644
--- a/src/ui/gui/marshaller-list
+++ b/src/ui/gui/marshaller-list
@@ -1,10 +1,14 @@
#List of custom marshallers used by psppire
BOOLEAN:BOOLEAN
+BOOLEAN:BOOLEAN,BOOLEAN,BOOLEAN
BOOLEAN:ENUM
+BOOLEAN:ENUM,INT
+BOOLEAN:BOXED,BOXED
BOOLEAN:BOXED,POINTER
BOOLEAN:VOID
VOID:BOXED,BOXED
+VOID:BOXED,OBJECT
VOID:INT,INT
VOID:INT,LONG
VOID:INT,INT,INT,INT
diff --git a/src/ui/gui/pspp-rb-tree.c b/src/ui/gui/pspp-rb-tree.c
new file mode 100644
index 0000000..98ea5b5
--- /dev/null
+++ b/src/ui/gui/pspp-rb-tree.c
@@ -0,0 +1,1753 @@
+/* gtkrbtree.c
+ * Copyright (C) 2000, 2011 Red Hat, Inc., Jonathan Blandford
<address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include <gtk/gtk.h>
+
+#include "ui/gui/pspp-rb-tree.h"
+
+static GtkRBNode * _pspp_rbnode_new (GtkRBTree *tree,
+ gint height);
+static void _pspp_rbnode_free (GtkRBNode *node);
+static void _pspp_rbnode_rotate_left (GtkRBTree *tree,
+ GtkRBNode *node);
+static void _pspp_rbnode_rotate_right (GtkRBTree *tree,
+ GtkRBNode *node);
+static void _pspp_rbtree_insert_fixup (GtkRBTree *tree,
+ GtkRBNode *node);
+static void _pspp_rbtree_remove_node_fixup (GtkRBTree *tree,
+ GtkRBNode *node);
+static inline void _fixup_validation (GtkRBTree *tree,
+ GtkRBNode *node);
+static inline void _fixup_parity (GtkRBTree *tree,
+ GtkRBNode *node);
+
+
+
+static GtkRBNode *
+_pspp_rbnode_new (GtkRBTree *tree,
+ gint height)
+{
+ GtkRBNode *node = g_slice_new (GtkRBNode);
+
+ node->left = tree->nil;
+ node->right = tree->nil;
+ node->parent = tree->nil;
+ node->flags = PSPP_RBNODE_RED;
+ node->parity = 1;
+ node->count = 1;
+ node->children = NULL;
+ node->offset = height;
+ return node;
+}
+
+static void
+_pspp_rbnode_free (GtkRBNode *node)
+{
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ {
+ node->left = (gpointer) 0xdeadbeef;
+ node->right = (gpointer) 0xdeadbeef;
+ node->parent = (gpointer) 0xdeadbeef;
+ node->offset = 56789;
+ node->count = 56789;
+ node->flags = 0;
+ }
+ g_slice_free (GtkRBNode, node);
+}
+
+static void
+_pspp_rbnode_rotate_left (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ gint node_height, right_height;
+ GtkRBNode *right = node->right;
+
+ g_return_if_fail (node != tree->nil);
+
+ node_height = node->offset -
+ (node->left?node->left->offset:0) -
+ (node->right?node->right->offset:0) -
+ (node->children?node->children->root->offset:0);
+ right_height = right->offset -
+ (right->left?right->left->offset:0) -
+ (right->right?right->right->offset:0) -
+ (right->children?right->children->root->offset:0);
+ node->right = right->left;
+ if (right->left != tree->nil)
+ right->left->parent = node;
+
+ if (right != tree->nil)
+ right->parent = node->parent;
+ if (node->parent != tree->nil)
+ {
+ if (node == node->parent->left)
+ node->parent->left = right;
+ else
+ node->parent->right = right;
+ } else {
+ tree->root = right;
+ }
+
+ right->left = node;
+ if (node != tree->nil)
+ node->parent = right;
+
+ node->count = 1 + (node->left?node->left->count:0) +
+ (node->right?node->right->count:0);
+ right->count = 1 + (right->left?right->left->count:0) +
+ (right->right?right->right->count:0);
+
+ node->offset = node_height +
+ (node->left?node->left->offset:0) +
+ (node->right?node->right->offset:0) +
+ (node->children?node->children->root->offset:0);
+ right->offset = right_height +
+ (right->left?right->left->offset:0) +
+ (right->right?right->right->offset:0) +
+ (right->children?right->children->root->offset:0);
+
+ _fixup_validation (tree, node);
+ _fixup_validation (tree, right);
+ _fixup_parity (tree, node);
+ _fixup_parity (tree, right);
+}
+
+static void
+_pspp_rbnode_rotate_right (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ gint node_height, left_height;
+ GtkRBNode *left = node->left;
+
+ g_return_if_fail (node != tree->nil);
+
+ node_height = node->offset -
+ (node->left?node->left->offset:0) -
+ (node->right?node->right->offset:0) -
+ (node->children?node->children->root->offset:0);
+ left_height = left->offset -
+ (left->left?left->left->offset:0) -
+ (left->right?left->right->offset:0) -
+ (left->children?left->children->root->offset:0);
+
+ node->left = left->right;
+ if (left->right != tree->nil)
+ left->right->parent = node;
+
+ if (left != tree->nil)
+ left->parent = node->parent;
+ if (node->parent != tree->nil)
+ {
+ if (node == node->parent->right)
+ node->parent->right = left;
+ else
+ node->parent->left = left;
+ }
+ else
+ {
+ tree->root = left;
+ }
+
+ /* link node and left */
+ left->right = node;
+ if (node != tree->nil)
+ node->parent = left;
+
+ node->count = 1 + (node->left?node->left->count:0) +
+ (node->right?node->right->count:0);
+ left->count = 1 + (left->left?left->left->count:0) +
+ (left->right?left->right->count:0);
+
+ node->offset = node_height +
+ (node->left?node->left->offset:0) +
+ (node->right?node->right->offset:0) +
+ (node->children?node->children->root->offset:0);
+ left->offset = left_height +
+ (left->left?left->left->offset:0) +
+ (left->right?left->right->offset:0) +
+ (left->children?left->children->root->offset:0);
+
+ _fixup_validation (tree, node);
+ _fixup_validation (tree, left);
+ _fixup_parity (tree, node);
+ _fixup_parity (tree, left);
+}
+
+static void
+_pspp_rbtree_insert_fixup (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+
+ /* check Red-Black properties */
+ while (node != tree->root && PSPP_RBNODE_GET_COLOR (node->parent) ==
PSPP_RBNODE_RED)
+ {
+ /* we have a violation */
+ if (node->parent == node->parent->parent->left)
+ {
+ GtkRBNode *y = node->parent->parent->right;
+ if (PSPP_RBNODE_GET_COLOR (y) == PSPP_RBNODE_RED)
+ {
+ /* uncle is PSPP_RBNODE_RED */
+ PSPP_RBNODE_SET_COLOR (node->parent, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (y, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (node->parent->parent, PSPP_RBNODE_RED);
+ node = node->parent->parent;
+ }
+ else
+ {
+ /* uncle is PSPP_RBNODE_BLACK */
+ if (node == node->parent->right)
+ {
+ /* make node a left child */
+ node = node->parent;
+ _pspp_rbnode_rotate_left (tree, node);
+ }
+
+ /* recolor and rotate */
+ PSPP_RBNODE_SET_COLOR (node->parent, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (node->parent->parent, PSPP_RBNODE_RED);
+ _pspp_rbnode_rotate_right(tree, node->parent->parent);
+ }
+ }
+ else
+ {
+ /* mirror image of above code */
+ GtkRBNode *y = node->parent->parent->left;
+ if (PSPP_RBNODE_GET_COLOR (y) == PSPP_RBNODE_RED)
+ {
+ /* uncle is PSPP_RBNODE_RED */
+ PSPP_RBNODE_SET_COLOR (node->parent, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (y, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (node->parent->parent, PSPP_RBNODE_RED);
+ node = node->parent->parent;
+ }
+ else
+ {
+ /* uncle is PSPP_RBNODE_BLACK */
+ if (node == node->parent->left)
+ {
+ node = node->parent;
+ _pspp_rbnode_rotate_right (tree, node);
+ }
+ PSPP_RBNODE_SET_COLOR (node->parent, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (node->parent->parent, PSPP_RBNODE_RED);
+ _pspp_rbnode_rotate_left (tree, node->parent->parent);
+ }
+ }
+ }
+ PSPP_RBNODE_SET_COLOR (tree->root, PSPP_RBNODE_BLACK);
+}
+
+static void
+_pspp_rbtree_remove_node_fixup (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ while (node != tree->root && PSPP_RBNODE_GET_COLOR (node) ==
PSPP_RBNODE_BLACK)
+ {
+ if (node == node->parent->left)
+ {
+ GtkRBNode *w = node->parent->right;
+ if (PSPP_RBNODE_GET_COLOR (w) == PSPP_RBNODE_RED)
+ {
+ PSPP_RBNODE_SET_COLOR (w, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (node->parent, PSPP_RBNODE_RED);
+ _pspp_rbnode_rotate_left (tree, node->parent);
+ w = node->parent->right;
+ }
+ if (PSPP_RBNODE_GET_COLOR (w->left) == PSPP_RBNODE_BLACK &&
PSPP_RBNODE_GET_COLOR (w->right) == PSPP_RBNODE_BLACK)
+ {
+ PSPP_RBNODE_SET_COLOR (w, PSPP_RBNODE_RED);
+ node = node->parent;
+ }
+ else
+ {
+ if (PSPP_RBNODE_GET_COLOR (w->right) == PSPP_RBNODE_BLACK)
+ {
+ PSPP_RBNODE_SET_COLOR (w->left, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (w, PSPP_RBNODE_RED);
+ _pspp_rbnode_rotate_right (tree, w);
+ w = node->parent->right;
+ }
+ PSPP_RBNODE_SET_COLOR (w, PSPP_RBNODE_GET_COLOR (node->parent));
+ PSPP_RBNODE_SET_COLOR (node->parent, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (w->right, PSPP_RBNODE_BLACK);
+ _pspp_rbnode_rotate_left (tree, node->parent);
+ node = tree->root;
+ }
+ }
+ else
+ {
+ GtkRBNode *w = node->parent->left;
+ if (PSPP_RBNODE_GET_COLOR (w) == PSPP_RBNODE_RED)
+ {
+ PSPP_RBNODE_SET_COLOR (w, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (node->parent, PSPP_RBNODE_RED);
+ _pspp_rbnode_rotate_right (tree, node->parent);
+ w = node->parent->left;
+ }
+ if (PSPP_RBNODE_GET_COLOR (w->right) == PSPP_RBNODE_BLACK &&
PSPP_RBNODE_GET_COLOR (w->left) == PSPP_RBNODE_BLACK)
+ {
+ PSPP_RBNODE_SET_COLOR (w, PSPP_RBNODE_RED);
+ node = node->parent;
+ }
+ else
+ {
+ if (PSPP_RBNODE_GET_COLOR (w->left) == PSPP_RBNODE_BLACK)
+ {
+ PSPP_RBNODE_SET_COLOR (w->right, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (w, PSPP_RBNODE_RED);
+ _pspp_rbnode_rotate_left (tree, w);
+ w = node->parent->left;
+ }
+ PSPP_RBNODE_SET_COLOR (w, PSPP_RBNODE_GET_COLOR (node->parent));
+ PSPP_RBNODE_SET_COLOR (node->parent, PSPP_RBNODE_BLACK);
+ PSPP_RBNODE_SET_COLOR (w->left, PSPP_RBNODE_BLACK);
+ _pspp_rbnode_rotate_right (tree, node->parent);
+ node = tree->root;
+ }
+ }
+ }
+ PSPP_RBNODE_SET_COLOR (node, PSPP_RBNODE_BLACK);
+}
+
+GtkRBTree *
+_pspp_rbtree_new (void)
+{
+ GtkRBTree *retval;
+
+ retval = g_new (GtkRBTree, 1);
+ retval->parent_tree = NULL;
+ retval->parent_node = NULL;
+
+ retval->nil = g_slice_new (GtkRBNode);
+ retval->nil->left = NULL;
+ retval->nil->right = NULL;
+ retval->nil->parent = NULL;
+ retval->nil->flags = PSPP_RBNODE_BLACK;
+ retval->nil->count = 0;
+ retval->nil->offset = 0;
+ retval->nil->parity = 0;
+
+ retval->root = retval->nil;
+ return retval;
+}
+
+static void
+_pspp_rbtree_free_helper (GtkRBTree *tree,
+ GtkRBNode *node,
+ gpointer data)
+{
+ if (node->children)
+ _pspp_rbtree_free (node->children);
+
+ _pspp_rbnode_free (node);
+}
+
+void
+_pspp_rbtree_free (GtkRBTree *tree)
+{
+ _pspp_rbtree_traverse (tree,
+ tree->root,
+ G_POST_ORDER,
+ _pspp_rbtree_free_helper,
+ NULL);
+
+ if (tree->parent_node &&
+ tree->parent_node->children == tree)
+ tree->parent_node->children = NULL;
+ _pspp_rbnode_free (tree->nil);
+ g_free (tree);
+}
+
+void
+_pspp_rbtree_remove (GtkRBTree *tree)
+{
+ GtkRBTree *tmp_tree;
+ GtkRBNode *tmp_node;
+
+ gint height = tree->root->offset;
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ _pspp_rbtree_test (G_STRLOC, tree);
+#endif
+
+ tmp_tree = tree->parent_tree;
+ tmp_node = tree->parent_node;
+
+ /* ugly hack to make _fixup_validation work in the first iteration of the
+ * loop below */
+ PSPP_RBNODE_UNSET_FLAG (tree->root, PSPP_RBNODE_DESCENDANTS_INVALID);
+
+ while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
+ {
+ _fixup_validation (tmp_tree, tmp_node);
+ tmp_node->offset -= height;
+
+ /* If the removed tree was odd, flip all parents */
+ if (tree->root->parity)
+ tmp_node->parity = !tmp_node->parity;
+
+ tmp_node = tmp_node->parent;
+ if (tmp_node == tmp_tree->nil)
+ {
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+
+ tmp_tree = tree->parent_tree;
+ tmp_node = tree->parent_node;
+ _pspp_rbtree_free (tree);
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ _pspp_rbtree_test (G_STRLOC, tmp_tree);
+#endif
+}
+
+
+GtkRBNode *
+_pspp_rbtree_insert_after (GtkRBTree *tree,
+ GtkRBNode *current,
+ gint height,
+ gboolean valid)
+{
+ GtkRBNode *node;
+ gboolean right = TRUE;
+ GtkRBNode *tmp_node;
+ GtkRBTree *tmp_tree;
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ {
+ g_print ("\n\n_pspp_rbtree_insert_after: %p\n", current);
+ _pspp_rbtree_debug_spew (tree);
+ _pspp_rbtree_test (G_STRLOC, tree);
+ }
+#endif /* G_ENABLE_DEBUG */
+
+ if (current != NULL && current->right != tree->nil)
+ {
+ current = current->right;
+ while (current->left != tree->nil)
+ current = current->left;
+ right = FALSE;
+ }
+ /* setup new node */
+ node = _pspp_rbnode_new (tree, height);
+ node->parent = (current?current:tree->nil);
+
+ /* insert node in tree */
+ if (current)
+ {
+ if (right)
+ current->right = node;
+ else
+ current->left = node;
+ tmp_node = node->parent;
+ tmp_tree = tree;
+ }
+ else
+ {
+ tree->root = node;
+ tmp_node = tree->parent_node;
+ tmp_tree = tree->parent_tree;
+ }
+
+ while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
+ {
+ /* We only want to propagate the count if we are in the tree we
+ * started in. */
+ if (tmp_tree == tree)
+ tmp_node->count++;
+
+ tmp_node->parity += 1;
+ tmp_node->offset += height;
+ tmp_node = tmp_node->parent;
+ if (tmp_node == tmp_tree->nil)
+ {
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+
+ if (valid)
+ _pspp_rbtree_node_mark_valid (tree, node);
+ else
+ _pspp_rbtree_node_mark_invalid (tree, node);
+
+ _pspp_rbtree_insert_fixup (tree, node);
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ {
+ g_print ("_pspp_rbtree_insert_after finished...\n");
+ _pspp_rbtree_debug_spew (tree);
+ g_print ("\n\n");
+ _pspp_rbtree_test (G_STRLOC, tree);
+ }
+#endif /* G_ENABLE_DEBUG */
+
+ return node;
+}
+
+GtkRBNode *
+_pspp_rbtree_insert_before (GtkRBTree *tree,
+ GtkRBNode *current,
+ gint height,
+ gboolean valid)
+{
+ GtkRBNode *node;
+ gboolean left = TRUE;
+ GtkRBNode *tmp_node;
+ GtkRBTree *tmp_tree;
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ {
+ g_print ("\n\n_pspp_rbtree_insert_before: %p\n", current);
+ _pspp_rbtree_debug_spew (tree);
+ _pspp_rbtree_test (G_STRLOC, tree);
+ }
+#endif /* G_ENABLE_DEBUG */
+
+ if (current != NULL && current->left != tree->nil)
+ {
+ current = current->left;
+ while (current->right != tree->nil)
+ current = current->right;
+ left = FALSE;
+ }
+
+ /* setup new node */
+ node = _pspp_rbnode_new (tree, height);
+ node->parent = (current?current:tree->nil);
+
+ /* insert node in tree */
+ if (current)
+ {
+ if (left)
+ current->left = node;
+ else
+ current->right = node;
+ tmp_node = node->parent;
+ tmp_tree = tree;
+ }
+ else
+ {
+ tree->root = node;
+ tmp_node = tree->parent_node;
+ tmp_tree = tree->parent_tree;
+ }
+
+ while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
+ {
+ /* We only want to propagate the count if we are in the tree we
+ * started in. */
+ if (tmp_tree == tree)
+ tmp_node->count++;
+
+ tmp_node->parity += 1;
+ tmp_node->offset += height;
+ tmp_node = tmp_node->parent;
+ if (tmp_node == tmp_tree->nil)
+ {
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+
+ if (valid)
+ _pspp_rbtree_node_mark_valid (tree, node);
+ else
+ _pspp_rbtree_node_mark_invalid (tree, node);
+
+ _pspp_rbtree_insert_fixup (tree, node);
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ {
+ g_print ("_pspp_rbtree_insert_before finished...\n");
+ _pspp_rbtree_debug_spew (tree);
+ g_print ("\n\n");
+ _pspp_rbtree_test (G_STRLOC, tree);
+ }
+#endif /* G_ENABLE_DEBUG */
+
+ return node;
+}
+
+GtkRBNode *
+_pspp_rbtree_find_count (GtkRBTree *tree,
+ gint count)
+{
+ GtkRBNode *node;
+
+ node = tree->root;
+ while (node != tree->nil && (node->left->count + 1 != count))
+ {
+ if (node->left->count >= count)
+ node = node->left;
+ else
+ {
+ count -= (node->left->count + 1);
+ node = node->right;
+ }
+ }
+ if (node == tree->nil)
+ return NULL;
+ return node;
+}
+
+void
+_pspp_rbtree_node_set_height (GtkRBTree *tree,
+ GtkRBNode *node,
+ gint height)
+{
+ gint diff = height - PSPP_RBNODE_GET_HEIGHT (node);
+ GtkRBNode *tmp_node = node;
+ GtkRBTree *tmp_tree = tree;
+
+ if (diff == 0)
+ return;
+
+ while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
+ {
+ tmp_node->offset += diff;
+ tmp_node = tmp_node->parent;
+ if (tmp_node == tmp_tree->nil)
+ {
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ _pspp_rbtree_test (G_STRLOC, tree);
+#endif
+}
+
+void
+_pspp_rbtree_node_mark_invalid (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID))
+ return;
+
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_INVALID);
+ do
+ {
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_DESCENDANTS_INVALID))
+ return;
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_DESCENDANTS_INVALID);
+ node = node->parent;
+ if (node == tree->nil)
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ }
+ }
+ while (node);
+}
+
+#if 0
+/* Draconian version. */
+void
+_pspp_rbtree_node_mark_invalid (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_INVALID);
+ do
+ {
+ _fixup_validation (tree, node);
+ node = node->parent;
+ if (node == tree->nil)
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ }
+ }
+ while (node);
+}
+#endif
+
+void
+_pspp_rbtree_node_mark_valid (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ if ((!PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID)) &&
+ (!PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID)))
+ return;
+
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_INVALID);
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_COLUMN_INVALID);
+
+ do
+ {
+ if ((PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID)) ||
+ (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID)) ||
+ (node->children && PSPP_RBNODE_FLAG_SET (node->children->root,
PSPP_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->left != tree->nil && PSPP_RBNODE_FLAG_SET (node->left,
PSPP_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->right != tree->nil && PSPP_RBNODE_FLAG_SET (node->right,
PSPP_RBNODE_DESCENDANTS_INVALID)))
+ return;
+
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_DESCENDANTS_INVALID);
+ node = node->parent;
+ if (node == tree->nil)
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ }
+ }
+ while (node);
+}
+
+#if 0
+/* Draconian version */
+void
+_pspp_rbtree_node_mark_valid (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_INVALID);
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_COLUMN_INVALID);
+
+ do
+ {
+ _fixup_validation (tree, node);
+ node = node->parent;
+ if (node == tree->nil)
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ }
+ }
+ while (node);
+}
+#endif
+/* Assume tree is the root node as it doesn't set DESCENDANTS_INVALID above.
+ */
+void
+_pspp_rbtree_column_invalid (GtkRBTree *tree)
+{
+ GtkRBNode *node;
+
+ if (tree == NULL)
+ return;
+ node = tree->root;
+ g_assert (node);
+
+ while (node->left != tree->nil)
+ node = node->left;
+
+ do
+ {
+ if (! (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID)))
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_COLUMN_INVALID);
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_DESCENDANTS_INVALID);
+
+ if (node->children)
+ _pspp_rbtree_column_invalid (node->children);
+ }
+ while ((node = _pspp_rbtree_next (tree, node)) != NULL);
+}
+
+void
+_pspp_rbtree_mark_invalid (GtkRBTree *tree)
+{
+ GtkRBNode *node;
+
+ if (tree == NULL)
+ return;
+ node = tree->root;
+ g_assert (node);
+
+ while (node->left != tree->nil)
+ node = node->left;
+
+ do
+ {
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_INVALID);
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_DESCENDANTS_INVALID);
+
+ if (node->children)
+ _pspp_rbtree_mark_invalid (node->children);
+ }
+ while ((node = _pspp_rbtree_next (tree, node)) != NULL);
+}
+
+void
+_pspp_rbtree_set_fixed_height (GtkRBTree *tree,
+ gint height,
+ gboolean mark_valid)
+{
+ GtkRBNode *node;
+
+ if (tree == NULL)
+ return;
+
+ node = tree->root;
+ g_assert (node);
+
+ while (node->left != tree->nil)
+ node = node->left;
+
+ do
+ {
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID))
+ {
+ _pspp_rbtree_node_set_height (tree, node, height);
+ if (mark_valid)
+ _pspp_rbtree_node_mark_valid (tree, node);
+ }
+
+ if (node->children)
+ _pspp_rbtree_set_fixed_height (node->children, height, mark_valid);
+ }
+ while ((node = _pspp_rbtree_next (tree, node)) != NULL);
+}
+
+typedef struct _GtkRBReorder
+{
+ GtkRBTree *children;
+ gint height;
+ gint flags;
+ gint order;
+ gint invert_order;
+ gint parity;
+} GtkRBReorder;
+
+static int
+pspp_rbtree_reorder_sort_func (gconstpointer a,
+ gconstpointer b)
+{
+ return ((GtkRBReorder *) a)->order - ((GtkRBReorder *) b)->order;
+}
+
+static int
+pspp_rbtree_reorder_invert_func (gconstpointer a,
+ gconstpointer b)
+{
+ return ((GtkRBReorder *) a)->invert_order - ((GtkRBReorder *)
b)->invert_order;
+}
+
+static void
+pspp_rbtree_reorder_fixup (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ if (node == tree->nil)
+ return;
+
+ node->parity = 1;
+
+ if (node->left != tree->nil)
+ {
+ pspp_rbtree_reorder_fixup (tree, node->left);
+ node->offset += node->left->offset;
+ node->parity += node->left->parity;
+ }
+ if (node->right != tree->nil)
+ {
+ pspp_rbtree_reorder_fixup (tree, node->right);
+ node->offset += node->right->offset;
+ node->parity += node->right->parity;
+ }
+
+ if (node->children)
+ {
+ node->offset += node->children->root->offset;
+ node->parity += node->children->root->parity;
+ }
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) ||
+ (node->right != tree->nil && PSPP_RBNODE_FLAG_SET (node->right,
PSPP_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->left != tree->nil && PSPP_RBNODE_FLAG_SET (node->left,
PSPP_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->children && PSPP_RBNODE_FLAG_SET (node->children->root,
PSPP_RBNODE_DESCENDANTS_INVALID)))
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_DESCENDANTS_INVALID);
+ else
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_DESCENDANTS_INVALID);
+}
+
+/* It basically pulls everything out of the tree, rearranges it, and puts it
+ * back together. Our strategy is to keep the old RBTree intact, and just
+ * rearrange the contents. When that is done, we go through and update the
+ * heights. There is probably a more elegant way to write this function. If
+ * anyone wants to spend the time writing it, patches will be accepted.
+ */
+void
+_pspp_rbtree_reorder (GtkRBTree *tree,
+ gint *new_order,
+ gint length)
+{
+ GtkRBReorder reorder = { NULL };
+ GArray *array;
+ GtkRBNode *node;
+ gint i;
+
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (length > 0);
+ g_return_if_fail (tree->root->count == length);
+
+ /* Sort the trees values in the new tree. */
+ array = g_array_sized_new (FALSE, FALSE, sizeof (GtkRBReorder), length);
+ for (i = 0; i < length; i++)
+ {
+ reorder.order = new_order[i];
+ reorder.invert_order = i;
+ g_array_append_val (array, reorder);
+ }
+
+ g_array_sort(array, pspp_rbtree_reorder_sort_func);
+
+ /* rewind node*/
+ node = tree->root;
+ while (node && node->left != tree->nil)
+ node = node->left;
+
+ for (i = 0; i < length; i++)
+ {
+ g_assert (node != tree->nil);
+ g_array_index (array, GtkRBReorder, i).children = node->children;
+ g_array_index (array, GtkRBReorder, i).flags = PSPP_RBNODE_NON_COLORS &
node->flags;
+ g_array_index (array, GtkRBReorder, i).height = PSPP_RBNODE_GET_HEIGHT
(node);
+
+ node = _pspp_rbtree_next (tree, node);
+ }
+
+ g_array_sort (array, pspp_rbtree_reorder_invert_func);
+
+ /* rewind node*/
+ node = tree->root;
+ while (node && node->left != tree->nil)
+ node = node->left;
+
+ /* Go through the tree and change the values to the new ones. */
+ for (i = 0; i < length; i++)
+ {
+ reorder = g_array_index (array, GtkRBReorder, i);
+ node->children = reorder.children;
+ if (node->children)
+ node->children->parent_node = node;
+ node->flags = PSPP_RBNODE_GET_COLOR (node) | reorder.flags;
+ /* We temporarily set the height to this. */
+ node->offset = reorder.height;
+ node = _pspp_rbtree_next (tree, node);
+ }
+ pspp_rbtree_reorder_fixup (tree, tree->root);
+
+ g_array_free (array, TRUE);
+}
+
+
+gint
+_pspp_rbtree_node_find_offset (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ GtkRBNode *last;
+ gint retval;
+
+ g_assert (node);
+ g_assert (node->left);
+
+ retval = node->left->offset;
+
+ while (tree && node && node != tree->nil)
+ {
+ last = node;
+ node = node->parent;
+
+ /* Add left branch, plus children, iff we came from the right */
+ if (node->right == last)
+ retval += node->offset - node->right->offset;
+
+ if (node == tree->nil)
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+
+ /* Add the parent node, plus the left branch. */
+ if (node)
+ retval += node->left->offset + PSPP_RBNODE_GET_HEIGHT (node);
+ }
+ }
+ return retval;
+}
+
+gint
+_pspp_rbtree_node_find_parity (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ GtkRBNode *last;
+ gint retval;
+
+ g_assert (node);
+ g_assert (node->left);
+
+ retval = node->left->parity;
+
+ while (tree && node && node != tree->nil)
+ {
+ last = node;
+ node = node->parent;
+
+ /* Add left branch, plus children, iff we came from the right */
+ if (node->right == last)
+ retval += node->parity - node->right->parity;
+
+ if (node == tree->nil)
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+
+ /* Add the parent node, plus the left branch. */
+ if (node)
+ retval += node->left->parity + 1; /* 1 == PSPP_RBNODE_GET_PARITY()
*/
+ }
+ }
+
+ return retval % 2;
+}
+
+gint
+_pspp_rbtree_real_find_offset (GtkRBTree *tree,
+ gint height,
+ GtkRBTree **new_tree,
+ GtkRBNode **new_node)
+{
+ GtkRBNode *tmp_node;
+
+ g_assert (tree);
+
+ if (height < 0)
+ {
+ *new_tree = NULL;
+ *new_node = NULL;
+
+ return 0;
+ }
+
+
+ tmp_node = tree->root;
+ while (tmp_node != tree->nil &&
+ (tmp_node->left->offset > height ||
+ (tmp_node->offset - tmp_node->right->offset) < height))
+ {
+ if (tmp_node->left->offset > height)
+ tmp_node = tmp_node->left;
+ else
+ {
+ height -= (tmp_node->offset - tmp_node->right->offset);
+ tmp_node = tmp_node->right;
+ }
+ }
+ if (tmp_node == tree->nil)
+ {
+ *new_tree = NULL;
+ *new_node = NULL;
+ return 0;
+ }
+ if (tmp_node->children)
+ {
+ if ((tmp_node->offset -
+ tmp_node->right->offset -
+ tmp_node->children->root->offset) > height)
+ {
+ *new_tree = tree;
+ *new_node = tmp_node;
+ return (height - tmp_node->left->offset);
+ }
+ return _pspp_rbtree_real_find_offset (tmp_node->children,
+ height - tmp_node->left->offset -
+ (tmp_node->offset -
+ tmp_node->left->offset -
+ tmp_node->right->offset -
+ tmp_node->children->root->offset),
+ new_tree,
+ new_node);
+ }
+ *new_tree = tree;
+ *new_node = tmp_node;
+ return (height - tmp_node->left->offset);
+}
+
+gint
+_pspp_rbtree_find_offset (GtkRBTree *tree,
+ gint height,
+ GtkRBTree **new_tree,
+ GtkRBNode **new_node)
+{
+ g_assert (tree);
+
+ if ((height < 0) ||
+ (height >= tree->root->offset))
+ {
+ *new_tree = NULL;
+ *new_node = NULL;
+
+ return 0;
+ }
+ return _pspp_rbtree_real_find_offset (tree, height, new_tree, new_node);
+}
+
+void
+_pspp_rbtree_remove_node (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ GtkRBNode *x, *y;
+ GtkRBTree *tmp_tree;
+ GtkRBNode *tmp_node;
+ gint y_height;
+
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (node != NULL);
+
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ {
+ g_print ("\n\n_pspp_rbtree_remove_node: %p\n", node);
+ _pspp_rbtree_debug_spew (tree);
+ _pspp_rbtree_test (G_STRLOC, tree);
+ }
+#endif /* G_ENABLE_DEBUG */
+
+ /* make sure we're deleting a node that's actually in the tree */
+ for (x = node; x->parent != tree->nil; x = x->parent)
+ ;
+ g_return_if_fail (x == tree->root);
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ _pspp_rbtree_test (G_STRLOC, tree);
+#endif
+
+ if (node->left == tree->nil || node->right == tree->nil)
+ {
+ y = node;
+ }
+ else
+ {
+ y = node->right;
+
+ while (y->left != tree->nil)
+ y = y->left;
+ }
+
+ /* adjust count only beneath tree */
+ for (x = y; x != tree->nil; x = x->parent)
+ {
+ x->count--;
+ }
+
+ /* offsets and parity adjust all the way up through parent trees */
+ y_height = PSPP_RBNODE_GET_HEIGHT (y);
+
+ tmp_tree = tree;
+ tmp_node = y;
+ while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
+ {
+ tmp_node->offset -= (y_height +
(y->children?y->children->root->offset:0));
+ _fixup_validation (tmp_tree, tmp_node);
+ _fixup_parity (tmp_tree, tmp_node);
+ tmp_node = tmp_node->parent;
+ if (tmp_node == tmp_tree->nil)
+ {
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+
+ /* x is y's only child, or nil */
+ if (y->left != tree->nil)
+ x = y->left;
+ else
+ x = y->right;
+
+ /* remove y from the parent chain */
+ x->parent = y->parent;
+ if (y->parent != tree->nil)
+ {
+ if (y == y->parent->left)
+ y->parent->left = x;
+ else
+ y->parent->right = x;
+ }
+ else
+ {
+ tree->root = x;
+ }
+
+ /* We need to clean up the validity of the tree.
+ */
+
+ tmp_tree = tree;
+ tmp_node = x;
+ do
+ {
+ /* We skip the first time, iff x is nil */
+ if (tmp_node != tmp_tree->nil)
+ {
+ _fixup_validation (tmp_tree, tmp_node);
+ _fixup_parity (tmp_tree, tmp_node);
+ }
+ tmp_node = tmp_node->parent;
+ if (tmp_node == tmp_tree->nil)
+ {
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+ while (tmp_tree != NULL);
+
+ if (y != node)
+ {
+ gint diff;
+
+ /* Copy the node over */
+ if (PSPP_RBNODE_GET_COLOR (node) == PSPP_RBNODE_BLACK)
+ node->flags = ((y->flags & (PSPP_RBNODE_NON_COLORS)) |
PSPP_RBNODE_BLACK);
+ else
+ node->flags = ((y->flags & (PSPP_RBNODE_NON_COLORS)) | PSPP_RBNODE_RED);
+ node->children = y->children;
+ if (y->children)
+ {
+ node->children = y->children;
+ node->children->parent_node = node;
+ }
+ else
+ {
+ node->children = NULL;
+ }
+ _fixup_validation (tree, node);
+ _fixup_parity (tree, node);
+ /* We want to see how different our height is from the previous node.
+ * To do this, we compare our current height with our supposed height.
+ */
+ diff = y_height - PSPP_RBNODE_GET_HEIGHT (node);
+ tmp_tree = tree;
+ tmp_node = node;
+
+ while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
+ {
+ tmp_node->offset += diff;
+ _fixup_validation (tmp_tree, tmp_node);
+ _fixup_parity (tmp_tree, tmp_node);
+ tmp_node = tmp_node->parent;
+ if (tmp_node == tmp_tree->nil)
+ {
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+ }
+
+ if (PSPP_RBNODE_GET_COLOR (y) == PSPP_RBNODE_BLACK)
+ _pspp_rbtree_remove_node_fixup (tree, x);
+ _pspp_rbnode_free (y);
+
+#ifdef G_ENABLE_DEBUG
+ if (gtk_debug_flags & GTK_DEBUG_TREE)
+ {
+ g_print ("_pspp_rbtree_remove_node finished...\n");
+ _pspp_rbtree_debug_spew (tree);
+ g_print ("\n\n");
+ _pspp_rbtree_test (G_STRLOC, tree);
+ }
+#endif /* G_ENABLE_DEBUG */
+}
+
+GtkRBNode *
+_pspp_rbtree_next (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ g_return_val_if_fail (tree != NULL, NULL);
+ g_return_val_if_fail (node != NULL, NULL);
+
+ /* Case 1: the node's below us. */
+ if (node->right != tree->nil)
+ {
+ node = node->right;
+ while (node->left != tree->nil)
+ node = node->left;
+ return node;
+ }
+
+ /* Case 2: it's an ancestor */
+ while (node->parent != tree->nil)
+ {
+ if (node->parent->right == node)
+ node = node->parent;
+ else
+ return (node->parent);
+ }
+
+ /* Case 3: There is no next node */
+ return NULL;
+}
+
+GtkRBNode *
+_pspp_rbtree_prev (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ g_return_val_if_fail (tree != NULL, NULL);
+ g_return_val_if_fail (node != NULL, NULL);
+
+ /* Case 1: the node's below us. */
+ if (node->left != tree->nil)
+ {
+ node = node->left;
+ while (node->right != tree->nil)
+ node = node->right;
+ return node;
+ }
+
+ /* Case 2: it's an ancestor */
+ while (node->parent != tree->nil)
+ {
+ if (node->parent->left == node)
+ node = node->parent;
+ else
+ return (node->parent);
+ }
+
+ /* Case 3: There is no next node */
+ return NULL;
+}
+
+void
+_pspp_rbtree_next_full (GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkRBTree **new_tree,
+ GtkRBNode **new_node)
+{
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (node != NULL);
+ g_return_if_fail (new_tree != NULL);
+ g_return_if_fail (new_node != NULL);
+
+ if (node->children)
+ {
+ *new_tree = node->children;
+ *new_node = (*new_tree)->root;
+ while ((*new_node)->left != (*new_tree)->nil)
+ *new_node = (*new_node)->left;
+ return;
+ }
+
+ *new_tree = tree;
+ *new_node = _pspp_rbtree_next (tree, node);
+
+ while ((*new_node == NULL) &&
+ (*new_tree != NULL))
+ {
+ *new_node = (*new_tree)->parent_node;
+ *new_tree = (*new_tree)->parent_tree;
+ if (*new_tree)
+ *new_node = _pspp_rbtree_next (*new_tree, *new_node);
+ }
+}
+
+void
+_pspp_rbtree_prev_full (GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkRBTree **new_tree,
+ GtkRBNode **new_node)
+{
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (node != NULL);
+ g_return_if_fail (new_tree != NULL);
+ g_return_if_fail (new_node != NULL);
+
+ *new_tree = tree;
+ *new_node = _pspp_rbtree_prev (tree, node);
+
+ if (*new_node == NULL)
+ {
+ *new_node = (*new_tree)->parent_node;
+ *new_tree = (*new_tree)->parent_tree;
+ }
+ else
+ {
+ while ((*new_node)->children)
+ {
+ *new_tree = (*new_node)->children;
+ *new_node = (*new_tree)->root;
+ while ((*new_node)->right != (*new_tree)->nil)
+ *new_node = (*new_node)->right;
+ }
+ }
+}
+
+gint
+_pspp_rbtree_get_depth (GtkRBTree *tree)
+{
+ GtkRBTree *tmp_tree;
+ gint depth = 0;
+
+ tmp_tree = tree->parent_tree;
+ while (tmp_tree)
+ {
+ ++depth;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+
+ return depth;
+}
+
+static void
+_pspp_rbtree_traverse_pre_order (GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkRBTreeTraverseFunc func,
+ gpointer data)
+{
+ if (node == tree->nil)
+ return;
+
+ (* func) (tree, node, data);
+ _pspp_rbtree_traverse_pre_order (tree, node->left, func, data);
+ _pspp_rbtree_traverse_pre_order (tree, node->right, func, data);
+}
+
+static void
+_pspp_rbtree_traverse_post_order (GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkRBTreeTraverseFunc func,
+ gpointer data)
+{
+ if (node == tree->nil)
+ return;
+
+ _pspp_rbtree_traverse_post_order (tree, node->left, func, data);
+ _pspp_rbtree_traverse_post_order (tree, node->right, func, data);
+ (* func) (tree, node, data);
+}
+
+void
+_pspp_rbtree_traverse (GtkRBTree *tree,
+ GtkRBNode *node,
+ GTraverseType order,
+ GtkRBTreeTraverseFunc func,
+ gpointer data)
+{
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (node != NULL);
+ g_return_if_fail (func != NULL);
+ g_return_if_fail (order <= G_LEVEL_ORDER);
+
+ switch (order)
+ {
+ case G_PRE_ORDER:
+ _pspp_rbtree_traverse_pre_order (tree, node, func, data);
+ break;
+ case G_POST_ORDER:
+ _pspp_rbtree_traverse_post_order (tree, node, func, data);
+ break;
+ case G_IN_ORDER:
+ case G_LEVEL_ORDER:
+ default:
+ g_warning ("unsupported traversal order.");
+ break;
+ }
+}
+
+static inline
+void _fixup_validation (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) ||
+ PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID) ||
+ (node->left != tree->nil && PSPP_RBNODE_FLAG_SET (node->left,
PSPP_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->right != tree->nil && PSPP_RBNODE_FLAG_SET (node->right,
PSPP_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->children != NULL && PSPP_RBNODE_FLAG_SET (node->children->root,
PSPP_RBNODE_DESCENDANTS_INVALID)))
+ {
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_DESCENDANTS_INVALID);
+ }
+ else
+ {
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_DESCENDANTS_INVALID);
+ }
+}
+
+static inline
+void _fixup_parity (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ node->parity = 1 +
+ ((node->children != NULL && node->children->root != node->children->nil) ?
node->children->root->parity : 0) +
+ ((node->left != tree->nil) ? node->left->parity : 0) +
+ ((node->right != tree->nil) ? node->right->parity : 0);
+}
+
+#ifdef G_ENABLE_DEBUG
+static guint
+get_parity (GtkRBNode *node)
+{
+ guint child_total = 0;
+ guint rem;
+
+ /* The parity of a node is node->parity minus
+ * the parity of left, right, and children.
+ *
+ * This is equivalent to saying that if left, right, children
+ * sum to 0 parity, then node->parity is the parity of node,
+ * and if left, right, children are odd parity, then
+ * node->parity is the reverse of the node's parity.
+ */
+
+ child_total += (guint) node->left->parity;
+ child_total += (guint) node->right->parity;
+
+ if (node->children)
+ child_total += (guint) node->children->root->parity;
+
+ rem = child_total % 2;
+
+ if (rem == 0)
+ return node->parity;
+ else
+ return !node->parity;
+}
+
+static guint
+count_parity (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ guint res;
+
+ if (node == tree->nil)
+ return 0;
+
+ res =
+ count_parity (tree, node->left) +
+ count_parity (tree, node->right) +
+ (guint)1 +
+ (node->children ? count_parity (node->children, node->children->root) : 0);
+
+ res = res % (guint)2;
+
+ if (res != node->parity)
+ g_print ("parity incorrect for node\n");
+
+ if (get_parity (node) != 1)
+ g_error ("Node has incorrect parity %u", get_parity (node));
+
+ return res;
+}
+
+static gint
+_count_nodes (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ gint res;
+ if (node == tree->nil)
+ return 0;
+
+ g_assert (node->left);
+ g_assert (node->right);
+
+ res = (_count_nodes (tree, node->left) +
+ _count_nodes (tree, node->right) + 1);
+
+ if (res != node->count)
+ g_print ("Tree failed\n");
+ return res;
+}
+
+static void
+_pspp_rbtree_test_height (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ gint computed_offset = 0;
+
+ /* This whole test is sort of a useless truism. */
+
+ if (node->left != tree->nil)
+ computed_offset += node->left->offset;
+
+ if (node->right != tree->nil)
+ computed_offset += node->right->offset;
+
+ if (node->children && node->children->root != node->children->nil)
+ computed_offset += node->children->root->offset;
+
+ if (PSPP_RBNODE_GET_HEIGHT (node) + computed_offset != node->offset)
+ g_error ("node has broken offset\n");
+
+ if (node->left != tree->nil)
+ _pspp_rbtree_test_height (tree, node->left);
+
+ if (node->right != tree->nil)
+ _pspp_rbtree_test_height (tree, node->right);
+
+ if (node->children && node->children->root != node->children->nil)
+ _pspp_rbtree_test_height (node->children, node->children->root);
+}
+
+static void
+_pspp_rbtree_test_dirty (GtkRBTree *tree,
+ GtkRBNode *node,
+ gint expected_dirtyness)
+{
+
+ if (expected_dirtyness)
+ {
+ g_assert (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID) ||
+ PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) ||
+ (node->left != tree->nil && PSPP_RBNODE_FLAG_SET (node->left,
PSPP_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->right != tree->nil && PSPP_RBNODE_FLAG_SET (node->right,
PSPP_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->children && PSPP_RBNODE_FLAG_SET (node->children->root,
PSPP_RBNODE_DESCENDANTS_INVALID)));
+ }
+ else
+ {
+ g_assert (! PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID) &&
+ ! PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID));
+ if (node->left != tree->nil)
+ g_assert (! PSPP_RBNODE_FLAG_SET (node->left,
PSPP_RBNODE_DESCENDANTS_INVALID));
+ if (node->right != tree->nil)
+ g_assert (! PSPP_RBNODE_FLAG_SET (node->right,
PSPP_RBNODE_DESCENDANTS_INVALID));
+ if (node->children != NULL)
+ g_assert (! PSPP_RBNODE_FLAG_SET (node->children->root,
PSPP_RBNODE_DESCENDANTS_INVALID));
+ }
+
+ if (node->left != tree->nil)
+ _pspp_rbtree_test_dirty (tree, node->left, PSPP_RBNODE_FLAG_SET
(node->left, PSPP_RBNODE_DESCENDANTS_INVALID));
+ if (node->right != tree->nil)
+ _pspp_rbtree_test_dirty (tree, node->right, PSPP_RBNODE_FLAG_SET
(node->right, PSPP_RBNODE_DESCENDANTS_INVALID));
+ if (node->children != NULL && node->children->root != node->children->nil)
+ _pspp_rbtree_test_dirty (node->children, node->children->root,
PSPP_RBNODE_FLAG_SET (node->children->root, PSPP_RBNODE_DESCENDANTS_INVALID));
+}
+
+static void _pspp_rbtree_test_structure (GtkRBTree *tree);
+
+static void
+_pspp_rbtree_test_structure_helper (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ g_assert (node != tree->nil);
+
+ g_assert (node->left != NULL);
+ g_assert (node->right != NULL);
+ g_assert (node->parent != NULL);
+
+ if (node->left != tree->nil)
+ {
+ g_assert (node->left->parent == node);
+ _pspp_rbtree_test_structure_helper (tree, node->left);
+ }
+ if (node->right != tree->nil)
+ {
+ g_assert (node->right->parent == node);
+ _pspp_rbtree_test_structure_helper (tree, node->right);
+ }
+
+ if (node->children != NULL)
+ {
+ g_assert (node->children->parent_tree == tree);
+ g_assert (node->children->parent_node == node);
+
+ _pspp_rbtree_test_structure (node->children);
+ }
+}
+static void
+_pspp_rbtree_test_structure (GtkRBTree *tree)
+{
+ g_assert (tree->root);
+ if (tree->root == tree->nil)
+ return;
+
+ g_assert (tree->root->parent == tree->nil);
+ _pspp_rbtree_test_structure_helper (tree, tree->root);
+}
+
+void
+_pspp_rbtree_test (const gchar *where,
+ GtkRBTree *tree)
+{
+ GtkRBTree *tmp_tree;
+
+ if (tree == NULL)
+ return;
+
+ /* Test the entire tree */
+ tmp_tree = tree;
+ while (tmp_tree->parent_tree)
+ tmp_tree = tmp_tree->parent_tree;
+
+ g_assert (tmp_tree->nil != NULL);
+
+ if (tmp_tree->root == tmp_tree->nil)
+ return;
+
+ _pspp_rbtree_test_structure (tmp_tree);
+
+ g_assert ((_count_nodes (tmp_tree, tmp_tree->root->left) +
+ _count_nodes (tmp_tree, tmp_tree->root->right) + 1) ==
tmp_tree->root->count);
+
+
+ _pspp_rbtree_test_height (tmp_tree, tmp_tree->root);
+ _pspp_rbtree_test_dirty (tmp_tree, tmp_tree->root, PSPP_RBNODE_FLAG_SET
(tmp_tree->root, PSPP_RBNODE_DESCENDANTS_INVALID));
+ g_assert (count_parity (tmp_tree, tmp_tree->root) == tmp_tree->root->parity);
+}
+
+static void
+_pspp_rbtree_debug_spew_helper (GtkRBTree *tree,
+ GtkRBNode *node,
+ gint depth)
+{
+ gint i;
+ for (i = 0; i < depth; i++)
+ g_print ("\t");
+
+ g_print ("(%p - %s) (Offset %d) (Parity %d) (Validity %d%d%d)\n",
+ node,
+ (PSPP_RBNODE_GET_COLOR (node) == PSPP_RBNODE_BLACK)?"BLACK":" RED ",
+ node->offset,
+ node->parity?1:0,
+ (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_DESCENDANTS_INVALID))?1:0,
+ (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID))?1:0,
+ (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID))?1:0);
+ if (node->children != NULL)
+ {
+ g_print ("Looking at child.\n");
+ _pspp_rbtree_debug_spew (node->children);
+ g_print ("Done looking at child.\n");
+ }
+ if (node->left != tree->nil)
+ {
+ _pspp_rbtree_debug_spew_helper (tree, node->left, depth+1);
+ }
+ if (node->right != tree->nil)
+ {
+ _pspp_rbtree_debug_spew_helper (tree, node->right, depth+1);
+ }
+}
+
+void
+_pspp_rbtree_debug_spew (GtkRBTree *tree)
+{
+ g_return_if_fail (tree != NULL);
+
+ if (tree->root == tree->nil)
+ g_print ("Empty tree...\n");
+ else
+ _pspp_rbtree_debug_spew_helper (tree, tree->root, 0);
+}
+#endif /* G_ENABLE_DEBUG */
diff --git a/src/ui/gui/pspp-rb-tree.h b/src/ui/gui/pspp-rb-tree.h
new file mode 100644
index 0000000..07fe470
--- /dev/null
+++ b/src/ui/gui/pspp-rb-tree.h
@@ -0,0 +1,200 @@
+ /* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2011 Free Software Foundation, Inc.
+
+ 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* gtkrbtree.h
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/* A Red-Black Tree implementation used specifically by PsppSheetView.
+ */
+#ifndef __PSPP_RBTREE_H__
+#define __PSPP_RBTREE_H__
+
+#include <glib.h>
+
+
+G_BEGIN_DECLS
+
+
+typedef enum
+{
+ PSPP_RBNODE_BLACK = 1 << 0,
+ PSPP_RBNODE_RED = 1 << 1,
+ PSPP_RBNODE_IS_PARENT = 1 << 2,
+ PSPP_RBNODE_IS_SELECTED = 1 << 3,
+ PSPP_RBNODE_IS_PRELIT = 1 << 4,
+ PSPP_RBNODE_IS_SEMI_COLLAPSED = 1 << 5,
+ PSPP_RBNODE_IS_SEMI_EXPANDED = 1 << 6,
+ PSPP_RBNODE_INVALID = 1 << 7,
+ PSPP_RBNODE_COLUMN_INVALID = 1 << 8,
+ PSPP_RBNODE_DESCENDANTS_INVALID = 1 << 9,
+ PSPP_RBNODE_NON_COLORS = PSPP_RBNODE_IS_PARENT |
+ PSPP_RBNODE_IS_SELECTED |
+ PSPP_RBNODE_IS_PRELIT |
+ PSPP_RBNODE_IS_SEMI_COLLAPSED |
+ PSPP_RBNODE_IS_SEMI_EXPANDED |
+ PSPP_RBNODE_INVALID |
+ PSPP_RBNODE_COLUMN_INVALID |
+ PSPP_RBNODE_DESCENDANTS_INVALID
+} GtkRBNodeColor;
+
+typedef struct _GtkRBTree GtkRBTree;
+typedef struct _GtkRBNode GtkRBNode;
+typedef struct _GtkRBTreeView GtkRBTreeView;
+
+typedef void (*GtkRBTreeTraverseFunc) (GtkRBTree *tree,
+ GtkRBNode *node,
+ gpointer data);
+
+struct _GtkRBTree
+{
+ GtkRBNode *root;
+ GtkRBNode *nil;
+ GtkRBTree *parent_tree;
+ GtkRBNode *parent_node;
+};
+
+struct _GtkRBNode
+{
+ guint flags : 14;
+
+ /* We keep track of whether the aggregate count of children plus 1
+ * for the node itself comes to an even number. The parity flag is
+ * the total count of children mod 2, where the total count of
+ * children gets computed in the same way that the total offset gets
+ * computed. i.e. not the same as the "count" field below which
+ * doesn't include children. We could replace parity with a
+ * full-size int field here, and then take % 2 to get the parity flag,
+ * but that would use extra memory.
+ */
+
+ guint parity : 1;
+
+ GtkRBNode *left;
+ GtkRBNode *right;
+ GtkRBNode *parent;
+
+ /* count is the number of nodes beneath us, plus 1 for ourselves.
+ * i.e. node->left->count + node->right->count + 1
+ */
+ gint count;
+
+ /* this is the total of sizes of
+ * node->left, node->right, our own height, and the height
+ * of all trees in ->children, iff children exists because
+ * the thing is expanded.
+ */
+ gint offset;
+
+ /* Child trees */
+ GtkRBTree *children;
+};
+
+
+#define PSPP_RBNODE_GET_COLOR(node)
(node?(((node->flags&PSPP_RBNODE_RED)==PSPP_RBNODE_RED)?PSPP_RBNODE_RED:PSPP_RBNODE_BLACK):PSPP_RBNODE_BLACK)
+#define PSPP_RBNODE_SET_COLOR(node,color)
if((node->flags&color)!=color)node->flags=node->flags^(PSPP_RBNODE_RED|PSPP_RBNODE_BLACK)
+#define PSPP_RBNODE_GET_HEIGHT(node)
(node->offset-(node->left->offset+node->right->offset+(node->children?node->children->root->offset:0)))
+#define PSPP_RBNODE_SET_FLAG(node, flag) G_STMT_START{
(node->flags|=flag); }G_STMT_END
+#define PSPP_RBNODE_UNSET_FLAG(node, flag) G_STMT_START{
(node->flags&=~(flag)); }G_STMT_END
+#define PSPP_RBNODE_FLAG_SET(node, flag)
(node?(((node->flags&flag)==flag)?TRUE:FALSE):FALSE)
+
+
+GtkRBTree *_pspp_rbtree_new (void);
+void _pspp_rbtree_free (GtkRBTree *tree);
+void _pspp_rbtree_remove (GtkRBTree *tree);
+void _pspp_rbtree_destroy (GtkRBTree *tree);
+GtkRBNode *_pspp_rbtree_insert_before (GtkRBTree *tree,
+ GtkRBNode *node,
+ gint height,
+ gboolean valid);
+GtkRBNode *_pspp_rbtree_insert_after (GtkRBTree *tree,
+ GtkRBNode *node,
+ gint height,
+ gboolean valid);
+void _pspp_rbtree_remove_node (GtkRBTree *tree,
+ GtkRBNode *node);
+void _pspp_rbtree_reorder (GtkRBTree *tree,
+ gint *new_order,
+ gint length);
+GtkRBNode *_pspp_rbtree_find_count (GtkRBTree *tree,
+ gint count);
+void _pspp_rbtree_node_set_height (GtkRBTree *tree,
+ GtkRBNode *node,
+ gint height);
+void _pspp_rbtree_node_mark_invalid(GtkRBTree *tree,
+ GtkRBNode *node);
+void _pspp_rbtree_node_mark_valid (GtkRBTree *tree,
+ GtkRBNode *node);
+void _pspp_rbtree_column_invalid (GtkRBTree *tree);
+void _pspp_rbtree_mark_invalid (GtkRBTree *tree);
+void _pspp_rbtree_set_fixed_height (GtkRBTree *tree,
+ gint height,
+ gboolean mark_valid);
+gint _pspp_rbtree_node_find_offset (GtkRBTree *tree,
+ GtkRBNode *node);
+gint _pspp_rbtree_node_find_parity (GtkRBTree *tree,
+ GtkRBNode *node);
+gint _pspp_rbtree_find_offset (GtkRBTree *tree,
+ gint offset,
+ GtkRBTree **new_tree,
+ GtkRBNode **new_node);
+void _pspp_rbtree_traverse (GtkRBTree *tree,
+ GtkRBNode *node,
+ GTraverseType order,
+ GtkRBTreeTraverseFunc func,
+ gpointer data);
+GtkRBNode *_pspp_rbtree_next (GtkRBTree *tree,
+ GtkRBNode *node);
+GtkRBNode *_pspp_rbtree_prev (GtkRBTree *tree,
+ GtkRBNode *node);
+void _pspp_rbtree_next_full (GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkRBTree **new_tree,
+ GtkRBNode **new_node);
+void _pspp_rbtree_prev_full (GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkRBTree **new_tree,
+ GtkRBNode **new_node);
+
+gint _pspp_rbtree_get_depth (GtkRBTree *tree);
+
+/* This func checks the integrity of the tree */
+#ifdef G_ENABLE_DEBUG
+void _pspp_rbtree_test (const gchar *where,
+ GtkRBTree *tree);
+void _pspp_rbtree_debug_spew (GtkRBTree *tree);
+#endif
+
+
+G_END_DECLS
+
+
+#endif /* __PSPP_RBTREE_H__ */
diff --git a/src/ui/gui/pspp-sheet-private.h b/src/ui/gui/pspp-sheet-private.h
new file mode 100644
index 0000000..c0ea0c8
--- /dev/null
+++ b/src/ui/gui/pspp-sheet-private.h
@@ -0,0 +1,480 @@
+ /* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2011 Free Software Foundation, Inc.
+
+ 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* gtktreeprivate.h
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GTK_TREE_PRIVATE_H__
+#define __GTK_TREE_PRIVATE_H__
+
+
+#include <gtk/gtk.h>
+#include "ui/gui/pspp-sheet-view.h"
+#include "ui/gui/pspp-sheet-view-column.h"
+#include "ui/gui/pspp-rb-tree.h"
+
+#define TREE_VIEW_DRAG_WIDTH 6
+
+typedef enum
+{
+ PSPP_SHEET_VIEW_IS_LIST = 1 << 0,
+ PSPP_SHEET_VIEW_SHOW_EXPANDERS = 1 << 1,
+ PSPP_SHEET_VIEW_IN_COLUMN_RESIZE = 1 << 2,
+ PSPP_SHEET_VIEW_ARROW_PRELIT = 1 << 3,
+ PSPP_SHEET_VIEW_HEADERS_VISIBLE = 1 << 4,
+ PSPP_SHEET_VIEW_DRAW_KEYFOCUS = 1 << 5,
+ PSPP_SHEET_VIEW_MODEL_SETUP = 1 << 6,
+ PSPP_SHEET_VIEW_IN_COLUMN_DRAG = 1 << 7
+} PsppSheetViewFlags;
+
+typedef enum
+{
+ GTK_TREE_SELECT_MODE_TOGGLE = 1 << 0,
+ GTK_TREE_SELECT_MODE_EXTEND = 1 << 1
+}
+GtkTreeSelectMode;
+
+enum
+{
+ DRAG_COLUMN_WINDOW_STATE_UNSET = 0,
+ DRAG_COLUMN_WINDOW_STATE_ORIGINAL = 1,
+ DRAG_COLUMN_WINDOW_STATE_ARROW = 2,
+ DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT = 3,
+ DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT = 4
+};
+
+enum
+{
+ RUBBER_BAND_OFF = 0,
+ RUBBER_BAND_MAYBE_START = 1,
+ RUBBER_BAND_ACTIVE = 2
+};
+
+#define PSPP_SHEET_VIEW_SET_FLAG(tree_view, flag) G_STMT_START{
(tree_view->priv->flags|=flag); }G_STMT_END
+#define PSPP_SHEET_VIEW_UNSET_FLAG(tree_view, flag) G_STMT_START{
(tree_view->priv->flags&=~(flag)); }G_STMT_END
+#define PSPP_SHEET_VIEW_FLAG_SET(tree_view, flag)
((tree_view->priv->flags&flag)==flag)
+#define TREE_VIEW_HEADER_HEIGHT(tree_view) (PSPP_SHEET_VIEW_FLAG_SET
(tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE)?tree_view->priv->header_height:0)
+#define TREE_VIEW_COLUMN_REQUESTED_WIDTH(column) (CLAMP
(column->requested_width,
(column->min_width!=-1)?column->min_width:column->requested_width,
(column->max_width!=-1)?column->max_width:column->requested_width))
+#define TREE_VIEW_DRAW_EXPANDERS(tree_view) (!PSPP_SHEET_VIEW_FLAG_SET
(tree_view, PSPP_SHEET_VIEW_IS_LIST)&&PSPP_SHEET_VIEW_FLAG_SET (tree_view,
PSPP_SHEET_VIEW_SHOW_EXPANDERS))
+
+ /* This lovely little value is used to determine how far away from the title
bar
+ * you can move the mouse and still have a column drag work.
+ */
+#define TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER(tree_view)
(10*TREE_VIEW_HEADER_HEIGHT(tree_view))
+
+typedef struct _PsppSheetViewColumnReorder PsppSheetViewColumnReorder;
+struct _PsppSheetViewColumnReorder
+{
+ gint left_align;
+ gint right_align;
+ PsppSheetViewColumn *left_column;
+ PsppSheetViewColumn *right_column;
+};
+
+struct _PsppSheetViewPrivate
+{
+ GtkTreeModel *model;
+
+ guint flags;
+ /* tree information */
+ GtkRBTree *tree;
+
+ /* Container info */
+ GList *children;
+ gint width;
+ gint height;
+
+ /* Adjustments */
+ GtkAdjustment *hadjustment;
+ GtkAdjustment *vadjustment;
+
+ /* Sub windows */
+ GdkWindow *bin_window;
+ GdkWindow *header_window;
+
+ /* Scroll position state keeping */
+ GtkTreeRowReference *top_row;
+ gint top_row_dy;
+ /* dy == y pos of top_row + top_row_dy */
+ /* we cache it for simplicity of the code */
+ gint dy;
+
+ guint presize_handler_timer;
+ guint validate_rows_timer;
+ guint scroll_sync_timer;
+
+ /* Indentation and expander layout */
+ gint expander_size;
+ PsppSheetViewColumn *expander_column;
+
+ gint level_indentation;
+
+ /* Key navigation (focus), selection */
+ gint cursor_offset;
+
+ GtkTreeRowReference *anchor;
+ GtkTreeRowReference *cursor;
+
+ PsppSheetViewColumn *focus_column;
+
+ /* Current pressed node, previously pressed, prelight */
+ GtkRBNode *button_pressed_node;
+ GtkRBTree *button_pressed_tree;
+
+ gint pressed_button;
+ gint press_start_x;
+ gint press_start_y;
+
+ gint event_last_x;
+ gint event_last_y;
+
+ guint last_button_time;
+ gint last_button_x;
+ gint last_button_y;
+
+ GtkRBNode *prelight_node;
+ GtkRBTree *prelight_tree;
+
+ /* Cell Editing */
+ PsppSheetViewColumn *edited_column;
+
+ /* The node that's currently being collapsed or expanded */
+ GtkRBNode *expanded_collapsed_node;
+ GtkRBTree *expanded_collapsed_tree;
+ guint expand_collapse_timeout;
+
+ /* Auto expand/collapse timeout in hover mode */
+ guint auto_expand_timeout;
+
+ /* Selection information */
+ PsppSheetSelection *selection;
+
+ /* Header information */
+ gint n_columns;
+ GList *columns;
+ gint header_height;
+
+ PsppSheetViewColumnDropFunc column_drop_func;
+ gpointer column_drop_func_data;
+ GDestroyNotify column_drop_func_data_destroy;
+ GList *column_drag_info;
+ PsppSheetViewColumnReorder *cur_reorder;
+
+ gint prev_width_before_expander;
+
+ /* Interactive Header reordering */
+ GdkWindow *drag_window;
+ GdkWindow *drag_highlight_window;
+ PsppSheetViewColumn *drag_column;
+ gint drag_column_x;
+
+ /* Interactive Header Resizing */
+ gint drag_pos;
+ gint x_drag;
+
+ /* Non-interactive Header Resizing, expand flag support */
+ gint prev_width;
+
+ gint last_extra_space;
+ gint last_extra_space_per_column;
+ gint last_number_of_expand_columns;
+
+ /* ATK Hack */
+ PsppSheetDestroyCountFunc destroy_count_func;
+ gpointer destroy_count_data;
+ GDestroyNotify destroy_count_destroy;
+
+ /* Scroll timeout (e.g. during dnd, rubber banding) */
+ guint scroll_timeout;
+
+ /* Row drag-and-drop */
+ GtkTreeRowReference *drag_dest_row;
+ PsppSheetViewDropPosition drag_dest_pos;
+ guint open_dest_timeout;
+
+ /* Rubber banding */
+ gint rubber_band_status;
+ gint rubber_band_x;
+ gint rubber_band_y;
+ gint rubber_band_shift;
+ gint rubber_band_ctrl;
+
+ GtkRBNode *rubber_band_start_node;
+ GtkRBTree *rubber_band_start_tree;
+
+ GtkRBNode *rubber_band_end_node;
+ GtkRBTree *rubber_band_end_tree;
+
+ /* fixed height */
+ gint fixed_height;
+
+ /* Scroll-to functionality when unrealized */
+ GtkTreeRowReference *scroll_to_path;
+ PsppSheetViewColumn *scroll_to_column;
+ gfloat scroll_to_row_align;
+ gfloat scroll_to_col_align;
+
+ /* Interactive search */
+ gint selected_iter;
+ gint search_column;
+ PsppSheetViewSearchPositionFunc search_position_func;
+ PsppSheetViewSearchEqualFunc search_equal_func;
+ gpointer search_user_data;
+ GDestroyNotify search_destroy;
+ gpointer search_position_user_data;
+ GDestroyNotify search_position_destroy;
+ GtkWidget *search_window;
+ GtkWidget *search_entry;
+ guint search_entry_changed_id;
+ guint typeselect_flush_timeout;
+
+ /* Grid and tree lines */
+ PsppSheetViewGridLines grid_lines;
+ GdkGC *grid_line_gc;
+
+ gboolean tree_lines_enabled;
+ GdkGC *tree_line_gc;
+
+ /* Row separators */
+ PsppSheetViewRowSeparatorFunc row_separator_func;
+ gpointer row_separator_data;
+ GDestroyNotify row_separator_destroy;
+
+ /* Tooltip support */
+ gint tooltip_column;
+
+ /* Here comes the bitfield */
+ guint scroll_to_use_align : 1;
+
+ guint fixed_height_mode : 1;
+ guint fixed_height_check : 1;
+
+ guint reorderable : 1;
+ guint header_has_focus : 1;
+ guint drag_column_window_state : 3;
+ /* hint to display rows in alternating colors */
+ guint has_rules : 1;
+ guint mark_rows_col_dirty : 1;
+
+ /* for DnD */
+ guint empty_view_drop : 1;
+
+ guint ctrl_pressed : 1;
+ guint shift_pressed : 1;
+
+ guint init_hadjust_value : 1;
+
+ guint in_top_row_to_dy : 1;
+
+ /* interactive search */
+ guint enable_search : 1;
+ guint disable_popdown : 1;
+ guint search_custom_entry_set : 1;
+
+ guint hover_selection : 1;
+ guint hover_expand : 1;
+ guint imcontext_changed : 1;
+
+ guint rubber_banding_enable : 1;
+
+ guint in_grab : 1;
+
+ guint post_validation_flag : 1;
+
+ /* Whether our key press handler is to avoid sending an unhandled binding to
the search entry */
+ guint search_entry_avoid_unhandled_binding : 1;
+};
+
+#ifdef __GNUC__
+
+#define TREE_VIEW_INTERNAL_ASSERT(expr, ret) G_STMT_START{ \
+ if (!(expr)) \
+ { \
+ g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ "%s (%s): assertion `%s' failed.\n" \
+ "There is a disparity between the internal view of the
PsppSheetView,\n" \
+ "and the GtkTreeModel. This generally means that the model has
changed\n"\
+ "without letting the view know. Any display from now on is
likely to\n" \
+ "be incorrect.\n",
\
+ G_STRLOC, \
+ G_STRFUNC, \
+ #expr); \
+ return ret; \
+ }; }G_STMT_END
+
+#define TREE_VIEW_INTERNAL_ASSERT_VOID(expr) G_STMT_START{ \
+ if (!(expr)) \
+ { \
+ g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ "%s (%s): assertion `%s' failed.\n" \
+ "There is a disparity between the internal view of the
PsppSheetView,\n" \
+ "and the GtkTreeModel. This generally means that the model has
changed\n"\
+ "without letting the view know. Any display from now on is
likely to\n" \
+ "be incorrect.\n",
\
+ G_STRLOC, \
+ G_STRFUNC, \
+ #expr); \
+ return; \
+ }; }G_STMT_END
+
+#else
+
+#define TREE_VIEW_INTERNAL_ASSERT(expr, ret) G_STMT_START{ \
+ if (!(expr)) \
+ { \
+ g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ "file %s: line %d: assertion `%s' failed.\n" \
+ "There is a disparity between the internal view of the
PsppSheetView,\n" \
+ "and the GtkTreeModel. This generally means that the model has
changed\n"\
+ "without letting the view know. Any display from now on is
likely to\n" \
+ "be incorrect.\n",
\
+ __FILE__, \
+ __LINE__, \
+ #expr); \
+ return ret; \
+ }; }G_STMT_END
+
+#define TREE_VIEW_INTERNAL_ASSERT_VOID(expr) G_STMT_START{ \
+ if (!(expr)) \
+ { \
+ g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ "file %s: line %d: assertion '%s' failed.\n" \
+ "There is a disparity between the internal view of the
PsppSheetView,\n" \
+ "and the GtkTreeModel. This generally means that the model has
changed\n"\
+ "without letting the view know. Any display from now on is
likely to\n" \
+ "be incorrect.\n",
\
+ __FILE__, \
+ __LINE__, \
+ #expr); \
+ return; \
+ }; }G_STMT_END
+#endif
+
+
+/* functions that shouldn't be exported */
+void _pspp_sheet_selection_internal_select_node (PsppSheetSelection
*selection,
+ GtkRBNode *node,
+ GtkRBTree *tree,
+ GtkTreePath *path,
+ GtkTreeSelectMode mode,
+ gboolean
override_browse_mode);
+void _pspp_sheet_selection_emit_changed (PsppSheetSelection
*selection);
+gboolean _pspp_sheet_view_find_node (PsppSheetView
*tree_view,
+ GtkTreePath *path,
+ GtkRBTree **tree,
+ GtkRBNode **node);
+GtkTreePath *_pspp_sheet_view_find_path (PsppSheetView
*tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node);
+void _pspp_sheet_view_child_move_resize (PsppSheetView
*tree_view,
+ GtkWidget
*widget,
+ gint x,
+ gint y,
+ gint width,
+ gint
height);
+void _pspp_sheet_view_queue_draw_node (PsppSheetView
*tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ const GdkRectangle
*clip_rect);
+
+void _pspp_sheet_view_column_realize_button (PsppSheetViewColumn *column);
+void _pspp_sheet_view_column_unrealize_button (PsppSheetViewColumn *column);
+void _pspp_sheet_view_column_set_tree_view (PsppSheetViewColumn *column,
+ PsppSheetView *tree_view);
+void _pspp_sheet_view_column_unset_model (PsppSheetViewColumn *column,
+ GtkTreeModel *old_model);
+void _pspp_sheet_view_column_unset_tree_view (PsppSheetViewColumn *column);
+void _pspp_sheet_view_column_set_width (PsppSheetViewColumn *column,
+ gint width);
+void _pspp_sheet_view_column_start_drag (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column);
+gboolean _pspp_sheet_view_column_cell_event (PsppSheetViewColumn
*tree_column,
+ GtkCellEditable
**editable_widget,
+ GdkEvent *event,
+ gchar *path_string,
+ const GdkRectangle
*background_area,
+ const GdkRectangle *cell_area,
+ guint flags);
+void _pspp_sheet_view_column_start_editing (PsppSheetViewColumn *tree_column,
+ GtkCellEditable *editable_widget);
+void _pspp_sheet_view_column_stop_editing (PsppSheetViewColumn *tree_column);
+void _pspp_sheet_view_install_mark_rows_col_dirty (PsppSheetView *tree_view);
+void _pspp_sheet_view_column_autosize (PsppSheetView
*tree_view,
+ PsppSheetViewColumn
*column);
+
+gboolean _pspp_sheet_view_column_has_editable_cell
(PsppSheetViewColumn *column);
+GtkCellRenderer *_pspp_sheet_view_column_get_edited_cell
(PsppSheetViewColumn *column);
+gint _pspp_sheet_view_column_count_special_cells
(PsppSheetViewColumn *column);
+GtkCellRenderer *_pspp_sheet_view_column_get_cell_at_pos
(PsppSheetViewColumn *column,
+ gint x);
+
+PsppSheetSelection* _pspp_sheet_selection_new (void);
+PsppSheetSelection* _pspp_sheet_selection_new_with_tree_view (PsppSheetView
*tree_view);
+void _pspp_sheet_selection_set_tree_view (PsppSheetSelection
*selection,
+ PsppSheetView
*tree_view);
+gboolean _pspp_sheet_selection_row_is_selectable (PsppSheetSelection
*selection,
+ GtkRBNode
*node,
+ GtkTreePath
*path);
+
+void _pspp_sheet_view_column_cell_render (PsppSheetViewColumn
*tree_column,
+ GdkWindow
*window,
+ const GdkRectangle
*background_area,
+ const GdkRectangle
*cell_area,
+ const GdkRectangle
*expose_area,
+ guint
flags);
+void _pspp_sheet_view_column_get_focus_area (PsppSheetViewColumn
*tree_column,
+ const GdkRectangle
*background_area,
+ const GdkRectangle
*cell_area,
+ GdkRectangle
*focus_area);
+gboolean _pspp_sheet_view_column_cell_focus (PsppSheetViewColumn
*tree_column,
+ gint
direction,
+ gboolean
left,
+ gboolean
right);
+void _pspp_sheet_view_column_cell_draw_focus (PsppSheetViewColumn
*tree_column,
+ GdkWindow
*window,
+ const GdkRectangle
*background_area,
+ const GdkRectangle
*cell_area,
+ const GdkRectangle
*expose_area,
+ guint
flags);
+void _pspp_sheet_view_column_cell_set_dirty
(PsppSheetViewColumn *tree_column,
+ gboolean
install_handler);
+void _pspp_sheet_view_column_get_neighbor_sizes
(PsppSheetViewColumn *column,
+ GtkCellRenderer
*cell,
+ gint
*left,
+ gint
*right);
+
+#endif /* __GTK_TREE_PRIVATE_H__ */
+
diff --git a/src/ui/gui/pspp-sheet-selection.c
b/src/ui/gui/pspp-sheet-selection.c
new file mode 100644
index 0000000..81f7d5e
--- /dev/null
+++ b/src/ui/gui/pspp-sheet-selection.c
@@ -0,0 +1,1486 @@
+/* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2011, 2012 Free Software Foundation, Inc.
+
+ 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* gtktreeselection.h
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "ui/gui/pspp-sheet-private.h"
+
+#include <gtk/gtk.h>
+#include <string.h>
+
+#include "ui/gui/pspp-sheet-selection.h"
+
+#define I_(STRING) STRING
+
+static void pspp_sheet_selection_finalize (GObject
*object);
+static gint pspp_sheet_selection_real_select_all (PsppSheetSelection
*selection);
+static gint pspp_sheet_selection_real_unselect_all (PsppSheetSelection
*selection);
+static gint pspp_sheet_selection_real_select_node (PsppSheetSelection
*selection,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ gboolean
select);
+
+enum
+{
+ CHANGED,
+ LAST_SIGNAL
+};
+
+static guint tree_selection_signals [LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (PsppSheetSelection, pspp_sheet_selection, G_TYPE_OBJECT)
+
+static void
+pspp_sheet_selection_class_init (PsppSheetSelectionClass *class)
+{
+ GObjectClass *object_class;
+
+ object_class = (GObjectClass*) class;
+
+ object_class->finalize = pspp_sheet_selection_finalize;
+ class->changed = NULL;
+
+ tree_selection_signals[CHANGED] =
+ g_signal_new (I_("changed"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (PsppSheetSelectionClass, changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+}
+
+static void
+pspp_sheet_selection_init (PsppSheetSelection *selection)
+{
+ selection->type = GTK_SELECTION_SINGLE;
+}
+
+static void
+pspp_sheet_selection_finalize (GObject *object)
+{
+ PsppSheetSelection *selection = PSPP_SHEET_SELECTION (object);
+
+ if (selection->destroy)
+ {
+ GDestroyNotify d = selection->destroy;
+
+ selection->destroy = NULL;
+ d (selection->user_data);
+ }
+
+ /* chain parent_class' handler */
+ G_OBJECT_CLASS (pspp_sheet_selection_parent_class)->finalize (object);
+}
+
+/**
+ * _pspp_sheet_selection_new:
+ *
+ * Creates a new #PsppSheetSelection object. This function should not be
invoked,
+ * as each #PsppSheetView will create its own #PsppSheetSelection.
+ *
+ * Return value: A newly created #PsppSheetSelection object.
+ **/
+PsppSheetSelection*
+_pspp_sheet_selection_new (void)
+{
+ PsppSheetSelection *selection;
+
+ selection = g_object_new (PSPP_TYPE_SHEET_SELECTION, NULL);
+
+ return selection;
+}
+
+/**
+ * _pspp_sheet_selection_new_with_tree_view:
+ * @tree_view: The #PsppSheetView.
+ *
+ * Creates a new #PsppSheetSelection object. This function should not be
invoked,
+ * as each #PsppSheetView will create its own #PsppSheetSelection.
+ *
+ * Return value: A newly created #PsppSheetSelection object.
+ **/
+PsppSheetSelection*
+_pspp_sheet_selection_new_with_tree_view (PsppSheetView *tree_view)
+{
+ PsppSheetSelection *selection;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ selection = _pspp_sheet_selection_new ();
+ _pspp_sheet_selection_set_tree_view (selection, tree_view);
+
+ return selection;
+}
+
+/**
+ * _pspp_sheet_selection_set_tree_view:
+ * @selection: A #PsppSheetSelection.
+ * @tree_view: The #PsppSheetView.
+ *
+ * Sets the #PsppSheetView of @selection. This function should not be
invoked, as
+ * it is used internally by #PsppSheetView.
+ **/
+void
+_pspp_sheet_selection_set_tree_view (PsppSheetSelection *selection,
+ PsppSheetView *tree_view)
+{
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ if (tree_view != NULL)
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ selection->tree_view = tree_view;
+}
+
+/**
+ * pspp_sheet_selection_set_mode:
+ * @selection: A #PsppSheetSelection.
+ * @type: The selection mode
+ *
+ * Sets the selection mode of the @selection. If the previous type was
+ * #GTK_SELECTION_MULTIPLE, then the anchor is kept selected, if it was
+ * previously selected.
+ **/
+void
+pspp_sheet_selection_set_mode (PsppSheetSelection *selection,
+ GtkSelectionMode type)
+{
+ PsppSheetSelectionFunc tmp_func;
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+
+ if (selection->type == type)
+ return;
+
+
+ if (type == GTK_SELECTION_NONE)
+ {
+ /* We do this so that we unconditionally unset all rows
+ */
+ tmp_func = selection->user_func;
+ selection->user_func = NULL;
+ pspp_sheet_selection_unselect_all (selection);
+ selection->user_func = tmp_func;
+
+ gtk_tree_row_reference_free (selection->tree_view->priv->anchor);
+ selection->tree_view->priv->anchor = NULL;
+ }
+ else if (type == GTK_SELECTION_SINGLE ||
+ type == GTK_SELECTION_BROWSE)
+ {
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ gint selected = FALSE;
+ GtkTreePath *anchor_path = NULL;
+
+ if (selection->tree_view->priv->anchor)
+ {
+ anchor_path = gtk_tree_row_reference_get_path
(selection->tree_view->priv->anchor);
+
+ if (anchor_path)
+ {
+ _pspp_sheet_view_find_node (selection->tree_view,
+ anchor_path,
+ &tree,
+ &node);
+
+ if (node && PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ selected = TRUE;
+ }
+ }
+
+ /* We do this so that we unconditionally unset all rows
+ */
+ tmp_func = selection->user_func;
+ selection->user_func = NULL;
+ pspp_sheet_selection_unselect_all (selection);
+ selection->user_func = tmp_func;
+
+ if (node && selected)
+ _pspp_sheet_selection_internal_select_node (selection,
+ node,
+ tree,
+ anchor_path,
+ 0,
+ FALSE);
+ if (anchor_path)
+ gtk_tree_path_free (anchor_path);
+ }
+
+ selection->type = type;
+}
+
+/**
+ * pspp_sheet_selection_get_mode:
+ * @selection: a #PsppSheetSelection
+ *
+ * Gets the selection mode for @selection. See
+ * pspp_sheet_selection_set_mode().
+ *
+ * Return value: the current selection mode
+ **/
+GtkSelectionMode
+pspp_sheet_selection_get_mode (PsppSheetSelection *selection)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection),
GTK_SELECTION_SINGLE);
+
+ return selection->type;
+}
+
+/**
+ * pspp_sheet_selection_set_select_function:
+ * @selection: A #PsppSheetSelection.
+ * @func: The selection function.
+ * @data: The selection function's data.
+ * @destroy: The destroy function for user data. May be NULL.
+ *
+ * Sets the selection function. If set, this function is called before any
node
+ * is selected or unselected, giving some control over which nodes are
selected.
+ * The select function should return %TRUE if the state of the node may be
toggled,
+ * and %FALSE if the state of the node should be left unchanged.
+ **/
+void
+pspp_sheet_selection_set_select_function (PsppSheetSelection *selection,
+ PsppSheetSelectionFunc func,
+ gpointer data,
+ GDestroyNotify destroy)
+{
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (func != NULL);
+
+ if (selection->destroy)
+ {
+ GDestroyNotify d = selection->destroy;
+
+ selection->destroy = NULL;
+ d (selection->user_data);
+ }
+
+ selection->user_func = func;
+ selection->user_data = data;
+ selection->destroy = destroy;
+}
+
+/**
+ * pspp_sheet_selection_get_select_function:
+ * @selection: A #PsppSheetSelection.
+ *
+ * Returns the current selection function.
+ *
+ * Return value: The function.
+ *
+ * Since: 2.14
+ **/
+PsppSheetSelectionFunc
+pspp_sheet_selection_get_select_function (PsppSheetSelection *selection)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection), NULL);
+
+ return selection->user_func;
+}
+
+/**
+ * pspp_sheet_selection_get_user_data:
+ * @selection: A #PsppSheetSelection.
+ *
+ * Returns the user data for the selection function.
+ *
+ * Return value: The user data.
+ **/
+gpointer
+pspp_sheet_selection_get_user_data (PsppSheetSelection *selection)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection), NULL);
+
+ return selection->user_data;
+}
+
+/**
+ * pspp_sheet_selection_get_tree_view:
+ * @selection: A #PsppSheetSelection
+ *
+ * Returns the tree view associated with @selection.
+ *
+ * Return value: A #PsppSheetView
+ **/
+PsppSheetView *
+pspp_sheet_selection_get_tree_view (PsppSheetSelection *selection)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection), NULL);
+
+ return selection->tree_view;
+}
+
+/**
+ * pspp_sheet_selection_get_selected:
+ * @selection: A #PsppSheetSelection.
+ * @model: (out) (allow-none): A pointer to set to the #GtkTreeModel, or NULL.
+ * @iter: (allow-none): The #GtkTreeIter, or NULL.
+ *
+ * Sets @iter to the currently selected node if @selection is set to
+ * #GTK_SELECTION_SINGLE or #GTK_SELECTION_BROWSE. @iter may be NULL if you
+ * just want to test if @selection has any selected nodes. @model is filled
+ * with the current model as a convenience. This function will not work if you
+ * use @selection is #GTK_SELECTION_MULTIPLE.
+ *
+ * Return value: TRUE, if there is a selected node.
+ **/
+gboolean
+pspp_sheet_selection_get_selected (PsppSheetSelection *selection,
+ GtkTreeModel **model,
+ GtkTreeIter *iter)
+{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ GtkTreePath *anchor_path;
+ gboolean retval;
+ gboolean found_node;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection), FALSE);
+ g_return_val_if_fail (selection->type != GTK_SELECTION_MULTIPLE, FALSE);
+ g_return_val_if_fail (selection->tree_view != NULL, FALSE);
+
+ /* Clear the iter */
+ if (iter)
+ memset (iter, 0, sizeof (GtkTreeIter));
+
+ if (model)
+ *model = selection->tree_view->priv->model;
+
+ if (selection->tree_view->priv->anchor == NULL)
+ return FALSE;
+
+ anchor_path = gtk_tree_row_reference_get_path
(selection->tree_view->priv->anchor);
+
+ if (anchor_path == NULL)
+ return FALSE;
+
+ retval = FALSE;
+
+ found_node = !_pspp_sheet_view_find_node (selection->tree_view,
+ anchor_path,
+ &tree,
+ &node);
+
+ if (found_node && PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ {
+ /* we only want to return the anchor if it exists in the rbtree and
+ * is selected.
+ */
+ if (iter == NULL)
+ retval = TRUE;
+ else
+ retval = gtk_tree_model_get_iter (selection->tree_view->priv->model,
+ iter,
+ anchor_path);
+ }
+ else
+ {
+ /* We don't want to return the anchor if it isn't actually selected.
+ */
+ retval = FALSE;
+ }
+
+ gtk_tree_path_free (anchor_path);
+
+ return retval;
+}
+
+/**
+ * pspp_sheet_selection_get_selected_rows:
+ * @selection: A #PsppSheetSelection.
+ * @model: (allow-none): A pointer to set to the #GtkTreeModel, or NULL.
+ *
+ * Creates a list of path of all selected rows. Additionally, if you are
+ * planning on modifying the model after calling this function, you may
+ * want to convert the returned list into a list of #GtkTreeRowReference<!--
-->s.
+ * To do this, you can use gtk_tree_row_reference_new().
+ *
+ * To free the return value, use:
+ * |[
+ * g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
+ * g_list_free (list);
+ * ]|
+ *
+ * Return value: (element-type GtkTreePath) (transfer full): A #GList
containing a #GtkTreePath for each selected row.
+ *
+ * Since: 2.2
+ **/
+GList *
+pspp_sheet_selection_get_selected_rows (PsppSheetSelection *selection,
+ GtkTreeModel **model)
+{
+ GList *list = NULL;
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ GtkTreePath *path;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection), NULL);
+ g_return_val_if_fail (selection->tree_view != NULL, NULL);
+
+ if (model)
+ *model = selection->tree_view->priv->model;
+
+ if (selection->tree_view->priv->tree == NULL ||
+ selection->tree_view->priv->tree->root == NULL)
+ return NULL;
+
+ if (selection->type == GTK_SELECTION_NONE)
+ return NULL;
+ else if (selection->type != GTK_SELECTION_MULTIPLE)
+ {
+ GtkTreeIter iter;
+
+ if (pspp_sheet_selection_get_selected (selection, NULL, &iter))
+ {
+ GtkTreePath *path;
+
+ path = gtk_tree_model_get_path (selection->tree_view->priv->model,
&iter);
+ list = g_list_append (list, path);
+
+ return list;
+ }
+
+ return NULL;
+ }
+
+ tree = selection->tree_view->priv->tree;
+ node = selection->tree_view->priv->tree->root;
+
+ while (node->left != tree->nil)
+ node = node->left;
+ path = gtk_tree_path_new_first ();
+
+ do
+ {
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ list = g_list_prepend (list, gtk_tree_path_copy (path));
+
+ if (node->children)
+ {
+ tree = node->children;
+ node = tree->root;
+
+ while (node->left != tree->nil)
+ node = node->left;
+
+ gtk_tree_path_append_index (path, 0);
+ }
+ else
+ {
+ gboolean done = FALSE;
+
+ do
+ {
+ node = _pspp_rbtree_next (tree, node);
+ if (node != NULL)
+ {
+ done = TRUE;
+ gtk_tree_path_next (path);
+ }
+ else
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+
+ if (!tree)
+ {
+ gtk_tree_path_free (path);
+
+ goto done;
+ }
+
+ gtk_tree_path_up (path);
+ }
+ }
+ while (!done);
+ }
+ }
+ while (TRUE);
+
+ gtk_tree_path_free (path);
+
+ done:
+ return g_list_reverse (list);
+}
+
+static void
+pspp_sheet_selection_count_selected_rows_helper (GtkRBTree *tree,
+ GtkRBNode *node,
+ gpointer data)
+{
+ gint *count = (gint *)data;
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ (*count)++;
+
+ if (node->children)
+ _pspp_rbtree_traverse (node->children, node->children->root,
+ G_PRE_ORDER,
+ pspp_sheet_selection_count_selected_rows_helper,
data);
+}
+
+/**
+ * pspp_sheet_selection_count_selected_rows:
+ * @selection: A #PsppSheetSelection.
+ *
+ * Returns the number of rows that have been selected in @tree.
+ *
+ * Return value: The number of rows selected.
+ *
+ * Since: 2.2
+ **/
+gint
+pspp_sheet_selection_count_selected_rows (PsppSheetSelection *selection)
+{
+ gint count = 0;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection), 0);
+ g_return_val_if_fail (selection->tree_view != NULL, 0);
+
+ if (selection->tree_view->priv->tree == NULL ||
+ selection->tree_view->priv->tree->root == NULL)
+ return 0;
+
+ if (selection->type == GTK_SELECTION_SINGLE ||
+ selection->type == GTK_SELECTION_BROWSE)
+ {
+ if (pspp_sheet_selection_get_selected (selection, NULL, NULL))
+ return 1;
+ else
+ return 0;
+ }
+
+ _pspp_rbtree_traverse (selection->tree_view->priv->tree,
+ selection->tree_view->priv->tree->root,
+ G_PRE_ORDER,
+ pspp_sheet_selection_count_selected_rows_helper,
+ &count);
+
+ return count;
+}
+
+/* pspp_sheet_selection_selected_foreach helper */
+static void
+model_changed (gpointer data)
+{
+ gboolean *stop = (gboolean *)data;
+
+ *stop = TRUE;
+}
+
+/**
+ * pspp_sheet_selection_selected_foreach:
+ * @selection: A #PsppSheetSelection.
+ * @func: The function to call for each selected node.
+ * @data: user data to pass to the function.
+ *
+ * Calls a function for each selected node. Note that you cannot modify
+ * the tree or selection from within this function. As a result,
+ * pspp_sheet_selection_get_selected_rows() might be more useful.
+ **/
+void
+pspp_sheet_selection_selected_foreach (PsppSheetSelection
*selection,
+ PsppSheetSelectionForeachFunc func,
+ gpointer data)
+{
+ GtkTreePath *path;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+
+ gulong inserted_id, deleted_id, reordered_id, changed_id;
+ gboolean stop = FALSE;
+
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+
+ if (func == NULL ||
+ selection->tree_view->priv->tree == NULL ||
+ selection->tree_view->priv->tree->root == NULL)
+ return;
+
+ if (selection->type == GTK_SELECTION_SINGLE ||
+ selection->type == GTK_SELECTION_BROWSE)
+ {
+ if (gtk_tree_row_reference_valid (selection->tree_view->priv->anchor))
+ {
+ path = gtk_tree_row_reference_get_path
(selection->tree_view->priv->anchor);
+ gtk_tree_model_get_iter (selection->tree_view->priv->model, &iter,
path);
+ (* func) (selection->tree_view->priv->model, path, &iter, data);
+ gtk_tree_path_free (path);
+ }
+ return;
+ }
+
+ tree = selection->tree_view->priv->tree;
+ node = selection->tree_view->priv->tree->root;
+
+ while (node->left != tree->nil)
+ node = node->left;
+
+ model = selection->tree_view->priv->model;
+ g_object_ref (model);
+
+ /* connect to signals to monitor changes in treemodel */
+ inserted_id = g_signal_connect_swapped (model, "row-inserted",
+ G_CALLBACK (model_changed),
+ &stop);
+ deleted_id = g_signal_connect_swapped (model, "row-deleted",
+ G_CALLBACK (model_changed),
+ &stop);
+ reordered_id = g_signal_connect_swapped (model, "rows-reordered",
+ G_CALLBACK (model_changed),
+ &stop);
+ changed_id = g_signal_connect_swapped (selection->tree_view, "notify::model",
+ G_CALLBACK (model_changed),
+ &stop);
+
+ /* find the node internally */
+ path = gtk_tree_path_new_first ();
+
+ do
+ {
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ {
+ gtk_tree_model_get_iter (model, &iter, path);
+ (* func) (model, path, &iter, data);
+ }
+
+ if (stop)
+ goto out;
+
+ if (node->children)
+ {
+ tree = node->children;
+ node = tree->root;
+
+ while (node->left != tree->nil)
+ node = node->left;
+
+ gtk_tree_path_append_index (path, 0);
+ }
+ else
+ {
+ gboolean done = FALSE;
+
+ do
+ {
+ node = _pspp_rbtree_next (tree, node);
+ if (node != NULL)
+ {
+ done = TRUE;
+ gtk_tree_path_next (path);
+ }
+ else
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+
+ if (tree == NULL)
+ {
+ /* we've run out of tree */
+ /* We're done with this function */
+
+ goto out;
+ }
+
+ gtk_tree_path_up (path);
+ }
+ }
+ while (!done);
+ }
+ }
+ while (TRUE);
+
+out:
+ if (path)
+ gtk_tree_path_free (path);
+
+ g_signal_handler_disconnect (model, inserted_id);
+ g_signal_handler_disconnect (model, deleted_id);
+ g_signal_handler_disconnect (model, reordered_id);
+ g_signal_handler_disconnect (selection->tree_view, changed_id);
+ g_object_unref (model);
+
+ /* check if we have to spew a scary message */
+ if (stop)
+ g_warning ("The model has been modified from within
pspp_sheet_selection_selected_foreach.\n"
+ "This function is for observing the selections of the tree only.
If\n"
+ "you are trying to get all selected items from the tree, try
using\n"
+ "pspp_sheet_selection_get_selected_rows instead.\n");
+}
+
+/**
+ * pspp_sheet_selection_select_path:
+ * @selection: A #PsppSheetSelection.
+ * @path: The #GtkTreePath to be selected.
+ *
+ * Select the row at @path.
+ **/
+void
+pspp_sheet_selection_select_path (PsppSheetSelection *selection,
+ GtkTreePath *path)
+{
+ GtkRBNode *node;
+ GtkRBTree *tree;
+ gboolean ret;
+ GtkTreeSelectMode mode = 0;
+
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+ g_return_if_fail (path != NULL);
+
+ ret = _pspp_sheet_view_find_node (selection->tree_view,
+ path,
+ &tree,
+ &node);
+
+ if (node == NULL || PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED) ||
+ ret == TRUE)
+ return;
+
+ if (selection->type == GTK_SELECTION_MULTIPLE)
+ mode = GTK_TREE_SELECT_MODE_TOGGLE;
+
+ _pspp_sheet_selection_internal_select_node (selection,
+ node,
+ tree,
+ path,
+ mode,
+ FALSE);
+}
+
+/**
+ * pspp_sheet_selection_unselect_path:
+ * @selection: A #PsppSheetSelection.
+ * @path: The #GtkTreePath to be unselected.
+ *
+ * Unselects the row at @path.
+ **/
+void
+pspp_sheet_selection_unselect_path (PsppSheetSelection *selection,
+ GtkTreePath *path)
+{
+ GtkRBNode *node;
+ GtkRBTree *tree;
+ gboolean ret;
+
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+ g_return_if_fail (path != NULL);
+
+ ret = _pspp_sheet_view_find_node (selection->tree_view,
+ path,
+ &tree,
+ &node);
+
+ if (node == NULL || !PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED) ||
+ ret == TRUE)
+ return;
+
+ _pspp_sheet_selection_internal_select_node (selection,
+ node,
+ tree,
+ path,
+ GTK_TREE_SELECT_MODE_TOGGLE,
+ TRUE);
+}
+
+/**
+ * pspp_sheet_selection_select_iter:
+ * @selection: A #PsppSheetSelection.
+ * @iter: The #GtkTreeIter to be selected.
+ *
+ * Selects the specified iterator.
+ **/
+void
+pspp_sheet_selection_select_iter (PsppSheetSelection *selection,
+ GtkTreeIter *iter)
+{
+ GtkTreePath *path;
+
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+ g_return_if_fail (selection->tree_view->priv->model != NULL);
+ g_return_if_fail (iter != NULL);
+
+ path = gtk_tree_model_get_path (selection->tree_view->priv->model,
+ iter);
+
+ if (path == NULL)
+ return;
+
+ pspp_sheet_selection_select_path (selection, path);
+ gtk_tree_path_free (path);
+}
+
+
+/**
+ * pspp_sheet_selection_unselect_iter:
+ * @selection: A #PsppSheetSelection.
+ * @iter: The #GtkTreeIter to be unselected.
+ *
+ * Unselects the specified iterator.
+ **/
+void
+pspp_sheet_selection_unselect_iter (PsppSheetSelection *selection,
+ GtkTreeIter *iter)
+{
+ GtkTreePath *path;
+
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+ g_return_if_fail (selection->tree_view->priv->model != NULL);
+ g_return_if_fail (iter != NULL);
+
+ path = gtk_tree_model_get_path (selection->tree_view->priv->model,
+ iter);
+
+ if (path == NULL)
+ return;
+
+ pspp_sheet_selection_unselect_path (selection, path);
+ gtk_tree_path_free (path);
+}
+
+/**
+ * pspp_sheet_selection_path_is_selected:
+ * @selection: A #PsppSheetSelection.
+ * @path: A #GtkTreePath to check selection on.
+ *
+ * Returns %TRUE if the row pointed to by @path is currently selected. If
@path
+ * does not point to a valid location, %FALSE is returned
+ *
+ * Return value: %TRUE if @path is selected.
+ **/
+gboolean
+pspp_sheet_selection_path_is_selected (PsppSheetSelection *selection,
+ GtkTreePath *path)
+{
+ GtkRBNode *node;
+ GtkRBTree *tree;
+ gboolean ret;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection), FALSE);
+ g_return_val_if_fail (path != NULL, FALSE);
+ g_return_val_if_fail (selection->tree_view != NULL, FALSE);
+
+ if (selection->tree_view->priv->model == NULL)
+ return FALSE;
+
+ ret = _pspp_sheet_view_find_node (selection->tree_view,
+ path,
+ &tree,
+ &node);
+
+ if ((node == NULL) || !PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED)
||
+ ret == TRUE)
+ return FALSE;
+
+ return TRUE;
+}
+
+/**
+ * pspp_sheet_selection_iter_is_selected:
+ * @selection: A #PsppSheetSelection
+ * @iter: A valid #GtkTreeIter
+ *
+ * Returns %TRUE if the row at @iter is currently selected.
+ *
+ * Return value: %TRUE, if @iter is selected
+ **/
+gboolean
+pspp_sheet_selection_iter_is_selected (PsppSheetSelection *selection,
+ GtkTreeIter *iter)
+{
+ GtkTreePath *path;
+ gboolean retval;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_SELECTION (selection), FALSE);
+ g_return_val_if_fail (iter != NULL, FALSE);
+ g_return_val_if_fail (selection->tree_view != NULL, FALSE);
+ g_return_val_if_fail (selection->tree_view->priv->model != NULL, FALSE);
+
+ path = gtk_tree_model_get_path (selection->tree_view->priv->model, iter);
+ if (path == NULL)
+ return FALSE;
+
+ retval = pspp_sheet_selection_path_is_selected (selection, path);
+ gtk_tree_path_free (path);
+
+ return retval;
+}
+
+
+/* Wish I was in python, right now... */
+struct _TempTuple {
+ PsppSheetSelection *selection;
+ gint dirty;
+};
+
+static void
+select_all_helper (GtkRBTree *tree,
+ GtkRBNode *node,
+ gpointer data)
+{
+ struct _TempTuple *tuple = data;
+
+ if (node->children)
+ _pspp_rbtree_traverse (node->children,
+ node->children->root,
+ G_PRE_ORDER,
+ select_all_helper,
+ data);
+ if (!PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ {
+ tuple->dirty = pspp_sheet_selection_real_select_node (tuple->selection,
tree, node, TRUE) || tuple->dirty;
+ }
+}
+
+
+/* We have a real_{un,}select_all function that doesn't emit the signal, so we
+ * can use it in other places without fear of the signal being emitted.
+ */
+static gint
+pspp_sheet_selection_real_select_all (PsppSheetSelection *selection)
+{
+ struct _TempTuple *tuple;
+
+ if (selection->tree_view->priv->tree == NULL)
+ return FALSE;
+
+ /* Mark all nodes selected */
+ tuple = g_new (struct _TempTuple, 1);
+ tuple->selection = selection;
+ tuple->dirty = FALSE;
+
+ _pspp_rbtree_traverse (selection->tree_view->priv->tree,
+ selection->tree_view->priv->tree->root,
+ G_PRE_ORDER,
+ select_all_helper,
+ tuple);
+ if (tuple->dirty)
+ {
+ g_free (tuple);
+ return TRUE;
+ }
+ g_free (tuple);
+ return FALSE;
+}
+
+/**
+ * pspp_sheet_selection_select_all:
+ * @selection: A #PsppSheetSelection.
+ *
+ * Selects all the nodes. @selection must be set to #GTK_SELECTION_MULTIPLE
+ * mode.
+ **/
+void
+pspp_sheet_selection_select_all (PsppSheetSelection *selection)
+{
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+
+ if (selection->tree_view->priv->tree == NULL ||
selection->tree_view->priv->model == NULL)
+ return;
+
+ g_return_if_fail (selection->type == GTK_SELECTION_MULTIPLE);
+
+ if (pspp_sheet_selection_real_select_all (selection))
+ g_signal_emit (selection, tree_selection_signals[CHANGED], 0);
+}
+
+static void
+unselect_all_helper (GtkRBTree *tree,
+ GtkRBNode *node,
+ gpointer data)
+{
+ struct _TempTuple *tuple = data;
+
+ if (node->children)
+ _pspp_rbtree_traverse (node->children,
+ node->children->root,
+ G_PRE_ORDER,
+ unselect_all_helper,
+ data);
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ {
+ tuple->dirty = pspp_sheet_selection_real_select_node (tuple->selection,
tree, node, FALSE) || tuple->dirty;
+ }
+}
+
+static gint
+pspp_sheet_selection_real_unselect_all (PsppSheetSelection *selection)
+{
+ struct _TempTuple *tuple;
+
+ if (selection->type == GTK_SELECTION_SINGLE ||
+ selection->type == GTK_SELECTION_BROWSE)
+ {
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ GtkTreePath *anchor_path;
+
+ if (selection->tree_view->priv->anchor == NULL)
+ return FALSE;
+
+ anchor_path = gtk_tree_row_reference_get_path
(selection->tree_view->priv->anchor);
+
+ if (anchor_path == NULL)
+ return FALSE;
+
+ _pspp_sheet_view_find_node (selection->tree_view,
+ anchor_path,
+ &tree,
+ &node);
+
+ gtk_tree_path_free (anchor_path);
+
+ if (tree == NULL)
+ return FALSE;
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ {
+ if (pspp_sheet_selection_real_select_node (selection, tree, node,
FALSE))
+ {
+ gtk_tree_row_reference_free (selection->tree_view->priv->anchor);
+ selection->tree_view->priv->anchor = NULL;
+ return TRUE;
+ }
+ }
+ return FALSE;
+ }
+ else
+ {
+ tuple = g_new (struct _TempTuple, 1);
+ tuple->selection = selection;
+ tuple->dirty = FALSE;
+
+ _pspp_rbtree_traverse (selection->tree_view->priv->tree,
+ selection->tree_view->priv->tree->root,
+ G_PRE_ORDER,
+ unselect_all_helper,
+ tuple);
+
+ if (tuple->dirty)
+ {
+ g_free (tuple);
+ return TRUE;
+ }
+ g_free (tuple);
+ return FALSE;
+ }
+}
+
+/**
+ * pspp_sheet_selection_unselect_all:
+ * @selection: A #PsppSheetSelection.
+ *
+ * Unselects all the nodes.
+ **/
+void
+pspp_sheet_selection_unselect_all (PsppSheetSelection *selection)
+{
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+
+ if (selection->tree_view->priv->tree == NULL ||
selection->tree_view->priv->model == NULL)
+ return;
+
+ if (pspp_sheet_selection_real_unselect_all (selection))
+ g_signal_emit (selection, tree_selection_signals[CHANGED], 0);
+}
+
+enum
+{
+ RANGE_SELECT,
+ RANGE_UNSELECT
+};
+
+static gint
+pspp_sheet_selection_real_modify_range (PsppSheetSelection *selection,
+ gint mode,
+ GtkTreePath *start_path,
+ GtkTreePath *end_path)
+{
+ GtkRBNode *start_node, *end_node;
+ GtkRBTree *start_tree, *end_tree;
+ GtkTreePath *anchor_path = NULL;
+ gboolean dirty = FALSE;
+
+ switch (gtk_tree_path_compare (start_path, end_path))
+ {
+ case 1:
+ _pspp_sheet_view_find_node (selection->tree_view,
+ end_path,
+ &start_tree,
+ &start_node);
+ _pspp_sheet_view_find_node (selection->tree_view,
+ start_path,
+ &end_tree,
+ &end_node);
+ anchor_path = start_path;
+ break;
+ case 0:
+ _pspp_sheet_view_find_node (selection->tree_view,
+ start_path,
+ &start_tree,
+ &start_node);
+ end_tree = start_tree;
+ end_node = start_node;
+ anchor_path = start_path;
+ break;
+ case -1:
+ _pspp_sheet_view_find_node (selection->tree_view,
+ start_path,
+ &start_tree,
+ &start_node);
+ _pspp_sheet_view_find_node (selection->tree_view,
+ end_path,
+ &end_tree,
+ &end_node);
+ anchor_path = start_path;
+ break;
+ }
+
+ g_return_val_if_fail (start_node != NULL, FALSE);
+ g_return_val_if_fail (end_node != NULL, FALSE);
+
+ if (anchor_path)
+ {
+ if (selection->tree_view->priv->anchor)
+ gtk_tree_row_reference_free (selection->tree_view->priv->anchor);
+
+ selection->tree_view->priv->anchor =
+ gtk_tree_row_reference_new_proxy (G_OBJECT (selection->tree_view),
+ selection->tree_view->priv->model,
+ anchor_path);
+ }
+
+ do
+ {
+ dirty |= pspp_sheet_selection_real_select_node (selection, start_tree,
start_node, (mode == RANGE_SELECT)?TRUE:FALSE);
+
+ if (start_node == end_node)
+ break;
+
+ if (start_node->children)
+ {
+ start_tree = start_node->children;
+ start_node = start_tree->root;
+ while (start_node->left != start_tree->nil)
+ start_node = start_node->left;
+ }
+ else
+ {
+ _pspp_rbtree_next_full (start_tree, start_node, &start_tree,
&start_node);
+ if (start_tree == NULL)
+ {
+ /* we just ran out of tree. That means someone passed in bogus
values.
+ */
+ return dirty;
+ }
+ }
+ }
+ while (TRUE);
+
+ return dirty;
+}
+
+/**
+ * pspp_sheet_selection_select_range:
+ * @selection: A #PsppSheetSelection.
+ * @start_path: The initial node of the range.
+ * @end_path: The final node of the range.
+ *
+ * Selects a range of nodes, determined by @start_path and @end_path inclusive.
+ * @selection must be set to #GTK_SELECTION_MULTIPLE mode.
+ **/
+void
+pspp_sheet_selection_select_range (PsppSheetSelection *selection,
+ GtkTreePath *start_path,
+ GtkTreePath *end_path)
+{
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+ g_return_if_fail (selection->type == GTK_SELECTION_MULTIPLE);
+ g_return_if_fail (selection->tree_view->priv->model != NULL);
+
+ if (pspp_sheet_selection_real_modify_range (selection, RANGE_SELECT,
start_path, end_path))
+ g_signal_emit (selection, tree_selection_signals[CHANGED], 0);
+}
+
+/**
+ * pspp_sheet_selection_unselect_range:
+ * @selection: A #PsppSheetSelection.
+ * @start_path: The initial node of the range.
+ * @end_path: The initial node of the range.
+ *
+ * Unselects a range of nodes, determined by @start_path and @end_path
+ * inclusive.
+ *
+ * Since: 2.2
+ **/
+void
+pspp_sheet_selection_unselect_range (PsppSheetSelection *selection,
+ GtkTreePath *start_path,
+ GtkTreePath *end_path)
+{
+ g_return_if_fail (PSPP_IS_SHEET_SELECTION (selection));
+ g_return_if_fail (selection->tree_view != NULL);
+ g_return_if_fail (selection->tree_view->priv->model != NULL);
+
+ if (pspp_sheet_selection_real_modify_range (selection, RANGE_UNSELECT,
start_path, end_path))
+ g_signal_emit (selection, tree_selection_signals[CHANGED], 0);
+}
+
+gboolean
+_pspp_sheet_selection_row_is_selectable (PsppSheetSelection *selection,
+ GtkRBNode *node,
+ GtkTreePath *path)
+{
+ GtkTreeIter iter;
+ gboolean sensitive = FALSE;
+
+ if (!gtk_tree_model_get_iter (selection->tree_view->priv->model, &iter,
path))
+ sensitive = TRUE;
+
+ if (!sensitive && selection->tree_view->priv->row_separator_func)
+ {
+ /* never allow separators to be selected */
+ if ((* selection->tree_view->priv->row_separator_func)
(selection->tree_view->priv->model,
+ &iter,
+
selection->tree_view->priv->row_separator_data))
+ return FALSE;
+ }
+
+ if (selection->user_func)
+ return (*selection->user_func) (selection,
selection->tree_view->priv->model, path,
+ PSPP_RBNODE_FLAG_SET (node,
PSPP_RBNODE_IS_SELECTED),
+ selection->user_data);
+ else
+ return TRUE;
+}
+
+
+/* Called internally by gtktreeview.c It handles actually selecting the tree.
+ */
+
+/*
+ * docs about the 'override_browse_mode', we set this flag when we want to
+ * unset select the node and override the select browse mode behaviour (that is
+ * 'one node should *always* be selected').
+ */
+void
+_pspp_sheet_selection_internal_select_node (PsppSheetSelection *selection,
+ GtkRBNode *node,
+ GtkRBTree *tree,
+ GtkTreePath *path,
+ GtkTreeSelectMode mode,
+ gboolean
override_browse_mode)
+{
+ gint flags;
+ gint dirty = FALSE;
+ GtkTreePath *anchor_path = NULL;
+
+ if (selection->type == GTK_SELECTION_NONE)
+ return;
+
+ if (selection->tree_view->priv->anchor)
+ anchor_path = gtk_tree_row_reference_get_path
(selection->tree_view->priv->anchor);
+
+ if (selection->type == GTK_SELECTION_SINGLE ||
+ selection->type == GTK_SELECTION_BROWSE)
+ {
+ /* just unselect */
+ if (selection->type == GTK_SELECTION_BROWSE && override_browse_mode)
+ {
+ dirty = pspp_sheet_selection_real_unselect_all (selection);
+ }
+ /* Did we try to select the same node again? */
+ else if (selection->type == GTK_SELECTION_SINGLE &&
+ anchor_path && gtk_tree_path_compare (path, anchor_path) == 0)
+ {
+ if ((mode & GTK_TREE_SELECT_MODE_TOGGLE) ==
GTK_TREE_SELECT_MODE_TOGGLE)
+ {
+ dirty = pspp_sheet_selection_real_unselect_all (selection);
+ }
+ }
+ else
+ {
+ if (anchor_path)
+ {
+ /* We only want to select the new node if we can unselect the old
one,
+ * and we can select the new one. */
+ dirty = _pspp_sheet_selection_row_is_selectable (selection, node,
path);
+
+ /* if dirty is FALSE, we weren't able to select the new one,
otherwise, we try to
+ * unselect the new one
+ */
+ if (dirty)
+ dirty = pspp_sheet_selection_real_unselect_all (selection);
+
+ /* if dirty is TRUE at this point, we successfully unselected the
+ * old one, and can then select the new one */
+ if (dirty)
+ {
+ if (selection->tree_view->priv->anchor)
+ {
+ gtk_tree_row_reference_free
(selection->tree_view->priv->anchor);
+ selection->tree_view->priv->anchor = NULL;
+ }
+
+ if (pspp_sheet_selection_real_select_node (selection, tree,
node, TRUE))
+ {
+ selection->tree_view->priv->anchor =
+ gtk_tree_row_reference_new_proxy (G_OBJECT
(selection->tree_view), selection->tree_view->priv->model, path);
+ }
+ }
+ }
+ else
+ {
+ if (pspp_sheet_selection_real_select_node (selection, tree, node,
TRUE))
+ {
+ dirty = TRUE;
+ if (selection->tree_view->priv->anchor)
+ gtk_tree_row_reference_free
(selection->tree_view->priv->anchor);
+
+ selection->tree_view->priv->anchor =
+ gtk_tree_row_reference_new_proxy (G_OBJECT
(selection->tree_view), selection->tree_view->priv->model, path);
+ }
+ }
+ }
+ }
+ else if (selection->type == GTK_SELECTION_MULTIPLE)
+ {
+ if ((mode & GTK_TREE_SELECT_MODE_EXTEND) == GTK_TREE_SELECT_MODE_EXTEND
+ && (anchor_path == NULL))
+ {
+ if (selection->tree_view->priv->anchor)
+ gtk_tree_row_reference_free (selection->tree_view->priv->anchor);
+
+ selection->tree_view->priv->anchor =
+ gtk_tree_row_reference_new_proxy (G_OBJECT (selection->tree_view),
selection->tree_view->priv->model, path);
+ dirty = pspp_sheet_selection_real_select_node (selection, tree, node,
TRUE);
+ }
+ else if ((mode & (GTK_TREE_SELECT_MODE_EXTEND |
GTK_TREE_SELECT_MODE_TOGGLE)) == (GTK_TREE_SELECT_MODE_EXTEND |
GTK_TREE_SELECT_MODE_TOGGLE))
+ {
+ pspp_sheet_selection_select_range (selection,
+ anchor_path,
+ path);
+ }
+ else if ((mode & GTK_TREE_SELECT_MODE_TOGGLE) ==
GTK_TREE_SELECT_MODE_TOGGLE)
+ {
+ flags = node->flags;
+ if (selection->tree_view->priv->anchor)
+ gtk_tree_row_reference_free (selection->tree_view->priv->anchor);
+
+ selection->tree_view->priv->anchor =
+ gtk_tree_row_reference_new_proxy (G_OBJECT (selection->tree_view),
selection->tree_view->priv->model, path);
+
+ if ((flags & PSPP_RBNODE_IS_SELECTED) == PSPP_RBNODE_IS_SELECTED)
+ dirty |= pspp_sheet_selection_real_select_node (selection, tree,
node, FALSE);
+ else
+ dirty |= pspp_sheet_selection_real_select_node (selection, tree,
node, TRUE);
+ }
+ else if ((mode & GTK_TREE_SELECT_MODE_EXTEND) ==
GTK_TREE_SELECT_MODE_EXTEND)
+ {
+ dirty = pspp_sheet_selection_real_unselect_all (selection);
+ dirty |= pspp_sheet_selection_real_modify_range (selection,
+ RANGE_SELECT,
+ anchor_path,
+ path);
+ }
+ else
+ {
+ dirty = pspp_sheet_selection_real_unselect_all (selection);
+
+ if (selection->tree_view->priv->anchor)
+ gtk_tree_row_reference_free (selection->tree_view->priv->anchor);
+
+ selection->tree_view->priv->anchor =
+ gtk_tree_row_reference_new_proxy (G_OBJECT (selection->tree_view),
selection->tree_view->priv->model, path);
+
+ dirty |= pspp_sheet_selection_real_select_node (selection, tree,
node, TRUE);
+ }
+ }
+
+ if (anchor_path)
+ gtk_tree_path_free (anchor_path);
+
+ if (dirty)
+ g_signal_emit (selection, tree_selection_signals[CHANGED], 0);
+}
+
+
+void
+_pspp_sheet_selection_emit_changed (PsppSheetSelection *selection)
+{
+ g_signal_emit (selection, tree_selection_signals[CHANGED], 0);
+}
+
+/* NOTE: Any {un,}selection ever done _MUST_ be done through this function!
+ */
+
+static gint
+pspp_sheet_selection_real_select_node (PsppSheetSelection *selection,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ gboolean select)
+{
+ gboolean toggle = FALSE;
+ GtkTreePath *path = NULL;
+
+ select = !! select;
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED) != select)
+ {
+ path = _pspp_sheet_view_find_path (selection->tree_view, tree, node);
+ toggle = _pspp_sheet_selection_row_is_selectable (selection, node, path);
+ gtk_tree_path_free (path);
+ }
+
+ if (toggle)
+ {
+ node->flags ^= PSPP_RBNODE_IS_SELECTED;
+
+ _pspp_sheet_view_queue_draw_node (selection->tree_view, tree, node,
NULL);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
diff --git a/src/ui/gui/pspp-sheet-selection.h
b/src/ui/gui/pspp-sheet-selection.h
new file mode 100644
index 0000000..9c0bcbe
--- /dev/null
+++ b/src/ui/gui/pspp-sheet-selection.h
@@ -0,0 +1,137 @@
+/* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2011 Free Software Foundation, Inc.
+
+ 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* gtktreeselection.h
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __PSPP_SHEET_SELECTION_H__
+#define __PSPP_SHEET_SELECTION_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+
+#define PSPP_TYPE_SHEET_SELECTION
(pspp_sheet_selection_get_type ())
+#define PSPP_SHEET_SELECTION(obj)
(G_TYPE_CHECK_INSTANCE_CAST ((obj), PSPP_TYPE_SHEET_SELECTION,
PsppSheetSelection))
+#define PSPP_SHEET_SELECTION_CLASS(klass)
(G_TYPE_CHECK_CLASS_CAST ((klass), PSPP_TYPE_SHEET_SELECTION,
PsppSheetSelectionClass))
+#define PSPP_IS_SHEET_SELECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE
((obj), PSPP_TYPE_SHEET_SELECTION))
+#define PSPP_IS_SHEET_SELECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE
((klass), PSPP_TYPE_SHEET_SELECTION))
+#define PSPP_SHEET_SELECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS
((obj), PSPP_TYPE_SHEET_SELECTION, PsppSheetSelectionClass))
+
+typedef gboolean (* PsppSheetSelectionFunc) (PsppSheetSelection *selection,
+ GtkTreeModel *model,
+ GtkTreePath *path,
+ gboolean
path_currently_selected,
+ gpointer data);
+typedef void (* PsppSheetSelectionForeachFunc) (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data);
+
+struct _PsppSheetSelection
+{
+ GObject parent;
+
+ /*< private >*/
+
+ PsppSheetView *GSEAL (tree_view);
+ GtkSelectionMode GSEAL (type);
+ PsppSheetSelectionFunc GSEAL (user_func);
+ gpointer GSEAL (user_data);
+ GDestroyNotify GSEAL (destroy);
+};
+
+struct _PsppSheetSelectionClass
+{
+ GObjectClass parent_class;
+
+ void (* changed) (PsppSheetSelection *selection);
+
+ /* Padding for future expansion */
+ void (*_gtk_reserved1) (void);
+ void (*_gtk_reserved2) (void);
+ void (*_gtk_reserved3) (void);
+ void (*_gtk_reserved4) (void);
+};
+
+
+GType pspp_sheet_selection_get_type (void) G_GNUC_CONST;
+
+void pspp_sheet_selection_set_mode (PsppSheetSelection
*selection,
+ GtkSelectionMode
type);
+GtkSelectionMode pspp_sheet_selection_get_mode (PsppSheetSelection
*selection);
+void pspp_sheet_selection_set_select_function (PsppSheetSelection
*selection,
+ PsppSheetSelectionFunc
func,
+ gpointer
data,
+ GDestroyNotify
destroy);
+gpointer pspp_sheet_selection_get_user_data (PsppSheetSelection
*selection);
+PsppSheetView* pspp_sheet_selection_get_tree_view
(PsppSheetSelection *selection);
+
+PsppSheetSelectionFunc pspp_sheet_selection_get_select_function
(PsppSheetSelection *selection);
+
+/* Only meaningful if GTK_SELECTION_SINGLE or GTK_SELECTION_BROWSE is set */
+/* Use selected_foreach or get_selected_rows for GTK_SELECTION_MULTIPLE */
+gboolean pspp_sheet_selection_get_selected (PsppSheetSelection
*selection,
+ GtkTreeModel
**model,
+ GtkTreeIter
*iter);
+GList * pspp_sheet_selection_get_selected_rows (PsppSheetSelection
*selection,
+ GtkTreeModel
**model);
+gint pspp_sheet_selection_count_selected_rows (PsppSheetSelection
*selection);
+void pspp_sheet_selection_selected_foreach (PsppSheetSelection
*selection,
+
PsppSheetSelectionForeachFunc func,
+ gpointer
data);
+void pspp_sheet_selection_select_path (PsppSheetSelection
*selection,
+ GtkTreePath
*path);
+void pspp_sheet_selection_unselect_path (PsppSheetSelection
*selection,
+ GtkTreePath
*path);
+void pspp_sheet_selection_select_iter (PsppSheetSelection
*selection,
+ GtkTreeIter
*iter);
+void pspp_sheet_selection_unselect_iter (PsppSheetSelection
*selection,
+ GtkTreeIter
*iter);
+gboolean pspp_sheet_selection_path_is_selected (PsppSheetSelection
*selection,
+ GtkTreePath
*path);
+gboolean pspp_sheet_selection_iter_is_selected (PsppSheetSelection
*selection,
+ GtkTreeIter
*iter);
+void pspp_sheet_selection_select_all (PsppSheetSelection
*selection);
+void pspp_sheet_selection_unselect_all (PsppSheetSelection
*selection);
+void pspp_sheet_selection_select_range (PsppSheetSelection
*selection,
+ GtkTreePath
*start_path,
+ GtkTreePath
*end_path);
+void pspp_sheet_selection_unselect_range (PsppSheetSelection
*selection,
+ GtkTreePath
*start_path,
+ GtkTreePath
*end_path);
+
+
+G_END_DECLS
+
+#endif /* __PSPP_SHEET_SELECTION_H__ */
diff --git a/src/ui/gui/pspp-sheet-view-column.c
b/src/ui/gui/pspp-sheet-view-column.c
new file mode 100644
index 0000000..db41a1d
--- /dev/null
+++ b/src/ui/gui/pspp-sheet-view-column.c
@@ -0,0 +1,3948 @@
+/* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2011 Free Software Foundation, Inc.
+
+ 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* gtktreeviewcolumn.c
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "ui/gui/pspp-sheet-private.h"
+
+#include <errno.h>
+#include <gtk/gtk.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ui/gui/psppire-marshal.h"
+
+#define I_(STRING) STRING
+#define P_(STRING) STRING
+#define GTK_PARAM_READABLE
G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+#define GTK_PARAM_READWRITE
G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+
+enum
+{
+ PROP_0,
+ PROP_VISIBLE,
+ PROP_RESIZABLE,
+ PROP_WIDTH,
+ PROP_SPACING,
+ PROP_SIZING,
+ PROP_FIXED_WIDTH,
+ PROP_MIN_WIDTH,
+ PROP_MAX_WIDTH,
+ PROP_TITLE,
+ PROP_EXPAND,
+ PROP_CLICKABLE,
+ PROP_WIDGET,
+ PROP_ALIGNMENT,
+ PROP_REORDERABLE,
+ PROP_SORT_INDICATOR,
+ PROP_SORT_ORDER,
+ PROP_SORT_COLUMN_ID
+};
+
+enum
+{
+ CLICKED,
+ LAST_SIGNAL
+};
+
+typedef struct _PsppSheetViewColumnCellInfo PsppSheetViewColumnCellInfo;
+struct _PsppSheetViewColumnCellInfo
+{
+ GtkCellRenderer *cell;
+ GSList *attributes;
+ PsppSheetCellDataFunc func;
+ gpointer func_data;
+ GDestroyNotify destroy;
+ gint requested_width;
+ gint real_width;
+ guint expand : 1;
+ guint pack : 1;
+ guint has_focus : 1;
+ guint in_editing_mode : 1;
+};
+
+/* Type methods */
+static void pspp_sheet_view_column_cell_layout_init
(GtkCellLayoutIface *iface);
+
+/* GObject methods */
+static void pspp_sheet_view_column_set_property (GObject
*object,
+ guint
prop_id,
+ const GValue
*value,
+ GParamSpec
*pspec);
+static void pspp_sheet_view_column_get_property (GObject
*object,
+ guint
prop_id,
+ GValue
*value,
+ GParamSpec
*pspec);
+static void pspp_sheet_view_column_finalize (GObject
*object);
+
+/* GtkCellLayout implementation */
+static void pspp_sheet_view_column_cell_layout_pack_start
(GtkCellLayout *cell_layout,
+
GtkCellRenderer *cell,
+ gboolean
expand);
+static void pspp_sheet_view_column_cell_layout_pack_end
(GtkCellLayout *cell_layout,
+
GtkCellRenderer *cell,
+ gboolean
expand);
+static void pspp_sheet_view_column_cell_layout_clear
(GtkCellLayout *cell_layout);
+static void pspp_sheet_view_column_cell_layout_add_attribute
(GtkCellLayout *cell_layout,
+
GtkCellRenderer *cell,
+ const gchar
*attribute,
+ gint
column);
+static void pspp_sheet_view_column_cell_layout_set_cell_data_func
(GtkCellLayout *cell_layout,
+
GtkCellRenderer *cell,
+
GtkCellLayoutDataFunc func,
+ gpointer
func_data,
+
GDestroyNotify destroy);
+static void pspp_sheet_view_column_cell_layout_clear_attributes
(GtkCellLayout *cell_layout,
+
GtkCellRenderer *cell);
+static void pspp_sheet_view_column_cell_layout_reorder
(GtkCellLayout *cell_layout,
+
GtkCellRenderer *cell,
+ gint
position);
+static GList *pspp_sheet_view_column_cell_layout_get_cells
(GtkCellLayout *cell_layout);
+
+/* Button handling code */
+static void pspp_sheet_view_column_create_button
(PsppSheetViewColumn *tree_column);
+static void pspp_sheet_view_column_update_button
(PsppSheetViewColumn *tree_column);
+
+/* Button signal handlers */
+static gint pspp_sheet_view_column_button_event (GtkWidget
*widget,
+ GdkEvent
*event,
+ gpointer
data);
+static void pspp_sheet_view_column_button_clicked (GtkWidget
*widget,
+ gpointer
data);
+static gboolean pspp_sheet_view_column_mnemonic_activate (GtkWidget
*widget,
+ gboolean
group_cycling,
+ gpointer
data);
+
+/* Property handlers */
+static void pspp_sheet_view_model_sort_column_changed
(GtkTreeSortable *sortable,
+
PsppSheetViewColumn *tree_column);
+
+/* Internal functions */
+static void pspp_sheet_view_column_sort
(PsppSheetViewColumn *tree_column,
+ gpointer
data);
+static void pspp_sheet_view_column_setup_sort_column_id_callback
(PsppSheetViewColumn *tree_column);
+static void pspp_sheet_view_column_set_attributesv
(PsppSheetViewColumn *tree_column,
+ GtkCellRenderer
*cell_renderer,
+ va_list
args);
+static PsppSheetViewColumnCellInfo *pspp_sheet_view_column_get_cell_info
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell_renderer);
+
+/* cell list manipulation */
+static GList *pspp_sheet_view_column_cell_first
(PsppSheetViewColumn *tree_column);
+static GList *pspp_sheet_view_column_cell_last
(PsppSheetViewColumn *tree_column);
+static GList *pspp_sheet_view_column_cell_next
(PsppSheetViewColumn *tree_column,
+ GList
*current);
+static GList *pspp_sheet_view_column_cell_prev
(PsppSheetViewColumn *tree_column,
+ GList
*current);
+static void pspp_sheet_view_column_clear_attributes_by_info
(PsppSheetViewColumn *tree_column,
+
PsppSheetViewColumnCellInfo *info);
+/* GtkBuildable implementation */
+static void pspp_sheet_view_column_buildable_init
(GtkBuildableIface *iface);
+
+static guint tree_column_signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE_WITH_CODE (PsppSheetViewColumn, pspp_sheet_view_column,
GTK_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
+
pspp_sheet_view_column_cell_layout_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+
pspp_sheet_view_column_buildable_init))
+
+
+static void
+pspp_sheet_view_column_class_init (PsppSheetViewColumnClass *class)
+{
+ GObjectClass *object_class;
+
+ object_class = (GObjectClass*) class;
+
+ class->clicked = NULL;
+
+ object_class->finalize = pspp_sheet_view_column_finalize;
+ object_class->set_property = pspp_sheet_view_column_set_property;
+ object_class->get_property = pspp_sheet_view_column_get_property;
+
+ tree_column_signals[CLICKED] =
+ g_signal_new (I_("clicked"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PsppSheetViewColumnClass, clicked),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ g_object_class_install_property (object_class,
+ PROP_VISIBLE,
+ g_param_spec_boolean ("visible",
+ P_("Visible"),
+ P_("Whether to display
the column"),
+ TRUE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_RESIZABLE,
+ g_param_spec_boolean ("resizable",
+ P_("Resizable"),
+ P_("Column is
user-resizable"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_WIDTH,
+ g_param_spec_int ("width",
+ P_("Width"),
+ P_("Current width of the
column"),
+ 0,
+ G_MAXINT,
+ 0,
+ GTK_PARAM_READABLE));
+ g_object_class_install_property (object_class,
+ PROP_SPACING,
+ g_param_spec_int ("spacing",
+ P_("Spacing"),
+ P_("Space which is
inserted between cells"),
+ 0,
+ G_MAXINT,
+ 0,
+ GTK_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_SIZING,
+ g_param_spec_enum ("sizing",
+ P_("Sizing"),
+ P_("Resize mode of the
column"),
+
PSPP_TYPE_SHEET_VIEW_COLUMN_SIZING,
+
PSPP_SHEET_VIEW_COLUMN_GROW_ONLY,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_FIXED_WIDTH,
+ g_param_spec_int ("fixed-width",
+ P_("Fixed Width"),
+ P_("Current fixed width
of the column"),
+ 1,
+ G_MAXINT,
+ 1, /* not useful */
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_MIN_WIDTH,
+ g_param_spec_int ("min-width",
+ P_("Minimum Width"),
+ P_("Minimum allowed width
of the column"),
+ -1,
+ G_MAXINT,
+ -1,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_MAX_WIDTH,
+ g_param_spec_int ("max-width",
+ P_("Maximum Width"),
+ P_("Maximum allowed width
of the column"),
+ -1,
+ G_MAXINT,
+ -1,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_TITLE,
+ g_param_spec_string ("title",
+ P_("Title"),
+ P_("Title to appear in
column header"),
+ "",
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_EXPAND,
+ g_param_spec_boolean ("expand",
+ P_("Expand"),
+ P_("Column gets share
of extra width allocated to the widget"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_CLICKABLE,
+ g_param_spec_boolean ("clickable",
+ P_("Clickable"),
+ P_("Whether the header
can be clicked"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+
+ g_object_class_install_property (object_class,
+ PROP_WIDGET,
+ g_param_spec_object ("widget",
+ P_("Widget"),
+ P_("Widget to put in
column header button instead of column title"),
+ GTK_TYPE_WIDGET,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_ALIGNMENT,
+ g_param_spec_float ("alignment",
+ P_("Alignment"),
+ P_("X Alignment of the
column header text or widget"),
+ 0.0,
+ 1.0,
+ 0.0,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_REORDERABLE,
+ g_param_spec_boolean ("reorderable",
+ P_("Reorderable"),
+ P_("Whether the column
can be reordered around the headers"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_SORT_INDICATOR,
+ g_param_spec_boolean ("sort-indicator",
+ P_("Sort indicator"),
+ P_("Whether to show a
sort indicator"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (object_class,
+ PROP_SORT_ORDER,
+ g_param_spec_enum ("sort-order",
+ P_("Sort order"),
+ P_("Sort direction the
sort indicator should indicate"),
+ GTK_TYPE_SORT_TYPE,
+ GTK_SORT_ASCENDING,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * PsppSheetViewColumn:sort-column-id:
+ *
+ * Logical sort column ID this column sorts on when selected for sorting.
Setting the sort column ID makes the column header
+ * clickable. Set to %-1 to make the column unsortable.
+ *
+ * Since: 2.18
+ **/
+ g_object_class_install_property (object_class,
+ PROP_SORT_COLUMN_ID,
+ g_param_spec_int ("sort-column-id",
+ P_("Sort column ID"),
+ P_("Logical sort column
ID this column sorts on when selected for sorting"),
+ -1,
+ G_MAXINT,
+ -1,
+ GTK_PARAM_READWRITE));
+}
+
+static void
+pspp_sheet_view_column_buildable_init (GtkBuildableIface *iface)
+{
+ iface->add_child = _gtk_cell_layout_buildable_add_child;
+ iface->custom_tag_start = _gtk_cell_layout_buildable_custom_tag_start;
+ iface->custom_tag_end = _gtk_cell_layout_buildable_custom_tag_end;
+}
+
+static void
+pspp_sheet_view_column_cell_layout_init (GtkCellLayoutIface *iface)
+{
+ iface->pack_start = pspp_sheet_view_column_cell_layout_pack_start;
+ iface->pack_end = pspp_sheet_view_column_cell_layout_pack_end;
+ iface->clear = pspp_sheet_view_column_cell_layout_clear;
+ iface->add_attribute = pspp_sheet_view_column_cell_layout_add_attribute;
+ iface->set_cell_data_func =
pspp_sheet_view_column_cell_layout_set_cell_data_func;
+ iface->clear_attributes =
pspp_sheet_view_column_cell_layout_clear_attributes;
+ iface->reorder = pspp_sheet_view_column_cell_layout_reorder;
+ iface->get_cells = pspp_sheet_view_column_cell_layout_get_cells;
+}
+
+static void
+pspp_sheet_view_column_init (PsppSheetViewColumn *tree_column)
+{
+ tree_column->button = NULL;
+ tree_column->xalign = 0.0;
+ tree_column->width = 0;
+ tree_column->spacing = 0;
+ tree_column->requested_width = -1;
+ tree_column->min_width = -1;
+ tree_column->max_width = -1;
+ tree_column->resized_width = 0;
+ tree_column->column_type = PSPP_SHEET_VIEW_COLUMN_GROW_ONLY;
+ tree_column->visible = TRUE;
+ tree_column->resizable = FALSE;
+ tree_column->expand = FALSE;
+ tree_column->clickable = FALSE;
+ tree_column->dirty = TRUE;
+ tree_column->sort_order = GTK_SORT_ASCENDING;
+ tree_column->show_sort_indicator = FALSE;
+ tree_column->property_changed_signal = 0;
+ tree_column->sort_clicked_signal = 0;
+ tree_column->sort_column_changed_signal = 0;
+ tree_column->sort_column_id = -1;
+ tree_column->reorderable = FALSE;
+ tree_column->maybe_reordered = FALSE;
+ tree_column->fixed_width = 1;
+ tree_column->use_resized_width = FALSE;
+ tree_column->title = g_strdup ("");
+}
+
+static void
+pspp_sheet_view_column_finalize (GObject *object)
+{
+ PsppSheetViewColumn *tree_column = (PsppSheetViewColumn *) object;
+ GList *list;
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)
list->data;
+
+ if (info->destroy)
+ {
+ GDestroyNotify d = info->destroy;
+
+ info->destroy = NULL;
+ d (info->func_data);
+ }
+ pspp_sheet_view_column_clear_attributes_by_info (tree_column, info);
+ g_object_unref (info->cell);
+ g_free (info);
+ }
+
+ g_free (tree_column->title);
+ g_list_free (tree_column->cell_list);
+
+ if (tree_column->child)
+ g_object_unref (tree_column->child);
+
+ G_OBJECT_CLASS (pspp_sheet_view_column_parent_class)->finalize (object);
+}
+
+static void
+pspp_sheet_view_column_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ PsppSheetViewColumn *tree_column;
+
+ tree_column = PSPP_SHEET_VIEW_COLUMN (object);
+
+ switch (prop_id)
+ {
+ case PROP_VISIBLE:
+ pspp_sheet_view_column_set_visible (tree_column,
+ g_value_get_boolean (value));
+ break;
+
+ case PROP_RESIZABLE:
+ pspp_sheet_view_column_set_resizable (tree_column,
+ g_value_get_boolean (value));
+ break;
+
+ case PROP_SIZING:
+ pspp_sheet_view_column_set_sizing (tree_column,
+ g_value_get_enum (value));
+ break;
+
+ case PROP_FIXED_WIDTH:
+ pspp_sheet_view_column_set_fixed_width (tree_column,
+ g_value_get_int (value));
+ break;
+
+ case PROP_MIN_WIDTH:
+ pspp_sheet_view_column_set_min_width (tree_column,
+ g_value_get_int (value));
+ break;
+
+ case PROP_MAX_WIDTH:
+ pspp_sheet_view_column_set_max_width (tree_column,
+ g_value_get_int (value));
+ break;
+
+ case PROP_SPACING:
+ pspp_sheet_view_column_set_spacing (tree_column,
+ g_value_get_int (value));
+ break;
+
+ case PROP_TITLE:
+ pspp_sheet_view_column_set_title (tree_column,
+ g_value_get_string (value));
+ break;
+
+ case PROP_EXPAND:
+ pspp_sheet_view_column_set_expand (tree_column,
+ g_value_get_boolean (value));
+ break;
+
+ case PROP_CLICKABLE:
+ pspp_sheet_view_column_set_clickable (tree_column,
+ g_value_get_boolean (value));
+ break;
+
+ case PROP_WIDGET:
+ pspp_sheet_view_column_set_widget (tree_column,
+ (GtkWidget*) g_value_get_object
(value));
+ break;
+
+ case PROP_ALIGNMENT:
+ pspp_sheet_view_column_set_alignment (tree_column,
+ g_value_get_float (value));
+ break;
+
+ case PROP_REORDERABLE:
+ pspp_sheet_view_column_set_reorderable (tree_column,
+ g_value_get_boolean (value));
+ break;
+
+ case PROP_SORT_INDICATOR:
+ pspp_sheet_view_column_set_sort_indicator (tree_column,
+ g_value_get_boolean (value));
+ break;
+
+ case PROP_SORT_ORDER:
+ pspp_sheet_view_column_set_sort_order (tree_column,
+ g_value_get_enum (value));
+ break;
+
+ case PROP_SORT_COLUMN_ID:
+ pspp_sheet_view_column_set_sort_column_id (tree_column,
+ g_value_get_int (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+pspp_sheet_view_column_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ PsppSheetViewColumn *tree_column;
+
+ tree_column = PSPP_SHEET_VIEW_COLUMN (object);
+
+ switch (prop_id)
+ {
+ case PROP_VISIBLE:
+ g_value_set_boolean (value,
+ pspp_sheet_view_column_get_visible (tree_column));
+ break;
+
+ case PROP_RESIZABLE:
+ g_value_set_boolean (value,
+ pspp_sheet_view_column_get_resizable (tree_column));
+ break;
+
+ case PROP_WIDTH:
+ g_value_set_int (value,
+ pspp_sheet_view_column_get_width (tree_column));
+ break;
+
+ case PROP_SPACING:
+ g_value_set_int (value,
+ pspp_sheet_view_column_get_spacing (tree_column));
+ break;
+
+ case PROP_SIZING:
+ g_value_set_enum (value,
+ pspp_sheet_view_column_get_sizing (tree_column));
+ break;
+
+ case PROP_FIXED_WIDTH:
+ g_value_set_int (value,
+ pspp_sheet_view_column_get_fixed_width (tree_column));
+ break;
+
+ case PROP_MIN_WIDTH:
+ g_value_set_int (value,
+ pspp_sheet_view_column_get_min_width (tree_column));
+ break;
+
+ case PROP_MAX_WIDTH:
+ g_value_set_int (value,
+ pspp_sheet_view_column_get_max_width (tree_column));
+ break;
+
+ case PROP_TITLE:
+ g_value_set_string (value,
+ pspp_sheet_view_column_get_title (tree_column));
+ break;
+
+ case PROP_EXPAND:
+ g_value_set_boolean (value,
+ pspp_sheet_view_column_get_expand (tree_column));
+ break;
+
+ case PROP_CLICKABLE:
+ g_value_set_boolean (value,
+ pspp_sheet_view_column_get_clickable (tree_column));
+ break;
+
+ case PROP_WIDGET:
+ g_value_set_object (value,
+ (GObject*) pspp_sheet_view_column_get_widget
(tree_column));
+ break;
+
+ case PROP_ALIGNMENT:
+ g_value_set_float (value,
+ pspp_sheet_view_column_get_alignment (tree_column));
+ break;
+
+ case PROP_REORDERABLE:
+ g_value_set_boolean (value,
+ pspp_sheet_view_column_get_reorderable
(tree_column));
+ break;
+
+ case PROP_SORT_INDICATOR:
+ g_value_set_boolean (value,
+ pspp_sheet_view_column_get_sort_indicator
(tree_column));
+ break;
+
+ case PROP_SORT_ORDER:
+ g_value_set_enum (value,
+ pspp_sheet_view_column_get_sort_order (tree_column));
+ break;
+
+ case PROP_SORT_COLUMN_ID:
+ g_value_set_int (value,
+ pspp_sheet_view_column_get_sort_column_id
(tree_column));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+/* Implementation of GtkCellLayout interface
+ */
+
+static void
+pspp_sheet_view_column_cell_layout_pack_start (GtkCellLayout *cell_layout,
+ GtkCellRenderer *cell,
+ gboolean expand)
+{
+ PsppSheetViewColumn *column;
+ PsppSheetViewColumnCellInfo *cell_info;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
+ column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
+ g_return_if_fail (! pspp_sheet_view_column_get_cell_info (column, cell));
+
+ g_object_ref_sink (cell);
+
+ cell_info = g_new0 (PsppSheetViewColumnCellInfo, 1);
+ cell_info->cell = cell;
+ cell_info->expand = expand ? TRUE : FALSE;
+ cell_info->pack = GTK_PACK_START;
+ cell_info->has_focus = 0;
+ cell_info->attributes = NULL;
+
+ column->cell_list = g_list_append (column->cell_list, cell_info);
+}
+
+static void
+pspp_sheet_view_column_cell_layout_pack_end (GtkCellLayout *cell_layout,
+ GtkCellRenderer *cell,
+ gboolean expand)
+{
+ PsppSheetViewColumn *column;
+ PsppSheetViewColumnCellInfo *cell_info;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
+ column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
+ g_return_if_fail (! pspp_sheet_view_column_get_cell_info (column, cell));
+
+ g_object_ref_sink (cell);
+
+ cell_info = g_new0 (PsppSheetViewColumnCellInfo, 1);
+ cell_info->cell = cell;
+ cell_info->expand = expand ? TRUE : FALSE;
+ cell_info->pack = GTK_PACK_END;
+ cell_info->has_focus = 0;
+ cell_info->attributes = NULL;
+
+ column->cell_list = g_list_append (column->cell_list, cell_info);
+}
+
+static void
+pspp_sheet_view_column_cell_layout_clear (GtkCellLayout *cell_layout)
+{
+ PsppSheetViewColumn *column;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
+ column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
+
+ while (column->cell_list)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo
*)column->cell_list->data;
+
+ pspp_sheet_view_column_cell_layout_clear_attributes (cell_layout,
info->cell);
+ g_object_unref (info->cell);
+ g_free (info);
+ column->cell_list = g_list_delete_link (column->cell_list,
+ column->cell_list);
+ }
+}
+
+static void
+pspp_sheet_view_column_cell_layout_add_attribute (GtkCellLayout *cell_layout,
+ GtkCellRenderer *cell,
+ const gchar *attribute,
+ gint column)
+{
+ PsppSheetViewColumn *tree_column;
+ PsppSheetViewColumnCellInfo *info;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
+ tree_column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
+
+ info = pspp_sheet_view_column_get_cell_info (tree_column, cell);
+ g_return_if_fail (info != NULL);
+
+ info->attributes = g_slist_prepend (info->attributes, GINT_TO_POINTER
(column));
+ info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute));
+
+ if (tree_column->tree_view)
+ _pspp_sheet_view_column_cell_set_dirty (tree_column, TRUE);
+}
+
+static void
+pspp_sheet_view_column_cell_layout_set_cell_data_func (GtkCellLayout
*cell_layout,
+ GtkCellRenderer
*cell,
+ GtkCellLayoutDataFunc
func,
+ gpointer
func_data,
+ GDestroyNotify
destroy)
+{
+ PsppSheetViewColumn *column;
+ PsppSheetViewColumnCellInfo *info;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
+ column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
+
+ info = pspp_sheet_view_column_get_cell_info (column, cell);
+ g_return_if_fail (info != NULL);
+
+ if (info->destroy)
+ {
+ GDestroyNotify d = info->destroy;
+
+ info->destroy = NULL;
+ d (info->func_data);
+ }
+
+ info->func = (PsppSheetCellDataFunc)func;
+ info->func_data = func_data;
+ info->destroy = destroy;
+
+ if (column->tree_view)
+ _pspp_sheet_view_column_cell_set_dirty (column, TRUE);
+}
+
+static void
+pspp_sheet_view_column_cell_layout_clear_attributes (GtkCellLayout
*cell_layout,
+ GtkCellRenderer
*cell_renderer)
+{
+ PsppSheetViewColumn *column;
+ PsppSheetViewColumnCellInfo *info;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
+ column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
+
+ info = pspp_sheet_view_column_get_cell_info (column, cell_renderer);
+ if (info)
+ pspp_sheet_view_column_clear_attributes_by_info (column, info);
+}
+
+static void
+pspp_sheet_view_column_cell_layout_reorder (GtkCellLayout *cell_layout,
+ GtkCellRenderer *cell,
+ gint position)
+{
+ GList *link;
+ PsppSheetViewColumn *column;
+ PsppSheetViewColumnCellInfo *info;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (cell_layout));
+ column = PSPP_SHEET_VIEW_COLUMN (cell_layout);
+
+ info = pspp_sheet_view_column_get_cell_info (column, cell);
+
+ g_return_if_fail (info != NULL);
+ g_return_if_fail (position >= 0);
+
+ link = g_list_find (column->cell_list, info);
+
+ g_return_if_fail (link != NULL);
+
+ column->cell_list = g_list_delete_link (column->cell_list, link);
+ column->cell_list = g_list_insert (column->cell_list, info, position);
+
+ if (column->tree_view)
+ gtk_widget_queue_draw (column->tree_view);
+}
+
+static void
+pspp_sheet_view_column_clear_attributes_by_info (PsppSheetViewColumn
*tree_column,
+ PsppSheetViewColumnCellInfo
*info)
+{
+ GSList *list;
+
+ list = info->attributes;
+
+ while (list && list->next)
+ {
+ g_free (list->data);
+ list = list->next->next;
+ }
+ g_slist_free (info->attributes);
+ info->attributes = NULL;
+
+ if (tree_column->tree_view)
+ _pspp_sheet_view_column_cell_set_dirty (tree_column, TRUE);
+}
+
+/* Helper functions
+ */
+
+/* Button handling code
+ */
+static void
+pspp_sheet_view_column_create_button (PsppSheetViewColumn *tree_column)
+{
+ PsppSheetView *tree_view;
+ GtkWidget *child;
+ GtkWidget *hbox;
+
+ tree_view = (PsppSheetView *) tree_column->tree_view;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (tree_column->button == NULL);
+
+ gtk_widget_push_composite_child ();
+ tree_column->button = gtk_button_new ();
+ gtk_widget_add_events (tree_column->button, GDK_POINTER_MOTION_MASK);
+ gtk_widget_pop_composite_child ();
+
+ /* make sure we own a reference to it as well. */
+ if (tree_view->priv->header_window)
+ gtk_widget_set_parent_window (tree_column->button,
tree_view->priv->header_window);
+ gtk_widget_set_parent (tree_column->button, GTK_WIDGET (tree_view));
+
+ g_signal_connect (tree_column->button, "event",
+ G_CALLBACK (pspp_sheet_view_column_button_event),
+ tree_column);
+ g_signal_connect (tree_column->button, "clicked",
+ G_CALLBACK (pspp_sheet_view_column_button_clicked),
+ tree_column);
+
+ tree_column->alignment = gtk_alignment_new (tree_column->xalign, 0.5, 0.0,
0.0);
+
+ hbox = gtk_hbox_new (FALSE, 2);
+ tree_column->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
+
+ if (tree_column->child)
+ child = tree_column->child;
+ else
+ {
+ child = gtk_label_new (tree_column->title);
+ gtk_widget_show (child);
+ }
+
+ g_signal_connect (child, "mnemonic-activate",
+ G_CALLBACK (pspp_sheet_view_column_mnemonic_activate),
+ tree_column);
+
+ if (tree_column->xalign <= 0.5)
+ gtk_box_pack_end (GTK_BOX (hbox), tree_column->arrow, FALSE, FALSE, 0);
+ else
+ gtk_box_pack_start (GTK_BOX (hbox), tree_column->arrow, FALSE, FALSE, 0);
+
+ gtk_box_pack_start (GTK_BOX (hbox), tree_column->alignment, TRUE, TRUE, 0);
+
+ gtk_container_add (GTK_CONTAINER (tree_column->alignment), child);
+ gtk_container_add (GTK_CONTAINER (tree_column->button), hbox);
+
+ gtk_widget_show (hbox);
+ gtk_widget_show (tree_column->alignment);
+ pspp_sheet_view_column_update_button (tree_column);
+}
+
+static void
+pspp_sheet_view_column_update_button (PsppSheetViewColumn *tree_column)
+{
+ gint sort_column_id = -1;
+ GtkWidget *hbox;
+ GtkWidget *alignment;
+ GtkWidget *arrow;
+ GtkWidget *current_child;
+ GtkArrowType arrow_type = GTK_ARROW_NONE;
+ GtkTreeModel *model;
+
+ if (tree_column->tree_view)
+ model = pspp_sheet_view_get_model (PSPP_SHEET_VIEW
(tree_column->tree_view));
+ else
+ model = NULL;
+
+ /* Create a button if necessary */
+ if (tree_column->visible &&
+ tree_column->button == NULL &&
+ tree_column->tree_view &&
+ gtk_widget_get_realized (tree_column->tree_view))
+ pspp_sheet_view_column_create_button (tree_column);
+
+ if (! tree_column->button)
+ return;
+
+ hbox = GTK_BIN (tree_column->button)->child;
+ alignment = tree_column->alignment;
+ arrow = tree_column->arrow;
+ current_child = GTK_BIN (alignment)->child;
+
+ /* Set up the actual button */
+ gtk_alignment_set (GTK_ALIGNMENT (alignment), tree_column->xalign,
+ 0.5, 0.0, 0.0);
+
+ if (tree_column->child)
+ {
+ if (current_child != tree_column->child)
+ {
+ gtk_container_remove (GTK_CONTAINER (alignment),
+ current_child);
+ gtk_container_add (GTK_CONTAINER (alignment),
+ tree_column->child);
+ }
+ }
+ else
+ {
+ if (current_child == NULL)
+ {
+ current_child = gtk_label_new (NULL);
+ gtk_widget_show (current_child);
+ gtk_container_add (GTK_CONTAINER (alignment),
+ current_child);
+ }
+
+ g_return_if_fail (GTK_IS_LABEL (current_child));
+
+ if (tree_column->title)
+ gtk_label_set_text_with_mnemonic (GTK_LABEL (current_child),
+ tree_column->title);
+ else
+ gtk_label_set_text_with_mnemonic (GTK_LABEL (current_child),
+ "");
+ }
+
+ if (GTK_IS_TREE_SORTABLE (model))
+ gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
+ &sort_column_id,
+ NULL);
+
+ if (tree_column->show_sort_indicator)
+ {
+ gboolean alternative;
+
+ g_object_get (gtk_widget_get_settings (tree_column->tree_view),
+ "gtk-alternative-sort-arrows", &alternative,
+ NULL);
+
+ switch (tree_column->sort_order)
+ {
+ case GTK_SORT_ASCENDING:
+ arrow_type = alternative ? GTK_ARROW_UP : GTK_ARROW_DOWN;
+ break;
+
+ case GTK_SORT_DESCENDING:
+ arrow_type = alternative ? GTK_ARROW_DOWN : GTK_ARROW_UP;
+ break;
+
+ default:
+ g_warning (G_STRLOC": bad sort order");
+ break;
+ }
+ }
+
+ gtk_arrow_set (GTK_ARROW (arrow),
+ arrow_type,
+ GTK_SHADOW_IN);
+
+ /* Put arrow on the right if the text is left-or-center justified, and on the
+ * left otherwise; do this by packing boxes, so flipping text direction will
+ * reverse things
+ */
+ g_object_ref (arrow);
+ gtk_container_remove (GTK_CONTAINER (hbox), arrow);
+
+ if (tree_column->xalign <= 0.5)
+ {
+ gtk_box_pack_end (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
+ }
+ else
+ {
+ gtk_box_pack_start (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
+ /* move it to the front */
+ gtk_box_reorder_child (GTK_BOX (hbox), arrow, 0);
+ }
+ g_object_unref (arrow);
+
+ if (tree_column->show_sort_indicator
+ || (GTK_IS_TREE_SORTABLE (model) && tree_column->sort_column_id >= 0))
+ gtk_widget_show (arrow);
+ else
+ gtk_widget_hide (arrow);
+
+ /* It's always safe to hide the button. It isn't always safe to show it, as
+ * if you show it before it's realized, it'll get the wrong window. */
+ if (tree_column->button &&
+ tree_column->tree_view != NULL &&
+ gtk_widget_get_realized (tree_column->tree_view))
+ {
+ if (tree_column->visible)
+ {
+ gtk_widget_show_now (tree_column->button);
+ if (tree_column->window)
+ {
+ if (tree_column->resizable)
+ {
+ gdk_window_show (tree_column->window);
+ gdk_window_raise (tree_column->window);
+ }
+ else
+ {
+ gdk_window_hide (tree_column->window);
+ }
+ }
+ }
+ else
+ {
+ gtk_widget_hide (tree_column->button);
+ if (tree_column->window)
+ gdk_window_hide (tree_column->window);
+ }
+ }
+
+ if (tree_column->reorderable || tree_column->clickable)
+ {
+ gtk_widget_set_can_focus (tree_column->button, TRUE);
+ }
+ else
+ {
+ gtk_widget_set_can_focus (tree_column->button, FALSE);
+ if (gtk_widget_has_focus (tree_column->button))
+ {
+ GtkWidget *toplevel = gtk_widget_get_toplevel
(tree_column->tree_view);
+ if (gtk_widget_is_toplevel (toplevel))
+ {
+ gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
+ }
+ }
+ }
+ /* Queue a resize on the assumption that we always want to catch all changes
+ * and columns don't change all that often.
+ */
+ if (gtk_widget_get_realized (tree_column->tree_view))
+ gtk_widget_queue_resize (tree_column->tree_view);
+
+}
+
+/* Button signal handlers
+ */
+
+static gint
+pspp_sheet_view_column_button_event (GtkWidget *widget,
+ GdkEvent *event,
+ gpointer data)
+{
+ PsppSheetViewColumn *column = (PsppSheetViewColumn *) data;
+
+ g_return_val_if_fail (event != NULL, FALSE);
+
+ if (event->type == GDK_BUTTON_PRESS &&
+ column->reorderable &&
+ ((GdkEventButton *)event)->button == 1)
+ {
+ column->maybe_reordered = TRUE;
+ gdk_window_get_pointer (GTK_BUTTON (widget)->event_window,
+ &column->drag_x,
+ &column->drag_y,
+ NULL);
+ gtk_widget_grab_focus (widget);
+ }
+
+ if (event->type == GDK_BUTTON_RELEASE ||
+ event->type == GDK_LEAVE_NOTIFY)
+ column->maybe_reordered = FALSE;
+
+ if (event->type == GDK_MOTION_NOTIFY &&
+ column->maybe_reordered &&
+ (gtk_drag_check_threshold (widget,
+ column->drag_x,
+ column->drag_y,
+ (gint) ((GdkEventMotion *)event)->x,
+ (gint) ((GdkEventMotion *)event)->y)))
+ {
+ column->maybe_reordered = FALSE;
+ _pspp_sheet_view_column_start_drag (PSPP_SHEET_VIEW (column->tree_view),
column);
+ return TRUE;
+ }
+ if (column->clickable == FALSE)
+ {
+ switch (event->type)
+ {
+ case GDK_BUTTON_PRESS:
+ case GDK_2BUTTON_PRESS:
+ case GDK_3BUTTON_PRESS:
+ case GDK_MOTION_NOTIFY:
+ case GDK_BUTTON_RELEASE:
+ case GDK_ENTER_NOTIFY:
+ case GDK_LEAVE_NOTIFY:
+ return TRUE;
+ default:
+ return FALSE;
+ }
+ }
+ return FALSE;
+}
+
+
+static void
+pspp_sheet_view_column_button_clicked (GtkWidget *widget, gpointer data)
+{
+ g_signal_emit_by_name (data, "clicked");
+}
+
+static gboolean
+pspp_sheet_view_column_mnemonic_activate (GtkWidget *widget,
+ gboolean group_cycling,
+ gpointer data)
+{
+ PsppSheetViewColumn *column = (PsppSheetViewColumn *)data;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column), FALSE);
+
+ PSPP_SHEET_VIEW (column->tree_view)->priv->focus_column = column;
+ if (column->clickable)
+ gtk_button_clicked (GTK_BUTTON (column->button));
+ else if (gtk_widget_get_can_focus (column->button))
+ gtk_widget_grab_focus (column->button);
+ else
+ gtk_widget_grab_focus (column->tree_view);
+
+ return TRUE;
+}
+
+static void
+pspp_sheet_view_model_sort_column_changed (GtkTreeSortable *sortable,
+ PsppSheetViewColumn *column)
+{
+ gint sort_column_id;
+ GtkSortType order;
+
+ if (gtk_tree_sortable_get_sort_column_id (sortable,
+ &sort_column_id,
+ &order))
+ {
+ if (sort_column_id == column->sort_column_id)
+ {
+ pspp_sheet_view_column_set_sort_indicator (column, TRUE);
+ pspp_sheet_view_column_set_sort_order (column, order);
+ }
+ else
+ {
+ pspp_sheet_view_column_set_sort_indicator (column, FALSE);
+ }
+ }
+ else
+ {
+ pspp_sheet_view_column_set_sort_indicator (column, FALSE);
+ }
+}
+
+static void
+pspp_sheet_view_column_sort (PsppSheetViewColumn *tree_column,
+ gpointer data)
+{
+ gint sort_column_id;
+ GtkSortType order;
+ gboolean has_sort_column;
+ gboolean has_default_sort_func;
+
+ g_return_if_fail (tree_column->tree_view != NULL);
+
+ has_sort_column =
+ gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (PSPP_SHEET_VIEW
(tree_column->tree_view)->priv->model),
+ &sort_column_id,
+ &order);
+ has_default_sort_func =
+ gtk_tree_sortable_has_default_sort_func (GTK_TREE_SORTABLE
(PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model));
+
+ if (has_sort_column &&
+ sort_column_id == tree_column->sort_column_id)
+ {
+ if (order == GTK_SORT_ASCENDING)
+ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
(PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model),
+ tree_column->sort_column_id,
+ GTK_SORT_DESCENDING);
+ else if (order == GTK_SORT_DESCENDING && has_default_sort_func)
+ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
(PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model),
+
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
+ GTK_SORT_ASCENDING);
+ else
+ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
(PSPP_SHEET_VIEW (tree_column->tree_view)->priv->model),
+ tree_column->sort_column_id,
+ GTK_SORT_ASCENDING);
+ }
+ else
+ {
+ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (PSPP_SHEET_VIEW
(tree_column->tree_view)->priv->model),
+ tree_column->sort_column_id,
+ GTK_SORT_ASCENDING);
+ }
+}
+
+
+static void
+pspp_sheet_view_column_setup_sort_column_id_callback (PsppSheetViewColumn
*tree_column)
+{
+ GtkTreeModel *model;
+
+ if (tree_column->tree_view == NULL)
+ return;
+
+ model = pspp_sheet_view_get_model (PSPP_SHEET_VIEW (tree_column->tree_view));
+
+ if (model == NULL)
+ return;
+
+ if (GTK_IS_TREE_SORTABLE (model) &&
+ tree_column->sort_column_id != -1)
+ {
+ gint real_sort_column_id;
+ GtkSortType real_order;
+
+ if (tree_column->sort_column_changed_signal == 0)
+ tree_column->sort_column_changed_signal =
+ g_signal_connect (model, "sort-column-changed",
+ G_CALLBACK
(pspp_sheet_view_model_sort_column_changed),
+ tree_column);
+
+ if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
+ &real_sort_column_id,
+ &real_order) &&
+ (real_sort_column_id == tree_column->sort_column_id))
+ {
+ pspp_sheet_view_column_set_sort_indicator (tree_column, TRUE);
+ pspp_sheet_view_column_set_sort_order (tree_column, real_order);
+ }
+ else
+ {
+ pspp_sheet_view_column_set_sort_indicator (tree_column, FALSE);
+ }
+ }
+}
+
+
+/* Exported Private Functions.
+ * These should only be called by gtktreeview.c or gtktreeviewcolumn.c
+ */
+
+void
+_pspp_sheet_view_column_realize_button (PsppSheetViewColumn *column)
+{
+ PsppSheetView *tree_view;
+ GdkWindowAttr attr;
+ guint attributes_mask;
+ gboolean rtl;
+
+ tree_view = (PsppSheetView *)column->tree_view;
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
+ g_return_if_fail (tree_view->priv->header_window != NULL);
+ g_return_if_fail (column->button != NULL);
+
+ gtk_widget_set_parent_window (column->button,
tree_view->priv->header_window);
+
+ if (column->visible)
+ gtk_widget_show (column->button);
+
+ attr.window_type = GDK_WINDOW_CHILD;
+ attr.wclass = GDK_INPUT_ONLY;
+ attr.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
+ attr.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
+ attr.event_mask = gtk_widget_get_events (GTK_WIDGET (tree_view)) |
+ (GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK |
+ GDK_POINTER_MOTION_HINT_MASK |
+ GDK_KEY_PRESS_MASK);
+ attributes_mask = GDK_WA_CURSOR | GDK_WA_X | GDK_WA_Y;
+ attr.cursor = gdk_cursor_new_for_display (gdk_drawable_get_display
(tree_view->priv->header_window),
+ GDK_SB_H_DOUBLE_ARROW);
+ attr.y = 0;
+ attr.width = TREE_VIEW_DRAG_WIDTH;
+ attr.height = tree_view->priv->header_height;
+
+ attr.x = (column->button->allocation.x + (rtl ? 0 :
column->button->allocation.width)) - TREE_VIEW_DRAG_WIDTH / 2;
+ column->window = gdk_window_new (tree_view->priv->header_window,
+ &attr, attributes_mask);
+ gdk_window_set_user_data (column->window, tree_view);
+
+ pspp_sheet_view_column_update_button (column);
+
+ gdk_cursor_unref (attr.cursor);
+}
+
+void
+_pspp_sheet_view_column_unrealize_button (PsppSheetViewColumn *column)
+{
+ g_return_if_fail (column != NULL);
+ g_return_if_fail (column->window != NULL);
+
+ gdk_window_set_user_data (column->window, NULL);
+ gdk_window_destroy (column->window);
+ column->window = NULL;
+}
+
+void
+_pspp_sheet_view_column_unset_model (PsppSheetViewColumn *column,
+ GtkTreeModel *old_model)
+{
+ if (column->sort_column_changed_signal)
+ {
+ g_signal_handler_disconnect (old_model,
+ column->sort_column_changed_signal);
+ column->sort_column_changed_signal = 0;
+ }
+ pspp_sheet_view_column_set_sort_indicator (column, FALSE);
+}
+
+void
+_pspp_sheet_view_column_set_tree_view (PsppSheetViewColumn *column,
+ PsppSheetView *tree_view)
+{
+ g_assert (column->tree_view == NULL);
+
+ column->tree_view = GTK_WIDGET (tree_view);
+ pspp_sheet_view_column_create_button (column);
+
+ column->property_changed_signal =
+ g_signal_connect_swapped (tree_view,
+ "notify::model",
+ G_CALLBACK
(pspp_sheet_view_column_setup_sort_column_id_callback),
+ column);
+
+ pspp_sheet_view_column_setup_sort_column_id_callback (column);
+}
+
+void
+_pspp_sheet_view_column_unset_tree_view (PsppSheetViewColumn *column)
+{
+ if (column->tree_view && column->button)
+ {
+ gtk_container_remove (GTK_CONTAINER (column->tree_view), column->button);
+ }
+ if (column->property_changed_signal)
+ {
+ g_signal_handler_disconnect (column->tree_view,
column->property_changed_signal);
+ column->property_changed_signal = 0;
+ }
+
+ if (column->sort_column_changed_signal)
+ {
+ g_signal_handler_disconnect (pspp_sheet_view_get_model (PSPP_SHEET_VIEW
(column->tree_view)),
+ column->sort_column_changed_signal);
+ column->sort_column_changed_signal = 0;
+ }
+
+ column->tree_view = NULL;
+ column->button = NULL;
+}
+
+gboolean
+_pspp_sheet_view_column_has_editable_cell (PsppSheetViewColumn *column)
+{
+ GList *list;
+
+ for (list = column->cell_list; list; list = list->next)
+ if (((PsppSheetViewColumnCellInfo *)list->data)->cell->mode ==
+ GTK_CELL_RENDERER_MODE_EDITABLE)
+ return TRUE;
+
+ return FALSE;
+}
+
+/* gets cell being edited */
+GtkCellRenderer *
+_pspp_sheet_view_column_get_edited_cell (PsppSheetViewColumn *column)
+{
+ GList *list;
+
+ for (list = column->cell_list; list; list = list->next)
+ if (((PsppSheetViewColumnCellInfo *)list->data)->in_editing_mode)
+ return ((PsppSheetViewColumnCellInfo *)list->data)->cell;
+
+ return NULL;
+}
+
+gint
+_pspp_sheet_view_column_count_special_cells (PsppSheetViewColumn *column)
+{
+ gint i = 0;
+ GList *list;
+
+ for (list = column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *cellinfo = list->data;
+
+ if ((cellinfo->cell->mode == GTK_CELL_RENDERER_MODE_EDITABLE ||
+ cellinfo->cell->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE) &&
+ cellinfo->cell->visible)
+ i++;
+ }
+
+ return i;
+}
+
+GtkCellRenderer *
+_pspp_sheet_view_column_get_cell_at_pos (PsppSheetViewColumn *column,
+ gint x)
+{
+ GList *list;
+ gint current_x = 0;
+
+ list = pspp_sheet_view_column_cell_first (column);
+ for (; list; list = pspp_sheet_view_column_cell_next (column, list))
+ {
+ PsppSheetViewColumnCellInfo *cellinfo = list->data;
+ if (current_x <= x && x <= current_x + cellinfo->real_width)
+ return cellinfo->cell;
+ current_x += cellinfo->real_width;
+ }
+
+ return NULL;
+}
+
+/* Public Functions */
+
+
+/**
+ * pspp_sheet_view_column_new:
+ *
+ * Creates a new #PsppSheetViewColumn.
+ *
+ * Return value: A newly created #PsppSheetViewColumn.
+ **/
+PsppSheetViewColumn *
+pspp_sheet_view_column_new (void)
+{
+ PsppSheetViewColumn *tree_column;
+
+ tree_column = g_object_new (PSPP_TYPE_SHEET_VIEW_COLUMN, NULL);
+
+ return tree_column;
+}
+
+/**
+ * pspp_sheet_view_column_new_with_attributes:
+ * @title: The title to set the header to.
+ * @cell: The #GtkCellRenderer.
+ * @Varargs: A %NULL-terminated list of attributes.
+ *
+ * Creates a new #PsppSheetViewColumn with a number of default values. This is
+ * equivalent to calling pspp_sheet_view_column_set_title(),
+ * pspp_sheet_view_column_pack_start(), and
+ * pspp_sheet_view_column_set_attributes() on the newly created
#PsppSheetViewColumn.
+ *
+ * Here's a simple example:
+ * |[
+ * enum { TEXT_COLUMN, COLOR_COLUMN, N_COLUMNS };
+ * ...
+ * {
+ * PsppSheetViewColumn *column;
+ * GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
+ *
+ * column = pspp_sheet_view_column_new_with_attributes ("Title",
+ * renderer,
+ * "text", TEXT_COLUMN,
+ * "foreground",
COLOR_COLUMN,
+ * NULL);
+ * }
+ * ]|
+ *
+ * Return value: A newly created #PsppSheetViewColumn.
+ **/
+PsppSheetViewColumn *
+pspp_sheet_view_column_new_with_attributes (const gchar *title,
+ GtkCellRenderer *cell,
+ ...)
+{
+ PsppSheetViewColumn *retval;
+ va_list args;
+
+ retval = pspp_sheet_view_column_new ();
+
+ pspp_sheet_view_column_set_title (retval, title);
+ pspp_sheet_view_column_pack_start (retval, cell, TRUE);
+
+ va_start (args, cell);
+ pspp_sheet_view_column_set_attributesv (retval, cell, args);
+ va_end (args);
+
+ return retval;
+}
+
+static PsppSheetViewColumnCellInfo *
+pspp_sheet_view_column_get_cell_info (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell_renderer)
+{
+ GList *list;
+ for (list = tree_column->cell_list; list; list = list->next)
+ if (((PsppSheetViewColumnCellInfo *)list->data)->cell == cell_renderer)
+ return (PsppSheetViewColumnCellInfo *) list->data;
+ return NULL;
+}
+
+
+/**
+ * pspp_sheet_view_column_pack_start:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @cell: The #GtkCellRenderer.
+ * @expand: %TRUE if @cell is to be given extra space allocated to
@tree_column.
+ *
+ * Packs the @cell into the beginning of the column. If @expand is %FALSE, then
+ * the @cell is allocated no more space than it needs. Any unused space is
divided
+ * evenly between cells for which @expand is %TRUE.
+ **/
+void
+pspp_sheet_view_column_pack_start (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell,
+ gboolean expand)
+{
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tree_column), cell, expand);
+}
+
+/**
+ * pspp_sheet_view_column_pack_end:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @cell: The #GtkCellRenderer.
+ * @expand: %TRUE if @cell is to be given extra space allocated to
@tree_column.
+ *
+ * Adds the @cell to end of the column. If @expand is %FALSE, then the @cell
+ * is allocated no more space than it needs. Any unused space is divided
+ * evenly between cells for which @expand is %TRUE.
+ **/
+void
+pspp_sheet_view_column_pack_end (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell,
+ gboolean expand)
+{
+ gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (tree_column), cell, expand);
+}
+
+/**
+ * pspp_sheet_view_column_clear:
+ * @tree_column: A #PsppSheetViewColumn
+ *
+ * Unsets all the mappings on all renderers on the @tree_column.
+ **/
+void
+pspp_sheet_view_column_clear (PsppSheetViewColumn *tree_column)
+{
+ gtk_cell_layout_clear (GTK_CELL_LAYOUT (tree_column));
+}
+
+static GList *
+pspp_sheet_view_column_cell_layout_get_cells (GtkCellLayout *layout)
+{
+ PsppSheetViewColumn *tree_column = PSPP_SHEET_VIEW_COLUMN (layout);
+ GList *retval = NULL, *list;
+
+ g_return_val_if_fail (tree_column != NULL, NULL);
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo
*)list->data;
+
+ retval = g_list_append (retval, info->cell);
+ }
+
+ return retval;
+}
+
+/**
+ * pspp_sheet_view_column_get_cell_renderers:
+ * @tree_column: A #PsppSheetViewColumn
+ *
+ * Returns a newly-allocated #GList of all the cell renderers in the column,
+ * in no particular order. The list must be freed with g_list_free().
+ *
+ * Return value: A list of #GtkCellRenderers
+ *
+ * Deprecated: 2.18: use gtk_cell_layout_get_cells() instead.
+ **/
+GList *
+pspp_sheet_view_column_get_cell_renderers (PsppSheetViewColumn *tree_column)
+{
+ return pspp_sheet_view_column_cell_layout_get_cells (GTK_CELL_LAYOUT
(tree_column));
+}
+
+/**
+ * pspp_sheet_view_column_add_attribute:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @cell_renderer: the #GtkCellRenderer to set attributes on
+ * @attribute: An attribute on the renderer
+ * @column: The column position on the model to get the attribute from.
+ *
+ * Adds an attribute mapping to the list in @tree_column. The @column is the
+ * column of the model to get a value from, and the @attribute is the
+ * parameter on @cell_renderer to be set from the value. So for example
+ * if column 2 of the model contains strings, you could have the
+ * "text" attribute of a #GtkCellRendererText get its values from
+ * column 2.
+ **/
+void
+pspp_sheet_view_column_add_attribute (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell_renderer,
+ const gchar *attribute,
+ gint column)
+{
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (tree_column),
+ cell_renderer, attribute, column);
+}
+
+static void
+pspp_sheet_view_column_set_attributesv (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell_renderer,
+ va_list args)
+{
+ gchar *attribute;
+ gint column;
+
+ attribute = va_arg (args, gchar *);
+
+ pspp_sheet_view_column_clear_attributes (tree_column, cell_renderer);
+
+ while (attribute != NULL)
+ {
+ column = va_arg (args, gint);
+ pspp_sheet_view_column_add_attribute (tree_column, cell_renderer,
attribute, column);
+ attribute = va_arg (args, gchar *);
+ }
+}
+
+/**
+ * pspp_sheet_view_column_set_attributes:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @cell_renderer: the #GtkCellRenderer we're setting the attributes of
+ * @Varargs: A %NULL-terminated list of attributes.
+ *
+ * Sets the attributes in the list as the attributes of @tree_column.
+ * The attributes should be in attribute/column order, as in
+ * pspp_sheet_view_column_add_attribute(). All existing attributes
+ * are removed, and replaced with the new attributes.
+ **/
+void
+pspp_sheet_view_column_set_attributes (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell_renderer,
+ ...)
+{
+ va_list args;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer));
+ g_return_if_fail (pspp_sheet_view_column_get_cell_info (tree_column,
cell_renderer));
+
+ va_start (args, cell_renderer);
+ pspp_sheet_view_column_set_attributesv (tree_column, cell_renderer, args);
+ va_end (args);
+}
+
+
+/**
+ * pspp_sheet_view_column_set_cell_data_func:
+ * @tree_column: A #PsppSheetViewColumn
+ * @cell_renderer: A #GtkCellRenderer
+ * @func: The #PsppSheetViewColumnFunc to use.
+ * @func_data: The user data for @func.
+ * @destroy: The destroy notification for @func_data
+ *
+ * Sets the #PsppSheetViewColumnFunc to use for the column. This
+ * function is used instead of the standard attributes mapping for
+ * setting the column value, and should set the value of @tree_column's
+ * cell renderer as appropriate. @func may be %NULL to remove an
+ * older one.
+ **/
+void
+pspp_sheet_view_column_set_cell_data_func (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell_renderer,
+ PsppSheetCellDataFunc func,
+ gpointer func_data,
+ GDestroyNotify destroy)
+{
+ gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (tree_column),
+ cell_renderer,
+ (GtkCellLayoutDataFunc)func,
+ func_data, destroy);
+}
+
+
+/**
+ * pspp_sheet_view_column_clear_attributes:
+ * @tree_column: a #PsppSheetViewColumn
+ * @cell_renderer: a #GtkCellRenderer to clear the attribute mapping on.
+ *
+ * Clears all existing attributes previously set with
+ * pspp_sheet_view_column_set_attributes().
+ **/
+void
+pspp_sheet_view_column_clear_attributes (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell_renderer)
+{
+ gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (tree_column),
+ cell_renderer);
+}
+
+/**
+ * pspp_sheet_view_column_set_spacing:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @spacing: distance between cell renderers in pixels.
+ *
+ * Sets the spacing field of @tree_column, which is the number of pixels to
+ * place between cell renderers packed into it.
+ **/
+void
+pspp_sheet_view_column_set_spacing (PsppSheetViewColumn *tree_column,
+ gint spacing)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (spacing >= 0);
+
+ if (tree_column->spacing == spacing)
+ return;
+
+ tree_column->spacing = spacing;
+ if (tree_column->tree_view)
+ _pspp_sheet_view_column_cell_set_dirty (tree_column, TRUE);
+}
+
+/**
+ * pspp_sheet_view_column_get_spacing:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns the spacing of @tree_column.
+ *
+ * Return value: the spacing of @tree_column.
+ **/
+gint
+pspp_sheet_view_column_get_spacing (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
+
+ return tree_column->spacing;
+}
+
+/* Options for manipulating the columns */
+
+/**
+ * pspp_sheet_view_column_set_visible:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @visible: %TRUE if the @tree_column is visible.
+ *
+ * Sets the visibility of @tree_column.
+ **/
+void
+pspp_sheet_view_column_set_visible (PsppSheetViewColumn *tree_column,
+ gboolean visible)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ visible = !! visible;
+
+ if (tree_column->visible == visible)
+ return;
+
+ tree_column->visible = visible;
+
+ if (tree_column->visible)
+ _pspp_sheet_view_column_cell_set_dirty (tree_column, TRUE);
+
+ pspp_sheet_view_column_update_button (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "visible");
+}
+
+/**
+ * pspp_sheet_view_column_get_visible:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns %TRUE if @tree_column is visible.
+ *
+ * Return value: whether the column is visible or not. If it is visible, then
+ * the tree will show the column.
+ **/
+gboolean
+pspp_sheet_view_column_get_visible (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
+
+ return tree_column->visible;
+}
+
+/**
+ * pspp_sheet_view_column_set_resizable:
+ * @tree_column: A #PsppSheetViewColumn
+ * @resizable: %TRUE, if the column can be resized
+ *
+ * If @resizable is %TRUE, then the user can explicitly resize the column by
+ * grabbing the outer edge of the column button. If resizable is %TRUE and
+ * sizing mode of the column is #PSPP_SHEET_VIEW_COLUMN_AUTOSIZE, then the
sizing
+ * mode is changed to #PSPP_SHEET_VIEW_COLUMN_GROW_ONLY.
+ **/
+void
+pspp_sheet_view_column_set_resizable (PsppSheetViewColumn *tree_column,
+ gboolean resizable)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ resizable = !! resizable;
+
+ if (tree_column->resizable == resizable)
+ return;
+
+ tree_column->resizable = resizable;
+
+ if (resizable && tree_column->column_type == PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ pspp_sheet_view_column_set_sizing (tree_column,
PSPP_SHEET_VIEW_COLUMN_GROW_ONLY);
+
+ pspp_sheet_view_column_update_button (tree_column);
+
+ g_object_notify (G_OBJECT (tree_column), "resizable");
+}
+
+/**
+ * pspp_sheet_view_column_get_resizable:
+ * @tree_column: A #PsppSheetViewColumn
+ *
+ * Returns %TRUE if the @tree_column can be resized by the end user.
+ *
+ * Return value: %TRUE, if the @tree_column can be resized.
+ **/
+gboolean
+pspp_sheet_view_column_get_resizable (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
+
+ return tree_column->resizable;
+}
+
+
+/**
+ * pspp_sheet_view_column_set_sizing:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @type: The #PsppSheetViewColumnSizing.
+ *
+ * Sets the growth behavior of @tree_column to @type.
+ **/
+void
+pspp_sheet_view_column_set_sizing (PsppSheetViewColumn *tree_column,
+ PsppSheetViewColumnSizing type)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ if (type == tree_column->column_type)
+ return;
+
+ if (type == PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ pspp_sheet_view_column_set_resizable (tree_column, FALSE);
+
+#if 0
+ /* I was clearly on crack when I wrote this. I'm not sure what's supposed to
+ * be below so I'll leave it until I figure it out.
+ */
+ if (tree_column->column_type == PSPP_SHEET_VIEW_COLUMN_AUTOSIZE &&
+ tree_column->requested_width != -1)
+ {
+ pspp_sheet_view_column_set_sizing (tree_column,
tree_column->requested_width);
+ }
+#endif
+ tree_column->column_type = type;
+
+ pspp_sheet_view_column_update_button (tree_column);
+
+ g_object_notify (G_OBJECT (tree_column), "sizing");
+}
+
+/**
+ * pspp_sheet_view_column_get_sizing:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns the current type of @tree_column.
+ *
+ * Return value: The type of @tree_column.
+ **/
+PsppSheetViewColumnSizing
+pspp_sheet_view_column_get_sizing (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
+
+ return tree_column->column_type;
+}
+
+/**
+ * pspp_sheet_view_column_get_width:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns the current size of @tree_column in pixels.
+ *
+ * Return value: The current width of @tree_column.
+ **/
+gint
+pspp_sheet_view_column_get_width (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
+
+ return tree_column->width;
+}
+
+/**
+ * pspp_sheet_view_column_set_fixed_width:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @fixed_width: The size to set @tree_column to. Must be greater than 0.
+ *
+ * Sets the size of the column in pixels. This is meaningful only if the
sizing
+ * type is #PSPP_SHEET_VIEW_COLUMN_FIXED. The size of the column is clamped to
+ * the min/max width for the column. Please note that the min/max width of the
+ * column doesn't actually affect the "fixed_width" property of the widget,
just
+ * the actual size when displayed.
+ **/
+void
+pspp_sheet_view_column_set_fixed_width (PsppSheetViewColumn *tree_column,
+ gint fixed_width)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (fixed_width > 0);
+
+ tree_column->fixed_width = fixed_width;
+ tree_column->use_resized_width = FALSE;
+
+ if (tree_column->tree_view &&
+ gtk_widget_get_realized (tree_column->tree_view) &&
+ tree_column->column_type == PSPP_SHEET_VIEW_COLUMN_FIXED)
+ {
+ gtk_widget_queue_resize (tree_column->tree_view);
+ }
+
+ g_object_notify (G_OBJECT (tree_column), "fixed-width");
+}
+
+/**
+ * pspp_sheet_view_column_get_fixed_width:
+ * @tree_column: a #PsppSheetViewColumn
+ *
+ * Gets the fixed width of the column. This value is only meaning may not be
+ * the actual width of the column on the screen, just what is requested.
+ *
+ * Return value: the fixed width of the column
+ **/
+gint
+pspp_sheet_view_column_get_fixed_width (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
+
+ return tree_column->fixed_width;
+}
+
+/**
+ * pspp_sheet_view_column_set_min_width:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @min_width: The minimum width of the column in pixels, or -1.
+ *
+ * Sets the minimum width of the @tree_column. If @min_width is -1, then the
+ * minimum width is unset.
+ **/
+void
+pspp_sheet_view_column_set_min_width (PsppSheetViewColumn *tree_column,
+ gint min_width)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (min_width >= -1);
+
+ if (min_width == tree_column->min_width)
+ return;
+
+ if (tree_column->visible &&
+ tree_column->tree_view != NULL &&
+ gtk_widget_get_realized (tree_column->tree_view))
+ {
+ if (min_width > tree_column->width)
+ gtk_widget_queue_resize (tree_column->tree_view);
+ }
+
+ tree_column->min_width = min_width;
+ g_object_freeze_notify (G_OBJECT (tree_column));
+ if (tree_column->max_width != -1 && tree_column->max_width < min_width)
+ {
+ tree_column->max_width = min_width;
+ g_object_notify (G_OBJECT (tree_column), "max-width");
+ }
+ g_object_notify (G_OBJECT (tree_column), "min-width");
+ g_object_thaw_notify (G_OBJECT (tree_column));
+
+ if (tree_column->column_type == PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ _pspp_sheet_view_column_autosize (PSPP_SHEET_VIEW (tree_column->tree_view),
+ tree_column);
+}
+
+/**
+ * pspp_sheet_view_column_get_min_width:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns the minimum width in pixels of the @tree_column, or -1 if no minimum
+ * width is set.
+ *
+ * Return value: The minimum width of the @tree_column.
+ **/
+gint
+pspp_sheet_view_column_get_min_width (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), -1);
+
+ return tree_column->min_width;
+}
+
+/**
+ * pspp_sheet_view_column_set_max_width:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @max_width: The maximum width of the column in pixels, or -1.
+ *
+ * Sets the maximum width of the @tree_column. If @max_width is -1, then the
+ * maximum width is unset. Note, the column can actually be wider than max
+ * width if it's the last column in a view. In this case, the column expands
to
+ * fill any extra space.
+ **/
+void
+pspp_sheet_view_column_set_max_width (PsppSheetViewColumn *tree_column,
+ gint max_width)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (max_width >= -1);
+
+ if (max_width == tree_column->max_width)
+ return;
+
+ if (tree_column->visible &&
+ tree_column->tree_view != NULL &&
+ gtk_widget_get_realized (tree_column->tree_view))
+ {
+ if (max_width != -1 && max_width < tree_column->width)
+ gtk_widget_queue_resize (tree_column->tree_view);
+ }
+
+ tree_column->max_width = max_width;
+ g_object_freeze_notify (G_OBJECT (tree_column));
+ if (max_width != -1 && max_width < tree_column->min_width)
+ {
+ tree_column->min_width = max_width;
+ g_object_notify (G_OBJECT (tree_column), "min-width");
+ }
+ g_object_notify (G_OBJECT (tree_column), "max-width");
+ g_object_thaw_notify (G_OBJECT (tree_column));
+
+ if (tree_column->column_type == PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ _pspp_sheet_view_column_autosize (PSPP_SHEET_VIEW (tree_column->tree_view),
+ tree_column);
+}
+
+/**
+ * pspp_sheet_view_column_get_max_width:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns the maximum width in pixels of the @tree_column, or -1 if no maximum
+ * width is set.
+ *
+ * Return value: The maximum width of the @tree_column.
+ **/
+gint
+pspp_sheet_view_column_get_max_width (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), -1);
+
+ return tree_column->max_width;
+}
+
+/**
+ * pspp_sheet_view_column_clicked:
+ * @tree_column: a #PsppSheetViewColumn
+ *
+ * Emits the "clicked" signal on the column. This function will only work if
+ * @tree_column is clickable.
+ **/
+void
+pspp_sheet_view_column_clicked (PsppSheetViewColumn *tree_column)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ if (tree_column->visible &&
+ tree_column->button &&
+ tree_column->clickable)
+ gtk_button_clicked (GTK_BUTTON (tree_column->button));
+}
+
+/**
+ * pspp_sheet_view_column_set_title:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @title: The title of the @tree_column.
+ *
+ * Sets the title of the @tree_column. If a custom widget has been set, then
+ * this value is ignored.
+ **/
+void
+pspp_sheet_view_column_set_title (PsppSheetViewColumn *tree_column,
+ const gchar *title)
+{
+ gchar *new_title;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ new_title = g_strdup (title);
+ g_free (tree_column->title);
+ tree_column->title = new_title;
+
+ pspp_sheet_view_column_update_button (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "title");
+}
+
+/**
+ * pspp_sheet_view_column_get_title:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns the title of the widget.
+ *
+ * Return value: the title of the column. This string should not be
+ * modified or freed.
+ **/
+G_CONST_RETURN gchar *
+pspp_sheet_view_column_get_title (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), NULL);
+
+ return tree_column->title;
+}
+
+/**
+ * pspp_sheet_view_column_set_expand:
+ * @tree_column: A #PsppSheetViewColumn
+ * @expand: %TRUE if the column should take available extra space, %FALSE if
not
+ *
+ * Sets the column to take available extra space. This space is shared equally
+ * amongst all columns that have the expand set to %TRUE. If no column has
this
+ * option set, then the last column gets all extra space. By default, every
+ * column is created with this %FALSE.
+ *
+ * Since: 2.4
+ **/
+void
+pspp_sheet_view_column_set_expand (PsppSheetViewColumn *tree_column,
+ gboolean expand)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ expand = expand?TRUE:FALSE;
+ if (tree_column->expand == expand)
+ return;
+ tree_column->expand = expand;
+
+ if (tree_column->visible &&
+ tree_column->tree_view != NULL &&
+ gtk_widget_get_realized (tree_column->tree_view))
+ {
+ /* We want to continue using the original width of the
+ * column that includes additional space added by the user
+ * resizing the columns and possibly extra (expanded) space, which
+ * are not included in the resized width.
+ */
+ tree_column->use_resized_width = FALSE;
+
+ gtk_widget_queue_resize (tree_column->tree_view);
+ }
+
+ g_object_notify (G_OBJECT (tree_column), "expand");
+}
+
+/**
+ * pspp_sheet_view_column_get_expand:
+ * @tree_column: a #PsppSheetViewColumn
+ *
+ * Return %TRUE if the column expands to take any available space.
+ *
+ * Return value: %TRUE, if the column expands
+ *
+ * Since: 2.4
+ **/
+gboolean
+pspp_sheet_view_column_get_expand (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
+
+ return tree_column->expand;
+}
+
+/**
+ * pspp_sheet_view_column_set_clickable:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @clickable: %TRUE if the header is active.
+ *
+ * Sets the header to be active if @active is %TRUE. When the header is
active,
+ * then it can take keyboard focus, and can be clicked.
+ **/
+void
+pspp_sheet_view_column_set_clickable (PsppSheetViewColumn *tree_column,
+ gboolean clickable)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ clickable = !! clickable;
+ if (tree_column->clickable == clickable)
+ return;
+
+ tree_column->clickable = clickable;
+ pspp_sheet_view_column_update_button (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "clickable");
+}
+
+/**
+ * pspp_sheet_view_column_get_clickable:
+ * @tree_column: a #PsppSheetViewColumn
+ *
+ * Returns %TRUE if the user can click on the header for the column.
+ *
+ * Return value: %TRUE if user can click the column header.
+ **/
+gboolean
+pspp_sheet_view_column_get_clickable (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
+
+ return tree_column->clickable;
+}
+
+/**
+ * pspp_sheet_view_column_set_widget:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @widget: (allow-none): A child #GtkWidget, or %NULL.
+ *
+ * Sets the widget in the header to be @widget. If widget is %NULL, then the
+ * header button is set with a #GtkLabel set to the title of @tree_column.
+ **/
+void
+pspp_sheet_view_column_set_widget (PsppSheetViewColumn *tree_column,
+ GtkWidget *widget)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));
+
+ if (widget)
+ g_object_ref_sink (widget);
+
+ if (tree_column->child)
+ g_object_unref (tree_column->child);
+
+ tree_column->child = widget;
+ pspp_sheet_view_column_update_button (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "widget");
+}
+
+/**
+ * pspp_sheet_view_column_get_widget:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns the #GtkWidget in the button on the column header. If a custom
+ * widget has not been set then %NULL is returned.
+ *
+ * Return value: The #GtkWidget in the column header, or %NULL
+ **/
+GtkWidget *
+pspp_sheet_view_column_get_widget (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), NULL);
+
+ return tree_column->child;
+}
+
+/**
+ * pspp_sheet_view_column_set_alignment:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @xalign: The alignment, which is between [0.0 and 1.0] inclusive.
+ *
+ * Sets the alignment of the title or custom widget inside the column header.
+ * The alignment determines its location inside the button -- 0.0 for left, 0.5
+ * for center, 1.0 for right.
+ **/
+void
+pspp_sheet_view_column_set_alignment (PsppSheetViewColumn *tree_column,
+ gfloat xalign)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ xalign = CLAMP (xalign, 0.0, 1.0);
+
+ if (tree_column->xalign == xalign)
+ return;
+
+ tree_column->xalign = xalign;
+ pspp_sheet_view_column_update_button (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "alignment");
+}
+
+/**
+ * pspp_sheet_view_column_get_alignment:
+ * @tree_column: A #PsppSheetViewColumn.
+ *
+ * Returns the current x alignment of @tree_column. This value can range
+ * between 0.0 and 1.0.
+ *
+ * Return value: The current alignent of @tree_column.
+ **/
+gfloat
+pspp_sheet_view_column_get_alignment (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0.5);
+
+ return tree_column->xalign;
+}
+
+/**
+ * pspp_sheet_view_column_set_reorderable:
+ * @tree_column: A #PsppSheetViewColumn
+ * @reorderable: %TRUE, if the column can be reordered.
+ *
+ * If @reorderable is %TRUE, then the column can be reordered by the end user
+ * dragging the header.
+ **/
+void
+pspp_sheet_view_column_set_reorderable (PsppSheetViewColumn *tree_column,
+ gboolean reorderable)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ /* if (reorderable)
+ pspp_sheet_view_column_set_clickable (tree_column, TRUE);*/
+
+ if (tree_column->reorderable == (reorderable?TRUE:FALSE))
+ return;
+
+ tree_column->reorderable = (reorderable?TRUE:FALSE);
+ pspp_sheet_view_column_update_button (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "reorderable");
+}
+
+/**
+ * pspp_sheet_view_column_get_reorderable:
+ * @tree_column: A #PsppSheetViewColumn
+ *
+ * Returns %TRUE if the @tree_column can be reordered by the user.
+ *
+ * Return value: %TRUE if the @tree_column can be reordered by the user.
+ **/
+gboolean
+pspp_sheet_view_column_get_reorderable (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
+
+ return tree_column->reorderable;
+}
+
+
+/**
+ * pspp_sheet_view_column_set_sort_column_id:
+ * @tree_column: a #PsppSheetViewColumn
+ * @sort_column_id: The @sort_column_id of the model to sort on.
+ *
+ * Sets the logical @sort_column_id that this column sorts on when this column
+ * is selected for sorting. Doing so makes the column header clickable.
+ **/
+void
+pspp_sheet_view_column_set_sort_column_id (PsppSheetViewColumn *tree_column,
+ gint sort_column_id)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (sort_column_id >= -1);
+
+ if (tree_column->sort_column_id == sort_column_id)
+ return;
+
+ tree_column->sort_column_id = sort_column_id;
+
+ /* Handle unsetting the id */
+ if (sort_column_id == -1)
+ {
+ GtkTreeModel *model = pspp_sheet_view_get_model (PSPP_SHEET_VIEW
(tree_column->tree_view));
+
+ if (tree_column->sort_clicked_signal)
+ {
+ g_signal_handler_disconnect (tree_column,
tree_column->sort_clicked_signal);
+ tree_column->sort_clicked_signal = 0;
+ }
+
+ if (tree_column->sort_column_changed_signal)
+ {
+ g_signal_handler_disconnect (model,
tree_column->sort_column_changed_signal);
+ tree_column->sort_column_changed_signal = 0;
+ }
+
+ pspp_sheet_view_column_set_sort_order (tree_column, GTK_SORT_ASCENDING);
+ pspp_sheet_view_column_set_sort_indicator (tree_column, FALSE);
+ pspp_sheet_view_column_set_clickable (tree_column, FALSE);
+ g_object_notify (G_OBJECT (tree_column), "sort-column-id");
+ return;
+ }
+
+ pspp_sheet_view_column_set_clickable (tree_column, TRUE);
+
+ if (! tree_column->sort_clicked_signal)
+ tree_column->sort_clicked_signal = g_signal_connect (tree_column,
+ "clicked",
+ G_CALLBACK
(pspp_sheet_view_column_sort),
+ NULL);
+
+ pspp_sheet_view_column_setup_sort_column_id_callback (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "sort-column-id");
+}
+
+/**
+ * pspp_sheet_view_column_get_sort_column_id:
+ * @tree_column: a #PsppSheetViewColumn
+ *
+ * Gets the logical @sort_column_id that the model sorts on when this
+ * column is selected for sorting.
+ * See pspp_sheet_view_column_set_sort_column_id().
+ *
+ * Return value: the current @sort_column_id for this column, or -1 if
+ * this column can't be used for sorting.
+ **/
+gint
+pspp_sheet_view_column_get_sort_column_id (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
+
+ return tree_column->sort_column_id;
+}
+
+/**
+ * pspp_sheet_view_column_set_sort_indicator:
+ * @tree_column: a #PsppSheetViewColumn
+ * @setting: %TRUE to display an indicator that the column is sorted
+ *
+ * Call this function with a @setting of %TRUE to display an arrow in
+ * the header button indicating the column is sorted. Call
+ * pspp_sheet_view_column_set_sort_order() to change the direction of
+ * the arrow.
+ *
+ **/
+void
+pspp_sheet_view_column_set_sort_indicator (PsppSheetViewColumn
*tree_column,
+ gboolean setting)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ setting = setting != FALSE;
+
+ if (setting == tree_column->show_sort_indicator)
+ return;
+
+ tree_column->show_sort_indicator = setting;
+ pspp_sheet_view_column_update_button (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "sort-indicator");
+}
+
+/**
+ * pspp_sheet_view_column_get_sort_indicator:
+ * @tree_column: a #PsppSheetViewColumn
+ *
+ * Gets the value set by pspp_sheet_view_column_set_sort_indicator().
+ *
+ * Return value: whether the sort indicator arrow is displayed
+ **/
+gboolean
+pspp_sheet_view_column_get_sort_indicator (PsppSheetViewColumn
*tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
+
+ return tree_column->show_sort_indicator;
+}
+
+/**
+ * pspp_sheet_view_column_set_sort_order:
+ * @tree_column: a #PsppSheetViewColumn
+ * @order: sort order that the sort indicator should indicate
+ *
+ * Changes the appearance of the sort indicator.
+ *
+ * This <emphasis>does not</emphasis> actually sort the model. Use
+ * pspp_sheet_view_column_set_sort_column_id() if you want automatic sorting
+ * support. This function is primarily for custom sorting behavior, and should
+ * be used in conjunction with gtk_tree_sortable_set_sort_column() to do
+ * that. For custom models, the mechanism will vary.
+ *
+ * The sort indicator changes direction to indicate normal sort or reverse
sort.
+ * Note that you must have the sort indicator enabled to see anything when
+ * calling this function; see pspp_sheet_view_column_set_sort_indicator().
+ **/
+void
+pspp_sheet_view_column_set_sort_order (PsppSheetViewColumn
*tree_column,
+ GtkSortType order)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ if (order == tree_column->sort_order)
+ return;
+
+ tree_column->sort_order = order;
+ pspp_sheet_view_column_update_button (tree_column);
+ g_object_notify (G_OBJECT (tree_column), "sort-order");
+}
+
+/**
+ * pspp_sheet_view_column_get_sort_order:
+ * @tree_column: a #PsppSheetViewColumn
+ *
+ * Gets the value set by pspp_sheet_view_column_set_sort_order().
+ *
+ * Return value: the sort order the sort indicator is indicating
+ **/
+GtkSortType
+pspp_sheet_view_column_get_sort_order (PsppSheetViewColumn
*tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), 0);
+
+ return tree_column->sort_order;
+}
+
+/**
+ * pspp_sheet_view_column_cell_set_cell_data:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from.
+ * @iter: The #GtkTreeIter to to get the cell renderer's attributes from.
+ * @is_expander: %TRUE, if the row has children
+ * @is_expanded: %TRUE, if the row has visible children
+ *
+ * Sets the cell renderer based on the @tree_model and @iter. That is, for
+ * every attribute mapping in @tree_column, it will get a value from the set
+ * column on the @iter, and use that value to set the attribute on the cell
+ * renderer. This is used primarily by the #PsppSheetView.
+ **/
+void
+pspp_sheet_view_column_cell_set_cell_data (PsppSheetViewColumn *tree_column,
+ GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gboolean is_expander,
+ gboolean is_expanded)
+{
+ GSList *list;
+ GValue value = { 0, };
+ GList *cell_list;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ if (tree_model == NULL)
+ return;
+
+ for (cell_list = tree_column->cell_list; cell_list; cell_list =
cell_list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)
cell_list->data;
+ GObject *cell = (GObject *) info->cell;
+
+ list = info->attributes;
+
+ g_object_freeze_notify (cell);
+
+ if (info->cell->is_expander != is_expander)
+ g_object_set (cell, "is-expander", is_expander, NULL);
+
+ if (info->cell->is_expanded != is_expanded)
+ g_object_set (cell, "is-expanded", is_expanded, NULL);
+
+ while (list && list->next)
+ {
+ gtk_tree_model_get_value (tree_model, iter,
+ GPOINTER_TO_INT (list->next->data),
+ &value);
+ g_object_set_property (cell, (gchar *) list->data, &value);
+ g_value_unset (&value);
+ list = list->next->next;
+ }
+
+ if (info->func)
+ (* info->func) (tree_column, info->cell, tree_model, iter,
info->func_data);
+ g_object_thaw_notify (G_OBJECT (info->cell));
+ }
+
+}
+
+/**
+ * pspp_sheet_view_column_cell_get_size:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @cell_area: (allow-none): The area a cell in the column will be allocated,
or %NULL
+ * @x_offset: (allow-none): location to return x offset of a cell relative to
@cell_area, or %NULL
+ * @y_offset: (allow-none): location to return y offset of a cell relative to
@cell_area, or %NULL
+ * @width: (allow-none): location to return width needed to render a cell, or
%NULL
+ * @height: (allow-none): location to return height needed to render a cell,
or %NULL
+ *
+ * Obtains the width and height needed to render the column. This is used
+ * primarily by the #PsppSheetView.
+ **/
+void
+pspp_sheet_view_column_cell_get_size (PsppSheetViewColumn *tree_column,
+ const GdkRectangle *cell_area,
+ gint *x_offset,
+ gint *y_offset,
+ gint *width,
+ gint *height)
+{
+ GList *list;
+ gboolean first_cell = TRUE;
+ gint focus_line_width;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ if (height)
+ * height = 0;
+ if (width)
+ * width = 0;
+
+ gtk_widget_style_get (tree_column->tree_view, "focus-line-width",
&focus_line_width, NULL);
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)
list->data;
+ gboolean visible;
+ gint new_height = 0;
+ gint new_width = 0;
+ g_object_get (info->cell, "visible", &visible, NULL);
+
+ if (visible == FALSE)
+ continue;
+
+ if (first_cell == FALSE && width)
+ *width += tree_column->spacing;
+
+ gtk_cell_renderer_get_size (info->cell,
+ tree_column->tree_view,
+ cell_area,
+ x_offset,
+ y_offset,
+ &new_width,
+ &new_height);
+
+ if (height)
+ * height = MAX (*height, new_height + focus_line_width * 2);
+ info->requested_width = MAX (info->requested_width, new_width +
focus_line_width * 2);
+ if (width)
+ * width += info->requested_width;
+ first_cell = FALSE;
+ }
+}
+
+/* rendering, event handling and rendering focus are somewhat complicated, and
+ * quite a bit of code. Rather than duplicate them, we put them together to
+ * keep the code in one place.
+ *
+ * To better understand what's going on, check out
+ * docs/tree-column-sizing.png
+ */
+enum {
+ CELL_ACTION_RENDER,
+ CELL_ACTION_FOCUS,
+ CELL_ACTION_EVENT
+};
+
+static gboolean
+pspp_sheet_view_column_cell_process_action (PsppSheetViewColumn *tree_column,
+ GdkWindow *window,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ guint flags,
+ gint action,
+ const GdkRectangle *expose_area,
/* RENDER */
+ GdkRectangle *focus_rectangle,
/* FOCUS */
+ GtkCellEditable **editable_widget,
/* EVENT */
+ GdkEvent *event,
/* EVENT */
+ gchar *path_string)
/* EVENT */
+{
+ GList *list;
+ GdkRectangle real_cell_area;
+ GdkRectangle real_background_area;
+ GdkRectangle real_expose_area = *cell_area;
+ gint depth = 0;
+ gint expand_cell_count = 0;
+ gint full_requested_width = 0;
+ gint extra_space;
+ gint min_x, min_y, max_x, max_y;
+ gint focus_line_width;
+ gint special_cells;
+ gint horizontal_separator;
+ gboolean cursor_row = FALSE;
+ gboolean first_cell = TRUE;
+ gboolean rtl;
+ /* If we have rtl text, we need to transform our areas */
+ GdkRectangle rtl_cell_area;
+ GdkRectangle rtl_background_area;
+
+ min_x = G_MAXINT;
+ min_y = G_MAXINT;
+ max_x = 0;
+ max_y = 0;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_column->tree_view)) ==
GTK_TEXT_DIR_RTL);
+ special_cells = _pspp_sheet_view_column_count_special_cells (tree_column);
+
+ if (special_cells > 1 && action == CELL_ACTION_FOCUS)
+ {
+ PsppSheetViewColumnCellInfo *info = NULL;
+ gboolean found_has_focus = FALSE;
+
+ /* one should have focus */
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ info = list->data;
+ if (info && info->has_focus)
+ {
+ found_has_focus = TRUE;
+ break;
+ }
+ }
+
+ if (!found_has_focus)
+ {
+ /* give the first one focus */
+ info = pspp_sheet_view_column_cell_first (tree_column)->data;
+ info->has_focus = TRUE;
+ }
+ }
+
+ cursor_row = flags & GTK_CELL_RENDERER_FOCUSED;
+
+ gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view),
+ "focus-line-width", &focus_line_width,
+ "horizontal-separator", &horizontal_separator,
+ NULL);
+
+ real_cell_area = *cell_area;
+ real_background_area = *background_area;
+
+
+ real_cell_area.x += focus_line_width;
+ real_cell_area.y += focus_line_width;
+ real_cell_area.height -= 2 * focus_line_width;
+
+ if (rtl)
+ depth = real_background_area.width - real_cell_area.width;
+ else
+ depth = real_cell_area.x - real_background_area.x;
+
+ /* Find out how much extra space we have to allocate */
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo
*)list->data;
+
+ if (! info->cell->visible)
+ continue;
+
+ if (info->expand == TRUE)
+ expand_cell_count ++;
+ full_requested_width += info->requested_width;
+
+ if (!first_cell)
+ full_requested_width += tree_column->spacing;
+
+ first_cell = FALSE;
+ }
+
+ extra_space = cell_area->width - full_requested_width;
+ if (extra_space < 0)
+ extra_space = 0;
+ else if (extra_space > 0 && expand_cell_count > 0)
+ extra_space /= expand_cell_count;
+
+ /* iterate list for GTK_PACK_START cells */
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)
list->data;
+
+ if (info->pack == GTK_PACK_END)
+ continue;
+
+ if (! info->cell->visible)
+ continue;
+
+ if ((info->has_focus || special_cells == 1) && cursor_row)
+ flags |= GTK_CELL_RENDERER_FOCUSED;
+ else
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+
+ info->real_width = info->requested_width + (info->expand?extra_space:0);
+
+ /* We constrain ourselves to only the width available */
+ if (real_cell_area.x - focus_line_width + info->real_width >
cell_area->x + cell_area->width)
+ {
+ info->real_width = cell_area->x + cell_area->width - real_cell_area.x;
+ }
+
+ if (real_cell_area.x > cell_area->x + cell_area->width)
+ break;
+
+ real_cell_area.width = info->real_width;
+ real_cell_area.width -= 2 * focus_line_width;
+
+ if (list->next)
+ {
+ real_background_area.width = info->real_width + depth;
+ }
+ else
+ {
+ /* fill the rest of background for the last cell */
+ real_background_area.width = background_area->x +
background_area->width - real_background_area.x;
+ }
+
+ rtl_cell_area = real_cell_area;
+ rtl_background_area = real_background_area;
+
+ if (rtl)
+ {
+ rtl_cell_area.x = cell_area->x + cell_area->width - (real_cell_area.x
- cell_area->x) - real_cell_area.width;
+ rtl_background_area.x = background_area->x + background_area->width -
(real_background_area.x - background_area->x) - real_background_area.width;
+ }
+
+ /* RENDER */
+ if (action == CELL_ACTION_RENDER)
+ {
+ gtk_cell_renderer_render (info->cell,
+ window,
+ tree_column->tree_view,
+ &rtl_background_area,
+ &rtl_cell_area,
+ &real_expose_area,
+ flags);
+ }
+ /* FOCUS */
+ else if (action == CELL_ACTION_FOCUS)
+ {
+ gint x_offset, y_offset, width, height;
+
+ gtk_cell_renderer_get_size (info->cell,
+ tree_column->tree_view,
+ &rtl_cell_area,
+ &x_offset, &y_offset,
+ &width, &height);
+
+ if (special_cells > 1)
+ {
+ if (info->has_focus)
+ {
+ min_x = rtl_cell_area.x + x_offset;
+ max_x = min_x + width;
+ min_y = rtl_cell_area.y + y_offset;
+ max_y = min_y + height;
+ }
+ }
+ else
+ {
+ if (min_x > (rtl_cell_area.x + x_offset))
+ min_x = rtl_cell_area.x + x_offset;
+ if (max_x < rtl_cell_area.x + x_offset + width)
+ max_x = rtl_cell_area.x + x_offset + width;
+ if (min_y > (rtl_cell_area.y + y_offset))
+ min_y = rtl_cell_area.y + y_offset;
+ if (max_y < rtl_cell_area.y + y_offset + height)
+ max_y = rtl_cell_area.y + y_offset + height;
+ }
+ }
+ /* EVENT */
+ else if (action == CELL_ACTION_EVENT)
+ {
+ gboolean try_event = FALSE;
+
+ if (event)
+ {
+ if (special_cells == 1)
+ {
+ /* only 1 activatable cell -> whole column can activate */
+ if (cell_area->x <= ((GdkEventButton *)event)->x &&
+ cell_area->x + cell_area->width > ((GdkEventButton
*)event)->x)
+ try_event = TRUE;
+ }
+ else if (rtl_cell_area.x <= ((GdkEventButton *)event)->x &&
+ rtl_cell_area.x + rtl_cell_area.width > ((GdkEventButton
*)event)->x)
+ /* only activate cell if the user clicked on an individual
+ * cell
+ */
+ try_event = TRUE;
+ }
+ else if (special_cells > 1 && info->has_focus)
+ try_event = TRUE;
+ else if (special_cells == 1)
+ try_event = TRUE;
+
+ if (try_event)
+ {
+ gboolean visible, mode;
+
+ g_object_get (info->cell,
+ "visible", &visible,
+ "mode", &mode,
+ NULL);
+ if (visible && mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
+ {
+ if (gtk_cell_renderer_activate (info->cell,
+ event,
+ tree_column->tree_view,
+ path_string,
+ &rtl_background_area,
+ &rtl_cell_area,
+ flags))
+ {
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+ return TRUE;
+ }
+ }
+ else if (visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE)
+ {
+ *editable_widget =
+ gtk_cell_renderer_start_editing (info->cell,
+ event,
+ tree_column->tree_view,
+ path_string,
+ &rtl_background_area,
+ &rtl_cell_area,
+ flags);
+
+ if (*editable_widget != NULL)
+ {
+ g_return_val_if_fail (GTK_IS_CELL_EDITABLE
(*editable_widget), FALSE);
+ info->in_editing_mode = TRUE;
+ pspp_sheet_view_column_focus_cell (tree_column,
info->cell);
+
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+
+ return TRUE;
+ }
+ }
+ }
+ }
+
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+
+ real_cell_area.x += (real_cell_area.width + 2 * focus_line_width +
tree_column->spacing);
+ real_background_area.x += real_background_area.width +
tree_column->spacing;
+
+ /* Only needed for first cell */
+ depth = 0;
+ }
+
+ /* iterate list for PACK_END cells */
+ for (list = g_list_last (tree_column->cell_list); list; list = list->prev)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)
list->data;
+
+ if (info->pack == GTK_PACK_START)
+ continue;
+
+ if (! info->cell->visible)
+ continue;
+
+ if ((info->has_focus || special_cells == 1) && cursor_row)
+ flags |= GTK_CELL_RENDERER_FOCUSED;
+ else
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+
+ info->real_width = info->requested_width + (info->expand?extra_space:0);
+
+ /* We constrain ourselves to only the width available */
+ if (real_cell_area.x - focus_line_width + info->real_width >
cell_area->x + cell_area->width)
+ {
+ info->real_width = cell_area->x + cell_area->width - real_cell_area.x;
+ }
+
+ if (real_cell_area.x > cell_area->x + cell_area->width)
+ break;
+
+ real_cell_area.width = info->real_width;
+ real_cell_area.width -= 2 * focus_line_width;
+ real_background_area.width = info->real_width + depth;
+
+ rtl_cell_area = real_cell_area;
+ rtl_background_area = real_background_area;
+ if (rtl)
+ {
+ rtl_cell_area.x = cell_area->x + cell_area->width - (real_cell_area.x
- cell_area->x) - real_cell_area.width;
+ rtl_background_area.x = background_area->x + background_area->width -
(real_background_area.x - background_area->x) - real_background_area.width;
+ }
+
+ /* RENDER */
+ if (action == CELL_ACTION_RENDER)
+ {
+ gtk_cell_renderer_render (info->cell,
+ window,
+ tree_column->tree_view,
+ &rtl_background_area,
+ &rtl_cell_area,
+ &real_expose_area,
+ flags);
+ }
+ /* FOCUS */
+ else if (action == CELL_ACTION_FOCUS)
+ {
+ gint x_offset, y_offset, width, height;
+
+ gtk_cell_renderer_get_size (info->cell,
+ tree_column->tree_view,
+ &rtl_cell_area,
+ &x_offset, &y_offset,
+ &width, &height);
+
+ if (special_cells > 1)
+ {
+ if (info->has_focus)
+ {
+ min_x = rtl_cell_area.x + x_offset;
+ max_x = min_x + width;
+ min_y = rtl_cell_area.y + y_offset;
+ max_y = min_y + height;
+ }
+ }
+ else
+ {
+ if (min_x > (rtl_cell_area.x + x_offset))
+ min_x = rtl_cell_area.x + x_offset;
+ if (max_x < rtl_cell_area.x + x_offset + width)
+ max_x = rtl_cell_area.x + x_offset + width;
+ if (min_y > (rtl_cell_area.y + y_offset))
+ min_y = rtl_cell_area.y + y_offset;
+ if (max_y < rtl_cell_area.y + y_offset + height)
+ max_y = rtl_cell_area.y + y_offset + height;
+ }
+ }
+ /* EVENT */
+ else if (action == CELL_ACTION_EVENT)
+ {
+ gboolean try_event = FALSE;
+
+ if (event)
+ {
+ if (special_cells == 1)
+ {
+ /* only 1 activatable cell -> whole column can activate */
+ if (cell_area->x <= ((GdkEventButton *)event)->x &&
+ cell_area->x + cell_area->width > ((GdkEventButton
*)event)->x)
+ try_event = TRUE;
+ }
+ else if (rtl_cell_area.x <= ((GdkEventButton *)event)->x &&
+ rtl_cell_area.x + rtl_cell_area.width > ((GdkEventButton
*)event)->x)
+ /* only activate cell if the user clicked on an individual
+ * cell
+ */
+ try_event = TRUE;
+ }
+ else if (special_cells > 1 && info->has_focus)
+ try_event = TRUE;
+ else if (special_cells == 1)
+ try_event = TRUE;
+
+ if (try_event)
+ {
+ gboolean visible, mode;
+
+ g_object_get (info->cell,
+ "visible", &visible,
+ "mode", &mode,
+ NULL);
+ if (visible && mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
+ {
+ if (gtk_cell_renderer_activate (info->cell,
+ event,
+ tree_column->tree_view,
+ path_string,
+ &rtl_background_area,
+ &rtl_cell_area,
+ flags))
+ {
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+ return TRUE;
+ }
+ }
+ else if (visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE)
+ {
+ *editable_widget =
+ gtk_cell_renderer_start_editing (info->cell,
+ event,
+ tree_column->tree_view,
+ path_string,
+ &rtl_background_area,
+ &rtl_cell_area,
+ flags);
+
+ if (*editable_widget != NULL)
+ {
+ g_return_val_if_fail (GTK_IS_CELL_EDITABLE
(*editable_widget), FALSE);
+ info->in_editing_mode = TRUE;
+ pspp_sheet_view_column_focus_cell (tree_column,
info->cell);
+
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+ return TRUE;
+ }
+ }
+ }
+ }
+
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+
+ real_cell_area.x += (real_cell_area.width + 2 * focus_line_width +
tree_column->spacing);
+ real_background_area.x += (real_background_area.width +
tree_column->spacing);
+
+ /* Only needed for first cell */
+ depth = 0;
+ }
+
+ /* fill focus_rectangle when required */
+ if (action == CELL_ACTION_FOCUS)
+ {
+ if (min_x >= max_x || min_y >= max_y)
+ {
+ *focus_rectangle = *cell_area;
+ /* don't change the focus_rectangle, just draw it nicely inside
+ * the cell area */
+ }
+ else
+ {
+ focus_rectangle->x = min_x - focus_line_width;
+ focus_rectangle->y = min_y - focus_line_width;
+ focus_rectangle->width = (max_x - min_x) + 2 * focus_line_width;
+ focus_rectangle->height = (max_y - min_y) + 2 * focus_line_width;
+ }
+ }
+
+ return FALSE;
+}
+
+/**
+ * pspp_sheet_view_column_cell_render:
+ * @tree_column: A #PsppSheetViewColumn.
+ * @window: a #GdkDrawable to draw to
+ * @background_area: entire cell area (including tree expanders and maybe
padding on the sides)
+ * @cell_area: area normally rendered by a cell renderer
+ * @expose_area: area that actually needs updating
+ * @flags: flags that affect rendering
+ *
+ * Renders the cell contained by #tree_column. This is used primarily by the
+ * #PsppSheetView.
+ **/
+void
+_pspp_sheet_view_column_cell_render (PsppSheetViewColumn *tree_column,
+ GdkWindow *window,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ const GdkRectangle *expose_area,
+ guint flags)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (background_area != NULL);
+ g_return_if_fail (cell_area != NULL);
+ g_return_if_fail (expose_area != NULL);
+
+ pspp_sheet_view_column_cell_process_action (tree_column,
+ window,
+ background_area,
+ cell_area,
+ flags,
+ CELL_ACTION_RENDER,
+ expose_area,
+ NULL, NULL, NULL, NULL);
+}
+
+gboolean
+_pspp_sheet_view_column_cell_event (PsppSheetViewColumn *tree_column,
+ GtkCellEditable **editable_widget,
+ GdkEvent *event,
+ gchar *path_string,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ guint flags)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
+
+ return pspp_sheet_view_column_cell_process_action (tree_column,
+ NULL,
+ background_area,
+ cell_area,
+ flags,
+ CELL_ACTION_EVENT,
+ NULL, NULL,
+ editable_widget,
+ event,
+ path_string);
+}
+
+void
+_pspp_sheet_view_column_get_focus_area (PsppSheetViewColumn *tree_column,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ GdkRectangle *focus_area)
+{
+ pspp_sheet_view_column_cell_process_action (tree_column,
+ NULL,
+ background_area,
+ cell_area,
+ 0,
+ CELL_ACTION_FOCUS,
+ NULL,
+ focus_area,
+ NULL, NULL, NULL);
+}
+
+
+/* cell list manipulation */
+static GList *
+pspp_sheet_view_column_cell_first (PsppSheetViewColumn *tree_column)
+{
+ GList *list = tree_column->cell_list;
+
+ /* first GTK_PACK_START cell we find */
+ for ( ; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = list->data;
+ if (info->pack == GTK_PACK_START)
+ return list;
+ }
+
+ /* hmm, else the *last* GTK_PACK_END cell */
+ list = g_list_last (tree_column->cell_list);
+
+ for ( ; list; list = list->prev)
+ {
+ PsppSheetViewColumnCellInfo *info = list->data;
+ if (info->pack == GTK_PACK_END)
+ return list;
+ }
+
+ return NULL;
+}
+
+static GList *
+pspp_sheet_view_column_cell_last (PsppSheetViewColumn *tree_column)
+{
+ GList *list = tree_column->cell_list;
+
+ /* *first* GTK_PACK_END cell we find */
+ for ( ; list ; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = list->data;
+ if (info->pack == GTK_PACK_END)
+ return list;
+ }
+
+ /* hmm, else the last GTK_PACK_START cell */
+ list = g_list_last (tree_column->cell_list);
+
+ for ( ; list; list = list->prev)
+ {
+ PsppSheetViewColumnCellInfo *info = list->data;
+ if (info->pack == GTK_PACK_START)
+ return list;
+ }
+
+ return NULL;
+}
+
+static GList *
+pspp_sheet_view_column_cell_next (PsppSheetViewColumn *tree_column,
+ GList *current)
+{
+ GList *list;
+ PsppSheetViewColumnCellInfo *info = current->data;
+
+ if (info->pack == GTK_PACK_START)
+ {
+ for (list = current->next; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *inf = list->data;
+ if (inf->pack == GTK_PACK_START)
+ return list;
+ }
+
+ /* out of GTK_PACK_START cells, get *last* GTK_PACK_END one */
+ list = g_list_last (tree_column->cell_list);
+ for (; list; list = list->prev)
+ {
+ PsppSheetViewColumnCellInfo *inf = list->data;
+ if (inf->pack == GTK_PACK_END)
+ return list;
+ }
+ }
+
+ for (list = current->prev; list; list = list->prev)
+ {
+ PsppSheetViewColumnCellInfo *inf = list->data;
+ if (inf->pack == GTK_PACK_END)
+ return list;
+ }
+
+ return NULL;
+}
+
+static GList *
+pspp_sheet_view_column_cell_prev (PsppSheetViewColumn *tree_column,
+ GList *current)
+{
+ GList *list;
+ PsppSheetViewColumnCellInfo *info = current->data;
+
+ if (info->pack == GTK_PACK_END)
+ {
+ for (list = current->next; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *inf = list->data;
+ if (inf->pack == GTK_PACK_END)
+ return list;
+ }
+
+ /* out of GTK_PACK_END, get last GTK_PACK_START one */
+ list = g_list_last (tree_column->cell_list);
+ for ( ; list; list = list->prev)
+ {
+ PsppSheetViewColumnCellInfo *inf = list->data;
+ if (inf->pack == GTK_PACK_START)
+ return list;
+ }
+ }
+
+ for (list = current->prev; list; list = list->prev)
+ {
+ PsppSheetViewColumnCellInfo *inf = list->data;
+ if (inf->pack == GTK_PACK_START)
+ return list;
+ }
+
+ return NULL;
+}
+
+gboolean
+_pspp_sheet_view_column_cell_focus (PsppSheetViewColumn *tree_column,
+ gint direction,
+ gboolean left,
+ gboolean right)
+{
+ gint count;
+ gboolean rtl;
+
+ count = _pspp_sheet_view_column_count_special_cells (tree_column);
+ rtl = gtk_widget_get_direction (GTK_WIDGET (tree_column->tree_view)) ==
GTK_TEXT_DIR_RTL;
+
+ /* if we are the current focus column and have multiple editable cells,
+ * try to select the next one, else move the focus to the next column
+ */
+ if (PSPP_SHEET_VIEW (tree_column->tree_view)->priv->focus_column ==
tree_column)
+ {
+ if (count > 1)
+ {
+ GList *next, *prev;
+ GList *list = tree_column->cell_list;
+ PsppSheetViewColumnCellInfo *info = NULL;
+
+ /* find current focussed cell */
+ for ( ; list; list = list->next)
+ {
+ info = list->data;
+ if (info->has_focus)
+ break;
+ }
+
+ /* not a focussed cell in the focus column? */
+ if (!list || !info || !info->has_focus)
+ return FALSE;
+
+ if (rtl)
+ {
+ prev = pspp_sheet_view_column_cell_next (tree_column, list);
+ next = pspp_sheet_view_column_cell_prev (tree_column, list);
+ }
+ else
+ {
+ next = pspp_sheet_view_column_cell_next (tree_column, list);
+ prev = pspp_sheet_view_column_cell_prev (tree_column, list);
+ }
+
+ info->has_focus = FALSE;
+ if (direction > 0 && next)
+ {
+ info = next->data;
+ info->has_focus = TRUE;
+ return TRUE;
+ }
+ else if (direction > 0 && !next && !right)
+ {
+ /* keep focus on last cell */
+ if (rtl)
+ info = pspp_sheet_view_column_cell_first (tree_column)->data;
+ else
+ info = pspp_sheet_view_column_cell_last (tree_column)->data;
+
+ info->has_focus = TRUE;
+ return TRUE;
+ }
+ else if (direction < 0 && prev)
+ {
+ info = prev->data;
+ info->has_focus = TRUE;
+ return TRUE;
+ }
+ else if (direction < 0 && !prev && !left)
+ {
+ /* keep focus on first cell */
+ if (rtl)
+ info = pspp_sheet_view_column_cell_last (tree_column)->data;
+ else
+ info = pspp_sheet_view_column_cell_first (tree_column)->data;
+
+ info->has_focus = TRUE;
+ return TRUE;
+ }
+ }
+ return FALSE;
+ }
+
+ /* we get focus, if we have multiple editable cells, give the correct one
+ * focus
+ */
+ if (count > 1)
+ {
+ GList *list = tree_column->cell_list;
+
+ /* clear focus first */
+ for ( ; list ; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = list->data;
+ if (info->has_focus)
+ info->has_focus = FALSE;
+ }
+
+ list = NULL;
+ if (rtl)
+ {
+ if (direction > 0)
+ list = pspp_sheet_view_column_cell_last (tree_column);
+ else if (direction < 0)
+ list = pspp_sheet_view_column_cell_first (tree_column);
+ }
+ else
+ {
+ if (direction > 0)
+ list = pspp_sheet_view_column_cell_first (tree_column);
+ else if (direction < 0)
+ list = pspp_sheet_view_column_cell_last (tree_column);
+ }
+
+ if (list)
+ ((PsppSheetViewColumnCellInfo *) list->data)->has_focus = TRUE;
+ }
+
+ return TRUE;
+}
+
+void
+_pspp_sheet_view_column_cell_draw_focus (PsppSheetViewColumn *tree_column,
+ GdkWindow *window,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ const GdkRectangle *expose_area,
+ guint flags)
+{
+ gint focus_line_width;
+ GtkStateType cell_state;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view),
+ "focus-line-width", &focus_line_width, NULL);
+ if (tree_column->editable_widget)
+ {
+ /* This function is only called on the editable row when editing.
+ */
+#if 0
+ gtk_paint_focus (tree_column->tree_view->style,
+ window,
+ gtk_widget_get_state (tree_column->tree_view),
+ NULL,
+ tree_column->tree_view,
+ "treeview",
+ cell_area->x - focus_line_width,
+ cell_area->y - focus_line_width,
+ cell_area->width + 2 * focus_line_width,
+ cell_area->height + 2 * focus_line_width);
+#endif
+ }
+ else
+ {
+ GdkRectangle focus_rectangle;
+ pspp_sheet_view_column_cell_process_action (tree_column,
+ window,
+ background_area,
+ cell_area,
+ flags,
+ CELL_ACTION_FOCUS,
+ expose_area,
+ &focus_rectangle,
+ NULL, NULL, NULL);
+
+ cell_state = flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
+ (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
+ (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
GTK_STATE_NORMAL));
+ gtk_paint_focus (tree_column->tree_view->style,
+ window,
+ cell_state,
+ cell_area,
+ tree_column->tree_view,
+ "treeview",
+ focus_rectangle.x,
+ focus_rectangle.y,
+ focus_rectangle.width,
+ focus_rectangle.height);
+ }
+}
+
+/**
+ * pspp_sheet_view_column_cell_is_visible:
+ * @tree_column: A #PsppSheetViewColumn
+ *
+ * Returns %TRUE if any of the cells packed into the @tree_column are visible.
+ * For this to be meaningful, you must first initialize the cells with
+ * pspp_sheet_view_column_cell_set_cell_data()
+ *
+ * Return value: %TRUE, if any of the cells packed into the @tree_column are
currently visible
+ **/
+gboolean
+pspp_sheet_view_column_cell_is_visible (PsppSheetViewColumn *tree_column)
+{
+ GList *list;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), FALSE);
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)
list->data;
+
+ if (info->cell->visible)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/**
+ * pspp_sheet_view_column_focus_cell:
+ * @tree_column: A #PsppSheetViewColumn
+ * @cell: A #GtkCellRenderer
+ *
+ * Sets the current keyboard focus to be at @cell, if the column contains
+ * 2 or more editable and activatable cells.
+ *
+ * Since: 2.2
+ **/
+void
+pspp_sheet_view_column_focus_cell (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell)
+{
+ GList *list;
+ gboolean found_cell = FALSE;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+ g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
+
+ if (_pspp_sheet_view_column_count_special_cells (tree_column) < 2)
+ return;
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = list->data;
+
+ if (info->cell == cell)
+ {
+ info->has_focus = TRUE;
+ found_cell = TRUE;
+ break;
+ }
+ }
+
+ if (found_cell)
+ {
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = list->data;
+
+ if (info->cell != cell)
+ info->has_focus = FALSE;
+ }
+
+ /* FIXME: redraw? */
+ }
+}
+
+void
+_pspp_sheet_view_column_cell_set_dirty (PsppSheetViewColumn *tree_column,
+ gboolean install_handler)
+{
+ GList *list;
+
+ for (list = tree_column->cell_list; list; list = list->next)
+ {
+ PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)
list->data;
+
+ info->requested_width = 0;
+ }
+ tree_column->dirty = TRUE;
+ tree_column->requested_width = -1;
+ tree_column->width = 0;
+
+ if (tree_column->tree_view &&
+ gtk_widget_get_realized (tree_column->tree_view))
+ {
+ if (install_handler)
+ _pspp_sheet_view_install_mark_rows_col_dirty (PSPP_SHEET_VIEW
(tree_column->tree_view));
+ else
+ PSPP_SHEET_VIEW (tree_column->tree_view)->priv->mark_rows_col_dirty =
TRUE;
+ gtk_widget_queue_resize (tree_column->tree_view);
+ }
+}
+
+void
+_pspp_sheet_view_column_start_editing (PsppSheetViewColumn *tree_column,
+ GtkCellEditable *cell_editable)
+{
+ g_return_if_fail (tree_column->editable_widget == NULL);
+
+ tree_column->editable_widget = cell_editable;
+}
+
+void
+_pspp_sheet_view_column_stop_editing (PsppSheetViewColumn *tree_column)
+{
+ GList *list;
+
+ g_return_if_fail (tree_column->editable_widget != NULL);
+
+ tree_column->editable_widget = NULL;
+ for (list = tree_column->cell_list; list; list = list->next)
+ ((PsppSheetViewColumnCellInfo *)list->data)->in_editing_mode = FALSE;
+}
+
+void
+_pspp_sheet_view_column_get_neighbor_sizes (PsppSheetViewColumn *column,
+ GtkCellRenderer *cell,
+ gint *left,
+ gint *right)
+{
+ GList *list;
+ PsppSheetViewColumnCellInfo *info;
+ gint l, r;
+ gboolean rtl;
+
+ l = r = 0;
+
+ list = pspp_sheet_view_column_cell_first (column);
+
+ while (list)
+ {
+ info = (PsppSheetViewColumnCellInfo *)list->data;
+
+ list = pspp_sheet_view_column_cell_next (column, list);
+
+ if (info->cell == cell)
+ break;
+
+ if (info->cell->visible)
+ l += info->real_width + column->spacing;
+ }
+
+ while (list)
+ {
+ info = (PsppSheetViewColumnCellInfo *)list->data;
+
+ list = pspp_sheet_view_column_cell_next (column, list);
+
+ if (info->cell->visible)
+ r += info->real_width + column->spacing;
+ }
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (column->tree_view)) ==
GTK_TEXT_DIR_RTL);
+ if (left)
+ *left = rtl ? r : l;
+
+ if (right)
+ *right = rtl ? l : r;
+}
+
+/**
+ * pspp_sheet_view_column_cell_get_position:
+ * @tree_column: a #PsppSheetViewColumn
+ * @cell_renderer: a #GtkCellRenderer
+ * @start_pos: return location for the horizontal position of @cell within
+ * @tree_column, may be %NULL
+ * @width: return location for the width of @cell, may be %NULL
+ *
+ * Obtains the horizontal position and size of a cell in a column. If the
+ * cell is not found in the column, @start_pos and @width are not changed and
+ * %FALSE is returned.
+ *
+ * Return value: %TRUE if @cell belongs to @tree_column.
+ */
+gboolean
+pspp_sheet_view_column_cell_get_position (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell_renderer,
+ gint *start_pos,
+ gint *width)
+{
+ GList *list;
+ gint current_x = 0;
+ gboolean found_cell = FALSE;
+ PsppSheetViewColumnCellInfo *cellinfo = NULL;
+
+ list = pspp_sheet_view_column_cell_first (tree_column);
+ for (; list; list = pspp_sheet_view_column_cell_next (tree_column, list))
+ {
+ cellinfo = list->data;
+ if (cellinfo->cell == cell_renderer)
+ {
+ found_cell = TRUE;
+ break;
+ }
+
+ if (cellinfo->cell->visible)
+ current_x += cellinfo->real_width;
+ }
+
+ if (found_cell)
+ {
+ if (start_pos)
+ *start_pos = current_x;
+ if (width)
+ *width = cellinfo->real_width;
+ }
+
+ return found_cell;
+}
+
+/**
+ * pspp_sheet_view_column_queue_resize:
+ * @tree_column: A #PsppSheetViewColumn
+ *
+ * Flags the column, and the cell renderers added to this column, to have
+ * their sizes renegotiated.
+ *
+ * Since: 2.8
+ **/
+void
+pspp_sheet_view_column_queue_resize (PsppSheetViewColumn *tree_column)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
+
+ if (tree_column->tree_view)
+ _pspp_sheet_view_column_cell_set_dirty (tree_column, TRUE);
+}
+
+/**
+ * pspp_sheet_view_column_get_tree_view:
+ * @tree_column: A #PsppSheetViewColumn
+ *
+ * Returns the #PsppSheetView wherein @tree_column has been inserted. If
+ * @column is currently not inserted in any tree view, %NULL is
+ * returned.
+ *
+ * Return value: The tree view wherein @column has been inserted if any,
+ * %NULL otherwise.
+ *
+ * Since: 2.12
+ */
+GtkWidget *
+pspp_sheet_view_column_get_tree_view (PsppSheetViewColumn *tree_column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column), NULL);
+
+ return tree_column->tree_view;
+}
+
+typedef struct {
+ GtkCellLayout *cell_layout;
+ GtkCellRenderer *renderer;
+ gchar *attr_name;
+} AttributesSubParserData;
+
+static void
+attributes_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **names,
+ const gchar **values,
+ gpointer user_data,
+ GError **error)
+{
+ AttributesSubParserData *parser_data = (AttributesSubParserData*)user_data;
+ guint i;
+
+ if (strcmp (element_name, "attribute") == 0)
+ {
+ for (i = 0; names[i]; i++)
+ if (strcmp (names[i], "name") == 0)
+ parser_data->attr_name = g_strdup (values[i]);
+ }
+ else if (strcmp (element_name, "attributes") == 0)
+ return;
+ else
+ g_warning ("Unsupported tag for GtkCellLayout: %s\n", element_name);
+}
+
+static void
+attributes_text_element (GMarkupParseContext *context,
+ const gchar *text,
+ gsize text_len,
+ gpointer user_data,
+ GError **error)
+{
+ AttributesSubParserData *parser_data = (AttributesSubParserData*)user_data;
+ glong l;
+ gchar *endptr;
+ gchar *string;
+
+ if (!parser_data->attr_name)
+ return;
+
+ errno = 0;
+ string = g_strndup (text, text_len);
+ l = strtol (string, &endptr, 0);
+ if (errno || endptr == string)
+ {
+ g_set_error (error,
+ GTK_BUILDER_ERROR,
+ GTK_BUILDER_ERROR_INVALID_VALUE,
+ "Could not parse integer `%s'",
+ string);
+ g_free (string);
+ return;
+ }
+ g_free (string);
+
+ gtk_cell_layout_add_attribute (parser_data->cell_layout,
+ parser_data->renderer,
+ parser_data->attr_name, l);
+ g_free (parser_data->attr_name);
+ parser_data->attr_name = NULL;
+}
+
+static const GMarkupParser attributes_parser =
+ {
+ attributes_start_element,
+ NULL,
+ attributes_text_element,
+ };
+
+gboolean
+_gtk_cell_layout_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data)
+{
+ AttributesSubParserData *parser_data;
+
+ if (!child)
+ return FALSE;
+
+ if (strcmp (tagname, "attributes") == 0)
+ {
+ parser_data = g_slice_new0 (AttributesSubParserData);
+ parser_data->cell_layout = GTK_CELL_LAYOUT (buildable);
+ parser_data->renderer = GTK_CELL_RENDERER (child);
+ parser_data->attr_name = NULL;
+
+ *parser = attributes_parser;
+ *data = parser_data;
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+void
+_gtk_cell_layout_buildable_custom_tag_end (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer *data)
+{
+ AttributesSubParserData *parser_data;
+
+ parser_data = (AttributesSubParserData*)data;
+ g_assert (!parser_data->attr_name);
+ g_slice_free (AttributesSubParserData, parser_data);
+}
+
+void
+_gtk_cell_layout_buildable_add_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *type)
+{
+ GtkCellLayoutIface *iface;
+
+ g_return_if_fail (GTK_IS_CELL_LAYOUT (buildable));
+ g_return_if_fail (GTK_IS_CELL_RENDERER (child));
+
+ iface = GTK_CELL_LAYOUT_GET_IFACE (buildable);
+ g_return_if_fail (iface->pack_start != NULL);
+ iface->pack_start (GTK_CELL_LAYOUT (buildable), GTK_CELL_RENDERER (child),
FALSE);
+}
+
+GType
+pspp_sheet_view_column_sizing_get_type (void)
+{
+ static GType etype = 0;
+ if (G_UNLIKELY(etype == 0)) {
+ static const GEnumValue values[] = {
+ { PSPP_SHEET_VIEW_COLUMN_GROW_ONLY,
"PSPP_SHEET_VIEW_COLUMN_GROW_ONLY", "grow-only" },
+ { PSPP_SHEET_VIEW_COLUMN_AUTOSIZE,
"PSPP_SHEET_VIEW_COLUMN_AUTOSIZE", "autosize" },
+ { PSPP_SHEET_VIEW_COLUMN_FIXED, "PSPP_SHEET_VIEW_COLUMN_FIXED",
"fixed" },
+ { 0, NULL, NULL }
+ };
+ etype = g_enum_register_static (g_intern_static_string
("PsppSheetViewColumnSizing"), values);
+ }
+ return etype;
+}
diff --git a/src/ui/gui/pspp-sheet-view-column.h
b/src/ui/gui/pspp-sheet-view-column.h
new file mode 100644
index 0000000..82c20e4
--- /dev/null
+++ b/src/ui/gui/pspp-sheet-view-column.h
@@ -0,0 +1,254 @@
+/* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2011 Free Software Foundation, Inc.
+
+ 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* gtktreeviewcolumn.h
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __PSPP_SHEET_VIEW_COLUMN_H__
+#define __PSPP_SHEET_VIEW_COLUMN_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+
+#define PSPP_TYPE_SHEET_VIEW_COLUMN (pspp_sheet_view_column_get_type
())
+#define PSPP_SHEET_VIEW_COLUMN(obj) (G_TYPE_CHECK_INSTANCE_CAST
((obj), PSPP_TYPE_SHEET_VIEW_COLUMN, PsppSheetViewColumn))
+#define PSPP_SHEET_VIEW_COLUMN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST
((klass), PSPP_TYPE_SHEET_VIEW_COLUMN, PsppSheetViewColumnClass))
+#define PSPP_IS_SHEET_VIEW_COLUMN(obj) (G_TYPE_CHECK_INSTANCE_TYPE
((obj), PSPP_TYPE_SHEET_VIEW_COLUMN))
+#define PSPP_IS_SHEET_VIEW_COLUMN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE
((klass), PSPP_TYPE_SHEET_VIEW_COLUMN))
+#define PSPP_SHEET_VIEW_COLUMN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS
((obj), PSPP_TYPE_SHEET_VIEW_COLUMN, PsppSheetViewColumnClass))
+
+typedef enum
+{
+ PSPP_SHEET_VIEW_COLUMN_GROW_ONLY,
+ PSPP_SHEET_VIEW_COLUMN_AUTOSIZE,
+ PSPP_SHEET_VIEW_COLUMN_FIXED
+} PsppSheetViewColumnSizing;
+
+GType pspp_sheet_view_column_sizing_get_type (void) G_GNUC_CONST;
+#define PSPP_TYPE_SHEET_VIEW_COLUMN_SIZING
(pspp_sheet_view_column_sizing_get_type ())
+
+typedef struct _PsppSheetViewColumn PsppSheetViewColumn;
+typedef struct _PsppSheetViewColumnClass PsppSheetViewColumnClass;
+
+typedef void (* PsppSheetCellDataFunc) (PsppSheetViewColumn *tree_column,
+ GtkCellRenderer *cell,
+ GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gpointer data);
+
+
+struct _PsppSheetViewColumn
+{
+ GtkObject parent;
+
+ GtkWidget *GSEAL (tree_view);
+ GtkWidget *GSEAL (button);
+ GtkWidget *GSEAL (child);
+ GtkWidget *GSEAL (arrow);
+ GtkWidget *GSEAL (alignment);
+ GdkWindow *GSEAL (window);
+ GtkCellEditable *GSEAL (editable_widget);
+ gfloat GSEAL (xalign);
+ guint GSEAL (property_changed_signal);
+ gint GSEAL (spacing);
+
+ /* Sizing fields */
+ /* see gtk+/doc/tree-column-sizing.txt for more information on them */
+ PsppSheetViewColumnSizing GSEAL (column_type);
+ gint GSEAL (requested_width);
+ gint GSEAL (button_request);
+ gint GSEAL (resized_width);
+ gint GSEAL (width);
+ gint GSEAL (fixed_width);
+ gint GSEAL (min_width);
+ gint GSEAL (max_width);
+
+ /* dragging columns */
+ gint GSEAL (drag_x);
+ gint GSEAL (drag_y);
+
+ gchar *GSEAL (title);
+ GList *GSEAL (cell_list);
+
+ /* Sorting */
+ guint GSEAL (sort_clicked_signal);
+ guint GSEAL (sort_column_changed_signal);
+ gint GSEAL (sort_column_id);
+ GtkSortType GSEAL (sort_order);
+
+ /* Flags */
+ guint GSEAL (visible) : 1;
+ guint GSEAL (resizable) : 1;
+ guint GSEAL (clickable) : 1;
+ guint GSEAL (dirty) : 1;
+ guint GSEAL (show_sort_indicator) : 1;
+ guint GSEAL (maybe_reordered) : 1;
+ guint GSEAL (reorderable) : 1;
+ guint GSEAL (use_resized_width) : 1;
+ guint GSEAL (expand) : 1;
+};
+
+struct _PsppSheetViewColumnClass
+{
+ GtkObjectClass parent_class;
+
+ void (*clicked) (PsppSheetViewColumn *tree_column);
+
+ /* Padding for future expansion */
+ void (*_gtk_reserved1) (void);
+ void (*_gtk_reserved2) (void);
+ void (*_gtk_reserved3) (void);
+ void (*_gtk_reserved4) (void);
+};
+
+GType pspp_sheet_view_column_get_type (void)
G_GNUC_CONST;
+PsppSheetViewColumn *pspp_sheet_view_column_new (void);
+PsppSheetViewColumn *pspp_sheet_view_column_new_with_attributes (const
gchar *title,
+
GtkCellRenderer *cell,
+ ...)
G_GNUC_NULL_TERMINATED;
+void pspp_sheet_view_column_pack_start
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell,
+ gboolean
expand);
+void pspp_sheet_view_column_pack_end
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell,
+ gboolean
expand);
+void pspp_sheet_view_column_clear
(PsppSheetViewColumn *tree_column);
+#ifndef GTK_DISABLE_DEPRECATED
+GList *pspp_sheet_view_column_get_cell_renderers
(PsppSheetViewColumn *tree_column);
+#endif
+void pspp_sheet_view_column_add_attribute
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell_renderer,
+ const gchar
*attribute,
+ gint
column);
+void pspp_sheet_view_column_set_attributes
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell_renderer,
+ ...)
G_GNUC_NULL_TERMINATED;
+void pspp_sheet_view_column_set_cell_data_func
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell_renderer,
+
PsppSheetCellDataFunc func,
+ gpointer
func_data,
+
GDestroyNotify destroy);
+void pspp_sheet_view_column_clear_attributes
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell_renderer);
+void pspp_sheet_view_column_set_spacing
(PsppSheetViewColumn *tree_column,
+ gint
spacing);
+gint pspp_sheet_view_column_get_spacing
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_visible
(PsppSheetViewColumn *tree_column,
+ gboolean
visible);
+gboolean pspp_sheet_view_column_get_visible
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_resizable
(PsppSheetViewColumn *tree_column,
+ gboolean
resizable);
+gboolean pspp_sheet_view_column_get_resizable
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_sizing
(PsppSheetViewColumn *tree_column,
+
PsppSheetViewColumnSizing type);
+PsppSheetViewColumnSizing pspp_sheet_view_column_get_sizing
(PsppSheetViewColumn *tree_column);
+gint pspp_sheet_view_column_get_width
(PsppSheetViewColumn *tree_column);
+gint pspp_sheet_view_column_get_fixed_width
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_fixed_width
(PsppSheetViewColumn *tree_column,
+ gint
fixed_width);
+void pspp_sheet_view_column_set_min_width
(PsppSheetViewColumn *tree_column,
+ gint
min_width);
+gint pspp_sheet_view_column_get_min_width
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_max_width
(PsppSheetViewColumn *tree_column,
+ gint
max_width);
+gint pspp_sheet_view_column_get_max_width
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_clicked
(PsppSheetViewColumn *tree_column);
+
+
+
+/* Options for manipulating the column headers
+ */
+void pspp_sheet_view_column_set_title
(PsppSheetViewColumn *tree_column,
+ const gchar
*title);
+G_CONST_RETURN gchar *pspp_sheet_view_column_get_title
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_expand
(PsppSheetViewColumn *tree_column,
+ gboolean
expand);
+gboolean pspp_sheet_view_column_get_expand
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_clickable
(PsppSheetViewColumn *tree_column,
+ gboolean
clickable);
+gboolean pspp_sheet_view_column_get_clickable
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_widget
(PsppSheetViewColumn *tree_column,
+ GtkWidget
*widget);
+GtkWidget *pspp_sheet_view_column_get_widget
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_alignment
(PsppSheetViewColumn *tree_column,
+ gfloat
xalign);
+gfloat pspp_sheet_view_column_get_alignment
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_reorderable
(PsppSheetViewColumn *tree_column,
+ gboolean
reorderable);
+gboolean pspp_sheet_view_column_get_reorderable
(PsppSheetViewColumn *tree_column);
+
+
+
+/* You probably only want to use pspp_sheet_view_column_set_sort_column_id.
The
+ * other sorting functions exist primarily to let others do their own custom
sorting.
+ */
+void pspp_sheet_view_column_set_sort_column_id
(PsppSheetViewColumn *tree_column,
+ gint
sort_column_id);
+gint pspp_sheet_view_column_get_sort_column_id
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_sort_indicator
(PsppSheetViewColumn *tree_column,
+ gboolean
setting);
+gboolean pspp_sheet_view_column_get_sort_indicator
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_set_sort_order
(PsppSheetViewColumn *tree_column,
+ GtkSortType
order);
+GtkSortType pspp_sheet_view_column_get_sort_order
(PsppSheetViewColumn *tree_column);
+
+
+/* These functions are meant primarily for interaction between the
PsppSheetView and the column.
+ */
+void pspp_sheet_view_column_cell_set_cell_data
(PsppSheetViewColumn *tree_column,
+ GtkTreeModel
*tree_model,
+ GtkTreeIter
*iter,
+ gboolean
is_expander,
+ gboolean
is_expanded);
+void pspp_sheet_view_column_cell_get_size
(PsppSheetViewColumn *tree_column,
+ const
GdkRectangle *cell_area,
+ gint
*x_offset,
+ gint
*y_offset,
+ gint
*width,
+ gint
*height);
+gboolean pspp_sheet_view_column_cell_is_visible
(PsppSheetViewColumn *tree_column);
+void pspp_sheet_view_column_focus_cell
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell);
+gboolean pspp_sheet_view_column_cell_get_position
(PsppSheetViewColumn *tree_column,
+
GtkCellRenderer *cell_renderer,
+ gint
*start_pos,
+ gint
*width);
+void pspp_sheet_view_column_queue_resize
(PsppSheetViewColumn *tree_column);
+GtkWidget *pspp_sheet_view_column_get_tree_view
(PsppSheetViewColumn *tree_column);
+
+
+G_END_DECLS
+
+
+#endif /* __PSPP_SHEET_VIEW_COLUMN_H__ */
diff --git a/src/ui/gui/pspp-sheet-view.c b/src/ui/gui/pspp-sheet-view.c
new file mode 100644
index 0000000..c623b31
--- /dev/null
+++ b/src/ui/gui/pspp-sheet-view.c
@@ -0,0 +1,15740 @@
+/* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2011 Free Software Foundation, Inc.
+
+ 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* gtktreeview.c
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "ui/gui/pspp-sheet-private.h"
+
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
+#include <string.h>
+
+#include "ui/gui/psppire-marshal.h"
+#include "ui/gui/pspp-sheet-selection.h"
+
+#define I_(STRING) STRING
+#define P_(STRING) STRING
+#define GTK_PARAM_READABLE
G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+#define GTK_PARAM_READWRITE
G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+
+/* Many keyboard shortcuts for Mac are the same as for X
+ * except they use Command key instead of Control (e.g. Cut,
+ * Copy, Paste). This symbol is for those simple cases. */
+#ifndef GDK_WINDOWING_QUARTZ
+#define GTK_DEFAULT_ACCEL_MOD_MASK GDK_CONTROL_MASK
+#else
+#define GTK_DEFAULT_ACCEL_MOD_MASK GDK_META_MASK
+#endif
+
+#define PSPP_SHEET_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
+#define PSPP_SHEET_VIEW_PRIORITY_SCROLL_SYNC
(PSPP_SHEET_VIEW_PRIORITY_VALIDATE + 2)
+#define PSPP_SHEET_VIEW_TIME_MS_PER_IDLE 30
+#define SCROLL_EDGE_SIZE 15
+#define EXPANDER_EXTRA_PADDING 4
+#define PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT 5000
+#define AUTO_EXPAND_TIMEOUT 500
+
+/* The "background" areas of all rows/cells add up to cover the entire tree.
+ * The background includes all inter-row and inter-cell spacing.
+ * The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
+ * i.e. just the cells, no spacing.
+ */
+
+#define BACKGROUND_HEIGHT(node) (PSPP_RBNODE_GET_HEIGHT (node))
+#define CELL_HEIGHT(node, separator) ((BACKGROUND_HEIGHT (node)) - (separator))
+
+/* Translate from bin_window coordinates to rbtree (tree coordinates) and
+ * vice versa.
+ */
+#define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
+#define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
+
+/* This is in bin_window coordinates */
+#define BACKGROUND_FIRST_PIXEL(tree_view,tree,node) (RBTREE_Y_TO_TREE_WINDOW_Y
(tree_view, _pspp_rbtree_node_find_offset ((tree), (node))))
+#define CELL_FIRST_PIXEL(tree_view,tree,node,separator)
(BACKGROUND_FIRST_PIXEL (tree_view,tree,node) + separator/2)
+
+#define ROW_HEIGHT(tree_view,height) \
+ ((height > 0) ? (height) : (tree_view)->priv->expander_size)
+
+
+typedef struct _PsppSheetViewChild PsppSheetViewChild;
+struct _PsppSheetViewChild
+{
+ GtkWidget *widget;
+ gint x;
+ gint y;
+ gint width;
+ gint height;
+};
+
+
+typedef struct _TreeViewDragInfo TreeViewDragInfo;
+struct _TreeViewDragInfo
+{
+ GdkModifierType start_button_mask;
+ GtkTargetList *_unused_source_target_list;
+ GdkDragAction source_actions;
+
+ GtkTargetList *_unused_dest_target_list;
+
+ guint source_set : 1;
+ guint dest_set : 1;
+};
+
+
+/* Signals */
+enum
+{
+ ROW_ACTIVATED,
+ TEST_EXPAND_ROW,
+ TEST_COLLAPSE_ROW,
+ ROW_EXPANDED,
+ ROW_COLLAPSED,
+ COLUMNS_CHANGED,
+ CURSOR_CHANGED,
+ MOVE_CURSOR,
+ SELECT_ALL,
+ UNSELECT_ALL,
+ SELECT_CURSOR_ROW,
+ TOGGLE_CURSOR_ROW,
+ EXPAND_COLLAPSE_CURSOR_ROW,
+ SELECT_CURSOR_PARENT,
+ START_INTERACTIVE_SEARCH,
+ LAST_SIGNAL
+};
+
+/* Properties */
+enum {
+ PROP_0,
+ PROP_MODEL,
+ PROP_HADJUSTMENT,
+ PROP_VADJUSTMENT,
+ PROP_HEADERS_VISIBLE,
+ PROP_HEADERS_CLICKABLE,
+ PROP_EXPANDER_COLUMN,
+ PROP_REORDERABLE,
+ PROP_RULES_HINT,
+ PROP_ENABLE_SEARCH,
+ PROP_SEARCH_COLUMN,
+ PROP_FIXED_HEIGHT_MODE,
+ PROP_HOVER_SELECTION,
+ PROP_HOVER_EXPAND,
+ PROP_SHOW_EXPANDERS,
+ PROP_LEVEL_INDENTATION,
+ PROP_RUBBER_BANDING,
+ PROP_ENABLE_GRID_LINES,
+ PROP_ENABLE_TREE_LINES,
+ PROP_TOOLTIP_COLUMN
+};
+
+/* object signals */
+static void pspp_sheet_view_finalize (GObject
*object);
+static void pspp_sheet_view_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void pspp_sheet_view_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+/* gtkobject signals */
+static void pspp_sheet_view_destroy (GtkObject
*object);
+
+/* gtkwidget signals */
+static void pspp_sheet_view_realize (GtkWidget
*widget);
+static void pspp_sheet_view_unrealize (GtkWidget
*widget);
+static void pspp_sheet_view_map (GtkWidget
*widget);
+static void pspp_sheet_view_size_request (GtkWidget *widget,
+ GtkRequisition
*requisition);
+static void pspp_sheet_view_size_allocate (GtkWidget *widget,
+ GtkAllocation
*allocation);
+static gboolean pspp_sheet_view_expose (GtkWidget *widget,
+ GdkEventExpose *event);
+static gboolean pspp_sheet_view_key_press (GtkWidget *widget,
+ GdkEventKey *event);
+static gboolean pspp_sheet_view_key_release (GtkWidget *widget,
+ GdkEventKey *event);
+static gboolean pspp_sheet_view_motion (GtkWidget *widget,
+ GdkEventMotion *event);
+static gboolean pspp_sheet_view_enter_notify (GtkWidget *widget,
+ GdkEventCrossing *event);
+static gboolean pspp_sheet_view_leave_notify (GtkWidget *widget,
+ GdkEventCrossing *event);
+static gboolean pspp_sheet_view_button_press (GtkWidget *widget,
+ GdkEventButton *event);
+static gboolean pspp_sheet_view_button_release (GtkWidget *widget,
+ GdkEventButton *event);
+static gboolean pspp_sheet_view_grab_broken (GtkWidget
*widget,
+ GdkEventGrabBroken *event);
+#if 0
+static gboolean pspp_sheet_view_configure (GtkWidget
*widget,
+ GdkEventConfigure *event);
+#endif
+
+static void pspp_sheet_view_set_focus_child (GtkContainer
*container,
+ GtkWidget *child);
+static gint pspp_sheet_view_focus_out (GtkWidget *widget,
+ GdkEventFocus *event);
+static gint pspp_sheet_view_focus (GtkWidget *widget,
+ GtkDirectionType
direction);
+static void pspp_sheet_view_grab_focus (GtkWidget
*widget);
+static void pspp_sheet_view_style_set (GtkWidget *widget,
+ GtkStyle
*previous_style);
+static void pspp_sheet_view_grab_notify (GtkWidget *widget,
+ gboolean
was_grabbed);
+static void pspp_sheet_view_state_changed (GtkWidget *widget,
+ GtkStateType
previous_state);
+
+/* container signals */
+static void pspp_sheet_view_remove (GtkContainer
*container,
+ GtkWidget *widget);
+static void pspp_sheet_view_forall (GtkContainer
*container,
+ gboolean
include_internals,
+ GtkCallback callback,
+ gpointer
callback_data);
+
+/* Source side drag signals */
+static void pspp_sheet_view_drag_begin (GtkWidget *widget,
+ GdkDragContext *context);
+static void pspp_sheet_view_drag_end (GtkWidget *widget,
+ GdkDragContext *context);
+static void pspp_sheet_view_drag_data_get (GtkWidget *widget,
+ GdkDragContext *context,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint time);
+static void pspp_sheet_view_drag_data_delete (GtkWidget *widget,
+ GdkDragContext *context);
+
+/* Target side drag signals */
+static void pspp_sheet_view_drag_leave (GtkWidget *widget,
+ GdkDragContext *context,
+ guint time);
+static gboolean pspp_sheet_view_drag_motion (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ guint time);
+static gboolean pspp_sheet_view_drag_drop (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ guint time);
+static void pspp_sheet_view_drag_data_received (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ GtkSelectionData
*selection_data,
+ guint info,
+ guint time);
+
+/* tree_model signals */
+static void pspp_sheet_view_set_adjustments (PsppSheetView
*tree_view,
+ GtkAdjustment
*hadj,
+ GtkAdjustment
*vadj);
+static gboolean pspp_sheet_view_real_move_cursor (PsppSheetView
*tree_view,
+ GtkMovementStep
step,
+ gint
count);
+static gboolean pspp_sheet_view_real_select_all (PsppSheetView
*tree_view);
+static gboolean pspp_sheet_view_real_unselect_all (PsppSheetView
*tree_view);
+static gboolean pspp_sheet_view_real_select_cursor_row (PsppSheetView
*tree_view,
+ gboolean
start_editing);
+static gboolean pspp_sheet_view_real_toggle_cursor_row (PsppSheetView
*tree_view);
+static gboolean pspp_sheet_view_real_expand_collapse_cursor_row (PsppSheetView
*tree_view,
+ gboolean
logical,
+ gboolean
expand,
+ gboolean
open_all);
+static gboolean pspp_sheet_view_real_select_cursor_parent (PsppSheetView
*tree_view);
+static void pspp_sheet_view_row_changed (GtkTreeModel
*model,
+ GtkTreePath
*path,
+ GtkTreeIter
*iter,
+ gpointer
data);
+static void pspp_sheet_view_row_inserted (GtkTreeModel
*model,
+ GtkTreePath
*path,
+ GtkTreeIter
*iter,
+ gpointer
data);
+static void pspp_sheet_view_row_has_child_toggled (GtkTreeModel
*model,
+ GtkTreePath
*path,
+ GtkTreeIter
*iter,
+ gpointer
data);
+static void pspp_sheet_view_row_deleted (GtkTreeModel
*model,
+ GtkTreePath
*path,
+ gpointer
data);
+static void pspp_sheet_view_rows_reordered (GtkTreeModel
*model,
+ GtkTreePath
*parent,
+ GtkTreeIter
*iter,
+ gint
*new_order,
+ gpointer
data);
+
+/* Incremental reflow */
+static gboolean validate_row (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkTreeIter *iter,
+ GtkTreePath *path);
+static void validate_visible_area (PsppSheetView *tree_view);
+static gboolean validate_rows_handler (PsppSheetView *tree_view);
+static gboolean do_validate_rows (PsppSheetView *tree_view,
+ gboolean size_request);
+static gboolean validate_rows (PsppSheetView *tree_view);
+static gboolean presize_handler_callback (gpointer data);
+static void install_presize_handler (PsppSheetView *tree_view);
+static void install_scroll_sync_handler (PsppSheetView *tree_view);
+static void pspp_sheet_view_set_top_row (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ gint offset);
+static void pspp_sheet_view_dy_to_top_row (PsppSheetView *tree_view);
+static void pspp_sheet_view_top_row_to_dy (PsppSheetView *tree_view);
+static void invalidate_empty_focus (PsppSheetView *tree_view);
+
+/* Internal functions */
+static gboolean pspp_sheet_view_is_expander_column (PsppSheetView
*tree_view,
+
PsppSheetViewColumn *column);
+static void pspp_sheet_view_add_move_binding (GtkBindingSet
*binding_set,
+ guint
keyval,
+ guint
modmask,
+ gboolean
add_shifted_binding,
+ GtkMovementStep
step,
+ gint
count);
+static gint pspp_sheet_view_unref_and_check_selection_tree (PsppSheetView
*tree_view,
+ GtkRBTree
*tree);
+static void pspp_sheet_view_queue_draw_path (PsppSheetView
*tree_view,
+ GtkTreePath
*path,
+ const
GdkRectangle *clip_rect);
+static void pspp_sheet_view_queue_draw_arrow (PsppSheetView
*tree_view,
+ GtkRBTree
*tree,
+ GtkRBNode
*node,
+ const
GdkRectangle *clip_rect);
+static void pspp_sheet_view_draw_arrow (PsppSheetView
*tree_view,
+ GtkRBTree
*tree,
+ GtkRBNode
*node,
+ gint
x,
+ gint
y);
+static void pspp_sheet_view_get_arrow_xrange (PsppSheetView
*tree_view,
+ GtkRBTree
*tree,
+ gint
*x1,
+ gint
*x2);
+static gint pspp_sheet_view_new_column_width (PsppSheetView
*tree_view,
+ gint
i,
+ gint
*x);
+static void pspp_sheet_view_adjustment_changed (GtkAdjustment
*adjustment,
+ PsppSheetView
*tree_view);
+static void pspp_sheet_view_build_tree (PsppSheetView
*tree_view,
+ GtkRBTree
*tree,
+ GtkTreeIter
*iter,
+ gint
depth,
+ gboolean
recurse);
+static void pspp_sheet_view_clamp_node_visible (PsppSheetView
*tree_view,
+ GtkRBTree
*tree,
+ GtkRBNode
*node);
+static void pspp_sheet_view_clamp_column_visible (PsppSheetView
*tree_view,
+
PsppSheetViewColumn *column,
+ gboolean
focus_to_cell);
+static gboolean pspp_sheet_view_maybe_begin_dragging_row (PsppSheetView
*tree_view,
+ GdkEventMotion
*event);
+static void pspp_sheet_view_focus_to_cursor (PsppSheetView
*tree_view);
+static void pspp_sheet_view_move_cursor_up_down (PsppSheetView
*tree_view,
+ gint
count);
+static void pspp_sheet_view_move_cursor_page_up_down (PsppSheetView
*tree_view,
+ gint
count);
+static void pspp_sheet_view_move_cursor_left_right (PsppSheetView
*tree_view,
+ gint
count);
+static void pspp_sheet_view_move_cursor_start_end (PsppSheetView
*tree_view,
+ gint
count);
+static gboolean pspp_sheet_view_real_collapse_row (PsppSheetView
*tree_view,
+ GtkTreePath
*path,
+ GtkRBTree
*tree,
+ GtkRBNode
*node,
+ gboolean
animate);
+static gboolean pspp_sheet_view_real_expand_row (PsppSheetView
*tree_view,
+ GtkTreePath
*path,
+ GtkRBTree
*tree,
+ GtkRBNode
*node,
+ gboolean
open_all,
+ gboolean
animate);
+static void pspp_sheet_view_real_set_cursor (PsppSheetView
*tree_view,
+ GtkTreePath
*path,
+ gboolean
clear_and_select,
+ gboolean
clamp_node);
+static gboolean pspp_sheet_view_has_special_cell (PsppSheetView
*tree_view);
+static void column_sizing_notify (GObject
*object,
+ GParamSpec
*pspec,
+ gpointer
data);
+static gboolean expand_collapse_timeout (gpointer
data);
+static void add_expand_collapse_timeout (PsppSheetView
*tree_view,
+ GtkRBTree
*tree,
+ GtkRBNode
*node,
+ gboolean
expand);
+static void remove_expand_collapse_timeout (PsppSheetView
*tree_view);
+static void cancel_arrow_animation (PsppSheetView
*tree_view);
+static gboolean do_expand_collapse (PsppSheetView
*tree_view);
+static void pspp_sheet_view_stop_rubber_band (PsppSheetView
*tree_view);
+static void update_prelight (PsppSheetView
*tree_view,
+ int
x,
+ int
y);
+
+/* interactive search */
+static void pspp_sheet_view_ensure_interactive_directory (PsppSheetView
*tree_view);
+static void pspp_sheet_view_search_dialog_hide (GtkWidget
*search_dialog,
+ PsppSheetView
*tree_view);
+static void pspp_sheet_view_search_position_func (PsppSheetView
*tree_view,
+ GtkWidget
*search_dialog,
+ gpointer
user_data);
+static void pspp_sheet_view_search_disable_popdown (GtkEntry
*entry,
+ GtkMenu *menu,
+ gpointer
data);
+static void pspp_sheet_view_search_preedit_changed (GtkIMContext
*im_context,
+ PsppSheetView
*tree_view);
+static void pspp_sheet_view_search_activate (GtkEntry
*entry,
+ PsppSheetView
*tree_view);
+static gboolean pspp_sheet_view_real_search_enable_popdown(gpointer
data);
+static void pspp_sheet_view_search_enable_popdown (GtkWidget
*widget,
+ gpointer
data);
+static gboolean pspp_sheet_view_search_delete_event (GtkWidget
*widget,
+ GdkEventAny
*event,
+ PsppSheetView
*tree_view);
+static gboolean pspp_sheet_view_search_button_press_event (GtkWidget
*widget,
+ GdkEventButton
*event,
+ PsppSheetView
*tree_view);
+static gboolean pspp_sheet_view_search_scroll_event (GtkWidget
*entry,
+ GdkEventScroll
*event,
+ PsppSheetView
*tree_view);
+static gboolean pspp_sheet_view_search_key_press_event (GtkWidget
*entry,
+ GdkEventKey
*event,
+ PsppSheetView
*tree_view);
+static gboolean pspp_sheet_view_search_move (GtkWidget
*window,
+ PsppSheetView
*tree_view,
+ gboolean up);
+static gboolean pspp_sheet_view_search_equal_func (GtkTreeModel
*model,
+ gint
column,
+ const gchar *key,
+ GtkTreeIter *iter,
+ gpointer
search_data);
+static gboolean pspp_sheet_view_search_iter (GtkTreeModel
*model,
+ PsppSheetSelection
*selection,
+ GtkTreeIter *iter,
+ const gchar *text,
+ gint
*count,
+ gint n);
+static void pspp_sheet_view_search_init (GtkWidget
*entry,
+ PsppSheetView
*tree_view);
+static void pspp_sheet_view_put (PsppSheetView
*tree_view,
+ GtkWidget
*child_widget,
+ gint x,
+ gint y,
+ gint
width,
+ gint
height);
+static gboolean pspp_sheet_view_start_editing (PsppSheetView
*tree_view,
+ GtkTreePath
*cursor_path);
+static void pspp_sheet_view_real_start_editing (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column,
+ GtkTreePath *path,
+ GtkCellEditable *cell_editable,
+ GdkRectangle *cell_area,
+ GdkEvent *event,
+ guint flags);
+static void pspp_sheet_view_stop_editing (PsppSheetView
*tree_view,
+ gboolean
cancel_editing);
+static gboolean pspp_sheet_view_real_start_interactive_search (PsppSheetView
*tree_view,
+ gboolean
keybinding);
+static gboolean pspp_sheet_view_start_interactive_search (PsppSheetView
*tree_view);
+static PsppSheetViewColumn *pspp_sheet_view_get_drop_column (PsppSheetView
*tree_view,
+ PsppSheetViewColumn
*column,
+ gint
drop_position);
+
+/* GtkBuildable */
+static void pspp_sheet_view_buildable_add_child (GtkBuildable *tree_view,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *type);
+static void pspp_sheet_view_buildable_init (GtkBuildableIface *iface);
+
+
+static gboolean scroll_row_timeout (gpointer data);
+static void add_scroll_timeout (PsppSheetView
*tree_view);
+static void remove_scroll_timeout (PsppSheetView
*tree_view);
+
+static guint tree_view_signals [LAST_SIGNAL] = { 0 };
+
+
+
+/* GType Methods
+ */
+
+G_DEFINE_TYPE_WITH_CODE (PsppSheetView, pspp_sheet_view, GTK_TYPE_CONTAINER,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+ pspp_sheet_view_buildable_init))
+
+static void
+pspp_sheet_view_class_init (PsppSheetViewClass *class)
+{
+ GObjectClass *o_class;
+ GtkObjectClass *object_class;
+ GtkWidgetClass *widget_class;
+ GtkContainerClass *container_class;
+ GtkBindingSet *binding_set;
+
+ binding_set = gtk_binding_set_by_class (class);
+
+ o_class = (GObjectClass *) class;
+ object_class = (GtkObjectClass *) class;
+ widget_class = (GtkWidgetClass *) class;
+ container_class = (GtkContainerClass *) class;
+
+ /* GObject signals */
+ o_class->set_property = pspp_sheet_view_set_property;
+ o_class->get_property = pspp_sheet_view_get_property;
+ o_class->finalize = pspp_sheet_view_finalize;
+
+ /* GtkObject signals */
+ object_class->destroy = pspp_sheet_view_destroy;
+
+ /* GtkWidget signals */
+ widget_class->map = pspp_sheet_view_map;
+ widget_class->realize = pspp_sheet_view_realize;
+ widget_class->unrealize = pspp_sheet_view_unrealize;
+ widget_class->size_request = pspp_sheet_view_size_request;
+ widget_class->size_allocate = pspp_sheet_view_size_allocate;
+ widget_class->button_press_event = pspp_sheet_view_button_press;
+ widget_class->button_release_event = pspp_sheet_view_button_release;
+ widget_class->grab_broken_event = pspp_sheet_view_grab_broken;
+ /*widget_class->configure_event = pspp_sheet_view_configure;*/
+ widget_class->motion_notify_event = pspp_sheet_view_motion;
+ widget_class->expose_event = pspp_sheet_view_expose;
+ widget_class->key_press_event = pspp_sheet_view_key_press;
+ widget_class->key_release_event = pspp_sheet_view_key_release;
+ widget_class->enter_notify_event = pspp_sheet_view_enter_notify;
+ widget_class->leave_notify_event = pspp_sheet_view_leave_notify;
+ widget_class->focus_out_event = pspp_sheet_view_focus_out;
+ widget_class->drag_begin = pspp_sheet_view_drag_begin;
+ widget_class->drag_end = pspp_sheet_view_drag_end;
+ widget_class->drag_data_get = pspp_sheet_view_drag_data_get;
+ widget_class->drag_data_delete = pspp_sheet_view_drag_data_delete;
+ widget_class->drag_leave = pspp_sheet_view_drag_leave;
+ widget_class->drag_motion = pspp_sheet_view_drag_motion;
+ widget_class->drag_drop = pspp_sheet_view_drag_drop;
+ widget_class->drag_data_received = pspp_sheet_view_drag_data_received;
+ widget_class->focus = pspp_sheet_view_focus;
+ widget_class->grab_focus = pspp_sheet_view_grab_focus;
+ widget_class->style_set = pspp_sheet_view_style_set;
+ widget_class->grab_notify = pspp_sheet_view_grab_notify;
+ widget_class->state_changed = pspp_sheet_view_state_changed;
+
+ /* GtkContainer signals */
+ container_class->remove = pspp_sheet_view_remove;
+ container_class->forall = pspp_sheet_view_forall;
+ container_class->set_focus_child = pspp_sheet_view_set_focus_child;
+
+ class->set_scroll_adjustments = pspp_sheet_view_set_adjustments;
+ class->move_cursor = pspp_sheet_view_real_move_cursor;
+ class->select_all = pspp_sheet_view_real_select_all;
+ class->unselect_all = pspp_sheet_view_real_unselect_all;
+ class->select_cursor_row = pspp_sheet_view_real_select_cursor_row;
+ class->toggle_cursor_row = pspp_sheet_view_real_toggle_cursor_row;
+ class->expand_collapse_cursor_row =
pspp_sheet_view_real_expand_collapse_cursor_row;
+ class->select_cursor_parent = pspp_sheet_view_real_select_cursor_parent;
+ class->start_interactive_search = pspp_sheet_view_start_interactive_search;
+
+ /* Properties */
+
+ g_object_class_install_property (o_class,
+ PROP_MODEL,
+ g_param_spec_object ("model",
+ P_("TreeView Model"),
+ P_("The model for the
tree view"),
+ GTK_TYPE_TREE_MODEL,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_HADJUSTMENT,
+ g_param_spec_object ("hadjustment",
+ P_("Horizontal
Adjustment"),
+ P_("Horizontal
Adjustment for the widget"),
+ GTK_TYPE_ADJUSTMENT,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_VADJUSTMENT,
+ g_param_spec_object ("vadjustment",
+ P_("Vertical
Adjustment"),
+ P_("Vertical
Adjustment for the widget"),
+ GTK_TYPE_ADJUSTMENT,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_HEADERS_VISIBLE,
+ g_param_spec_boolean ("headers-visible",
+ P_("Headers Visible"),
+ P_("Show the column
header buttons"),
+ TRUE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_HEADERS_CLICKABLE,
+ g_param_spec_boolean ("headers-clickable",
+ P_("Headers
Clickable"),
+ P_("Column headers
respond to click events"),
+ TRUE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_EXPANDER_COLUMN,
+ g_param_spec_object ("expander-column",
+ P_("Expander Column"),
+ P_("Set the column for
the expander column"),
+
PSPP_TYPE_SHEET_VIEW_COLUMN,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_REORDERABLE,
+ g_param_spec_boolean ("reorderable",
+ P_("Reorderable"),
+ P_("View is
reorderable"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_RULES_HINT,
+ g_param_spec_boolean ("rules-hint",
+ P_("Rules Hint"),
+ P_("Set a hint to the
theme engine to draw rows in alternating colors"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_ENABLE_SEARCH,
+ g_param_spec_boolean ("enable-search",
+ P_("Enable Search"),
+ P_("View allows user
to search through columns interactively"),
+ TRUE,
+
GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_SEARCH_COLUMN,
+ g_param_spec_int ("search-column",
+ P_("Search Column"),
+ P_("Model column to
search through during interactive search"),
+ -1,
+ G_MAXINT,
+ -1,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * PsppSheetView:fixed-height-mode:
+ *
+ * Setting the ::fixed-height-mode property to %TRUE speeds up
+ * #PsppSheetView by assuming that all rows have the same height.
+ * Only enable this option if all rows are the same height.
+ * Please see pspp_sheet_view_set_fixed_height_mode() for more
+ * information on this option.
+ *
+ * Since: 2.4
+ **/
+ g_object_class_install_property (o_class,
+ PROP_FIXED_HEIGHT_MODE,
+ g_param_spec_boolean ("fixed-height-mode",
+ P_("Fixed Height
Mode"),
+ P_("Speeds up
PsppSheetView by assuming that all rows have the same height"),
+ FALSE,
+
GTK_PARAM_READWRITE));
+
+ /**
+ * PsppSheetView:hover-selection:
+ *
+ * Enables of disables the hover selection mode of @tree_view.
+ * Hover selection makes the selected row follow the pointer.
+ * Currently, this works only for the selection modes
+ * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+ *
+ * This mode is primarily intended for treeviews in popups, e.g.
+ * in #GtkComboBox or #GtkEntryCompletion.
+ *
+ * Since: 2.6
+ */
+ g_object_class_install_property (o_class,
+ PROP_HOVER_SELECTION,
+ g_param_spec_boolean ("hover-selection",
+ P_("Hover
Selection"),
+ P_("Whether the
selection should follow the pointer"),
+ FALSE,
+
GTK_PARAM_READWRITE));
+
+ /**
+ * PsppSheetView:hover-expand:
+ *
+ * Enables of disables the hover expansion mode of @tree_view.
+ * Hover expansion makes rows expand or collapse if the pointer moves
+ * over them.
+ *
+ * This mode is primarily intended for treeviews in popups, e.g.
+ * in #GtkComboBox or #GtkEntryCompletion.
+ *
+ * Since: 2.6
+ */
+ g_object_class_install_property (o_class,
+ PROP_HOVER_EXPAND,
+ g_param_spec_boolean ("hover-expand",
+ P_("Hover Expand"),
+ P_("Whether rows
should be expanded/collapsed when the pointer moves over them"),
+ FALSE,
+
GTK_PARAM_READWRITE));
+
+ /**
+ * PsppSheetView:show-expanders:
+ *
+ * %TRUE if the view has expanders.
+ *
+ * Since: 2.12
+ */
+ g_object_class_install_property (o_class,
+ PROP_SHOW_EXPANDERS,
+ g_param_spec_boolean ("show-expanders",
+ P_("Show Expanders"),
+ P_("View has
expanders"),
+ TRUE,
+
GTK_PARAM_READWRITE));
+
+ /**
+ * PsppSheetView:level-indentation:
+ *
+ * Extra indentation for each level.
+ *
+ * Since: 2.12
+ */
+ g_object_class_install_property (o_class,
+ PROP_LEVEL_INDENTATION,
+ g_param_spec_int ("level-indentation",
+ P_("Level Indentation"),
+ P_("Extra indentation
for each level"),
+ 0,
+ G_MAXINT,
+ 0,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_RUBBER_BANDING,
+ g_param_spec_boolean ("rubber-banding",
+ P_("Rubber
Banding"),
+ P_("Whether to
enable selection of multiple items by dragging the mouse pointer"),
+ FALSE,
+
GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_ENABLE_GRID_LINES,
+ g_param_spec_enum ("enable-grid-lines",
+ P_("Enable Grid Lines"),
+ P_("Whether grid lines
should be drawn in the tree view"),
+
PSPP_TYPE_SHEET_VIEW_GRID_LINES,
+
PSPP_SHEET_VIEW_GRID_LINES_NONE,
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_ENABLE_TREE_LINES,
+ g_param_spec_boolean ("enable-tree-lines",
+ P_("Enable Tree
Lines"),
+ P_("Whether tree
lines should be drawn in the tree view"),
+ FALSE,
+
GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (o_class,
+ PROP_TOOLTIP_COLUMN,
+ g_param_spec_int ("tooltip-column",
+ P_("Tooltip Column"),
+ P_("The column in the
model containing the tooltip texts for the rows"),
+ -1,
+ G_MAXINT,
+ -1,
+ GTK_PARAM_READWRITE));
+
+ /* Style properties */
+#define _TREE_VIEW_EXPANDER_SIZE 12
+#define _TREE_VIEW_VERTICAL_SEPARATOR 2
+#define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_int ("expander-size",
+ P_("Expander
Size"),
+ P_("Size of the
expander arrow"),
+ 0,
+ G_MAXINT,
+
_TREE_VIEW_EXPANDER_SIZE,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_int
("vertical-separator",
+ P_("Vertical
Separator Width"),
+ P_("Vertical space
between cells. Must be an even number"),
+ 0,
+ G_MAXINT,
+
_TREE_VIEW_VERTICAL_SEPARATOR,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_int
("horizontal-separator",
+ P_("Horizontal
Separator Width"),
+ P_("Horizontal
space between cells. Must be an even number"),
+ 0,
+ G_MAXINT,
+
_TREE_VIEW_HORIZONTAL_SEPARATOR,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boolean ("allow-rules",
+ P_("Allow
Rules"),
+ P_("Allow
drawing of alternating color rows"),
+ TRUE,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boolean
("indent-expanders",
+ P_("Indent
Expanders"),
+ P_("Make the
expanders indented"),
+ TRUE,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boxed
("even-row-color",
+ P_("Even Row
Color"),
+ P_("Color to
use for even rows"),
+ GDK_TYPE_COLOR,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boxed ("odd-row-color",
+ P_("Odd Row
Color"),
+ P_("Color to
use for odd rows"),
+ GDK_TYPE_COLOR,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boolean
("row-ending-details",
+ P_("Row Ending
details"),
+ P_("Enable
extended row background theming"),
+ FALSE,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_int ("grid-line-width",
+ P_("Grid line
width"),
+ P_("Width, in
pixels, of the tree view grid lines"),
+ 0, G_MAXINT, 1,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_int ("tree-line-width",
+ P_("Tree line
width"),
+ P_("Width, in
pixels, of the tree view lines"),
+ 0, G_MAXINT, 1,
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_string
("grid-line-pattern",
+ P_("Grid line
pattern"),
+ P_("Dash
pattern used to draw the tree view grid lines"),
+ "\1\1",
+
GTK_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_string
("tree-line-pattern",
+ P_("Tree line
pattern"),
+ P_("Dash
pattern used to draw the tree view lines"),
+ "\1\1",
+
GTK_PARAM_READABLE));
+
+ /* Signals */
+ /**
+ * PsppSheetView::set-scroll-adjustments
+ * @horizontal: the horizontal #GtkAdjustment
+ * @vertical: the vertical #GtkAdjustment
+ *
+ * Set the scroll adjustments for the tree view. Usually scrolled containers
+ * like #GtkScrolledWindow will emit this signal to connect two instances
+ * of #GtkScrollbar to the scroll directions of the #PsppSheetView.
+ */
+ widget_class->set_scroll_adjustments_signal =
+ g_signal_new (I_("set-scroll-adjustments"),
+ G_TYPE_FROM_CLASS (o_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass, set_scroll_adjustments),
+ NULL, NULL,
+ psppire_marshal_VOID__OBJECT_OBJECT,
+ G_TYPE_NONE, 2,
+ GTK_TYPE_ADJUSTMENT,
+ GTK_TYPE_ADJUSTMENT);
+
+ /**
+ * PsppSheetView::row-activated:
+ * @tree_view: the object on which the signal is emitted
+ * @path: the #GtkTreePath for the activated row
+ * @column: the #PsppSheetViewColumn in which the activation occurred
+ *
+ * The "row-activated" signal is emitted when the method
+ * pspp_sheet_view_row_activated() is called or the user double clicks
+ * a treeview row. It is also emitted when a non-editable row is
+ * selected and one of the keys: Space, Shift+Space, Return or
+ * Enter is pressed.
+ *
+ * For selection handling refer to the <link linkend="TreeWidget">tree
+ * widget conceptual overview</link> as well as #PsppSheetSelection.
+ */
+ tree_view_signals[ROW_ACTIVATED] =
+ g_signal_new (I_("row-activated"),
+ G_TYPE_FROM_CLASS (o_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass, row_activated),
+ NULL, NULL,
+ psppire_marshal_VOID__BOXED_OBJECT,
+ G_TYPE_NONE, 2,
+ GTK_TYPE_TREE_PATH,
+ PSPP_TYPE_SHEET_VIEW_COLUMN);
+
+ /**
+ * PsppSheetView::test-expand-row:
+ * @tree_view: the object on which the signal is emitted
+ * @iter: the tree iter of the row to expand
+ * @path: a tree path that points to the row
+ *
+ * The given row is about to be expanded (show its children nodes). Use this
+ * signal if you need to control the expandability of individual rows.
+ *
+ * Returns: %FALSE to allow expansion, %TRUE to reject
+ */
+ tree_view_signals[TEST_EXPAND_ROW] =
+ g_signal_new (I_("test-expand-row"),
+ G_TYPE_FROM_CLASS (o_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PsppSheetViewClass, test_expand_row),
+ _gtk_boolean_handled_accumulator, NULL,
+ psppire_marshal_BOOLEAN__BOXED_BOXED,
+ G_TYPE_BOOLEAN, 2,
+ GTK_TYPE_TREE_ITER,
+ GTK_TYPE_TREE_PATH);
+
+ /**
+ * PsppSheetView::test-collapse-row:
+ * @tree_view: the object on which the signal is emitted
+ * @iter: the tree iter of the row to collapse
+ * @path: a tree path that points to the row
+ *
+ * The given row is about to be collapsed (hide its children nodes). Use this
+ * signal if you need to control the collapsibility of individual rows.
+ *
+ * Returns: %FALSE to allow collapsing, %TRUE to reject
+ */
+ tree_view_signals[TEST_COLLAPSE_ROW] =
+ g_signal_new (I_("test-collapse-row"),
+ G_TYPE_FROM_CLASS (o_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PsppSheetViewClass, test_collapse_row),
+ _gtk_boolean_handled_accumulator, NULL,
+ psppire_marshal_BOOLEAN__BOXED_BOXED,
+ G_TYPE_BOOLEAN, 2,
+ GTK_TYPE_TREE_ITER,
+ GTK_TYPE_TREE_PATH);
+
+ /**
+ * PsppSheetView::row-expanded:
+ * @tree_view: the object on which the signal is emitted
+ * @iter: the tree iter of the expanded row
+ * @path: a tree path that points to the row
+ *
+ * The given row has been expanded (child nodes are shown).
+ */
+ tree_view_signals[ROW_EXPANDED] =
+ g_signal_new (I_("row-expanded"),
+ G_TYPE_FROM_CLASS (o_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PsppSheetViewClass, row_expanded),
+ NULL, NULL,
+ psppire_marshal_VOID__BOXED_BOXED,
+ G_TYPE_NONE, 2,
+ GTK_TYPE_TREE_ITER,
+ GTK_TYPE_TREE_PATH);
+
+ /**
+ * PsppSheetView::row-collapsed:
+ * @tree_view: the object on which the signal is emitted
+ * @iter: the tree iter of the collapsed row
+ * @path: a tree path that points to the row
+ *
+ * The given row has been collapsed (child nodes are hidden).
+ */
+ tree_view_signals[ROW_COLLAPSED] =
+ g_signal_new (I_("row-collapsed"),
+ G_TYPE_FROM_CLASS (o_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PsppSheetViewClass, row_collapsed),
+ NULL, NULL,
+ psppire_marshal_VOID__BOXED_BOXED,
+ G_TYPE_NONE, 2,
+ GTK_TYPE_TREE_ITER,
+ GTK_TYPE_TREE_PATH);
+
+ /**
+ * PsppSheetView::columns-changed:
+ * @tree_view: the object on which the signal is emitted
+ *
+ * The number of columns of the treeview has changed.
+ */
+ tree_view_signals[COLUMNS_CHANGED] =
+ g_signal_new (I_("columns-changed"),
+ G_TYPE_FROM_CLASS (o_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PsppSheetViewClass, columns_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ /**
+ * PsppSheetView::cursor-changed:
+ * @tree_view: the object on which the signal is emitted
+ *
+ * The position of the cursor (focused cell) has changed.
+ */
+ tree_view_signals[CURSOR_CHANGED] =
+ g_signal_new (I_("cursor-changed"),
+ G_TYPE_FROM_CLASS (o_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PsppSheetViewClass, cursor_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ tree_view_signals[MOVE_CURSOR] =
+ g_signal_new (I_("move-cursor"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass, move_cursor),
+ NULL, NULL,
+ psppire_marshal_BOOLEAN__ENUM_INT,
+ G_TYPE_BOOLEAN, 2,
+ GTK_TYPE_MOVEMENT_STEP,
+ G_TYPE_INT);
+
+ tree_view_signals[SELECT_ALL] =
+ g_signal_new (I_("select-all"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass, select_all),
+ NULL, NULL,
+ psppire_marshal_BOOLEAN__VOID,
+ G_TYPE_BOOLEAN, 0);
+
+ tree_view_signals[UNSELECT_ALL] =
+ g_signal_new (I_("unselect-all"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass, unselect_all),
+ NULL, NULL,
+ psppire_marshal_BOOLEAN__VOID,
+ G_TYPE_BOOLEAN, 0);
+
+ tree_view_signals[SELECT_CURSOR_ROW] =
+ g_signal_new (I_("select-cursor-row"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass, select_cursor_row),
+ NULL, NULL,
+ psppire_marshal_BOOLEAN__BOOLEAN,
+ G_TYPE_BOOLEAN, 1,
+ G_TYPE_BOOLEAN);
+
+ tree_view_signals[TOGGLE_CURSOR_ROW] =
+ g_signal_new (I_("toggle-cursor-row"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass, toggle_cursor_row),
+ NULL, NULL,
+ psppire_marshal_BOOLEAN__VOID,
+ G_TYPE_BOOLEAN, 0);
+
+ tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
+ g_signal_new (I_("expand-collapse-cursor-row"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass,
expand_collapse_cursor_row),
+ NULL, NULL,
+ psppire_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
+ G_TYPE_BOOLEAN, 3,
+ G_TYPE_BOOLEAN,
+ G_TYPE_BOOLEAN,
+ G_TYPE_BOOLEAN);
+
+ tree_view_signals[SELECT_CURSOR_PARENT] =
+ g_signal_new (I_("select-cursor-parent"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass, select_cursor_parent),
+ NULL, NULL,
+ psppire_marshal_BOOLEAN__VOID,
+ G_TYPE_BOOLEAN, 0);
+
+ tree_view_signals[START_INTERACTIVE_SEARCH] =
+ g_signal_new (I_("start-interactive-search"),
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (PsppSheetViewClass,
start_interactive_search),
+ NULL, NULL,
+ psppire_marshal_BOOLEAN__VOID,
+ G_TYPE_BOOLEAN, 0);
+
+ /* Key bindings */
+ pspp_sheet_view_add_move_binding (binding_set, GDK_Up, 0, TRUE,
+ GTK_MOVEMENT_DISPLAY_LINES, -1);
+ pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Up, 0, TRUE,
+ GTK_MOVEMENT_DISPLAY_LINES, -1);
+
+ pspp_sheet_view_add_move_binding (binding_set, GDK_Down, 0, TRUE,
+ GTK_MOVEMENT_DISPLAY_LINES, 1);
+ pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Down, 0, TRUE,
+ GTK_MOVEMENT_DISPLAY_LINES, 1);
+
+ pspp_sheet_view_add_move_binding (binding_set, GDK_p, GDK_CONTROL_MASK,
FALSE,
+ GTK_MOVEMENT_DISPLAY_LINES, -1);
+
+ pspp_sheet_view_add_move_binding (binding_set, GDK_n, GDK_CONTROL_MASK,
FALSE,
+ GTK_MOVEMENT_DISPLAY_LINES, 1);
+
+ pspp_sheet_view_add_move_binding (binding_set, GDK_Home, 0, TRUE,
+ GTK_MOVEMENT_BUFFER_ENDS, -1);
+ pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Home, 0, TRUE,
+ GTK_MOVEMENT_BUFFER_ENDS, -1);
+
+ pspp_sheet_view_add_move_binding (binding_set, GDK_End, 0, TRUE,
+ GTK_MOVEMENT_BUFFER_ENDS, 1);
+ pspp_sheet_view_add_move_binding (binding_set, GDK_KP_End, 0, TRUE,
+ GTK_MOVEMENT_BUFFER_ENDS, 1);
+
+ pspp_sheet_view_add_move_binding (binding_set, GDK_Page_Up, 0, TRUE,
+ GTK_MOVEMENT_PAGES, -1);
+ pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Page_Up, 0, TRUE,
+ GTK_MOVEMENT_PAGES, -1);
+
+ pspp_sheet_view_add_move_binding (binding_set, GDK_Page_Down, 0, TRUE,
+ GTK_MOVEMENT_PAGES, 1);
+ pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Page_Down, 0, TRUE,
+ GTK_MOVEMENT_PAGES, 1);
+
+
+ gtk_binding_entry_add_signal (binding_set, GDK_Right, 0, "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_INT, 1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_Left, 0, "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_INT, -1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, 0, "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_INT, 1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0, "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_INT, -1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_Right, GDK_CONTROL_MASK,
+ "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_INT, 1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_Left, GDK_CONTROL_MASK,
+ "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_INT, -1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, GDK_CONTROL_MASK,
+ "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_INT, 1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, GDK_CONTROL_MASK,
+ "move-cursor", 2,
+ G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
+ G_TYPE_INT, -1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK,
"toggle-cursor-row", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_CONTROL_MASK,
"toggle-cursor-row", 0);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK,
"select-all", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK,
"select-all", 0);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_A, GDK_CONTROL_MASK |
GDK_SHIFT_MASK, "unselect-all", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_CONTROL_MASK,
"unselect-all", 0);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_SHIFT_MASK,
"select-cursor-row", 1,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_SHIFT_MASK,
"select-cursor-row", 1,
+ G_TYPE_BOOLEAN, TRUE);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_space, 0,
"select-cursor-row", 1,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, 0,
"select-cursor-row", 1,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_Return, 0,
"select-cursor-row", 1,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_ISO_Enter, 0,
"select-cursor-row", 1,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0,
"select-cursor-row", 1,
+ G_TYPE_BOOLEAN, TRUE);
+
+ /* expand and collapse rows */
+ gtk_binding_entry_add_signal (binding_set, GDK_plus, 0,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, FALSE);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_asterisk, 0,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Multiply, 0,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_slash, 0,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, FALSE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Divide, 0,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, FALSE);
+
+ /* Not doable on US keyboards */
+ gtk_binding_entry_add_signal (binding_set, GDK_plus, GDK_SHIFT_MASK,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, 0,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, FALSE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, GDK_SHIFT_MASK,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, GDK_SHIFT_MASK,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_Right, GDK_SHIFT_MASK,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, GDK_SHIFT_MASK,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_Right,
+ GDK_CONTROL_MASK | GDK_SHIFT_MASK,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Right,
+ GDK_CONTROL_MASK | GDK_SHIFT_MASK,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, TRUE);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_minus, 0,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, FALSE);
+ gtk_binding_entry_add_signal (binding_set, GDK_minus, GDK_SHIFT_MASK,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Subtract, 0,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, FALSE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Subtract, GDK_SHIFT_MASK,
"expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, TRUE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_Left, GDK_SHIFT_MASK,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, GDK_SHIFT_MASK,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_Left,
+ GDK_CONTROL_MASK | GDK_SHIFT_MASK,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Left,
+ GDK_CONTROL_MASK | GDK_SHIFT_MASK,
+ "expand-collapse-cursor-row", 3,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, FALSE,
+ G_TYPE_BOOLEAN, TRUE);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0,
"select-cursor-parent", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK,
"select-cursor-parent", 0);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_f, GDK_CONTROL_MASK,
"start-interactive-search", 0);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_F, GDK_CONTROL_MASK,
"start-interactive-search", 0);
+
+ g_type_class_add_private (o_class, sizeof (PsppSheetViewPrivate));
+}
+
+static void
+pspp_sheet_view_buildable_init (GtkBuildableIface *iface)
+{
+ iface->add_child = pspp_sheet_view_buildable_add_child;
+}
+
+static void
+pspp_sheet_view_init (PsppSheetView *tree_view)
+{
+ tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view,
PSPP_TYPE_SHEET_VIEW, PsppSheetViewPrivate);
+
+ gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
+ gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
+
+ tree_view->priv->flags = PSPP_SHEET_VIEW_SHOW_EXPANDERS
+ | PSPP_SHEET_VIEW_DRAW_KEYFOCUS
+ | PSPP_SHEET_VIEW_HEADERS_VISIBLE;
+
+ /* We need some padding */
+ tree_view->priv->dy = 0;
+ tree_view->priv->cursor_offset = 0;
+ tree_view->priv->n_columns = 0;
+ tree_view->priv->header_height = 1;
+ tree_view->priv->x_drag = 0;
+ tree_view->priv->drag_pos = -1;
+ tree_view->priv->header_has_focus = FALSE;
+ tree_view->priv->pressed_button = -1;
+ tree_view->priv->press_start_x = -1;
+ tree_view->priv->press_start_y = -1;
+ tree_view->priv->reorderable = FALSE;
+ tree_view->priv->presize_handler_timer = 0;
+ tree_view->priv->scroll_sync_timer = 0;
+ tree_view->priv->fixed_height = -1;
+ tree_view->priv->fixed_height_mode = FALSE;
+ tree_view->priv->fixed_height_check = 0;
+ pspp_sheet_view_set_adjustments (tree_view, NULL, NULL);
+ tree_view->priv->selection = _pspp_sheet_selection_new_with_tree_view
(tree_view);
+ tree_view->priv->enable_search = TRUE;
+ tree_view->priv->search_column = -1;
+ tree_view->priv->search_position_func = pspp_sheet_view_search_position_func;
+ tree_view->priv->search_equal_func = pspp_sheet_view_search_equal_func;
+ tree_view->priv->search_custom_entry_set = FALSE;
+ tree_view->priv->typeselect_flush_timeout = 0;
+ tree_view->priv->init_hadjust_value = TRUE;
+ tree_view->priv->width = 0;
+
+ tree_view->priv->hover_selection = FALSE;
+ tree_view->priv->hover_expand = FALSE;
+
+ tree_view->priv->level_indentation = 0;
+
+ tree_view->priv->rubber_banding_enable = FALSE;
+
+ tree_view->priv->grid_lines = PSPP_SHEET_VIEW_GRID_LINES_NONE;
+ tree_view->priv->tree_lines_enabled = FALSE;
+
+ tree_view->priv->tooltip_column = -1;
+
+ tree_view->priv->post_validation_flag = FALSE;
+
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
+
+ tree_view->priv->event_last_x = -10000;
+ tree_view->priv->event_last_y = -10000;
+}
+
+
+
+/* GObject Methods
+ */
+
+static void
+pspp_sheet_view_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ PsppSheetView *tree_view;
+
+ tree_view = PSPP_SHEET_VIEW (object);
+
+ switch (prop_id)
+ {
+ case PROP_MODEL:
+ pspp_sheet_view_set_model (tree_view, g_value_get_object (value));
+ break;
+ case PROP_HADJUSTMENT:
+ pspp_sheet_view_set_hadjustment (tree_view, g_value_get_object (value));
+ break;
+ case PROP_VADJUSTMENT:
+ pspp_sheet_view_set_vadjustment (tree_view, g_value_get_object (value));
+ break;
+ case PROP_HEADERS_VISIBLE:
+ pspp_sheet_view_set_headers_visible (tree_view, g_value_get_boolean
(value));
+ break;
+ case PROP_HEADERS_CLICKABLE:
+ pspp_sheet_view_set_headers_clickable (tree_view, g_value_get_boolean
(value));
+ break;
+ case PROP_EXPANDER_COLUMN:
+ pspp_sheet_view_set_expander_column (tree_view, g_value_get_object
(value));
+ break;
+ case PROP_REORDERABLE:
+ pspp_sheet_view_set_reorderable (tree_view, g_value_get_boolean (value));
+ break;
+ case PROP_RULES_HINT:
+ pspp_sheet_view_set_rules_hint (tree_view, g_value_get_boolean (value));
+ break;
+ case PROP_ENABLE_SEARCH:
+ pspp_sheet_view_set_enable_search (tree_view, g_value_get_boolean
(value));
+ break;
+ case PROP_SEARCH_COLUMN:
+ pspp_sheet_view_set_search_column (tree_view, g_value_get_int (value));
+ break;
+ case PROP_FIXED_HEIGHT_MODE:
+ pspp_sheet_view_set_fixed_height_mode (tree_view, g_value_get_boolean
(value));
+ break;
+ case PROP_HOVER_SELECTION:
+ tree_view->priv->hover_selection = g_value_get_boolean (value);
+ break;
+ case PROP_HOVER_EXPAND:
+ tree_view->priv->hover_expand = g_value_get_boolean (value);
+ break;
+ case PROP_SHOW_EXPANDERS:
+ pspp_sheet_view_set_show_expanders (tree_view, g_value_get_boolean
(value));
+ break;
+ case PROP_LEVEL_INDENTATION:
+ tree_view->priv->level_indentation = g_value_get_int (value);
+ break;
+ case PROP_RUBBER_BANDING:
+ tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
+ break;
+ case PROP_ENABLE_GRID_LINES:
+ pspp_sheet_view_set_grid_lines (tree_view, g_value_get_enum (value));
+ break;
+ case PROP_ENABLE_TREE_LINES:
+ pspp_sheet_view_set_enable_tree_lines (tree_view, g_value_get_boolean
(value));
+ break;
+ case PROP_TOOLTIP_COLUMN:
+ pspp_sheet_view_set_tooltip_column (tree_view, g_value_get_int (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+pspp_sheet_view_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ PsppSheetView *tree_view;
+
+ tree_view = PSPP_SHEET_VIEW (object);
+
+ switch (prop_id)
+ {
+ case PROP_MODEL:
+ g_value_set_object (value, tree_view->priv->model);
+ break;
+ case PROP_HADJUSTMENT:
+ g_value_set_object (value, tree_view->priv->hadjustment);
+ break;
+ case PROP_VADJUSTMENT:
+ g_value_set_object (value, tree_view->priv->vadjustment);
+ break;
+ case PROP_HEADERS_VISIBLE:
+ g_value_set_boolean (value, pspp_sheet_view_get_headers_visible
(tree_view));
+ break;
+ case PROP_HEADERS_CLICKABLE:
+ g_value_set_boolean (value, pspp_sheet_view_get_headers_clickable
(tree_view));
+ break;
+ case PROP_EXPANDER_COLUMN:
+ g_value_set_object (value, tree_view->priv->expander_column);
+ break;
+ case PROP_REORDERABLE:
+ g_value_set_boolean (value, tree_view->priv->reorderable);
+ break;
+ case PROP_RULES_HINT:
+ g_value_set_boolean (value, tree_view->priv->has_rules);
+ break;
+ case PROP_ENABLE_SEARCH:
+ g_value_set_boolean (value, tree_view->priv->enable_search);
+ break;
+ case PROP_SEARCH_COLUMN:
+ g_value_set_int (value, tree_view->priv->search_column);
+ break;
+ case PROP_FIXED_HEIGHT_MODE:
+ g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
+ break;
+ case PROP_HOVER_SELECTION:
+ g_value_set_boolean (value, tree_view->priv->hover_selection);
+ break;
+ case PROP_HOVER_EXPAND:
+ g_value_set_boolean (value, tree_view->priv->hover_expand);
+ break;
+ case PROP_SHOW_EXPANDERS:
+ g_value_set_boolean (value, PSPP_SHEET_VIEW_FLAG_SET (tree_view,
PSPP_SHEET_VIEW_SHOW_EXPANDERS));
+ break;
+ case PROP_LEVEL_INDENTATION:
+ g_value_set_int (value, tree_view->priv->level_indentation);
+ break;
+ case PROP_RUBBER_BANDING:
+ g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
+ break;
+ case PROP_ENABLE_GRID_LINES:
+ g_value_set_enum (value, tree_view->priv->grid_lines);
+ break;
+ case PROP_ENABLE_TREE_LINES:
+ g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
+ break;
+ case PROP_TOOLTIP_COLUMN:
+ g_value_set_int (value, tree_view->priv->tooltip_column);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+pspp_sheet_view_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (pspp_sheet_view_parent_class)->finalize (object);
+}
+
+
+
+static void
+pspp_sheet_view_buildable_add_child (GtkBuildable *tree_view,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *type)
+{
+ pspp_sheet_view_append_column (PSPP_SHEET_VIEW (tree_view),
PSPP_SHEET_VIEW_COLUMN (child));
+}
+
+/* GtkObject Methods
+ */
+
+static void
+pspp_sheet_view_free_rbtree (PsppSheetView *tree_view)
+{
+ _pspp_rbtree_free (tree_view->priv->tree);
+
+ tree_view->priv->tree = NULL;
+ tree_view->priv->button_pressed_node = NULL;
+ tree_view->priv->button_pressed_tree = NULL;
+ tree_view->priv->prelight_tree = NULL;
+ tree_view->priv->prelight_node = NULL;
+ tree_view->priv->expanded_collapsed_node = NULL;
+ tree_view->priv->expanded_collapsed_tree = NULL;
+}
+
+static void
+pspp_sheet_view_destroy (GtkObject *object)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (object);
+ GList *list;
+
+ pspp_sheet_view_stop_editing (tree_view, TRUE);
+
+ if (tree_view->priv->columns != NULL)
+ {
+ list = tree_view->priv->columns;
+ while (list)
+ {
+ PsppSheetViewColumn *column;
+ column = PSPP_SHEET_VIEW_COLUMN (list->data);
+ list = list->next;
+ pspp_sheet_view_remove_column (tree_view, column);
+ }
+ tree_view->priv->columns = NULL;
+ }
+
+ if (tree_view->priv->tree != NULL)
+ {
+ pspp_sheet_view_unref_and_check_selection_tree (tree_view,
tree_view->priv->tree);
+
+ pspp_sheet_view_free_rbtree (tree_view);
+ }
+
+ if (tree_view->priv->selection != NULL)
+ {
+ _pspp_sheet_selection_set_tree_view (tree_view->priv->selection, NULL);
+ g_object_unref (tree_view->priv->selection);
+ tree_view->priv->selection = NULL;
+ }
+
+ if (tree_view->priv->scroll_to_path != NULL)
+ {
+ gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
+ tree_view->priv->scroll_to_path = NULL;
+ }
+
+ if (tree_view->priv->drag_dest_row != NULL)
+ {
+ gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
+ tree_view->priv->drag_dest_row = NULL;
+ }
+
+ if (tree_view->priv->top_row != NULL)
+ {
+ gtk_tree_row_reference_free (tree_view->priv->top_row);
+ tree_view->priv->top_row = NULL;
+ }
+
+ if (tree_view->priv->column_drop_func_data &&
+ tree_view->priv->column_drop_func_data_destroy)
+ {
+ tree_view->priv->column_drop_func_data_destroy
(tree_view->priv->column_drop_func_data);
+ tree_view->priv->column_drop_func_data = NULL;
+ }
+
+ if (tree_view->priv->destroy_count_destroy &&
+ tree_view->priv->destroy_count_data)
+ {
+ tree_view->priv->destroy_count_destroy
(tree_view->priv->destroy_count_data);
+ tree_view->priv->destroy_count_data = NULL;
+ }
+
+ gtk_tree_row_reference_free (tree_view->priv->cursor);
+ tree_view->priv->cursor = NULL;
+
+ gtk_tree_row_reference_free (tree_view->priv->anchor);
+ tree_view->priv->anchor = NULL;
+
+ /* destroy interactive search dialog */
+ if (tree_view->priv->search_window)
+ {
+ gtk_widget_destroy (tree_view->priv->search_window);
+ tree_view->priv->search_window = NULL;
+ tree_view->priv->search_entry = NULL;
+ if (tree_view->priv->typeselect_flush_timeout)
+ {
+ g_source_remove (tree_view->priv->typeselect_flush_timeout);
+ tree_view->priv->typeselect_flush_timeout = 0;
+ }
+ }
+
+ if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
+ {
+ tree_view->priv->search_destroy (tree_view->priv->search_user_data);
+ tree_view->priv->search_user_data = NULL;
+ }
+
+ if (tree_view->priv->search_position_destroy &&
tree_view->priv->search_position_user_data)
+ {
+ tree_view->priv->search_position_destroy
(tree_view->priv->search_position_user_data);
+ tree_view->priv->search_position_user_data = NULL;
+ }
+
+ if (tree_view->priv->row_separator_destroy &&
tree_view->priv->row_separator_data)
+ {
+ tree_view->priv->row_separator_destroy
(tree_view->priv->row_separator_data);
+ tree_view->priv->row_separator_data = NULL;
+ }
+
+ pspp_sheet_view_set_model (tree_view, NULL);
+
+ if (tree_view->priv->hadjustment)
+ {
+ g_object_unref (tree_view->priv->hadjustment);
+ tree_view->priv->hadjustment = NULL;
+ }
+ if (tree_view->priv->vadjustment)
+ {
+ g_object_unref (tree_view->priv->vadjustment);
+ tree_view->priv->vadjustment = NULL;
+ }
+
+ GTK_OBJECT_CLASS (pspp_sheet_view_parent_class)->destroy (object);
+}
+
+
+
+/* GtkWidget Methods
+ */
+
+/* GtkWidget::map helper */
+static void
+pspp_sheet_view_map_buttons (PsppSheetView *tree_view)
+{
+ GList *list;
+
+ g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE))
+ {
+ PsppSheetViewColumn *column;
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ column = list->data;
+ if (gtk_widget_get_visible (column->button) &&
+ !gtk_widget_get_mapped (column->button))
+ gtk_widget_map (column->button);
+ }
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ column = list->data;
+ if (column->visible == FALSE)
+ continue;
+ if (column->resizable)
+ {
+ gdk_window_raise (column->window);
+ gdk_window_show (column->window);
+ }
+ else
+ gdk_window_hide (column->window);
+ }
+ gdk_window_show (tree_view->priv->header_window);
+ }
+}
+
+static void
+pspp_sheet_view_map (GtkWidget *widget)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GList *tmp_list;
+
+ gtk_widget_set_mapped (widget, TRUE);
+
+ tmp_list = tree_view->priv->children;
+ while (tmp_list)
+ {
+ PsppSheetViewChild *child = tmp_list->data;
+ tmp_list = tmp_list->next;
+
+ if (gtk_widget_get_visible (child->widget))
+ {
+ if (!gtk_widget_get_mapped (child->widget))
+ gtk_widget_map (child->widget);
+ }
+ }
+ gdk_window_show (tree_view->priv->bin_window);
+
+ pspp_sheet_view_map_buttons (tree_view);
+
+ gdk_window_show (widget->window);
+}
+
+static void
+pspp_sheet_view_realize (GtkWidget *widget)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GList *tmp_list;
+ GdkWindowAttr attributes;
+ gint attributes_mask;
+
+ gtk_widget_set_realized (widget, TRUE);
+
+ /* Make the main, clipping window */
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.x = widget->allocation.x;
+ attributes.y = widget->allocation.y;
+ attributes.width = widget->allocation.width;
+ attributes.height = widget->allocation.height;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.visual = gtk_widget_get_visual (widget);
+ attributes.colormap = gtk_widget_get_colormap (widget);
+ attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
+
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+ widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask);
+ gdk_window_set_user_data (widget->window, widget);
+
+ /* Make the window for the tree */
+ attributes.x = 0;
+ attributes.y = TREE_VIEW_HEADER_HEIGHT (tree_view);
+ attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
+ attributes.height = widget->allocation.height;
+ attributes.event_mask = (GDK_EXPOSURE_MASK |
+ GDK_SCROLL_MASK |
+ GDK_POINTER_MOTION_MASK |
+ GDK_ENTER_NOTIFY_MASK |
+ GDK_LEAVE_NOTIFY_MASK |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ gtk_widget_get_events (widget));
+
+ tree_view->priv->bin_window = gdk_window_new (widget->window,
+ &attributes, attributes_mask);
+ gdk_window_set_user_data (tree_view->priv->bin_window, widget);
+
+ /* Make the column header window */
+ attributes.x = 0;
+ attributes.y = 0;
+ attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
+ attributes.height = tree_view->priv->header_height;
+ attributes.event_mask = (GDK_EXPOSURE_MASK |
+ GDK_SCROLL_MASK |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_KEY_PRESS_MASK |
+ GDK_KEY_RELEASE_MASK |
+ gtk_widget_get_events (widget));
+
+ tree_view->priv->header_window = gdk_window_new (widget->window,
+ &attributes,
attributes_mask);
+ gdk_window_set_user_data (tree_view->priv->header_window, widget);
+
+ /* Add them all up. */
+ widget->style = gtk_style_attach (widget->style, widget->window);
+ gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
+ gdk_window_set_background (tree_view->priv->bin_window,
&widget->style->base[widget->state]);
+ gtk_style_set_background (widget->style, tree_view->priv->header_window,
GTK_STATE_NORMAL);
+
+ tmp_list = tree_view->priv->children;
+ while (tmp_list)
+ {
+ PsppSheetViewChild *child = tmp_list->data;
+ tmp_list = tmp_list->next;
+
+ gtk_widget_set_parent_window (child->widget,
tree_view->priv->bin_window);
+ }
+
+ for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list =
tmp_list->next)
+ _pspp_sheet_view_column_realize_button (PSPP_SHEET_VIEW_COLUMN
(tmp_list->data));
+
+ /* Need to call those here, since they create GCs */
+ pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
+ pspp_sheet_view_set_enable_tree_lines (tree_view,
tree_view->priv->tree_lines_enabled);
+
+ install_presize_handler (tree_view);
+}
+
+static void
+pspp_sheet_view_unrealize (GtkWidget *widget)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ PsppSheetViewPrivate *priv = tree_view->priv;
+ GList *list;
+
+ if (priv->scroll_timeout != 0)
+ {
+ g_source_remove (priv->scroll_timeout);
+ priv->scroll_timeout = 0;
+ }
+
+ if (priv->auto_expand_timeout != 0)
+ {
+ g_source_remove (priv->auto_expand_timeout);
+ priv->auto_expand_timeout = 0;
+ }
+
+ if (priv->open_dest_timeout != 0)
+ {
+ g_source_remove (priv->open_dest_timeout);
+ priv->open_dest_timeout = 0;
+ }
+
+ remove_expand_collapse_timeout (tree_view);
+
+ if (priv->presize_handler_timer != 0)
+ {
+ g_source_remove (priv->presize_handler_timer);
+ priv->presize_handler_timer = 0;
+ }
+
+ if (priv->validate_rows_timer != 0)
+ {
+ g_source_remove (priv->validate_rows_timer);
+ priv->validate_rows_timer = 0;
+ }
+
+ if (priv->scroll_sync_timer != 0)
+ {
+ g_source_remove (priv->scroll_sync_timer);
+ priv->scroll_sync_timer = 0;
+ }
+
+ if (priv->typeselect_flush_timeout)
+ {
+ g_source_remove (priv->typeselect_flush_timeout);
+ priv->typeselect_flush_timeout = 0;
+ }
+
+ for (list = priv->columns; list; list = list->next)
+ _pspp_sheet_view_column_unrealize_button (PSPP_SHEET_VIEW_COLUMN
(list->data));
+
+ gdk_window_set_user_data (priv->bin_window, NULL);
+ gdk_window_destroy (priv->bin_window);
+ priv->bin_window = NULL;
+
+ gdk_window_set_user_data (priv->header_window, NULL);
+ gdk_window_destroy (priv->header_window);
+ priv->header_window = NULL;
+
+ if (priv->drag_window)
+ {
+ gdk_window_set_user_data (priv->drag_window, NULL);
+ gdk_window_destroy (priv->drag_window);
+ priv->drag_window = NULL;
+ }
+
+ if (priv->drag_highlight_window)
+ {
+ gdk_window_set_user_data (priv->drag_highlight_window, NULL);
+ gdk_window_destroy (priv->drag_highlight_window);
+ priv->drag_highlight_window = NULL;
+ }
+
+ if (priv->tree_line_gc)
+ {
+ g_object_unref (priv->tree_line_gc);
+ priv->tree_line_gc = NULL;
+ }
+
+ if (priv->grid_line_gc)
+ {
+ g_object_unref (priv->grid_line_gc);
+ priv->grid_line_gc = NULL;
+ }
+
+ GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->unrealize (widget);
+}
+
+/* GtkWidget::size_request helper */
+static void
+pspp_sheet_view_size_request_columns (PsppSheetView *tree_view)
+{
+ GList *list;
+
+ tree_view->priv->header_height = 0;
+
+ if (tree_view->priv->model)
+ {
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ GtkRequisition requisition;
+ PsppSheetViewColumn *column = list->data;
+
+ if (column->button == NULL)
+ continue;
+
+ column = list->data;
+
+ gtk_widget_size_request (column->button, &requisition);
+ column->button_request = requisition.width;
+ tree_view->priv->header_height = MAX
(tree_view->priv->header_height, requisition.height);
+ }
+ }
+}
+
+
+/* Called only by ::size_request */
+static void
+pspp_sheet_view_update_size (PsppSheetView *tree_view)
+{
+ GList *list;
+ PsppSheetViewColumn *column;
+ gint i;
+
+ if (tree_view->priv->model == NULL)
+ {
+ tree_view->priv->width = 0;
+ tree_view->priv->prev_width = 0;
+ tree_view->priv->height = 0;
+ return;
+ }
+
+ tree_view->priv->prev_width = tree_view->priv->width;
+ tree_view->priv->width = 0;
+
+ /* keep this in sync with size_allocate below */
+ for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
+ {
+ gint real_requested_width = 0;
+ column = list->data;
+ if (!column->visible)
+ continue;
+
+ if (column->use_resized_width)
+ {
+ real_requested_width = column->resized_width;
+ }
+ else if (column->column_type == PSPP_SHEET_VIEW_COLUMN_FIXED)
+ {
+ real_requested_width = column->fixed_width;
+ }
+ else if (PSPP_SHEET_VIEW_FLAG_SET (tree_view,
PSPP_SHEET_VIEW_HEADERS_VISIBLE))
+ {
+ real_requested_width = MAX (column->requested_width,
column->button_request);
+ }
+ else
+ {
+ real_requested_width = column->requested_width;
+ }
+
+ if (column->min_width != -1)
+ real_requested_width = MAX (real_requested_width, column->min_width);
+ if (column->max_width != -1)
+ real_requested_width = MIN (real_requested_width, column->max_width);
+
+ tree_view->priv->width += real_requested_width;
+ }
+
+ if (tree_view->priv->tree == NULL)
+ tree_view->priv->height = 0;
+ else
+ tree_view->priv->height = tree_view->priv->tree->root->offset;
+}
+
+static void
+pspp_sheet_view_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GList *tmp_list;
+
+ /* we validate some rows initially just to make sure we have some size.
+ * In practice, with a lot of static lists, this should get a good width.
+ */
+ do_validate_rows (tree_view, FALSE);
+ pspp_sheet_view_size_request_columns (tree_view);
+ pspp_sheet_view_update_size (PSPP_SHEET_VIEW (widget));
+
+ requisition->width = tree_view->priv->width;
+ requisition->height = tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT
(tree_view);
+
+ tmp_list = tree_view->priv->children;
+
+ while (tmp_list)
+ {
+ PsppSheetViewChild *child = tmp_list->data;
+ GtkRequisition child_requisition;
+
+ tmp_list = tmp_list->next;
+
+ if (gtk_widget_get_visible (child->widget))
+ gtk_widget_size_request (child->widget, &child_requisition);
+ }
+}
+
+static int
+pspp_sheet_view_calculate_width_before_expander (PsppSheetView *tree_view)
+{
+ int width = 0;
+ GList *list;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list->data != tree_view->priv->expander_column;
+ list = (rtl ? list->prev : list->next))
+ {
+ PsppSheetViewColumn *column = list->data;
+
+ width += column->width;
+ }
+
+ return width;
+}
+
+static void
+invalidate_column (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column)
+{
+ gint column_offset = 0;
+ GList *list;
+ GtkWidget *widget = GTK_WIDGET (tree_view);
+ gboolean rtl;
+
+ if (!gtk_widget_get_realized (widget))
+ return;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list;
+ list = (rtl ? list->prev : list->next))
+ {
+ PsppSheetViewColumn *tmpcolumn = list->data;
+ if (tmpcolumn == column)
+ {
+ GdkRectangle invalid_rect;
+
+ invalid_rect.x = column_offset;
+ invalid_rect.y = 0;
+ invalid_rect.width = column->width;
+ invalid_rect.height = widget->allocation.height;
+
+ gdk_window_invalidate_rect (widget->window, &invalid_rect, TRUE);
+ break;
+ }
+
+ column_offset += tmpcolumn->width;
+ }
+}
+
+static void
+invalidate_last_column (PsppSheetView *tree_view)
+{
+ GList *last_column;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+
+ for (last_column = (rtl ? g_list_first (tree_view->priv->columns) :
g_list_last (tree_view->priv->columns));
+ last_column;
+ last_column = (rtl ? last_column->next : last_column->prev))
+ {
+ if (PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible)
+ {
+ invalidate_column (tree_view, last_column->data);
+ return;
+ }
+ }
+}
+
+static gint
+pspp_sheet_view_get_real_requested_width_from_column (PsppSheetView
*tree_view,
+ PsppSheetViewColumn
*column)
+{
+ gint real_requested_width;
+
+ if (column->use_resized_width)
+ {
+ real_requested_width = column->resized_width;
+ }
+ else if (column->column_type == PSPP_SHEET_VIEW_COLUMN_FIXED)
+ {
+ real_requested_width = column->fixed_width;
+ }
+ else if (PSPP_SHEET_VIEW_FLAG_SET (tree_view,
PSPP_SHEET_VIEW_HEADERS_VISIBLE))
+ {
+ real_requested_width = MAX (column->requested_width,
column->button_request);
+ }
+ else
+ {
+ real_requested_width = column->requested_width;
+ if (real_requested_width < 0)
+ real_requested_width = 0;
+ }
+
+ if (column->min_width != -1)
+ real_requested_width = MAX (real_requested_width, column->min_width);
+ if (column->max_width != -1)
+ real_requested_width = MIN (real_requested_width, column->max_width);
+
+ return real_requested_width;
+}
+
+/* GtkWidget::size_allocate helper */
+static void
+pspp_sheet_view_size_allocate_columns (GtkWidget *widget,
+ gboolean *width_changed)
+{
+ PsppSheetView *tree_view;
+ GList *list, *first_column, *last_column;
+ PsppSheetViewColumn *column;
+ GtkAllocation allocation;
+ gint width = 0;
+ gint extra, extra_per_column, extra_for_last;
+ gint full_requested_width = 0;
+ gint number_of_expand_columns = 0;
+ gboolean column_changed = FALSE;
+ gboolean rtl;
+ gboolean update_expand;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ for (last_column = g_list_last (tree_view->priv->columns);
+ last_column && !(PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible);
+ last_column = last_column->prev)
+ ;
+ if (last_column == NULL)
+ return;
+
+ for (first_column = g_list_first (tree_view->priv->columns);
+ first_column && !(PSPP_SHEET_VIEW_COLUMN (first_column->data)->visible);
+ first_column = first_column->next)
+ ;
+
+ allocation.y = 0;
+ allocation.height = tree_view->priv->header_height;
+
+ rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+
+ /* find out how many extra space and expandable columns we have */
+ for (list = tree_view->priv->columns; list != last_column->next; list =
list->next)
+ {
+ column = (PsppSheetViewColumn *)list->data;
+
+ if (!column->visible)
+ continue;
+
+ full_requested_width +=
pspp_sheet_view_get_real_requested_width_from_column (tree_view, column);
+
+ if (column->expand)
+ number_of_expand_columns++;
+ }
+
+ /* Only update the expand value if the width of the widget has changed,
+ * or the number of expand columns has changed, or if there are no expand
+ * columns, or if we didn't have an size-allocation yet after the
+ * last validated node.
+ */
+ update_expand = (width_changed && *width_changed == TRUE)
+ || number_of_expand_columns !=
tree_view->priv->last_number_of_expand_columns
+ || number_of_expand_columns == 0
+ || tree_view->priv->post_validation_flag == TRUE;
+
+ tree_view->priv->post_validation_flag = FALSE;
+
+ if (!update_expand)
+ {
+ extra = tree_view->priv->last_extra_space;
+ extra_for_last = MAX (widget->allocation.width - full_requested_width -
extra, 0);
+ }
+ else
+ {
+ extra = MAX (widget->allocation.width - full_requested_width, 0);
+ extra_for_last = 0;
+
+ tree_view->priv->last_extra_space = extra;
+ }
+
+ if (number_of_expand_columns > 0)
+ extra_per_column = extra/number_of_expand_columns;
+ else
+ extra_per_column = 0;
+
+ if (update_expand)
+ {
+ tree_view->priv->last_extra_space_per_column = extra_per_column;
+ tree_view->priv->last_number_of_expand_columns =
number_of_expand_columns;
+ }
+
+ for (list = (rtl ? last_column : first_column);
+ list != (rtl ? first_column->prev : last_column->next);
+ list = (rtl ? list->prev : list->next))
+ {
+ gint real_requested_width = 0;
+ gint old_width;
+
+ column = list->data;
+ old_width = column->width;
+
+ if (!column->visible)
+ continue;
+
+ /* We need to handle the dragged button specially.
+ */
+ if (column == tree_view->priv->drag_column)
+ {
+ GtkAllocation drag_allocation;
+ gdk_drawable_get_size (tree_view->priv->drag_window,
+ &(drag_allocation.width),
+ &(drag_allocation.height));
+ drag_allocation.x = 0;
+ drag_allocation.y = 0;
+ gtk_widget_size_allocate (tree_view->priv->drag_column->button,
+ &drag_allocation);
+ width += drag_allocation.width;
+ continue;
+ }
+
+ real_requested_width =
pspp_sheet_view_get_real_requested_width_from_column (tree_view, column);
+
+ allocation.x = width;
+ column->width = real_requested_width;
+
+ if (column->expand)
+ {
+ if (number_of_expand_columns == 1)
+ {
+ /* We add the remander to the last column as
+ * */
+ column->width += extra;
+ }
+ else
+ {
+ column->width += extra_per_column;
+ extra -= extra_per_column;
+ number_of_expand_columns --;
+ }
+ }
+ else if (number_of_expand_columns == 0 &&
+ list == last_column)
+ {
+ column->width += extra;
+ }
+
+ /* In addition to expand, the last column can get even more
+ * extra space so all available space is filled up.
+ */
+ if (extra_for_last > 0 && list == last_column)
+ column->width += extra_for_last;
+
+ g_object_notify (G_OBJECT (column), "width");
+
+ allocation.width = column->width;
+ width += column->width;
+
+ if (column->width > old_width)
+ column_changed = TRUE;
+
+ gtk_widget_size_allocate (column->button, &allocation);
+
+ if (column->window)
+ gdk_window_move_resize (column->window,
+ allocation.x + (rtl ? 0 : allocation.width) -
TREE_VIEW_DRAG_WIDTH/2,
+ allocation.y,
+ TREE_VIEW_DRAG_WIDTH, allocation.height);
+ }
+
+ /* We change the width here. The user might have been resizing columns,
+ * so the total width of the tree view changes.
+ */
+ tree_view->priv->width = width;
+ if (width_changed)
+ *width_changed = TRUE;
+
+ if (column_changed)
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+}
+
+
+static void
+pspp_sheet_view_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GList *tmp_list;
+ gboolean width_changed = FALSE;
+ gint old_width = widget->allocation.width;
+
+ if (allocation->width != widget->allocation.width)
+ width_changed = TRUE;
+
+ widget->allocation = *allocation;
+
+ tmp_list = tree_view->priv->children;
+
+ while (tmp_list)
+ {
+ GtkAllocation allocation;
+
+ PsppSheetViewChild *child = tmp_list->data;
+ tmp_list = tmp_list->next;
+
+ /* totally ignore our child's requisition */
+ allocation.x = child->x;
+ allocation.y = child->y;
+ allocation.width = child->width;
+ allocation.height = child->height;
+ gtk_widget_size_allocate (child->widget, &allocation);
+ }
+
+ /* We size-allocate the columns first because the width of the
+ * tree view (used in updating the adjustments below) might change.
+ */
+ pspp_sheet_view_size_allocate_columns (widget, &width_changed);
+
+ tree_view->priv->hadjustment->page_size = allocation->width;
+ tree_view->priv->hadjustment->page_increment = allocation->width * 0.9;
+ tree_view->priv->hadjustment->step_increment = allocation->width * 0.1;
+ tree_view->priv->hadjustment->lower = 0;
+ tree_view->priv->hadjustment->upper = MAX
(tree_view->priv->hadjustment->page_size, tree_view->priv->width);
+
+ if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
+ {
+ if (allocation->width < tree_view->priv->width)
+ {
+ if (tree_view->priv->init_hadjust_value)
+ {
+ tree_view->priv->hadjustment->value = MAX (tree_view->priv->width
- allocation->width, 0);
+ tree_view->priv->init_hadjust_value = FALSE;
+ }
+ else if (allocation->width != old_width)
+ {
+ tree_view->priv->hadjustment->value = CLAMP
(tree_view->priv->hadjustment->value - allocation->width + old_width, 0,
tree_view->priv->width - allocation->width);
+ }
+ else
+ tree_view->priv->hadjustment->value = CLAMP (tree_view->priv->width
- (tree_view->priv->prev_width - tree_view->priv->hadjustment->value), 0,
tree_view->priv->width - allocation->width);
+ }
+ else
+ {
+ tree_view->priv->hadjustment->value = 0;
+ tree_view->priv->init_hadjust_value = TRUE;
+ }
+ }
+ else
+ if (tree_view->priv->hadjustment->value + allocation->width >
tree_view->priv->width)
+ tree_view->priv->hadjustment->value = MAX (tree_view->priv->width -
allocation->width, 0);
+
+ gtk_adjustment_changed (tree_view->priv->hadjustment);
+
+ tree_view->priv->vadjustment->page_size = allocation->height -
TREE_VIEW_HEADER_HEIGHT (tree_view);
+ tree_view->priv->vadjustment->step_increment =
tree_view->priv->vadjustment->page_size * 0.1;
+ tree_view->priv->vadjustment->page_increment =
tree_view->priv->vadjustment->page_size * 0.9;
+ tree_view->priv->vadjustment->lower = 0;
+ tree_view->priv->vadjustment->upper = MAX
(tree_view->priv->vadjustment->page_size, tree_view->priv->height);
+
+ gtk_adjustment_changed (tree_view->priv->vadjustment);
+
+ /* now the adjustments and window sizes are in sync, we can sync toprow/dy
again */
+ if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
+ gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
0);
+ else if (tree_view->priv->vadjustment->value +
tree_view->priv->vadjustment->page_size > tree_view->priv->height)
+ gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
+ tree_view->priv->height -
tree_view->priv->vadjustment->page_size);
+ else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
+ pspp_sheet_view_top_row_to_dy (tree_view);
+ else
+ pspp_sheet_view_dy_to_top_row (tree_view);
+
+ if (gtk_widget_get_realized (widget))
+ {
+ gdk_window_move_resize (widget->window,
+ allocation->x, allocation->y,
+ allocation->width, allocation->height);
+ gdk_window_move_resize (tree_view->priv->header_window,
+ - (gint) tree_view->priv->hadjustment->value,
+ 0,
+ MAX (tree_view->priv->width, allocation->width),
+ tree_view->priv->header_height);
+ gdk_window_move_resize (tree_view->priv->bin_window,
+ - (gint) tree_view->priv->hadjustment->value,
+ TREE_VIEW_HEADER_HEIGHT (tree_view),
+ MAX (tree_view->priv->width, allocation->width),
+ allocation->height - TREE_VIEW_HEADER_HEIGHT
(tree_view));
+ }
+
+ if (tree_view->priv->tree == NULL)
+ invalidate_empty_focus (tree_view);
+
+ if (gtk_widget_get_realized (widget))
+ {
+ gboolean has_expand_column = FALSE;
+ for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list =
tmp_list->next)
+ {
+ if (pspp_sheet_view_column_get_expand (PSPP_SHEET_VIEW_COLUMN
(tmp_list->data)))
+ {
+ has_expand_column = TRUE;
+ break;
+ }
+ }
+
+ if (width_changed && tree_view->priv->expander_column)
+ {
+ /* Might seem awkward, but is the best heuristic I could come up
+ * with. Only if the width of the columns before the expander
+ * changes, we will update the prelight status. It is this
+ * width that makes the expander move vertically. Always updating
+ * prelight status causes trouble with hover selections.
+ */
+ gint width_before_expander;
+
+ width_before_expander =
pspp_sheet_view_calculate_width_before_expander (tree_view);
+
+ if (tree_view->priv->prev_width_before_expander
+ != width_before_expander)
+ update_prelight (tree_view,
+ tree_view->priv->event_last_x,
+ tree_view->priv->event_last_y);
+
+ tree_view->priv->prev_width_before_expander = width_before_expander;
+ }
+
+ /* This little hack only works if we have an LTR locale, and no column
has the */
+ if (width_changed)
+ {
+ if (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_LTR &&
+ ! has_expand_column)
+ invalidate_last_column (tree_view);
+ else
+ gtk_widget_queue_draw (widget);
+ }
+ }
+}
+
+/* Grabs the focus and unsets the PSPP_SHEET_VIEW_DRAW_KEYFOCUS flag */
+static void
+grab_focus_and_unset_draw_keyfocus (PsppSheetView *tree_view)
+{
+ GtkWidget *widget = GTK_WIDGET (tree_view);
+
+ if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
+ gtk_widget_grab_focus (widget);
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
+}
+
+static inline gboolean
+row_is_separator (PsppSheetView *tree_view,
+ GtkTreeIter *iter,
+ GtkTreePath *path)
+{
+ gboolean is_separator = FALSE;
+
+ if (tree_view->priv->row_separator_func)
+ {
+ GtkTreeIter tmpiter;
+
+ if (iter)
+ tmpiter = *iter;
+ else
+ gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path);
+
+ is_separator = tree_view->priv->row_separator_func
(tree_view->priv->model,
+ &tmpiter,
+
tree_view->priv->row_separator_data);
+ }
+
+ return is_separator;
+}
+
+static gboolean
+pspp_sheet_view_button_press (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GList *list;
+ PsppSheetViewColumn *column = NULL;
+ gint i;
+ GdkRectangle background_area;
+ GdkRectangle cell_area;
+ gint vertical_separator;
+ gint horizontal_separator;
+ gboolean path_is_selectable;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+ pspp_sheet_view_stop_editing (tree_view, FALSE);
+ gtk_widget_style_get (widget,
+ "vertical-separator", &vertical_separator,
+ "horizontal-separator", &horizontal_separator,
+ NULL);
+
+
+ /* Because grab_focus can cause reentrancy, we delay grab_focus until after
+ * we're done handling the button press.
+ */
+
+ if (event->window == tree_view->priv->bin_window)
+ {
+ GtkRBNode *node;
+ GtkRBTree *tree;
+ GtkTreePath *path;
+ gchar *path_string;
+ gint depth;
+ gint new_y;
+ gint y_offset;
+ gint dval;
+ gint pre_val, aft_val;
+ PsppSheetViewColumn *column = NULL;
+ GtkCellRenderer *focus_cell = NULL;
+ gint column_handled_click = FALSE;
+ gboolean row_double_click = FALSE;
+ gboolean rtl;
+ gboolean node_selected;
+
+ /* Empty tree? */
+ if (tree_view->priv->tree == NULL)
+ {
+ grab_focus_and_unset_draw_keyfocus (tree_view);
+ return TRUE;
+ }
+
+ /* are we in an arrow? */
+ if (tree_view->priv->prelight_node &&
+ PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_ARROW_PRELIT) &&
+ TREE_VIEW_DRAW_EXPANDERS (tree_view))
+ {
+ if (event->button == 1)
+ {
+ gtk_grab_add (widget);
+ tree_view->priv->button_pressed_node =
tree_view->priv->prelight_node;
+ tree_view->priv->button_pressed_tree =
tree_view->priv->prelight_tree;
+ pspp_sheet_view_draw_arrow (PSPP_SHEET_VIEW (widget),
+ tree_view->priv->prelight_tree,
+ tree_view->priv->prelight_node,
+ event->x,
+ event->y);
+ }
+
+ grab_focus_and_unset_draw_keyfocus (tree_view);
+ return TRUE;
+ }
+
+ /* find the node that was clicked */
+ new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
+ if (new_y < 0)
+ new_y = 0;
+ y_offset = -_pspp_rbtree_find_offset (tree_view->priv->tree, new_y,
&tree, &node);
+
+ if (node == NULL)
+ {
+ /* We clicked in dead space */
+ grab_focus_and_unset_draw_keyfocus (tree_view);
+ return TRUE;
+ }
+
+ /* Get the path and the node */
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ path_is_selectable = !row_is_separator (tree_view, NULL, path);
+
+ if (!path_is_selectable)
+ {
+ gtk_tree_path_free (path);
+ grab_focus_and_unset_draw_keyfocus (tree_view);
+ return TRUE;
+ }
+
+ depth = gtk_tree_path_get_depth (path);
+ background_area.y = y_offset + event->y;
+ background_area.height = ROW_HEIGHT (tree_view, PSPP_RBNODE_GET_HEIGHT
(node));
+ background_area.x = 0;
+
+
+ /* Let the column have a chance at selecting it. */
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list; list = (rtl ? list->prev : list->next))
+ {
+ PsppSheetViewColumn *candidate = list->data;
+
+ if (!candidate->visible)
+ continue;
+
+ background_area.width = candidate->width;
+ if ((background_area.x > (gint) event->x) ||
+ (background_area.x + background_area.width <= (gint) event->x))
+ {
+ background_area.x += background_area.width;
+ continue;
+ }
+
+ /* we found the focus column */
+ column = candidate;
+ cell_area = background_area;
+ cell_area.width -= horizontal_separator;
+ cell_area.height -= vertical_separator;
+ cell_area.x += horizontal_separator/2;
+ cell_area.y += vertical_separator/2;
+ if (pspp_sheet_view_is_expander_column (tree_view, column))
+ {
+ if (!rtl)
+ cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
+ cell_area.width -= (depth - 1) *
tree_view->priv->level_indentation;
+
+ if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
+ {
+ if (!rtl)
+ cell_area.x += depth * tree_view->priv->expander_size;
+ cell_area.width -= depth * tree_view->priv->expander_size;
+ }
+ }
+ break;
+ }
+
+ if (column == NULL)
+ {
+ gtk_tree_path_free (path);
+ grab_focus_and_unset_draw_keyfocus (tree_view);
+ return FALSE;
+ }
+
+ tree_view->priv->focus_column = column;
+
+ /* decide if we edit */
+ if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
+ !(event->state & gtk_accelerator_get_default_mod_mask ()))
+ {
+ GtkTreePath *anchor;
+ GtkTreeIter iter;
+
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+ pspp_sheet_view_column_cell_set_cell_data (column,
+ tree_view->priv->model,
+ &iter,
+ PSPP_RBNODE_FLAG_SET (node,
PSPP_RBNODE_IS_PARENT),
+ node->children?TRUE:FALSE);
+
+ if (tree_view->priv->anchor)
+ anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
+ else
+ anchor = NULL;
+
+ if ((anchor && !gtk_tree_path_compare (anchor, path))
+ || !_pspp_sheet_view_column_has_editable_cell (column))
+ {
+ GtkCellEditable *cell_editable = NULL;
+
+ /* FIXME: get the right flags */
+ guint flags = 0;
+
+ path_string = gtk_tree_path_to_string (path);
+
+ if (_pspp_sheet_view_column_cell_event (column,
+ &cell_editable,
+ (GdkEvent *)event,
+ path_string,
+ &background_area,
+ &cell_area, flags))
+ {
+ if (cell_editable != NULL)
+ {
+ gint left, right;
+ GdkRectangle area;
+
+ area = cell_area;
+ _pspp_sheet_view_column_get_neighbor_sizes (column,
_pspp_sheet_view_column_get_edited_cell (column), &left, &right);
+
+ area.x += left;
+ area.width -= right + left;
+
+ pspp_sheet_view_real_start_editing (tree_view,
+ column,
+ path,
+ cell_editable,
+ &area,
+ (GdkEvent *)event,
+ flags);
+ g_free (path_string);
+ gtk_tree_path_free (path);
+ gtk_tree_path_free (anchor);
+ return TRUE;
+ }
+ column_handled_click = TRUE;
+ }
+ g_free (path_string);
+ }
+ if (anchor)
+ gtk_tree_path_free (anchor);
+ }
+
+ /* select */
+ node_selected = PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED);
+ pre_val = tree_view->priv->vadjustment->value;
+
+ /* we only handle selection modifications on the first button press
+ */
+ if (event->type == GDK_BUTTON_PRESS)
+ {
+ if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
+ tree_view->priv->ctrl_pressed = TRUE;
+ if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
+ tree_view->priv->shift_pressed = TRUE;
+
+ focus_cell = _pspp_sheet_view_column_get_cell_at_pos (column,
event->x - background_area.x);
+ if (focus_cell)
+ pspp_sheet_view_column_focus_cell (column, focus_cell);
+
+ if (event->state & GDK_CONTROL_MASK)
+ {
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ pspp_sheet_view_real_toggle_cursor_row (tree_view);
+ }
+ else if (event->state & GDK_SHIFT_MASK)
+ {
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ pspp_sheet_view_real_select_cursor_row (tree_view, FALSE);
+ }
+ else
+ {
+ pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ }
+
+ tree_view->priv->ctrl_pressed = FALSE;
+ tree_view->priv->shift_pressed = FALSE;
+ }
+
+ /* the treeview may have been scrolled because of _set_cursor,
+ * correct here
+ */
+
+ aft_val = tree_view->priv->vadjustment->value;
+ dval = pre_val - aft_val;
+
+ cell_area.y += dval;
+ background_area.y += dval;
+
+ /* Save press to possibly begin a drag
+ */
+ if (!column_handled_click &&
+ !tree_view->priv->in_grab &&
+ tree_view->priv->pressed_button < 0)
+ {
+ tree_view->priv->pressed_button = event->button;
+ tree_view->priv->press_start_x = event->x;
+ tree_view->priv->press_start_y = event->y;
+
+ if (tree_view->priv->rubber_banding_enable
+ && !node_selected
+ && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
+ {
+ tree_view->priv->press_start_y += tree_view->priv->dy;
+ tree_view->priv->rubber_band_x = event->x;
+ tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
+ tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
+
+ if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
+ tree_view->priv->rubber_band_ctrl = TRUE;
+ if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
+ tree_view->priv->rubber_band_shift = TRUE;
+ }
+ }
+
+ /* Test if a double click happened on the same row. */
+ if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
+ {
+ int double_click_time, double_click_distance;
+
+ g_object_get (gtk_settings_get_for_screen (
+ gtk_widget_get_screen (widget)),
+ "gtk-double-click-time", &double_click_time,
+ "gtk-double-click-distance", &double_click_distance,
+ NULL);
+
+ /* Same conditions as _gdk_event_button_generate */
+ if (tree_view->priv->last_button_x != -1 &&
+ (event->time < tree_view->priv->last_button_time +
double_click_time) &&
+ (ABS (event->x - tree_view->priv->last_button_x) <=
double_click_distance) &&
+ (ABS (event->y - tree_view->priv->last_button_y) <=
double_click_distance))
+ {
+ /* We do no longer compare paths of this row and the
+ * row clicked previously. We use the double click
+ * distance to decide whether this is a valid click,
+ * allowing the mouse to slightly move over another row.
+ */
+ row_double_click = TRUE;
+
+ tree_view->priv->last_button_time = 0;
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
+ }
+ else
+ {
+ tree_view->priv->last_button_time = event->time;
+ tree_view->priv->last_button_x = event->x;
+ tree_view->priv->last_button_y = event->y;
+ }
+ }
+
+ if (row_double_click)
+ {
+ gtk_grab_remove (widget);
+ pspp_sheet_view_row_activated (tree_view, path, column);
+
+ if (tree_view->priv->pressed_button == event->button)
+ tree_view->priv->pressed_button = -1;
+ }
+
+ gtk_tree_path_free (path);
+
+ /* If we activated the row through a double click we don't want to grab
+ * focus back, as moving focus to another widget is pretty common.
+ */
+ if (!row_double_click)
+ grab_focus_and_unset_draw_keyfocus (tree_view);
+
+ return TRUE;
+ }
+
+ /* We didn't click in the window. Let's check to see if we clicked on a
column resize window.
+ */
+ for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
+ {
+ column = list->data;
+ if (event->window == column->window &&
+ column->resizable &&
+ column->window)
+ {
+ gpointer drag_data;
+
+ if (event->type == GDK_2BUTTON_PRESS &&
+ pspp_sheet_view_column_get_sizing (column) !=
PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ {
+ column->use_resized_width = FALSE;
+ _pspp_sheet_view_column_autosize (tree_view, column);
+ return TRUE;
+ }
+
+ if (gdk_pointer_grab (column->window, FALSE,
+ GDK_POINTER_MOTION_HINT_MASK |
+ GDK_BUTTON1_MOTION_MASK |
+ GDK_BUTTON_RELEASE_MASK,
+ NULL, NULL, event->time))
+ return FALSE;
+
+ gtk_grab_add (widget);
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view,
PSPP_SHEET_VIEW_IN_COLUMN_RESIZE);
+ column->resized_width = column->width -
tree_view->priv->last_extra_space_per_column;
+
+ /* block attached dnd signal handler */
+ drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
+ if (drag_data)
+ g_signal_handlers_block_matched (widget,
+ G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL,
+ drag_data);
+
+ tree_view->priv->drag_pos = i;
+ tree_view->priv->x_drag = column->button->allocation.x + (rtl ? 0 :
column->button->allocation.width);
+
+ if (!gtk_widget_has_focus (widget))
+ gtk_widget_grab_focus (widget);
+
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+/* GtkWidget::button_release_event helper */
+static gboolean
+pspp_sheet_view_button_release_drag_column (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ PsppSheetView *tree_view;
+ GList *l;
+ gboolean rtl;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
GDK_CURRENT_TIME);
+ gdk_display_keyboard_ungrab (gtk_widget_get_display (widget),
GDK_CURRENT_TIME);
+
+ /* Move the button back */
+ g_object_ref (tree_view->priv->drag_column->button);
+ gtk_container_remove (GTK_CONTAINER (tree_view),
tree_view->priv->drag_column->button);
+ gtk_widget_set_parent_window (tree_view->priv->drag_column->button,
tree_view->priv->header_window);
+ gtk_widget_set_parent (tree_view->priv->drag_column->button, GTK_WIDGET
(tree_view));
+ g_object_unref (tree_view->priv->drag_column->button);
+ gtk_widget_queue_resize (widget);
+ if (tree_view->priv->drag_column->resizable)
+ {
+ gdk_window_raise (tree_view->priv->drag_column->window);
+ gdk_window_show (tree_view->priv->drag_column->window);
+ }
+ else
+ gdk_window_hide (tree_view->priv->drag_column->window);
+
+ gtk_widget_grab_focus (tree_view->priv->drag_column->button);
+
+ if (rtl)
+ {
+ if (tree_view->priv->cur_reorder &&
+ tree_view->priv->cur_reorder->right_column !=
tree_view->priv->drag_column)
+ pspp_sheet_view_move_column_after (tree_view,
tree_view->priv->drag_column,
+
tree_view->priv->cur_reorder->right_column);
+ }
+ else
+ {
+ if (tree_view->priv->cur_reorder &&
+ tree_view->priv->cur_reorder->left_column !=
tree_view->priv->drag_column)
+ pspp_sheet_view_move_column_after (tree_view,
tree_view->priv->drag_column,
+
tree_view->priv->cur_reorder->left_column);
+ }
+ tree_view->priv->drag_column = NULL;
+ gdk_window_hide (tree_view->priv->drag_window);
+
+ for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
+ g_slice_free (PsppSheetViewColumnReorder, l->data);
+ g_list_free (tree_view->priv->column_drag_info);
+ tree_view->priv->column_drag_info = NULL;
+ tree_view->priv->cur_reorder = NULL;
+
+ if (tree_view->priv->drag_highlight_window)
+ gdk_window_hide (tree_view->priv->drag_highlight_window);
+
+ /* Reset our flags */
+ tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG);
+
+ return TRUE;
+}
+
+/* GtkWidget::button_release_event helper */
+static gboolean
+pspp_sheet_view_button_release_column_resize (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ PsppSheetView *tree_view;
+ gpointer drag_data;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ tree_view->priv->drag_pos = -1;
+
+ /* unblock attached dnd signal handler */
+ drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
+ if (drag_data)
+ g_signal_handlers_unblock_matched (widget,
+ G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL,
+ drag_data);
+
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE);
+ gtk_grab_remove (widget);
+ gdk_display_pointer_ungrab (gdk_drawable_get_display (event->window),
+ event->time);
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG))
+ return pspp_sheet_view_button_release_drag_column (widget, event);
+
+ if (tree_view->priv->rubber_band_status)
+ pspp_sheet_view_stop_rubber_band (tree_view);
+
+ if (tree_view->priv->pressed_button == event->button)
+ tree_view->priv->pressed_button = -1;
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE))
+ return pspp_sheet_view_button_release_column_resize (widget, event);
+
+ if (tree_view->priv->button_pressed_node == NULL)
+ return FALSE;
+
+ if (event->button == 1)
+ {
+ gtk_grab_remove (widget);
+ if (tree_view->priv->button_pressed_node ==
tree_view->priv->prelight_node &&
+ PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_ARROW_PRELIT))
+ {
+ GtkTreePath *path = NULL;
+
+ path = _pspp_sheet_view_find_path (tree_view,
+ tree_view->priv->button_pressed_tree,
+
tree_view->priv->button_pressed_node);
+ /* Actually activate the node */
+ if (tree_view->priv->button_pressed_node->children == NULL)
+ pspp_sheet_view_real_expand_row (tree_view, path,
+ tree_view->priv->button_pressed_tree,
+ tree_view->priv->button_pressed_node,
+ FALSE, TRUE);
+ else
+ pspp_sheet_view_real_collapse_row (PSPP_SHEET_VIEW (widget), path,
+
tree_view->priv->button_pressed_tree,
+
tree_view->priv->button_pressed_node, TRUE);
+ gtk_tree_path_free (path);
+ }
+
+ tree_view->priv->button_pressed_tree = NULL;
+ tree_view->priv->button_pressed_node = NULL;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_grab_broken (GtkWidget *widget,
+ GdkEventGrabBroken *event)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG))
+ pspp_sheet_view_button_release_drag_column (widget, (GdkEventButton
*)event);
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE))
+ pspp_sheet_view_button_release_column_resize (widget, (GdkEventButton
*)event);
+
+ return TRUE;
+}
+
+#if 0
+static gboolean
+pspp_sheet_view_configure (GtkWidget *widget,
+ GdkEventConfigure *event)
+{
+ PsppSheetView *tree_view;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+ tree_view->priv->search_position_func (tree_view,
tree_view->priv->search_window);
+
+ return FALSE;
+}
+#endif
+
+/* GtkWidget::motion_event function set.
+ */
+
+static gboolean
+coords_are_over_arrow (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ /* these are in bin window coords */
+ gint x,
+ gint y)
+{
+ GdkRectangle arrow;
+ gint x2;
+
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ return FALSE;
+
+ if ((node->flags & PSPP_RBNODE_IS_PARENT) == 0)
+ return FALSE;
+
+ arrow.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
+
+ arrow.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
+
+ pspp_sheet_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
+
+ arrow.width = x2 - arrow.x;
+
+ return (x >= arrow.x &&
+ x < (arrow.x + arrow.width) &&
+ y >= arrow.y &&
+ y < (arrow.y + arrow.height));
+}
+
+static gboolean
+auto_expand_timeout (gpointer data)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (data);
+ GtkTreePath *path;
+
+ if (tree_view->priv->prelight_node)
+ {
+ path = _pspp_sheet_view_find_path (tree_view,
+ tree_view->priv->prelight_tree,
+ tree_view->priv->prelight_node);
+
+ if (tree_view->priv->prelight_node->children)
+ pspp_sheet_view_collapse_row (tree_view, path);
+ else
+ pspp_sheet_view_expand_row (tree_view, path, FALSE);
+
+ gtk_tree_path_free (path);
+ }
+
+ tree_view->priv->auto_expand_timeout = 0;
+
+ return FALSE;
+}
+
+static void
+remove_auto_expand_timeout (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->auto_expand_timeout != 0)
+ {
+ g_source_remove (tree_view->priv->auto_expand_timeout);
+ tree_view->priv->auto_expand_timeout = 0;
+ }
+}
+
+static void
+do_prelight (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ /* these are in bin_window coords */
+ gint x,
+ gint y)
+{
+ if (tree_view->priv->prelight_tree == tree &&
+ tree_view->priv->prelight_node == node)
+ {
+ /* We are still on the same node,
+ but we might need to take care of the arrow */
+
+ if (tree && node && TREE_VIEW_DRAW_EXPANDERS (tree_view))
+ {
+ gboolean over_arrow;
+ gboolean flag_set;
+
+ over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
+ flag_set = PSPP_SHEET_VIEW_FLAG_SET (tree_view,
+ PSPP_SHEET_VIEW_ARROW_PRELIT);
+
+ if (over_arrow != flag_set)
+ {
+ if (over_arrow)
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view,
+ PSPP_SHEET_VIEW_ARROW_PRELIT);
+ else
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view,
+ PSPP_SHEET_VIEW_ARROW_PRELIT);
+
+ pspp_sheet_view_draw_arrow (tree_view, tree, node, x, y);
+ }
+ }
+
+ return;
+ }
+
+ if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
+ {
+ /* Unprelight the old node and arrow */
+
+ PSPP_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
+ PSPP_RBNODE_IS_PRELIT);
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_ARROW_PRELIT)
+ && TREE_VIEW_DRAW_EXPANDERS (tree_view))
+ {
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_ARROW_PRELIT);
+
+ pspp_sheet_view_draw_arrow (tree_view,
+ tree_view->priv->prelight_tree,
+ tree_view->priv->prelight_node,
+ x,
+ y);
+ }
+
+ _pspp_sheet_view_queue_draw_node (tree_view,
+ tree_view->priv->prelight_tree,
+ tree_view->priv->prelight_node,
+ NULL);
+ }
+
+
+ if (tree_view->priv->hover_expand)
+ remove_auto_expand_timeout (tree_view);
+
+ /* Set the new prelight values */
+ tree_view->priv->prelight_node = node;
+ tree_view->priv->prelight_tree = tree;
+
+ if (!node || !tree)
+ return;
+
+ /* Prelight the new node and arrow */
+
+ if (TREE_VIEW_DRAW_EXPANDERS (tree_view)
+ && coords_are_over_arrow (tree_view, tree, node, x, y))
+ {
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_ARROW_PRELIT);
+
+ pspp_sheet_view_draw_arrow (tree_view, tree, node, x, y);
+ }
+
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_IS_PRELIT);
+
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, NULL);
+
+ if (tree_view->priv->hover_expand)
+ {
+ tree_view->priv->auto_expand_timeout =
+ gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout,
tree_view);
+ }
+}
+
+static void
+prelight_or_select (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ /* these are in bin_window coords */
+ gint x,
+ gint y)
+{
+ GtkSelectionMode mode = pspp_sheet_selection_get_mode
(tree_view->priv->selection);
+
+ if (tree_view->priv->hover_selection &&
+ (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
+ !(tree_view->priv->edited_column &&
+ tree_view->priv->edited_column->editable_widget))
+ {
+ if (node)
+ {
+ if (!PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ {
+ GtkTreePath *path;
+
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ pspp_sheet_selection_select_path (tree_view->priv->selection,
path);
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ {
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view,
PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE,
FALSE);
+ }
+ gtk_tree_path_free (path);
+ }
+ }
+
+ else if (mode == GTK_SELECTION_SINGLE)
+ pspp_sheet_selection_unselect_all (tree_view->priv->selection);
+ }
+
+ do_prelight (tree_view, tree, node, x, y);
+}
+
+static void
+ensure_unprelighted (PsppSheetView *tree_view)
+{
+ do_prelight (tree_view,
+ NULL, NULL,
+ -1000, -1000); /* coords not possibly over an arrow */
+
+ g_assert (tree_view->priv->prelight_node == NULL);
+}
+
+static void
+update_prelight (PsppSheetView *tree_view,
+ gint x,
+ gint y)
+{
+ int new_y;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ if (tree_view->priv->tree == NULL)
+ return;
+
+ if (x == -10000)
+ {
+ ensure_unprelighted (tree_view);
+ return;
+ }
+
+ new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
+ if (new_y < 0)
+ new_y = 0;
+
+ _pspp_rbtree_find_offset (tree_view->priv->tree,
+ new_y, &tree, &node);
+
+ if (node)
+ prelight_or_select (tree_view, tree, node, x, y);
+}
+
+
+
+
+/* Our motion arrow is either a box (in the case of the original spot)
+ * or an arrow. It is expander_size wide.
+ */
+/*
+ * 11111111111111
+ * 01111111111110
+ * 00111111111100
+ * 00011111111000
+ * 00001111110000
+ * 00000111100000
+ * 00000111100000
+ * 00000111100000
+ * ~ ~ ~ ~ ~ ~ ~
+ * 00000111100000
+ * 00000111100000
+ * 00000111100000
+ * 00001111110000
+ * 00011111111000
+ * 00111111111100
+ * 01111111111110
+ * 11111111111111
+ */
+
+static void
+pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view)
+{
+ PsppSheetViewColumnReorder *reorder = tree_view->priv->cur_reorder;
+ GtkWidget *widget = GTK_WIDGET (tree_view);
+ GdkBitmap *mask = NULL;
+ gint x;
+ gint y;
+ gint width;
+ gint height;
+ gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
+ GdkWindowAttr attributes;
+ guint attributes_mask;
+
+ if (!reorder ||
+ reorder->left_column == tree_view->priv->drag_column ||
+ reorder->right_column == tree_view->priv->drag_column)
+ arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
+ else if (reorder->left_column || reorder->right_column)
+ {
+ GdkRectangle visible_rect;
+ pspp_sheet_view_get_visible_rect (tree_view, &visible_rect);
+ if (reorder->left_column)
+ x = reorder->left_column->button->allocation.x +
reorder->left_column->button->allocation.width;
+ else
+ x = reorder->right_column->button->allocation.x;
+
+ if (x < visible_rect.x)
+ arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
+ else if (x > visible_rect.x + visible_rect.width)
+ arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
+ else
+ arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
+ }
+
+ /* We want to draw the rectangle over the initial location. */
+ if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
+ {
+ GdkGC *gc;
+ GdkColor col;
+
+ if (tree_view->priv->drag_column_window_state !=
DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
+ {
+ if (tree_view->priv->drag_highlight_window)
+ {
+ gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
+ NULL);
+ gdk_window_destroy (tree_view->priv->drag_highlight_window);
+ }
+
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.x = tree_view->priv->drag_column_x;
+ attributes.y = 0;
+ width = attributes.width =
tree_view->priv->drag_column->button->allocation.width;
+ height = attributes.height =
tree_view->priv->drag_column->button->allocation.height;
+ attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
+ attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET
(tree_view));
+ attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK |
GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL |
GDK_WA_COLORMAP;
+ tree_view->priv->drag_highlight_window = gdk_window_new
(tree_view->priv->header_window, &attributes, attributes_mask);
+ gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
GTK_WIDGET (tree_view));
+
+ mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width,
height, 1);
+ gc = gdk_gc_new (mask);
+ col.pixel = 1;
+ gdk_gc_set_foreground (gc, &col);
+ gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
+ col.pixel = 0;
+ gdk_gc_set_foreground(gc, &col);
+ gdk_draw_rectangle (mask, gc, TRUE, 2, 2, width - 4, height - 4);
+ g_object_unref (gc);
+
+ gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
+ mask, 0, 0);
+ if (mask) g_object_unref (mask);
+ tree_view->priv->drag_column_window_state =
DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
+ }
+ }
+ else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
+ {
+ gint i, j = 1;
+ GdkGC *gc;
+ GdkColor col;
+
+ width = tree_view->priv->expander_size;
+
+ /* Get x, y, width, height of arrow */
+ gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
+ if (reorder->left_column)
+ {
+ x += reorder->left_column->button->allocation.x +
reorder->left_column->button->allocation.width - width/2;
+ height = reorder->left_column->button->allocation.height;
+ }
+ else
+ {
+ x += reorder->right_column->button->allocation.x - width/2;
+ height = reorder->right_column->button->allocation.height;
+ }
+ y -= tree_view->priv->expander_size/2; /* The arrow takes up only half
the space */
+ height += tree_view->priv->expander_size;
+
+ /* Create the new window */
+ if (tree_view->priv->drag_column_window_state !=
DRAG_COLUMN_WINDOW_STATE_ARROW)
+ {
+ if (tree_view->priv->drag_highlight_window)
+ {
+ gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
+ NULL);
+ gdk_window_destroy (tree_view->priv->drag_highlight_window);
+ }
+
+ attributes.window_type = GDK_WINDOW_TEMP;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
+ attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET
(tree_view));
+ attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK |
GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL |
GDK_WA_COLORMAP;
+ attributes.x = x;
+ attributes.y = y;
+ attributes.width = width;
+ attributes.height = height;
+ tree_view->priv->drag_highlight_window = gdk_window_new
(gtk_widget_get_root_window (widget),
+ &attributes,
attributes_mask);
+ gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
GTK_WIDGET (tree_view));
+
+ mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width,
height, 1);
+ gc = gdk_gc_new (mask);
+ col.pixel = 1;
+ gdk_gc_set_foreground (gc, &col);
+ gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
+
+ /* Draw the 2 arrows as per above */
+ col.pixel = 0;
+ gdk_gc_set_foreground (gc, &col);
+ for (i = 0; i < width; i ++)
+ {
+ if (i == (width/2 - 1))
+ continue;
+ gdk_draw_line (mask, gc, i, j, i, height - j);
+ if (i < (width/2 - 1))
+ j++;
+ else
+ j--;
+ }
+ g_object_unref (gc);
+ gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
+ mask, 0, 0);
+ if (mask) g_object_unref (mask);
+ }
+
+ tree_view->priv->drag_column_window_state =
DRAG_COLUMN_WINDOW_STATE_ARROW;
+ gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
+ }
+ else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
+ arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
+ {
+ gint i, j = 1;
+ GdkGC *gc;
+ GdkColor col;
+
+ width = tree_view->priv->expander_size;
+
+ /* Get x, y, width, height of arrow */
+ width = width/2; /* remember, the arrow only takes half the available
width */
+ gdk_window_get_origin (widget->window, &x, &y);
+ if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
+ x += widget->allocation.width - width;
+
+ if (reorder->left_column)
+ height = reorder->left_column->button->allocation.height;
+ else
+ height = reorder->right_column->button->allocation.height;
+
+ y -= tree_view->priv->expander_size;
+ height += 2*tree_view->priv->expander_size;
+
+ /* Create the new window */
+ if (tree_view->priv->drag_column_window_state !=
DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
+ tree_view->priv->drag_column_window_state !=
DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
+ {
+ if (tree_view->priv->drag_highlight_window)
+ {
+ gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
+ NULL);
+ gdk_window_destroy (tree_view->priv->drag_highlight_window);
+ }
+
+ attributes.window_type = GDK_WINDOW_TEMP;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
+ attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET
(tree_view));
+ attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK |
GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL |
GDK_WA_COLORMAP;
+ attributes.x = x;
+ attributes.y = y;
+ attributes.width = width;
+ attributes.height = height;
+ tree_view->priv->drag_highlight_window = gdk_window_new (NULL,
&attributes, attributes_mask);
+ gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
GTK_WIDGET (tree_view));
+
+ mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width,
height, 1);
+ gc = gdk_gc_new (mask);
+ col.pixel = 1;
+ gdk_gc_set_foreground (gc, &col);
+ gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
+
+ /* Draw the 2 arrows as per above */
+ col.pixel = 0;
+ gdk_gc_set_foreground (gc, &col);
+ j = tree_view->priv->expander_size;
+ for (i = 0; i < width; i ++)
+ {
+ gint k;
+ if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
+ k = width - i - 1;
+ else
+ k = i;
+ gdk_draw_line (mask, gc, k, j, k, height - j);
+ gdk_draw_line (mask, gc, k, 0, k, tree_view->priv->expander_size
- j);
+ gdk_draw_line (mask, gc, k, height, k, height -
tree_view->priv->expander_size + j);
+ j--;
+ }
+ g_object_unref (gc);
+ gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
+ mask, 0, 0);
+ if (mask) g_object_unref (mask);
+ }
+
+ tree_view->priv->drag_column_window_state = arrow_type;
+ gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
+ }
+ else
+ {
+ g_warning (G_STRLOC"Invalid PsppSheetViewColumnReorder struct");
+ gdk_window_hide (tree_view->priv->drag_highlight_window);
+ return;
+ }
+
+ gdk_window_show (tree_view->priv->drag_highlight_window);
+ gdk_window_raise (tree_view->priv->drag_highlight_window);
+}
+
+static gboolean
+pspp_sheet_view_motion_resize_column (GtkWidget *widget,
+ GdkEventMotion *event)
+{
+ gint x;
+ gint new_width;
+ PsppSheetViewColumn *column;
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+
+ column = pspp_sheet_view_get_column (tree_view, tree_view->priv->drag_pos);
+
+ if (event->is_hint || event->window != widget->window)
+ gtk_widget_get_pointer (widget, &x, NULL);
+ else
+ x = event->x;
+
+ if (tree_view->priv->hadjustment)
+ x += tree_view->priv->hadjustment->value;
+
+ new_width = pspp_sheet_view_new_column_width (tree_view,
+ tree_view->priv->drag_pos, &x);
+ if (x != tree_view->priv->x_drag &&
+ (new_width != column->fixed_width))
+ {
+ column->use_resized_width = TRUE;
+ column->resized_width = new_width;
+ if (column->expand)
+ column->resized_width -= tree_view->priv->last_extra_space_per_column;
+ gtk_widget_queue_resize (widget);
+ }
+
+ return FALSE;
+}
+
+
+static void
+pspp_sheet_view_update_current_reorder (PsppSheetView *tree_view)
+{
+ PsppSheetViewColumnReorder *reorder = NULL;
+ GList *list;
+ gint mouse_x;
+
+ gdk_window_get_pointer (tree_view->priv->header_window, &mouse_x, NULL,
NULL);
+ for (list = tree_view->priv->column_drag_info; list; list = list->next)
+ {
+ reorder = (PsppSheetViewColumnReorder *) list->data;
+ if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
+ break;
+ reorder = NULL;
+ }
+
+ /* if (reorder && reorder == tree_view->priv->cur_reorder)
+ return;*/
+
+ tree_view->priv->cur_reorder = reorder;
+ pspp_sheet_view_motion_draw_column_motion_arrow (tree_view);
+}
+
+static void
+pspp_sheet_view_vertical_autoscroll (PsppSheetView *tree_view)
+{
+ GdkRectangle visible_rect;
+ gint y;
+ gint offset;
+ gfloat value;
+
+ gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
+ y += tree_view->priv->dy;
+
+ pspp_sheet_view_get_visible_rect (tree_view, &visible_rect);
+
+ /* see if we are near the edge. */
+ offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
+ if (offset > 0)
+ {
+ offset = y - (visible_rect.y + visible_rect.height - 2 *
SCROLL_EDGE_SIZE);
+ if (offset < 0)
+ return;
+ }
+
+ value = CLAMP (tree_view->priv->vadjustment->value + offset, 0.0,
+ tree_view->priv->vadjustment->upper -
tree_view->priv->vadjustment->page_size);
+ gtk_adjustment_set_value (tree_view->priv->vadjustment, value);
+}
+
+static gboolean
+pspp_sheet_view_horizontal_autoscroll (PsppSheetView *tree_view)
+{
+ GdkRectangle visible_rect;
+ gint x;
+ gint offset;
+ gfloat value;
+
+ gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
+
+ pspp_sheet_view_get_visible_rect (tree_view, &visible_rect);
+
+ /* See if we are near the edge. */
+ offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
+ if (offset > 0)
+ {
+ offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
+ if (offset < 0)
+ return TRUE;
+ }
+ offset = offset/3;
+
+ value = CLAMP (tree_view->priv->hadjustment->value + offset,
+ 0.0, tree_view->priv->hadjustment->upper -
tree_view->priv->hadjustment->page_size);
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, value);
+
+ return TRUE;
+
+}
+
+static gboolean
+pspp_sheet_view_motion_drag_column (GtkWidget *widget,
+ GdkEventMotion *event)
+{
+ PsppSheetView *tree_view = (PsppSheetView *) widget;
+ PsppSheetViewColumn *column = tree_view->priv->drag_column;
+ gint x, y;
+
+ /* Sanity Check */
+ if ((column == NULL) ||
+ (event->window != tree_view->priv->drag_window))
+ return FALSE;
+
+ /* Handle moving the header */
+ gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
+ x = CLAMP (x + (gint)event->x - column->drag_x, 0,
+ MAX (tree_view->priv->width, GTK_WIDGET
(tree_view)->allocation.width) - column->button->allocation.width);
+ gdk_window_move (tree_view->priv->drag_window, x, y);
+
+ /* autoscroll, if needed */
+ pspp_sheet_view_horizontal_autoscroll (tree_view);
+ /* Update the current reorder position and arrow; */
+ pspp_sheet_view_update_current_reorder (tree_view);
+
+ return TRUE;
+}
+
+static void
+pspp_sheet_view_stop_rubber_band (PsppSheetView *tree_view)
+{
+ remove_scroll_timeout (tree_view);
+ gtk_grab_remove (GTK_WIDGET (tree_view));
+
+ if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
+ {
+ GtkTreePath *tmp_path;
+
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+
+ /* The anchor path should be set to the start path */
+ tmp_path = _pspp_sheet_view_find_path (tree_view,
+
tree_view->priv->rubber_band_start_tree,
+
tree_view->priv->rubber_band_start_node);
+
+ if (tree_view->priv->anchor)
+ gtk_tree_row_reference_free (tree_view->priv->anchor);
+
+ tree_view->priv->anchor =
+ gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
+ tree_view->priv->model,
+ tmp_path);
+
+ gtk_tree_path_free (tmp_path);
+
+ /* ... and the cursor to the end path */
+ tmp_path = _pspp_sheet_view_find_path (tree_view,
+
tree_view->priv->rubber_band_end_tree,
+
tree_view->priv->rubber_band_end_node);
+ pspp_sheet_view_real_set_cursor (PSPP_SHEET_VIEW (tree_view), tmp_path,
FALSE, FALSE);
+ gtk_tree_path_free (tmp_path);
+
+ _pspp_sheet_selection_emit_changed (tree_view->priv->selection);
+ }
+
+ /* Clear status variables */
+ tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
+ tree_view->priv->rubber_band_shift = 0;
+ tree_view->priv->rubber_band_ctrl = 0;
+
+ tree_view->priv->rubber_band_start_node = NULL;
+ tree_view->priv->rubber_band_start_tree = NULL;
+ tree_view->priv->rubber_band_end_node = NULL;
+ tree_view->priv->rubber_band_end_tree = NULL;
+}
+
+static void
+pspp_sheet_view_update_rubber_band_selection_range (PsppSheetView *tree_view,
+ GtkRBTree *start_tree,
+ GtkRBNode *start_node,
+ GtkRBTree *end_tree,
+ GtkRBNode *end_node,
+ gboolean select,
+ gboolean skip_start,
+ gboolean skip_end)
+{
+ if (start_node == end_node)
+ return;
+
+ /* We skip the first node and jump inside the loop */
+ if (skip_start)
+ goto skip_first;
+
+ do
+ {
+ /* Small optimization by assuming insensitive nodes are never
+ * selected.
+ */
+ if (!PSPP_RBNODE_FLAG_SET (start_node, PSPP_RBNODE_IS_SELECTED))
+ {
+ GtkTreePath *path;
+ gboolean selectable;
+
+ path = _pspp_sheet_view_find_path (tree_view, start_tree, start_node);
+ selectable = _pspp_sheet_selection_row_is_selectable
(tree_view->priv->selection, start_node, path);
+ gtk_tree_path_free (path);
+
+ if (!selectable)
+ goto node_not_selectable;
+ }
+
+ if (select)
+ {
+ if (tree_view->priv->rubber_band_shift)
+ PSPP_RBNODE_SET_FLAG (start_node, PSPP_RBNODE_IS_SELECTED);
+ else if (tree_view->priv->rubber_band_ctrl)
+ {
+ /* Toggle the selection state */
+ if (PSPP_RBNODE_FLAG_SET (start_node, PSPP_RBNODE_IS_SELECTED))
+ PSPP_RBNODE_UNSET_FLAG (start_node, PSPP_RBNODE_IS_SELECTED);
+ else
+ PSPP_RBNODE_SET_FLAG (start_node, PSPP_RBNODE_IS_SELECTED);
+ }
+ else
+ PSPP_RBNODE_SET_FLAG (start_node, PSPP_RBNODE_IS_SELECTED);
+ }
+ else
+ {
+ /* Mirror the above */
+ if (tree_view->priv->rubber_band_shift)
+ PSPP_RBNODE_UNSET_FLAG (start_node, PSPP_RBNODE_IS_SELECTED);
+ else if (tree_view->priv->rubber_band_ctrl)
+ {
+ /* Toggle the selection state */
+ if (PSPP_RBNODE_FLAG_SET (start_node, PSPP_RBNODE_IS_SELECTED))
+ PSPP_RBNODE_UNSET_FLAG (start_node, PSPP_RBNODE_IS_SELECTED);
+ else
+ PSPP_RBNODE_SET_FLAG (start_node, PSPP_RBNODE_IS_SELECTED);
+ }
+ else
+ PSPP_RBNODE_UNSET_FLAG (start_node, PSPP_RBNODE_IS_SELECTED);
+ }
+
+ _pspp_sheet_view_queue_draw_node (tree_view, start_tree, start_node,
NULL);
+
+node_not_selectable:
+ if (start_node == end_node)
+ break;
+
+skip_first:
+
+ if (start_node->children)
+ {
+ start_tree = start_node->children;
+ start_node = start_tree->root;
+ while (start_node->left != start_tree->nil)
+ start_node = start_node->left;
+ }
+ else
+ {
+ _pspp_rbtree_next_full (start_tree, start_node, &start_tree,
&start_node);
+
+ if (!start_tree)
+ /* Ran out of tree */
+ break;
+ }
+
+ if (skip_end && start_node == end_node)
+ break;
+ }
+ while (TRUE);
+}
+
+static void
+pspp_sheet_view_update_rubber_band_selection (PsppSheetView *tree_view)
+{
+ GtkRBTree *start_tree, *end_tree;
+ GtkRBNode *start_node, *end_node;
+
+ _pspp_rbtree_find_offset (tree_view->priv->tree, MIN
(tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &start_tree,
&start_node);
+ _pspp_rbtree_find_offset (tree_view->priv->tree, MAX
(tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &end_tree,
&end_node);
+
+ /* Handle the start area first */
+ if (!tree_view->priv->rubber_band_start_node)
+ {
+ pspp_sheet_view_update_rubber_band_selection_range (tree_view,
+ start_tree,
+ start_node,
+ end_tree,
+ end_node,
+ TRUE,
+ FALSE,
+ FALSE);
+ }
+ else if (_pspp_rbtree_node_find_offset (start_tree, start_node) <
+ _pspp_rbtree_node_find_offset
(tree_view->priv->rubber_band_start_tree,
tree_view->priv->rubber_band_start_node))
+ {
+ /* New node is above the old one; selection became bigger */
+ pspp_sheet_view_update_rubber_band_selection_range (tree_view,
+ start_tree,
+ start_node,
+
tree_view->priv->rubber_band_start_tree,
+
tree_view->priv->rubber_band_start_node,
+ TRUE,
+ FALSE,
+ TRUE);
+ }
+ else if (_pspp_rbtree_node_find_offset (start_tree, start_node) >
+ _pspp_rbtree_node_find_offset
(tree_view->priv->rubber_band_start_tree,
tree_view->priv->rubber_band_start_node))
+ {
+ /* New node is below the old one; selection became smaller */
+ pspp_sheet_view_update_rubber_band_selection_range (tree_view,
+
tree_view->priv->rubber_band_start_tree,
+
tree_view->priv->rubber_band_start_node,
+ start_tree,
+ start_node,
+ FALSE,
+ FALSE,
+ TRUE);
+ }
+
+ tree_view->priv->rubber_band_start_tree = start_tree;
+ tree_view->priv->rubber_band_start_node = start_node;
+
+ /* Next, handle the end area */
+ if (!tree_view->priv->rubber_band_end_node)
+ {
+ /* In the event this happens, start_node was also NULL; this case is
+ * handled above.
+ */
+ }
+ else if (!end_node)
+ {
+ /* Find the last node in the tree */
+ _pspp_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height
- 1,
+ &end_tree, &end_node);
+
+ /* Selection reached end of the tree */
+ pspp_sheet_view_update_rubber_band_selection_range (tree_view,
+
tree_view->priv->rubber_band_end_tree,
+
tree_view->priv->rubber_band_end_node,
+ end_tree,
+ end_node,
+ TRUE,
+ TRUE,
+ FALSE);
+ }
+ else if (_pspp_rbtree_node_find_offset (end_tree, end_node) >
+ _pspp_rbtree_node_find_offset
(tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
+ {
+ /* New node is below the old one; selection became bigger */
+ pspp_sheet_view_update_rubber_band_selection_range (tree_view,
+
tree_view->priv->rubber_band_end_tree,
+
tree_view->priv->rubber_band_end_node,
+ end_tree,
+ end_node,
+ TRUE,
+ TRUE,
+ FALSE);
+ }
+ else if (_pspp_rbtree_node_find_offset (end_tree, end_node) <
+ _pspp_rbtree_node_find_offset
(tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
+ {
+ /* New node is above the old one; selection became smaller */
+ pspp_sheet_view_update_rubber_band_selection_range (tree_view,
+ end_tree,
+ end_node,
+
tree_view->priv->rubber_band_end_tree,
+
tree_view->priv->rubber_band_end_node,
+ FALSE,
+ TRUE,
+ FALSE);
+ }
+
+ tree_view->priv->rubber_band_end_tree = end_tree;
+ tree_view->priv->rubber_band_end_node = end_node;
+}
+
+static void
+pspp_sheet_view_update_rubber_band (PsppSheetView *tree_view)
+{
+ gint x, y;
+ GdkRectangle old_area;
+ GdkRectangle new_area;
+ GdkRectangle common;
+ GdkRegion *invalid_region;
+
+ old_area.x = MIN (tree_view->priv->press_start_x,
tree_view->priv->rubber_band_x);
+ old_area.y = MIN (tree_view->priv->press_start_y,
tree_view->priv->rubber_band_y) - tree_view->priv->dy;
+ old_area.width = ABS (tree_view->priv->rubber_band_x -
tree_view->priv->press_start_x) + 1;
+ old_area.height = ABS (tree_view->priv->rubber_band_y -
tree_view->priv->press_start_y) + 1;
+
+ gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, NULL);
+
+ x = MAX (x, 0);
+ y = MAX (y, 0) + tree_view->priv->dy;
+
+ new_area.x = MIN (tree_view->priv->press_start_x, x);
+ new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
+ new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
+ new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
+
+ invalid_region = gdk_region_rectangle (&old_area);
+ gdk_region_union_with_rect (invalid_region, &new_area);
+
+ gdk_rectangle_intersect (&old_area, &new_area, &common);
+ if (common.width > 2 && common.height > 2)
+ {
+ GdkRegion *common_region;
+
+ /* make sure the border is invalidated */
+ common.x += 1;
+ common.y += 1;
+ common.width -= 2;
+ common.height -= 2;
+
+ common_region = gdk_region_rectangle (&common);
+
+ gdk_region_subtract (invalid_region, common_region);
+ gdk_region_destroy (common_region);
+ }
+
+ gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region,
TRUE);
+
+ gdk_region_destroy (invalid_region);
+
+ tree_view->priv->rubber_band_x = x;
+ tree_view->priv->rubber_band_y = y;
+
+ pspp_sheet_view_update_rubber_band_selection (tree_view);
+}
+
+static void
+pspp_sheet_view_paint_rubber_band (PsppSheetView *tree_view,
+ GdkRectangle *area)
+{
+ cairo_t *cr;
+ GdkRectangle rect;
+ GdkRectangle rubber_rect;
+
+ rubber_rect.x = MIN (tree_view->priv->press_start_x,
tree_view->priv->rubber_band_x);
+ rubber_rect.y = MIN (tree_view->priv->press_start_y,
tree_view->priv->rubber_band_y) - tree_view->priv->dy;
+ rubber_rect.width = ABS (tree_view->priv->press_start_x -
tree_view->priv->rubber_band_x) + 1;
+ rubber_rect.height = ABS (tree_view->priv->press_start_y -
tree_view->priv->rubber_band_y) + 1;
+
+ if (!gdk_rectangle_intersect (&rubber_rect, area, &rect))
+ return;
+
+ cr = gdk_cairo_create (tree_view->priv->bin_window);
+ cairo_set_line_width (cr, 1.0);
+
+ cairo_set_source_rgba (cr,
+ GTK_WIDGET
(tree_view)->style->fg[GTK_STATE_NORMAL].red / 65535.,
+ GTK_WIDGET
(tree_view)->style->fg[GTK_STATE_NORMAL].green / 65535.,
+ GTK_WIDGET
(tree_view)->style->fg[GTK_STATE_NORMAL].blue / 65535.,
+ .25);
+
+ gdk_cairo_rectangle (cr, &rect);
+ cairo_clip (cr);
+ cairo_paint (cr);
+
+ cairo_set_source_rgb (cr,
+ GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].red
/ 65535.,
+ GTK_WIDGET
(tree_view)->style->fg[GTK_STATE_NORMAL].green / 65535.,
+ GTK_WIDGET
(tree_view)->style->fg[GTK_STATE_NORMAL].blue / 65535.);
+
+ cairo_rectangle (cr,
+ rubber_rect.x + 0.5, rubber_rect.y + 0.5,
+ rubber_rect.width - 1, rubber_rect.height - 1);
+ cairo_stroke (cr);
+
+ cairo_destroy (cr);
+}
+
+static gboolean
+pspp_sheet_view_motion_bin_window (GtkWidget *widget,
+ GdkEventMotion *event)
+{
+ PsppSheetView *tree_view;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gint new_y;
+
+ tree_view = (PsppSheetView *) widget;
+
+ if (tree_view->priv->tree == NULL)
+ return FALSE;
+
+ if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
+ {
+ gtk_grab_add (GTK_WIDGET (tree_view));
+ pspp_sheet_view_update_rubber_band (tree_view);
+
+ tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
+ }
+ else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
+ {
+ pspp_sheet_view_update_rubber_band (tree_view);
+
+ add_scroll_timeout (tree_view);
+ }
+
+ /* only check for an initiated drag when a button is pressed */
+ if (tree_view->priv->pressed_button >= 0
+ && !tree_view->priv->rubber_band_status)
+ pspp_sheet_view_maybe_begin_dragging_row (tree_view, event);
+
+ new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
+ if (new_y < 0)
+ new_y = 0;
+
+ _pspp_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
+
+ /* If we are currently pressing down a button, we don't want to prelight
anything else. */
+ if ((tree_view->priv->button_pressed_node != NULL) &&
+ (tree_view->priv->button_pressed_node != node))
+ node = NULL;
+
+ tree_view->priv->event_last_x = event->x;
+ tree_view->priv->event_last_y = event->y;
+
+ prelight_or_select (tree_view, tree, node, event->x, event->y);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_motion (GtkWidget *widget,
+ GdkEventMotion *event)
+{
+ PsppSheetView *tree_view;
+
+ tree_view = (PsppSheetView *) widget;
+
+ /* Resizing a column */
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE))
+ return pspp_sheet_view_motion_resize_column (widget, event);
+
+ /* Drag column */
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG))
+ return pspp_sheet_view_motion_drag_column (widget, event);
+
+ /* Sanity check it */
+ if (event->window == tree_view->priv->bin_window)
+ return pspp_sheet_view_motion_bin_window (widget, event);
+
+ return FALSE;
+}
+
+/* Invalidate the focus rectangle near the edge of the bin_window; used when
+ * the tree is empty.
+ */
+static void
+invalidate_empty_focus (PsppSheetView *tree_view)
+{
+ GdkRectangle area;
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return;
+
+ area.x = 0;
+ area.y = 0;
+ gdk_drawable_get_size (tree_view->priv->bin_window, &area.width,
&area.height);
+ gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
+}
+
+/* Draws a focus rectangle near the edge of the bin_window; used when the tree
+ * is empty.
+ */
+static void
+draw_empty_focus (PsppSheetView *tree_view, GdkRectangle *clip_area)
+{
+ GtkWidget *widget = GTK_WIDGET (tree_view);
+ gint w, h;
+
+ if (!gtk_widget_has_focus (widget))
+ return;
+
+ gdk_drawable_get_size (tree_view->priv->bin_window, &w, &h);
+
+ w -= 2;
+ h -= 2;
+
+ if (w > 0 && h > 0)
+ gtk_paint_focus (gtk_widget_get_style (widget),
+ tree_view->priv->bin_window,
+ gtk_widget_get_state (widget),
+ clip_area,
+ widget,
+ NULL,
+ 1, 1, w, h);
+}
+
+static void
+pspp_sheet_view_draw_grid_lines (PsppSheetView *tree_view,
+ GdkEventExpose *event,
+ gint n_visible_columns)
+{
+ GList *list = tree_view->priv->columns;
+ gint i = 0;
+ gint current_x = 0;
+
+ if (tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
+ && tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_BOTH)
+ return;
+
+ /* Only draw the lines for visible rows and columns */
+ for (list = tree_view->priv->columns; list; list = list->next, i++)
+ {
+ PsppSheetViewColumn *column = list->data;
+
+ /* We don't want a line for the last column */
+ if (i == n_visible_columns - 1)
+ break;
+
+ if (! column->visible)
+ continue;
+
+ current_x += column->width;
+
+ gdk_draw_line (event->window,
+ tree_view->priv->grid_line_gc,
+ current_x - 1, 0,
+ current_x - 1, tree_view->priv->height);
+ }
+}
+
+/* Warning: Very scary function.
+ * Modify at your own risk
+ *
+ * KEEP IN SYNC WITH pspp_sheet_view_create_row_drag_icon()!
+ * FIXME: It's not...
+ */
+static gboolean
+pspp_sheet_view_bin_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GtkTreePath *path;
+ GtkRBTree *tree;
+ GList *list;
+ GtkRBNode *node;
+ GtkRBNode *cursor = NULL;
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *drag_highlight = NULL;
+ GtkRBTree *drag_highlight_tree = NULL;
+ GtkTreeIter iter;
+ gint new_y;
+ gint y_offset, cell_offset;
+ gint max_height;
+ gint depth;
+ GdkRectangle background_area;
+ GdkRectangle cell_area;
+ guint flags;
+ gint highlight_x;
+ gint expander_cell_width;
+ gint bin_window_width;
+ gint bin_window_height;
+ GtkTreePath *cursor_path;
+ GtkTreePath *drag_dest_path;
+ GList *first_column, *last_column;
+ gint vertical_separator;
+ gint horizontal_separator;
+ gint focus_line_width;
+ gboolean allow_rules;
+ gboolean has_special_cell;
+ gboolean rtl;
+ gint n_visible_columns;
+ gint pointer_x, pointer_y;
+ gint grid_line_width;
+ gboolean got_pointer = FALSE;
+ gboolean row_ending_details;
+ gboolean draw_vgrid_lines, draw_hgrid_lines;
+
+ rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+
+ gtk_widget_style_get (widget,
+ "horizontal-separator", &horizontal_separator,
+ "vertical-separator", &vertical_separator,
+ "allow-rules", &allow_rules,
+ "focus-line-width", &focus_line_width,
+ "row-ending-details", &row_ending_details,
+ NULL);
+
+ if (tree_view->priv->tree == NULL)
+ {
+ draw_empty_focus (tree_view, &event->area);
+ return TRUE;
+ }
+
+ /* clip event->area to the visible area */
+ if (event->area.height < 0)
+ return TRUE;
+
+ validate_visible_area (tree_view);
+
+ new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->area.y);
+
+ if (new_y < 0)
+ new_y = 0;
+ y_offset = -_pspp_rbtree_find_offset (tree_view->priv->tree, new_y, &tree,
&node);
+ gdk_drawable_get_size (tree_view->priv->bin_window,
+ &bin_window_width, &bin_window_height);
+
+ if (tree_view->priv->height < bin_window_height)
+ {
+ gtk_paint_flat_box (widget->style,
+ event->window,
+ widget->state,
+ GTK_SHADOW_NONE,
+ &event->area,
+ widget,
+ "cell_even",
+ 0, tree_view->priv->height,
+ bin_window_width,
+ bin_window_height - tree_view->priv->height);
+ }
+
+ if (node == NULL)
+ return TRUE;
+
+ /* find the path for the node */
+ path = _pspp_sheet_view_find_path ((PsppSheetView *)widget,
+ tree,
+ node);
+ gtk_tree_model_get_iter (tree_view->priv->model,
+ &iter,
+ path);
+ depth = gtk_tree_path_get_depth (path);
+ gtk_tree_path_free (path);
+
+ cursor_path = NULL;
+ drag_dest_path = NULL;
+
+ if (tree_view->priv->cursor)
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+
+ if (cursor_path)
+ _pspp_sheet_view_find_node (tree_view, cursor_path,
+ &cursor_tree, &cursor);
+
+ if (tree_view->priv->drag_dest_row)
+ drag_dest_path = gtk_tree_row_reference_get_path
(tree_view->priv->drag_dest_row);
+
+ if (drag_dest_path)
+ _pspp_sheet_view_find_node (tree_view, drag_dest_path,
+ &drag_highlight_tree, &drag_highlight);
+
+ draw_vgrid_lines =
+ tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
+ || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH;
+ draw_hgrid_lines =
+ tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL
+ || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH;
+
+ if (draw_vgrid_lines || draw_hgrid_lines)
+ gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
+
+ n_visible_columns = 0;
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ if (! PSPP_SHEET_VIEW_COLUMN (list->data)->visible)
+ continue;
+ n_visible_columns ++;
+ }
+
+ /* Find the last column */
+ for (last_column = g_list_last (tree_view->priv->columns);
+ last_column && !(PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible);
+ last_column = last_column->prev)
+ ;
+
+ /* and the first */
+ for (first_column = g_list_first (tree_view->priv->columns);
+ first_column && !(PSPP_SHEET_VIEW_COLUMN (first_column->data)->visible);
+ first_column = first_column->next)
+ ;
+
+ /* Actually process the expose event. To do this, we want to
+ * start at the first node of the event, and walk the tree in
+ * order, drawing each successive node.
+ */
+
+ do
+ {
+ gboolean parity;
+ gboolean is_separator = FALSE;
+ gboolean is_first = FALSE;
+ gboolean is_last = FALSE;
+
+ is_separator = row_is_separator (tree_view, &iter, NULL);
+
+ max_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
+
+ cell_offset = 0;
+ highlight_x = 0; /* should match x coord of first cell */
+ expander_cell_width = 0;
+
+ background_area.y = y_offset + event->area.y;
+ background_area.height = max_height;
+
+ flags = 0;
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_PRELIT))
+ flags |= GTK_CELL_RENDERER_PRELIT;
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ flags |= GTK_CELL_RENDERER_SELECTED;
+
+ parity = _pspp_rbtree_node_find_parity (tree, node);
+
+ /* we *need* to set cell data on all cells before the call
+ * to _has_special_cell, else _has_special_cell() does not
+ * return a correct value.
+ */
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list;
+ list = (rtl ? list->prev : list->next))
+ {
+ PsppSheetViewColumn *column = list->data;
+ pspp_sheet_view_column_cell_set_cell_data (column,
+ tree_view->priv->model,
+ &iter,
+ PSPP_RBNODE_FLAG_SET (node,
PSPP_RBNODE_IS_PARENT),
+ node->children?TRUE:FALSE);
+ }
+
+ has_special_cell = pspp_sheet_view_has_special_cell (tree_view);
+
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list;
+ list = (rtl ? list->prev : list->next))
+ {
+ PsppSheetViewColumn *column = list->data;
+ const gchar *detail = NULL;
+ GtkStateType state;
+
+ if (!column->visible)
+ continue;
+
+ if (cell_offset > event->area.x + event->area.width ||
+ cell_offset + column->width < event->area.x)
+ {
+ cell_offset += column->width;
+ continue;
+ }
+
+ if (column->show_sort_indicator)
+ flags |= GTK_CELL_RENDERER_SORTED;
+ else
+ flags &= ~GTK_CELL_RENDERER_SORTED;
+
+ if (cursor == node)
+ flags |= GTK_CELL_RENDERER_FOCUSED;
+ else
+ flags &= ~GTK_CELL_RENDERER_FOCUSED;
+
+ background_area.x = cell_offset;
+ background_area.width = column->width;
+
+ cell_area = background_area;
+ cell_area.y += vertical_separator / 2;
+ cell_area.x += horizontal_separator / 2;
+ cell_area.height -= vertical_separator;
+ cell_area.width -= horizontal_separator;
+
+ if (draw_vgrid_lines)
+ {
+ if (list == first_column)
+ {
+ cell_area.width -= grid_line_width / 2;
+ }
+ else if (list == last_column)
+ {
+ cell_area.x += grid_line_width / 2;
+ cell_area.width -= grid_line_width / 2;
+ }
+ else
+ {
+ cell_area.x += grid_line_width / 2;
+ cell_area.width -= grid_line_width;
+ }
+ }
+
+ if (draw_hgrid_lines)
+ {
+ cell_area.y += grid_line_width / 2;
+ cell_area.height -= grid_line_width;
+ }
+
+ if (gdk_region_rect_in (event->region, &background_area) ==
GDK_OVERLAP_RECTANGLE_OUT)
+ {
+ cell_offset += column->width;
+ continue;
+ }
+
+ pspp_sheet_view_column_cell_set_cell_data (column,
+ tree_view->priv->model,
+ &iter,
+ PSPP_RBNODE_FLAG_SET (node,
PSPP_RBNODE_IS_PARENT),
+ node->children?TRUE:FALSE);
+
+ /* Select the detail for drawing the cell. relevant
+ * factors are parity, sortedness, and whether to
+ * display rules.
+ */
+ if (allow_rules && tree_view->priv->has_rules)
+ {
+ if ((flags & GTK_CELL_RENDERER_SORTED) &&
+ n_visible_columns >= 3)
+ {
+ if (parity)
+ detail = "cell_odd_ruled_sorted";
+ else
+ detail = "cell_even_ruled_sorted";
+ }
+ else
+ {
+ if (parity)
+ detail = "cell_odd_ruled";
+ else
+ detail = "cell_even_ruled";
+ }
+ }
+ else
+ {
+ if ((flags & GTK_CELL_RENDERER_SORTED) &&
+ n_visible_columns >= 3)
+ {
+ if (parity)
+ detail = "cell_odd_sorted";
+ else
+ detail = "cell_even_sorted";
+ }
+ else
+ {
+ if (parity)
+ detail = "cell_odd";
+ else
+ detail = "cell_even";
+ }
+ }
+
+ g_assert (detail);
+
+ if (widget->state == GTK_STATE_INSENSITIVE)
+ state = GTK_STATE_INSENSITIVE;
+ else if (flags & GTK_CELL_RENDERER_SELECTED)
+ state = GTK_STATE_SELECTED;
+ else
+ state = GTK_STATE_NORMAL;
+
+ /* Draw background */
+ if (row_ending_details)
+ {
+ char new_detail[128];
+
+ is_first = (rtl ? !list->next : !list->prev);
+ is_last = (rtl ? !list->prev : !list->next);
+
+ /* (I don't like the snprintfs either, but couldn't find a
+ * less messy way).
+ */
+ if (is_first && is_last)
+ g_snprintf (new_detail, 127, "%s", detail);
+ else if (is_first)
+ g_snprintf (new_detail, 127, "%s_start", detail);
+ else if (is_last)
+ g_snprintf (new_detail, 127, "%s_end", detail);
+ else
+ g_snprintf (new_detail, 128, "%s_middle", detail);
+
+ gtk_paint_flat_box (widget->style,
+ event->window,
+ state,
+ GTK_SHADOW_NONE,
+ &event->area,
+ widget,
+ new_detail,
+ background_area.x,
+ background_area.y,
+ background_area.width,
+ background_area.height);
+ }
+ else
+ {
+ gtk_paint_flat_box (widget->style,
+ event->window,
+ state,
+ GTK_SHADOW_NONE,
+ &event->area,
+ widget,
+ detail,
+ background_area.x,
+ background_area.y,
+ background_area.width,
+ background_area.height);
+ }
+
+ if (draw_hgrid_lines)
+ {
+ if (background_area.y > 0)
+ gdk_draw_line (event->window,
+ tree_view->priv->grid_line_gc,
+ background_area.x, background_area.y,
+ background_area.x + background_area.width,
+ background_area.y);
+
+ if (y_offset + max_height >= event->area.height)
+ gdk_draw_line (event->window,
+ tree_view->priv->grid_line_gc,
+ background_area.x, background_area.y +
max_height,
+ background_area.x + background_area.width,
+ background_area.y + max_height);
+ }
+
+ if (pspp_sheet_view_is_expander_column (tree_view, column))
+ {
+ if (!rtl)
+ cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
+ cell_area.width -= (depth - 1) *
tree_view->priv->level_indentation;
+
+ if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
+ {
+ if (!rtl)
+ cell_area.x += depth * tree_view->priv->expander_size;
+ cell_area.width -= depth * tree_view->priv->expander_size;
+ }
+
+ /* If we have an expander column, the highlight underline
+ * starts with that column, so that it indicates which
+ * level of the tree we're dropping at.
+ */
+ highlight_x = cell_area.x;
+ expander_cell_width = cell_area.width;
+
+ if (is_separator)
+ gtk_paint_hline (widget->style,
+ event->window,
+ state,
+ &cell_area,
+ widget,
+ NULL,
+ cell_area.x,
+ cell_area.x + cell_area.width,
+ cell_area.y + cell_area.height / 2);
+ else
+ _pspp_sheet_view_column_cell_render (column,
+ event->window,
+ &background_area,
+ &cell_area,
+ &event->area,
+ flags);
+ if (TREE_VIEW_DRAW_EXPANDERS(tree_view)
+ && (node->flags & PSPP_RBNODE_IS_PARENT) ==
PSPP_RBNODE_IS_PARENT)
+ {
+ if (!got_pointer)
+ {
+ gdk_window_get_pointer (tree_view->priv->bin_window,
+ &pointer_x, &pointer_y, NULL);
+ got_pointer = TRUE;
+ }
+
+ pspp_sheet_view_draw_arrow (PSPP_SHEET_VIEW (widget),
+ tree,
+ node,
+ pointer_x, pointer_y);
+ }
+ }
+ else
+ {
+ if (is_separator)
+ gtk_paint_hline (widget->style,
+ event->window,
+ state,
+ &cell_area,
+ widget,
+ NULL,
+ cell_area.x,
+ cell_area.x + cell_area.width,
+ cell_area.y + cell_area.height / 2);
+ else
+ _pspp_sheet_view_column_cell_render (column,
+ event->window,
+ &background_area,
+ &cell_area,
+ &event->area,
+ flags);
+ }
+
+ if (pspp_sheet_view_is_expander_column (tree_view, column) &&
+ tree_view->priv->tree_lines_enabled)
+ {
+ gint x = background_area.x;
+ gint mult = rtl ? -1 : 1;
+ gint y0 = background_area.y;
+ gint y1 = background_area.y + background_area.height/2;
+ gint y2 = background_area.y + background_area.height;
+
+ if (rtl)
+ x += background_area.width - 1;
+
+ if ((node->flags & PSPP_RBNODE_IS_PARENT) == PSPP_RBNODE_IS_PARENT
+ && depth > 1)
+ {
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (depth -
1.5) * mult,
+ y1,
+ x + tree_view->priv->expander_size * (depth -
1.1) * mult,
+ y1);
+ }
+ else if (depth > 1)
+ {
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (depth -
1.5) * mult,
+ y1,
+ x + tree_view->priv->expander_size * (depth -
0.5) * mult,
+ y1);
+ }
+
+ if (depth > 1)
+ {
+ gint i;
+ GtkRBNode *tmp_node;
+ GtkRBTree *tmp_tree;
+
+ if (!_pspp_rbtree_next (tree, node))
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (depth
- 1.5) * mult,
+ y0,
+ x + tree_view->priv->expander_size * (depth
- 1.5) * mult,
+ y1);
+ else
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (depth
- 1.5) * mult,
+ y0,
+ x + tree_view->priv->expander_size * (depth
- 1.5) * mult,
+ y2);
+
+ tmp_node = tree->parent_node;
+ tmp_tree = tree->parent_tree;
+
+ for (i = depth - 2; i > 0; i--)
+ {
+ if (_pspp_rbtree_next (tmp_tree, tmp_node))
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (i
- 0.5) * mult,
+ y0,
+ x + tree_view->priv->expander_size * (i
- 0.5) * mult,
+ y2);
+
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+ }
+
+ if (node == cursor && has_special_cell &&
+ ((column == tree_view->priv->focus_column &&
+ PSPP_SHEET_VIEW_FLAG_SET (tree_view,
PSPP_SHEET_VIEW_DRAW_KEYFOCUS) &&
+ gtk_widget_has_focus (widget)) ||
+ (column == tree_view->priv->edited_column)))
+ {
+ _pspp_sheet_view_column_cell_draw_focus (column,
+ event->window,
+ &background_area,
+ &cell_area,
+ &event->area,
+ flags);
+ }
+
+ cell_offset += column->width;
+ }
+
+ if (node == drag_highlight)
+ {
+ /* Draw indicator for the drop
+ */
+ gint highlight_y = -1;
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ gint width;
+
+ switch (tree_view->priv->drag_dest_pos)
+ {
+ case PSPP_SHEET_VIEW_DROP_BEFORE:
+ highlight_y = background_area.y - 1;
+ if (highlight_y < 0)
+ highlight_y = 0;
+ break;
+
+ case PSPP_SHEET_VIEW_DROP_AFTER:
+ highlight_y = background_area.y + background_area.height - 1;
+ break;
+
+ case PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE:
+ case PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER:
+ _pspp_sheet_view_find_node (tree_view, drag_dest_path, &tree,
&node);
+
+ if (tree == NULL)
+ break;
+ gdk_drawable_get_size (tree_view->priv->bin_window,
+ &width, NULL);
+
+ if (row_ending_details)
+ gtk_paint_focus (widget->style,
+ tree_view->priv->bin_window,
+ gtk_widget_get_state (widget),
+ &event->area,
+ widget,
+ (is_first
+ ? (is_last ? "treeview-drop-indicator" :
"treeview-drop-indicator-left" )
+ : (is_last ? "treeview-drop-indicator-right"
: "tree-view-drop-indicator-middle" )),
+ 0, BACKGROUND_FIRST_PIXEL (tree_view, tree,
node)
+ - focus_line_width / 2,
+ width, ROW_HEIGHT (tree_view,
BACKGROUND_HEIGHT (node))
+ - focus_line_width + 1);
+ else
+ gtk_paint_focus (widget->style,
+ tree_view->priv->bin_window,
+ gtk_widget_get_state (widget),
+ &event->area,
+ widget,
+ "treeview-drop-indicator",
+ 0, BACKGROUND_FIRST_PIXEL (tree_view, tree,
node)
+ - focus_line_width / 2,
+ width, ROW_HEIGHT (tree_view,
BACKGROUND_HEIGHT (node))
+ - focus_line_width + 1);
+ break;
+ }
+
+ if (highlight_y >= 0)
+ {
+ gdk_draw_line (event->window,
+ widget->style->fg_gc[gtk_widget_get_state
(widget)],
+ rtl ? highlight_x + expander_cell_width :
highlight_x,
+ highlight_y,
+ rtl ? 0 : bin_window_width,
+ highlight_y);
+ }
+ }
+
+ /* draw the big row-spanning focus rectangle, if needed */
+ if (!has_special_cell && node == cursor &&
+ PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS) &&
+ gtk_widget_has_focus (widget))
+ {
+ gint tmp_y, tmp_height;
+ gint width;
+ GtkStateType focus_rect_state;
+
+ focus_rect_state =
+ flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
+ (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
+ (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
+ GTK_STATE_NORMAL));
+
+ gdk_drawable_get_size (tree_view->priv->bin_window,
+ &width, NULL);
+
+ if (draw_hgrid_lines)
+ {
+ tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node) +
grid_line_width / 2;
+ tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) -
grid_line_width;
+ }
+ else
+ {
+ tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
+ tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
+ }
+
+ if (row_ending_details)
+ gtk_paint_focus (widget->style,
+ tree_view->priv->bin_window,
+ focus_rect_state,
+ &event->area,
+ widget,
+ (is_first
+ ? (is_last ? "treeview" : "treeview-left" )
+ : (is_last ? "treeview-right" : "treeview-middle"
)),
+ 0, tmp_y,
+ width, tmp_height);
+ else
+ gtk_paint_focus (widget->style,
+ tree_view->priv->bin_window,
+ focus_rect_state,
+ &event->area,
+ widget,
+ "treeview",
+ 0, tmp_y,
+ width, tmp_height);
+ }
+
+ y_offset += max_height;
+ if (node->children)
+ {
+ GtkTreeIter parent = iter;
+ gboolean has_child;
+
+ tree = node->children;
+ node = tree->root;
+
+ g_assert (node != tree->nil);
+
+ while (node->left != tree->nil)
+ node = node->left;
+ has_child = gtk_tree_model_iter_children (tree_view->priv->model,
+ &iter,
+ &parent);
+ depth++;
+
+ /* Sanity Check! */
+ TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
+ }
+ else
+ {
+ gboolean done = FALSE;
+
+ do
+ {
+ node = _pspp_rbtree_next (tree, node);
+ if (node != NULL)
+ {
+ gboolean has_next = gtk_tree_model_iter_next
(tree_view->priv->model, &iter);
+ done = TRUE;
+
+ /* Sanity Check! */
+ TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
+ }
+ else
+ {
+ GtkTreeIter parent_iter = iter;
+ gboolean has_parent;
+
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ if (tree == NULL)
+ /* we should go to done to free some memory */
+ goto done;
+ has_parent = gtk_tree_model_iter_parent
(tree_view->priv->model,
+ &iter,
+ &parent_iter);
+ depth--;
+
+ /* Sanity check */
+ TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
+ }
+ }
+ while (!done);
+ }
+ }
+ while (y_offset < event->area.height);
+
+done:
+ pspp_sheet_view_draw_grid_lines (tree_view, event, n_visible_columns);
+
+ if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
+ {
+ GdkRectangle *rectangles;
+ gint n_rectangles;
+
+ gdk_region_get_rectangles (event->region,
+ &rectangles,
+ &n_rectangles);
+
+ while (n_rectangles--)
+ pspp_sheet_view_paint_rubber_band (tree_view,
&rectangles[n_rectangles]);
+
+ g_free (rectangles);
+ }
+
+ if (cursor_path)
+ gtk_tree_path_free (cursor_path);
+
+ if (drag_dest_path)
+ gtk_tree_path_free (drag_dest_path);
+
+ return FALSE;
+}
+
+static gboolean
+pspp_sheet_view_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+
+ if (event->window == tree_view->priv->bin_window)
+ {
+ gboolean retval;
+ GList *tmp_list;
+
+ retval = pspp_sheet_view_bin_expose (widget, event);
+
+ /* We can't just chain up to Container::expose as it will try to send the
+ * event to the headers, so we handle propagating it to our children
+ * (eg. widgets being edited) ourselves.
+ */
+ tmp_list = tree_view->priv->children;
+ while (tmp_list)
+ {
+ PsppSheetViewChild *child = tmp_list->data;
+ tmp_list = tmp_list->next;
+
+ gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
child->widget, event);
+ }
+
+ return retval;
+ }
+
+ else if (event->window == tree_view->priv->header_window)
+ {
+ GList *list;
+
+ for (list = tree_view->priv->columns; list != NULL; list = list->next)
+ {
+ PsppSheetViewColumn *column = list->data;
+
+ if (column == tree_view->priv->drag_column)
+ continue;
+
+ if (column->visible)
+ gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
+ column->button,
+ event);
+ }
+ }
+ else if (event->window == tree_view->priv->drag_window)
+ {
+ gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
+ tree_view->priv->drag_column->button,
+ event);
+ }
+ return TRUE;
+}
+
+enum
+{
+ DROP_HOME,
+ DROP_RIGHT,
+ DROP_LEFT,
+ DROP_END
+};
+
+/* returns 0x1 when no column has been found -- yes it's hackish */
+static PsppSheetViewColumn *
+pspp_sheet_view_get_drop_column (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column,
+ gint drop_position)
+{
+ PsppSheetViewColumn *left_column = NULL;
+ PsppSheetViewColumn *cur_column = NULL;
+ GList *tmp_list;
+
+ if (!column->reorderable)
+ return (PsppSheetViewColumn *)0x1;
+
+ switch (drop_position)
+ {
+ case DROP_HOME:
+ /* find first column where we can drop */
+ tmp_list = tree_view->priv->columns;
+ if (column == PSPP_SHEET_VIEW_COLUMN (tmp_list->data))
+ return (PsppSheetViewColumn *)0x1;
+
+ while (tmp_list)
+ {
+ g_assert (tmp_list);
+
+ cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
+ tmp_list = tmp_list->next;
+
+ if (left_column && left_column->visible == FALSE)
+ continue;
+
+ if (!tree_view->priv->column_drop_func)
+ return left_column;
+
+ if (!tree_view->priv->column_drop_func (tree_view, column,
left_column, cur_column, tree_view->priv->column_drop_func_data))
+ {
+ left_column = cur_column;
+ continue;
+ }
+
+ return left_column;
+ }
+
+ if (!tree_view->priv->column_drop_func)
+ return left_column;
+
+ if (tree_view->priv->column_drop_func (tree_view, column, left_column,
NULL, tree_view->priv->column_drop_func_data))
+ return left_column;
+ else
+ return (PsppSheetViewColumn *)0x1;
+ break;
+
+ case DROP_RIGHT:
+ /* find first column after column where we can drop */
+ tmp_list = tree_view->priv->columns;
+
+ for (; tmp_list; tmp_list = tmp_list->next)
+ if (PSPP_SHEET_VIEW_COLUMN (tmp_list->data) == column)
+ break;
+
+ if (!tmp_list || !tmp_list->next)
+ return (PsppSheetViewColumn *)0x1;
+
+ tmp_list = tmp_list->next;
+ left_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
+ tmp_list = tmp_list->next;
+
+ while (tmp_list)
+ {
+ g_assert (tmp_list);
+
+ cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
+ tmp_list = tmp_list->next;
+
+ if (left_column && left_column->visible == FALSE)
+ {
+ left_column = cur_column;
+ if (tmp_list)
+ tmp_list = tmp_list->next;
+ continue;
+ }
+
+ if (!tree_view->priv->column_drop_func)
+ return left_column;
+
+ if (!tree_view->priv->column_drop_func (tree_view, column,
left_column, cur_column, tree_view->priv->column_drop_func_data))
+ {
+ left_column = cur_column;
+ continue;
+ }
+
+ return left_column;
+ }
+
+ if (!tree_view->priv->column_drop_func)
+ return left_column;
+
+ if (tree_view->priv->column_drop_func (tree_view, column, left_column,
NULL, tree_view->priv->column_drop_func_data))
+ return left_column;
+ else
+ return (PsppSheetViewColumn *)0x1;
+ break;
+
+ case DROP_LEFT:
+ /* find first column before column where we can drop */
+ tmp_list = tree_view->priv->columns;
+
+ for (; tmp_list; tmp_list = tmp_list->next)
+ if (PSPP_SHEET_VIEW_COLUMN (tmp_list->data) == column)
+ break;
+
+ if (!tmp_list || !tmp_list->prev)
+ return (PsppSheetViewColumn *)0x1;
+
+ tmp_list = tmp_list->prev;
+ cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
+ tmp_list = tmp_list->prev;
+
+ while (tmp_list)
+ {
+ g_assert (tmp_list);
+
+ left_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
+
+ if (left_column && !left_column->visible)
+ {
+ /*if (!tmp_list->prev)
+ return (PsppSheetViewColumn *)0x1;
+ */
+/*
+ cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->prev->data);
+ tmp_list = tmp_list->prev->prev;
+ continue;*/
+
+ cur_column = left_column;
+ if (tmp_list)
+ tmp_list = tmp_list->prev;
+ continue;
+ }
+
+ if (!tree_view->priv->column_drop_func)
+ return left_column;
+
+ if (tree_view->priv->column_drop_func (tree_view, column,
left_column, cur_column, tree_view->priv->column_drop_func_data))
+ return left_column;
+
+ cur_column = left_column;
+ tmp_list = tmp_list->prev;
+ }
+
+ if (!tree_view->priv->column_drop_func)
+ return NULL;
+
+ if (tree_view->priv->column_drop_func (tree_view, column, NULL,
cur_column, tree_view->priv->column_drop_func_data))
+ return NULL;
+ else
+ return (PsppSheetViewColumn *)0x1;
+ break;
+
+ case DROP_END:
+ /* same as DROP_HOME case, but doing it backwards */
+ tmp_list = g_list_last (tree_view->priv->columns);
+ cur_column = NULL;
+
+ if (column == PSPP_SHEET_VIEW_COLUMN (tmp_list->data))
+ return (PsppSheetViewColumn *)0x1;
+
+ while (tmp_list)
+ {
+ g_assert (tmp_list);
+
+ left_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
+
+ if (left_column && !left_column->visible)
+ {
+ cur_column = left_column;
+ tmp_list = tmp_list->prev;
+ }
+
+ if (!tree_view->priv->column_drop_func)
+ return left_column;
+
+ if (tree_view->priv->column_drop_func (tree_view, column,
left_column, cur_column, tree_view->priv->column_drop_func_data))
+ return left_column;
+
+ cur_column = left_column;
+ tmp_list = tmp_list->prev;
+ }
+
+ if (!tree_view->priv->column_drop_func)
+ return NULL;
+
+ if (tree_view->priv->column_drop_func (tree_view, column, NULL,
cur_column, tree_view->priv->column_drop_func_data))
+ return NULL;
+ else
+ return (PsppSheetViewColumn *)0x1;
+ break;
+ }
+
+ return (PsppSheetViewColumn *)0x1;
+}
+
+static gboolean
+pspp_sheet_view_key_press (GtkWidget *widget,
+ GdkEventKey *event)
+{
+ PsppSheetView *tree_view = (PsppSheetView *) widget;
+
+ if (tree_view->priv->rubber_band_status)
+ {
+ if (event->keyval == GDK_Escape)
+ pspp_sheet_view_stop_rubber_band (tree_view);
+
+ return TRUE;
+ }
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG))
+ {
+ if (event->keyval == GDK_Escape)
+ {
+ tree_view->priv->cur_reorder = NULL;
+ pspp_sheet_view_button_release_drag_column (widget, NULL);
+ }
+ return TRUE;
+ }
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE))
+ {
+ GList *focus_column;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+
+ for (focus_column = tree_view->priv->columns;
+ focus_column;
+ focus_column = focus_column->next)
+ {
+ PsppSheetViewColumn *column = PSPP_SHEET_VIEW_COLUMN
(focus_column->data);
+
+ if (gtk_widget_has_focus (column->button))
+ break;
+ }
+
+ if (focus_column &&
+ (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
+ (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
+ || event->keyval == GDK_Right || event->keyval == GDK_KP_Right))
+ {
+ PsppSheetViewColumn *column = PSPP_SHEET_VIEW_COLUMN
(focus_column->data);
+
+ if (!column->resizable)
+ {
+ gtk_widget_error_bell (widget);
+ return TRUE;
+ }
+
+ if (event->keyval == (rtl ? GDK_Right : GDK_Left)
+ || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
+ {
+ gint old_width = column->resized_width;
+
+ column->resized_width = MAX (column->resized_width,
+ column->width);
+ column->resized_width -= 2;
+ if (column->resized_width < 0)
+ column->resized_width = 0;
+
+ if (column->min_width == -1)
+ column->resized_width = MAX (column->button->requisition.width,
+ column->resized_width);
+ else
+ column->resized_width = MAX (column->min_width,
+ column->resized_width);
+
+ if (column->max_width != -1)
+ column->resized_width = MIN (column->resized_width,
+ column->max_width);
+
+ column->use_resized_width = TRUE;
+
+ if (column->resized_width != old_width)
+ gtk_widget_queue_resize (widget);
+ else
+ gtk_widget_error_bell (widget);
+ }
+ else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
+ || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
+ {
+ gint old_width = column->resized_width;
+
+ column->resized_width = MAX (column->resized_width,
+ column->width);
+ column->resized_width += 2;
+
+ if (column->max_width != -1)
+ column->resized_width = MIN (column->resized_width,
+ column->max_width);
+
+ column->use_resized_width = TRUE;
+
+ if (column->resized_width != old_width)
+ gtk_widget_queue_resize (widget);
+ else
+ gtk_widget_error_bell (widget);
+ }
+
+ return TRUE;
+ }
+
+ if (focus_column &&
+ (event->state & GDK_MOD1_MASK) &&
+ (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
+ || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
+ || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
+ || event->keyval == GDK_End || event->keyval == GDK_KP_End))
+ {
+ PsppSheetViewColumn *column = PSPP_SHEET_VIEW_COLUMN
(focus_column->data);
+
+ if (event->keyval == (rtl ? GDK_Right : GDK_Left)
+ || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
+ {
+ PsppSheetViewColumn *col;
+ col = pspp_sheet_view_get_drop_column (tree_view, column,
DROP_LEFT);
+ if (col != (PsppSheetViewColumn *)0x1)
+ pspp_sheet_view_move_column_after (tree_view, column, col);
+ else
+ gtk_widget_error_bell (widget);
+ }
+ else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
+ || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
+ {
+ PsppSheetViewColumn *col;
+ col = pspp_sheet_view_get_drop_column (tree_view, column,
DROP_RIGHT);
+ if (col != (PsppSheetViewColumn *)0x1)
+ pspp_sheet_view_move_column_after (tree_view, column, col);
+ else
+ gtk_widget_error_bell (widget);
+ }
+ else if (event->keyval == GDK_Home || event->keyval == GDK_KP_Home)
+ {
+ PsppSheetViewColumn *col;
+ col = pspp_sheet_view_get_drop_column (tree_view, column,
DROP_HOME);
+ if (col != (PsppSheetViewColumn *)0x1)
+ pspp_sheet_view_move_column_after (tree_view, column, col);
+ else
+ gtk_widget_error_bell (widget);
+ }
+ else if (event->keyval == GDK_End || event->keyval == GDK_KP_End)
+ {
+ PsppSheetViewColumn *col;
+ col = pspp_sheet_view_get_drop_column (tree_view, column,
DROP_END);
+ if (col != (PsppSheetViewColumn *)0x1)
+ pspp_sheet_view_move_column_after (tree_view, column, col);
+ else
+ gtk_widget_error_bell (widget);
+ }
+
+ return TRUE;
+ }
+ }
+
+ /* Chain up to the parent class. It handles the keybindings. */
+ if (GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->key_press_event
(widget, event))
+ return TRUE;
+
+ if (tree_view->priv->search_entry_avoid_unhandled_binding)
+ {
+ tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
+ return FALSE;
+ }
+
+ /* We pass the event to the search_entry. If its text changes, then we start
+ * the typeahead find capabilities. */
+ if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
+ && tree_view->priv->enable_search
+ && !tree_view->priv->search_custom_entry_set)
+ {
+ GdkEvent *new_event;
+ char *old_text;
+ const char *new_text;
+ gboolean retval;
+ GdkScreen *screen;
+ gboolean text_modified;
+ gulong popup_menu_id;
+
+ pspp_sheet_view_ensure_interactive_directory (tree_view);
+
+ /* Make a copy of the current text */
+ old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY
(tree_view->priv->search_entry)));
+ new_event = gdk_event_copy ((GdkEvent *) event);
+ g_object_unref (((GdkEventKey *) new_event)->window);
+ ((GdkEventKey *) new_event)->window = g_object_ref
(tree_view->priv->search_window->window);
+ gtk_widget_realize (tree_view->priv->search_window);
+
+ popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
+ "popup-menu", G_CALLBACK (gtk_true),
+ NULL);
+
+ /* Move the entry off screen */
+ screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
+ gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
+ gdk_screen_get_width (screen) + 1,
+ gdk_screen_get_height (screen) + 1);
+ gtk_widget_show (tree_view->priv->search_window);
+
+ /* Send the event to the window. If the preedit_changed signal is
emitted
+ * during this event, we will set priv->imcontext_changed */
+ tree_view->priv->imcontext_changed = FALSE;
+ retval = gtk_widget_event (tree_view->priv->search_window, new_event);
+ gdk_event_free (new_event);
+ gtk_widget_hide (tree_view->priv->search_window);
+
+ g_signal_handler_disconnect (tree_view->priv->search_entry,
+ popup_menu_id);
+
+ /* We check to make sure that the entry tried to handle the text, and
that
+ * the text has changed.
+ */
+ new_text = gtk_entry_get_text (GTK_ENTRY
(tree_view->priv->search_entry));
+ text_modified = strcmp (old_text, new_text) != 0;
+ g_free (old_text);
+ if (tree_view->priv->imcontext_changed || /* we're in a preedit */
+ (retval && text_modified)) /* ...or the text was
modified */
+ {
+ if (pspp_sheet_view_real_start_interactive_search (tree_view, FALSE))
+ {
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ return TRUE;
+ }
+ else
+ {
+ gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry),
"");
+ return FALSE;
+ }
+ }
+ }
+
+ return FALSE;
+}
+
+static gboolean
+pspp_sheet_view_key_release (GtkWidget *widget,
+ GdkEventKey *event)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+
+ if (tree_view->priv->rubber_band_status)
+ return TRUE;
+
+ return GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->key_release_event
(widget, event);
+}
+
+/* FIXME Is this function necessary? Can I get an enter_notify event
+ * w/o either an expose event or a mouse motion event?
+ */
+static gboolean
+pspp_sheet_view_enter_notify (GtkWidget *widget,
+ GdkEventCrossing *event)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gint new_y;
+
+ /* Sanity check it */
+ if (event->window != tree_view->priv->bin_window)
+ return FALSE;
+
+ if (tree_view->priv->tree == NULL)
+ return FALSE;
+
+ if (event->mode == GDK_CROSSING_GRAB ||
+ event->mode == GDK_CROSSING_GTK_GRAB ||
+ event->mode == GDK_CROSSING_GTK_UNGRAB ||
+ event->mode == GDK_CROSSING_STATE_CHANGED)
+ return TRUE;
+
+ /* find the node internally */
+ new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
+ if (new_y < 0)
+ new_y = 0;
+ _pspp_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
+
+ tree_view->priv->event_last_x = event->x;
+ tree_view->priv->event_last_y = event->y;
+
+ if ((tree_view->priv->button_pressed_node == NULL) ||
+ (tree_view->priv->button_pressed_node == node))
+ prelight_or_select (tree_view, tree, node, event->x, event->y);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_leave_notify (GtkWidget *widget,
+ GdkEventCrossing *event)
+{
+ PsppSheetView *tree_view;
+
+ if (event->mode == GDK_CROSSING_GRAB)
+ return TRUE;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ if (tree_view->priv->prelight_node)
+ _pspp_sheet_view_queue_draw_node (tree_view,
+ tree_view->priv->prelight_tree,
+ tree_view->priv->prelight_node,
+ NULL);
+
+ tree_view->priv->event_last_x = -10000;
+ tree_view->priv->event_last_y = -10000;
+
+ prelight_or_select (tree_view,
+ NULL, NULL,
+ -1000, -1000); /* coords not possibly over an arrow */
+
+ return TRUE;
+}
+
+
+static gint
+pspp_sheet_view_focus_out (GtkWidget *widget,
+ GdkEventFocus *event)
+{
+ PsppSheetView *tree_view;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ gtk_widget_queue_draw (widget);
+
+ /* destroy interactive search dialog */
+ if (tree_view->priv->search_window)
+ pspp_sheet_view_search_dialog_hide (tree_view->priv->search_window,
tree_view);
+
+ return FALSE;
+}
+
+
+/* Incremental Reflow
+ */
+
+static void
+pspp_sheet_view_node_queue_redraw (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ gint y;
+
+ y = _pspp_rbtree_node_find_offset (tree, node)
+ - tree_view->priv->vadjustment->value
+ + TREE_VIEW_HEADER_HEIGHT (tree_view);
+
+ gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
+ 0, y,
+ GTK_WIDGET (tree_view)->allocation.width,
+ PSPP_RBNODE_GET_HEIGHT (node));
+}
+
+static gboolean
+node_is_visible (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ int y;
+ int height;
+
+ y = _pspp_rbtree_node_find_offset (tree, node);
+ height = ROW_HEIGHT (tree_view, PSPP_RBNODE_GET_HEIGHT (node));
+
+ if (y >= tree_view->priv->vadjustment->value &&
+ y + height <= (tree_view->priv->vadjustment->value
+ + tree_view->priv->vadjustment->page_size))
+ return TRUE;
+
+ return FALSE;
+}
+
+/* Returns TRUE if it updated the size
+ */
+static gboolean
+validate_row (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkTreeIter *iter,
+ GtkTreePath *path)
+{
+ PsppSheetViewColumn *column;
+ GList *list, *first_column, *last_column;
+ gint height = 0;
+ gint horizontal_separator;
+ gint vertical_separator;
+ gint focus_line_width;
+ gint depth = gtk_tree_path_get_depth (path);
+ gboolean retval = FALSE;
+ gboolean is_separator = FALSE;
+ gboolean draw_vgrid_lines, draw_hgrid_lines;
+ gint focus_pad;
+ gint grid_line_width;
+ gboolean wide_separators;
+ gint separator_height;
+
+ /* double check the row needs validating */
+ if (! PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) &&
+ ! PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID))
+ return FALSE;
+
+ is_separator = row_is_separator (tree_view, iter, NULL);
+
+ gtk_widget_style_get (GTK_WIDGET (tree_view),
+ "focus-padding", &focus_pad,
+ "focus-line-width", &focus_line_width,
+ "horizontal-separator", &horizontal_separator,
+ "vertical-separator", &vertical_separator,
+ "grid-line-width", &grid_line_width,
+ "wide-separators", &wide_separators,
+ "separator-height", &separator_height,
+ NULL);
+
+ draw_vgrid_lines =
+ tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
+ || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH;
+ draw_hgrid_lines =
+ tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL
+ || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH;
+
+ for (last_column = g_list_last (tree_view->priv->columns);
+ last_column && !(PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible);
+ last_column = last_column->prev)
+ ;
+
+ for (first_column = g_list_first (tree_view->priv->columns);
+ first_column && !(PSPP_SHEET_VIEW_COLUMN (first_column->data)->visible);
+ first_column = first_column->next)
+ ;
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ gint tmp_width;
+ gint tmp_height;
+
+ column = list->data;
+
+ if (! column->visible)
+ continue;
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID) &&
!column->dirty)
+ continue;
+
+ pspp_sheet_view_column_cell_set_cell_data (column,
tree_view->priv->model, iter,
+ PSPP_RBNODE_FLAG_SET (node,
PSPP_RBNODE_IS_PARENT),
+ node->children?TRUE:FALSE);
+ pspp_sheet_view_column_cell_get_size (column,
+ NULL, NULL, NULL,
+ &tmp_width, &tmp_height);
+
+ if (!is_separator)
+ {
+ tmp_height += vertical_separator;
+ height = MAX (height, tmp_height);
+ height = MAX (height, tree_view->priv->expander_size);
+ }
+ else
+ {
+ if (wide_separators)
+ height = separator_height + 2 * focus_pad;
+ else
+ height = 2 + 2 * focus_pad;
+ }
+
+ if (pspp_sheet_view_is_expander_column (tree_view, column))
+ {
+ tmp_width = tmp_width + horizontal_separator + (depth - 1) *
tree_view->priv->level_indentation;
+
+ if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
+ tmp_width += depth * tree_view->priv->expander_size;
+ }
+ else
+ tmp_width = tmp_width + horizontal_separator;
+
+ if (draw_vgrid_lines)
+ {
+ if (list->data == first_column || list->data == last_column)
+ tmp_width += grid_line_width / 2.0;
+ else
+ tmp_width += grid_line_width;
+ }
+
+ if (tmp_width > column->requested_width)
+ {
+ retval = TRUE;
+ column->requested_width = tmp_width;
+ }
+ }
+
+ if (draw_hgrid_lines)
+ height += grid_line_width;
+
+ if (height != PSPP_RBNODE_GET_HEIGHT (node))
+ {
+ retval = TRUE;
+ _pspp_rbtree_node_set_height (tree, node, height);
+ }
+ _pspp_rbtree_node_mark_valid (tree, node);
+ tree_view->priv->post_validation_flag = TRUE;
+
+ return retval;
+}
+
+
+static void
+validate_visible_area (PsppSheetView *tree_view)
+{
+ GtkTreePath *path = NULL;
+ GtkTreePath *above_path = NULL;
+ GtkTreeIter iter;
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ gboolean need_redraw = FALSE;
+ gboolean size_changed = FALSE;
+ gint total_height;
+ gint area_above = 0;
+ gint area_below = 0;
+
+ if (tree_view->priv->tree == NULL)
+ return;
+
+ if (! PSPP_RBNODE_FLAG_SET (tree_view->priv->tree->root,
PSPP_RBNODE_DESCENDANTS_INVALID) &&
+ tree_view->priv->scroll_to_path == NULL)
+ return;
+
+ total_height = GTK_WIDGET (tree_view)->allocation.height -
TREE_VIEW_HEADER_HEIGHT (tree_view);
+
+ if (total_height == 0)
+ return;
+
+ /* First, we check to see if we need to scroll anywhere
+ */
+ if (tree_view->priv->scroll_to_path)
+ {
+ path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
+ if (path && !_pspp_sheet_view_find_node (tree_view, path, &tree, &node))
+ {
+ /* we are going to scroll, and will update dy */
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) ||
+ PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID))
+ {
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, NULL);
+ if (validate_row (tree_view, tree, node, &iter, path))
+ size_changed = TRUE;
+ }
+
+ if (tree_view->priv->scroll_to_use_align)
+ {
+ gint height = ROW_HEIGHT (tree_view, PSPP_RBNODE_GET_HEIGHT
(node));
+ area_above = (total_height - height) *
+ tree_view->priv->scroll_to_row_align;
+ area_below = total_height - area_above - height;
+ area_above = MAX (area_above, 0);
+ area_below = MAX (area_below, 0);
+ }
+ else
+ {
+ /* two cases:
+ * 1) row not visible
+ * 2) row visible
+ */
+ gint dy;
+ gint height = ROW_HEIGHT (tree_view, PSPP_RBNODE_GET_HEIGHT
(node));
+
+ dy = _pspp_rbtree_node_find_offset (tree, node);
+
+ if (dy >= tree_view->priv->vadjustment->value &&
+ dy + height <= (tree_view->priv->vadjustment->value
+ + tree_view->priv->vadjustment->page_size))
+ {
+ /* row visible: keep the row at the same position */
+ area_above = dy - tree_view->priv->vadjustment->value;
+ area_below = (tree_view->priv->vadjustment->value +
+ tree_view->priv->vadjustment->page_size)
+ - dy - height;
+ }
+ else
+ {
+ /* row not visible */
+ if (dy >= 0
+ && dy + height <= tree_view->priv->vadjustment->page_size)
+ {
+ /* row at the beginning -- fixed */
+ area_above = dy;
+ area_below = tree_view->priv->vadjustment->page_size
+ - area_above - height;
+ }
+ else if (dy >= (tree_view->priv->vadjustment->upper -
+ tree_view->priv->vadjustment->page_size))
+ {
+ /* row at the end -- fixed */
+ area_above = dy - (tree_view->priv->vadjustment->upper -
+ tree_view->priv->vadjustment->page_size);
+ area_below = tree_view->priv->vadjustment->page_size -
+ area_above - height;
+
+ if (area_below < 0)
+ {
+ area_above = tree_view->priv->vadjustment->page_size
- height;
+ area_below = 0;
+ }
+ }
+ else
+ {
+ /* row somewhere in the middle, bring it to the top
+ * of the view
+ */
+ area_above = 0;
+ area_below = total_height - height;
+ }
+ }
+ }
+ }
+ else
+ /* the scroll to isn't valid; ignore it.
+ */
+ {
+ if (tree_view->priv->scroll_to_path && !path)
+ {
+ gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
+ tree_view->priv->scroll_to_path = NULL;
+ }
+ if (path)
+ gtk_tree_path_free (path);
+ path = NULL;
+ }
+ }
+
+ /* We didn't have a scroll_to set, so we just handle things normally
+ */
+ if (path == NULL)
+ {
+ gint offset;
+
+ offset = _pspp_rbtree_find_offset (tree_view->priv->tree,
+ TREE_WINDOW_Y_TO_RBTREE_Y (tree_view,
0),
+ &tree, &node);
+ if (node == NULL)
+ {
+ /* In this case, nothing has been validated */
+ path = gtk_tree_path_new_first ();
+ _pspp_sheet_view_find_node (tree_view, path, &tree, &node);
+ }
+ else
+ {
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ total_height += offset;
+ }
+
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) ||
+ PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID))
+ {
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, NULL);
+ if (validate_row (tree_view, tree, node, &iter, path))
+ size_changed = TRUE;
+ }
+ area_above = 0;
+ area_below = total_height - ROW_HEIGHT (tree_view,
PSPP_RBNODE_GET_HEIGHT (node));
+ }
+
+ above_path = gtk_tree_path_copy (path);
+
+ /* if we do not validate any row above the new top_row, we will make sure
+ * that the row immediately above top_row has been validated. (if we do not
+ * do this, _pspp_rbtree_find_offset will find the row above top_row, because
+ * when invalidated that row's height will be zero. and this will mess up
+ * scrolling).
+ */
+ if (area_above == 0)
+ {
+ GtkRBTree *tmptree;
+ GtkRBNode *tmpnode;
+
+ _pspp_sheet_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
+ _pspp_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
+
+ if (tmpnode)
+ {
+ GtkTreePath *tmppath;
+ GtkTreeIter tmpiter;
+
+ tmppath = _pspp_sheet_view_find_path (tree_view, tmptree, tmpnode);
+ gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
+
+ if (PSPP_RBNODE_FLAG_SET (tmpnode, PSPP_RBNODE_INVALID) ||
+ PSPP_RBNODE_FLAG_SET (tmpnode, PSPP_RBNODE_COLUMN_INVALID))
+ {
+ _pspp_sheet_view_queue_draw_node (tree_view, tmptree, tmpnode,
NULL);
+ if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
+ size_changed = TRUE;
+ }
+
+ gtk_tree_path_free (tmppath);
+ }
+ }
+
+ /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
+ * backwards is much slower then forward, as there is no iter_prev function.
+ * We go forwards first in case we run out of tree. Then we go backwards to
+ * fill out the top.
+ */
+ while (node && area_below > 0)
+ {
+ if (node->children)
+ {
+ GtkTreeIter parent = iter;
+ gboolean has_child;
+
+ tree = node->children;
+ node = tree->root;
+
+ g_assert (node != tree->nil);
+
+ while (node->left != tree->nil)
+ node = node->left;
+ has_child = gtk_tree_model_iter_children (tree_view->priv->model,
+ &iter,
+ &parent);
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
+ gtk_tree_path_down (path);
+ }
+ else
+ {
+ gboolean done = FALSE;
+ do
+ {
+ node = _pspp_rbtree_next (tree, node);
+ if (node != NULL)
+ {
+ gboolean has_next = gtk_tree_model_iter_next
(tree_view->priv->model, &iter);
+ done = TRUE;
+ gtk_tree_path_next (path);
+
+ /* Sanity Check! */
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
+ }
+ else
+ {
+ GtkTreeIter parent_iter = iter;
+ gboolean has_parent;
+
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ if (tree == NULL)
+ break;
+ has_parent = gtk_tree_model_iter_parent
(tree_view->priv->model,
+ &iter,
+ &parent_iter);
+ gtk_tree_path_up (path);
+
+ /* Sanity check */
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
+ }
+ }
+ while (!done);
+ }
+
+ if (!node)
+ break;
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) ||
+ PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID))
+ {
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, NULL);
+ if (validate_row (tree_view, tree, node, &iter, path))
+ size_changed = TRUE;
+ }
+
+ area_below -= ROW_HEIGHT (tree_view, PSPP_RBNODE_GET_HEIGHT (node));
+ }
+ gtk_tree_path_free (path);
+
+ /* If we ran out of tree, and have extra area_below left, we need to add it
+ * to area_above */
+ if (area_below > 0)
+ area_above += area_below;
+
+ _pspp_sheet_view_find_node (tree_view, above_path, &tree, &node);
+
+ /* We walk backwards */
+ while (area_above > 0)
+ {
+ _pspp_rbtree_prev_full (tree, node, &tree, &node);
+
+ /* Always find the new path in the tree. We cannot just assume
+ * a gtk_tree_path_prev() is enough here, as there might be children
+ * in between this node and the previous sibling node. If this
+ * appears to be a performance hotspot in profiles, we can look into
+ * intrigate logic for keeping path, node and iter in sync like
+ * we do for forward walks. (Which will be hard because of the lacking
+ * iter_prev).
+ */
+
+ if (node == NULL)
+ break;
+
+ gtk_tree_path_free (above_path);
+ above_path = _pspp_sheet_view_find_path (tree_view, tree, node);
+
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) ||
+ PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID))
+ {
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, NULL);
+ if (validate_row (tree_view, tree, node, &iter, above_path))
+ size_changed = TRUE;
+ }
+ area_above -= ROW_HEIGHT (tree_view, PSPP_RBNODE_GET_HEIGHT (node));
+ }
+
+ /* if we scrolled to a path, we need to set the dy here,
+ * and sync the top row accordingly
+ */
+ if (tree_view->priv->scroll_to_path)
+ {
+ pspp_sheet_view_set_top_row (tree_view, above_path, -area_above);
+ pspp_sheet_view_top_row_to_dy (tree_view);
+
+ need_redraw = TRUE;
+ }
+ else if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
+ {
+ /* when we are not scrolling, we should never set dy to something
+ * else than zero. we update top_row to be in sync with dy = 0.
+ */
+ gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
0);
+ pspp_sheet_view_dy_to_top_row (tree_view);
+ }
+ else if (tree_view->priv->vadjustment->value +
tree_view->priv->vadjustment->page_size > tree_view->priv->height)
+ {
+ gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
tree_view->priv->height - tree_view->priv->vadjustment->page_size);
+ pspp_sheet_view_dy_to_top_row (tree_view);
+ }
+ else
+ pspp_sheet_view_top_row_to_dy (tree_view);
+
+ /* update width/height and queue a resize */
+ if (size_changed)
+ {
+ GtkRequisition requisition;
+
+ /* We temporarily guess a size, under the assumption that it will be the
+ * same when we get our next size_allocate. If we don't do this, we'll
be
+ * in an inconsistent state if we call top_row_to_dy. */
+
+ gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
+ tree_view->priv->hadjustment->upper = MAX
(tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
+ tree_view->priv->vadjustment->upper = MAX
(tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
+ gtk_adjustment_changed (tree_view->priv->hadjustment);
+ gtk_adjustment_changed (tree_view->priv->vadjustment);
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ }
+
+ if (tree_view->priv->scroll_to_path)
+ {
+ gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
+ tree_view->priv->scroll_to_path = NULL;
+ }
+
+ if (above_path)
+ gtk_tree_path_free (above_path);
+
+ if (tree_view->priv->scroll_to_column)
+ {
+ tree_view->priv->scroll_to_column = NULL;
+ }
+ if (need_redraw)
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+}
+
+static void
+initialize_fixed_height_mode (PsppSheetView *tree_view)
+{
+ if (!tree_view->priv->tree)
+ return;
+
+ if (tree_view->priv->fixed_height < 0)
+ {
+ GtkTreeIter iter;
+ GtkTreePath *path;
+
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+
+ tree = tree_view->priv->tree;
+ node = tree->root;
+
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+
+ validate_row (tree_view, tree, node, &iter, path);
+
+ gtk_tree_path_free (path);
+
+ tree_view->priv->fixed_height = ROW_HEIGHT (tree_view,
PSPP_RBNODE_GET_HEIGHT (node));
+ }
+
+ _pspp_rbtree_set_fixed_height (tree_view->priv->tree,
+ tree_view->priv->fixed_height, TRUE);
+}
+
+/* Our strategy for finding nodes to validate is a little convoluted. We find
+ * the left-most uninvalidated node. We then try walking right, validating
+ * nodes. Once we find a valid node, we repeat the previous process of finding
+ * the first invalid node.
+ */
+
+static gboolean
+do_validate_rows (PsppSheetView *tree_view, gboolean queue_resize)
+{
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ gboolean validated_area = FALSE;
+ gint retval = TRUE;
+ GtkTreePath *path = NULL;
+ GtkTreeIter iter;
+ GTimer *timer;
+ gint i = 0;
+
+ gint prev_height = -1;
+ gboolean fixed_height = TRUE;
+
+ g_assert (tree_view);
+
+ if (tree_view->priv->tree == NULL)
+ return FALSE;
+
+ if (tree_view->priv->fixed_height_mode)
+ {
+ if (tree_view->priv->fixed_height < 0)
+ initialize_fixed_height_mode (tree_view);
+
+ return FALSE;
+ }
+
+ timer = g_timer_new ();
+ g_timer_start (timer);
+
+ do
+ {
+ if (! PSPP_RBNODE_FLAG_SET (tree_view->priv->tree->root,
PSPP_RBNODE_DESCENDANTS_INVALID))
+ {
+ retval = FALSE;
+ goto done;
+ }
+
+ if (path != NULL)
+ {
+ node = _pspp_rbtree_next (tree, node);
+ if (node != NULL)
+ {
+ TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next
(tree_view->priv->model, &iter), FALSE);
+ gtk_tree_path_next (path);
+ }
+ else
+ {
+ gtk_tree_path_free (path);
+ path = NULL;
+ }
+ }
+
+ if (path == NULL)
+ {
+ tree = tree_view->priv->tree;
+ node = tree_view->priv->tree->root;
+
+ g_assert (PSPP_RBNODE_FLAG_SET (node,
PSPP_RBNODE_DESCENDANTS_INVALID));
+
+ do
+ {
+ if (node->left != tree->nil &&
+ PSPP_RBNODE_FLAG_SET (node->left,
PSPP_RBNODE_DESCENDANTS_INVALID))
+ {
+ node = node->left;
+ }
+ else if (node->right != tree->nil &&
+ PSPP_RBNODE_FLAG_SET (node->right,
PSPP_RBNODE_DESCENDANTS_INVALID))
+ {
+ node = node->right;
+ }
+ else if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID) ||
+ PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_COLUMN_INVALID))
+ {
+ break;
+ }
+ else if (node->children != NULL)
+ {
+ tree = node->children;
+ node = tree->root;
+ }
+ else
+ /* RBTree corruption! All bad */
+ g_assert_not_reached ();
+ }
+ while (TRUE);
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+ }
+
+ validated_area = validate_row (tree_view, tree, node, &iter, path) ||
+ validated_area;
+
+ if (!tree_view->priv->fixed_height_check)
+ {
+ gint height;
+
+ height = ROW_HEIGHT (tree_view, PSPP_RBNODE_GET_HEIGHT (node));
+ if (prev_height < 0)
+ prev_height = height;
+ else if (prev_height != height)
+ fixed_height = FALSE;
+ }
+
+ i++;
+ }
+ while (g_timer_elapsed (timer, NULL) < PSPP_SHEET_VIEW_TIME_MS_PER_IDLE /
1000.);
+
+ if (!tree_view->priv->fixed_height_check)
+ {
+ if (fixed_height)
+ _pspp_rbtree_set_fixed_height (tree_view->priv->tree, prev_height,
FALSE);
+
+ tree_view->priv->fixed_height_check = 1;
+ }
+
+ done:
+ if (validated_area)
+ {
+ GtkRequisition requisition;
+ /* We temporarily guess a size, under the assumption that it will be the
+ * same when we get our next size_allocate. If we don't do this, we'll
be
+ * in an inconsistent state when we call top_row_to_dy. */
+
+ gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
+ tree_view->priv->hadjustment->upper = MAX
(tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
+ tree_view->priv->vadjustment->upper = MAX
(tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
+ gtk_adjustment_changed (tree_view->priv->hadjustment);
+ gtk_adjustment_changed (tree_view->priv->vadjustment);
+
+ if (queue_resize)
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ }
+
+ if (path) gtk_tree_path_free (path);
+ g_timer_destroy (timer);
+
+ return retval;
+}
+
+static gboolean
+validate_rows (PsppSheetView *tree_view)
+{
+ gboolean retval;
+
+ retval = do_validate_rows (tree_view, TRUE);
+
+ if (! retval && tree_view->priv->validate_rows_timer)
+ {
+ g_source_remove (tree_view->priv->validate_rows_timer);
+ tree_view->priv->validate_rows_timer = 0;
+ }
+
+ return retval;
+}
+
+static gboolean
+validate_rows_handler (PsppSheetView *tree_view)
+{
+ gboolean retval;
+
+ retval = do_validate_rows (tree_view, TRUE);
+ if (! retval && tree_view->priv->validate_rows_timer)
+ {
+ g_source_remove (tree_view->priv->validate_rows_timer);
+ tree_view->priv->validate_rows_timer = 0;
+ }
+
+ return retval;
+}
+
+static gboolean
+do_presize_handler (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->mark_rows_col_dirty)
+ {
+ if (tree_view->priv->tree)
+ _pspp_rbtree_column_invalid (tree_view->priv->tree);
+ tree_view->priv->mark_rows_col_dirty = FALSE;
+ }
+ validate_visible_area (tree_view);
+ tree_view->priv->presize_handler_timer = 0;
+
+ if (tree_view->priv->fixed_height_mode)
+ {
+ GtkRequisition requisition;
+
+ gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
+
+ tree_view->priv->hadjustment->upper = MAX
(tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
+ tree_view->priv->vadjustment->upper = MAX
(tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
+ gtk_adjustment_changed (tree_view->priv->hadjustment);
+ gtk_adjustment_changed (tree_view->priv->vadjustment);
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ }
+
+ return FALSE;
+}
+
+static gboolean
+presize_handler_callback (gpointer data)
+{
+ do_presize_handler (PSPP_SHEET_VIEW (data));
+
+ return FALSE;
+}
+
+static void
+install_presize_handler (PsppSheetView *tree_view)
+{
+ if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ return;
+
+ if (! tree_view->priv->presize_handler_timer)
+ {
+ tree_view->priv->presize_handler_timer =
+ gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2,
presize_handler_callback, tree_view, NULL);
+ }
+ if (! tree_view->priv->validate_rows_timer)
+ {
+ tree_view->priv->validate_rows_timer =
+ gdk_threads_add_idle_full (PSPP_SHEET_VIEW_PRIORITY_VALIDATE,
(GSourceFunc) validate_rows_handler, tree_view, NULL);
+ }
+}
+
+static gboolean
+scroll_sync_handler (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
+ gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
0);
+ else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
+ pspp_sheet_view_top_row_to_dy (tree_view);
+ else
+ pspp_sheet_view_dy_to_top_row (tree_view);
+
+ tree_view->priv->scroll_sync_timer = 0;
+
+ return FALSE;
+}
+
+static void
+install_scroll_sync_handler (PsppSheetView *tree_view)
+{
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ return;
+
+ if (!tree_view->priv->scroll_sync_timer)
+ {
+ tree_view->priv->scroll_sync_timer =
+ gdk_threads_add_idle_full (PSPP_SHEET_VIEW_PRIORITY_SCROLL_SYNC,
(GSourceFunc) scroll_sync_handler, tree_view, NULL);
+ }
+}
+
+static void
+pspp_sheet_view_set_top_row (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ gint offset)
+{
+ gtk_tree_row_reference_free (tree_view->priv->top_row);
+
+ if (!path)
+ {
+ tree_view->priv->top_row = NULL;
+ tree_view->priv->top_row_dy = 0;
+ }
+ else
+ {
+ tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT
(tree_view), tree_view->priv->model, path);
+ tree_view->priv->top_row_dy = offset;
+ }
+}
+
+/* Always call this iff dy is in the visible range. If the tree is empty, then
+ * it's set to be NULL, and top_row_dy is 0;
+ */
+static void
+pspp_sheet_view_dy_to_top_row (PsppSheetView *tree_view)
+{
+ gint offset;
+ GtkTreePath *path;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ if (tree_view->priv->tree == NULL)
+ {
+ pspp_sheet_view_set_top_row (tree_view, NULL, 0);
+ }
+ else
+ {
+ offset = _pspp_rbtree_find_offset (tree_view->priv->tree,
+ tree_view->priv->dy,
+ &tree, &node);
+
+ if (tree == NULL)
+ {
+ pspp_sheet_view_set_top_row (tree_view, NULL, 0);
+ }
+ else
+ {
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ pspp_sheet_view_set_top_row (tree_view, path, offset);
+ gtk_tree_path_free (path);
+ }
+ }
+}
+
+static void
+pspp_sheet_view_top_row_to_dy (PsppSheetView *tree_view)
+{
+ GtkTreePath *path;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ int new_dy;
+
+ /* Avoid recursive calls */
+ if (tree_view->priv->in_top_row_to_dy)
+ return;
+
+ if (tree_view->priv->top_row)
+ path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
+ else
+ path = NULL;
+
+ if (!path)
+ tree = NULL;
+ else
+ _pspp_sheet_view_find_node (tree_view, path, &tree, &node);
+
+ if (path)
+ gtk_tree_path_free (path);
+
+ if (tree == NULL)
+ {
+ /* keep dy and set new toprow */
+ gtk_tree_row_reference_free (tree_view->priv->top_row);
+ tree_view->priv->top_row = NULL;
+ tree_view->priv->top_row_dy = 0;
+ /* DO NOT install the idle handler */
+ pspp_sheet_view_dy_to_top_row (tree_view);
+ return;
+ }
+
+ if (ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
+ < tree_view->priv->top_row_dy)
+ {
+ /* new top row -- do NOT install the idle handler */
+ pspp_sheet_view_dy_to_top_row (tree_view);
+ return;
+ }
+
+ new_dy = _pspp_rbtree_node_find_offset (tree, node);
+ new_dy += tree_view->priv->top_row_dy;
+
+ if (new_dy + tree_view->priv->vadjustment->page_size >
tree_view->priv->height)
+ new_dy = tree_view->priv->height - tree_view->priv->vadjustment->page_size;
+
+ new_dy = MAX (0, new_dy);
+
+ tree_view->priv->in_top_row_to_dy = TRUE;
+ gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
+ tree_view->priv->in_top_row_to_dy = FALSE;
+}
+
+
+void
+_pspp_sheet_view_install_mark_rows_col_dirty (PsppSheetView *tree_view)
+{
+ tree_view->priv->mark_rows_col_dirty = TRUE;
+
+ install_presize_handler (tree_view);
+}
+
+/*
+ * This function works synchronously (due to the while (validate_rows...)
+ * loop).
+ *
+ * There was a check for column_type != PSPP_SHEET_VIEW_COLUMN_AUTOSIZE
+ * here. You now need to check that yourself.
+ */
+void
+_pspp_sheet_view_column_autosize (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column));
+
+ _pspp_sheet_view_column_cell_set_dirty (column, FALSE);
+
+ do_presize_handler (tree_view);
+ while (validate_rows (tree_view));
+
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+}
+
+/* Drag-and-drop */
+
+static void
+set_source_row (GdkDragContext *context,
+ GtkTreeModel *model,
+ GtkTreePath *source_row)
+{
+ g_object_set_data_full (G_OBJECT (context),
+ I_("gtk-tree-view-source-row"),
+ source_row ? gtk_tree_row_reference_new (model,
source_row) : NULL,
+ (GDestroyNotify) (source_row ?
gtk_tree_row_reference_free : NULL));
+}
+
+static GtkTreePath*
+get_source_row (GdkDragContext *context)
+{
+ GtkTreeRowReference *ref =
+ g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
+
+ if (ref)
+ return gtk_tree_row_reference_get_path (ref);
+ else
+ return NULL;
+}
+
+typedef struct
+{
+ GtkTreeRowReference *dest_row;
+ guint path_down_mode : 1;
+ guint empty_view_drop : 1;
+ guint drop_append_mode : 1;
+}
+DestRow;
+
+static void
+dest_row_free (gpointer data)
+{
+ DestRow *dr = (DestRow *)data;
+
+ gtk_tree_row_reference_free (dr->dest_row);
+ g_slice_free (DestRow, dr);
+}
+
+static void
+set_dest_row (GdkDragContext *context,
+ GtkTreeModel *model,
+ GtkTreePath *dest_row,
+ gboolean path_down_mode,
+ gboolean empty_view_drop,
+ gboolean drop_append_mode)
+{
+ DestRow *dr;
+
+ if (!dest_row)
+ {
+ g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
+ NULL, NULL);
+ return;
+ }
+
+ dr = g_slice_new (DestRow);
+
+ dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
+ dr->path_down_mode = path_down_mode != FALSE;
+ dr->empty_view_drop = empty_view_drop != FALSE;
+ dr->drop_append_mode = drop_append_mode != FALSE;
+
+ g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
+ dr, (GDestroyNotify) dest_row_free);
+}
+
+static GtkTreePath*
+get_dest_row (GdkDragContext *context,
+ gboolean *path_down_mode)
+{
+ DestRow *dr =
+ g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
+
+ if (dr)
+ {
+ GtkTreePath *path = NULL;
+
+ if (path_down_mode)
+ *path_down_mode = dr->path_down_mode;
+
+ if (dr->dest_row)
+ path = gtk_tree_row_reference_get_path (dr->dest_row);
+ else if (dr->empty_view_drop)
+ path = gtk_tree_path_new_from_indices (0, -1);
+ else
+ path = NULL;
+
+ if (path && dr->drop_append_mode)
+ gtk_tree_path_next (path);
+
+ return path;
+ }
+ else
+ return NULL;
+}
+
+/* Get/set whether drag_motion requested the drag data and
+ * drag_data_received should thus not actually insert the data,
+ * since the data doesn't result from a drop.
+ */
+static void
+set_status_pending (GdkDragContext *context,
+ GdkDragAction suggested_action)
+{
+ g_object_set_data (G_OBJECT (context),
+ I_("gtk-tree-view-status-pending"),
+ GINT_TO_POINTER (suggested_action));
+}
+
+static GdkDragAction
+get_status_pending (GdkDragContext *context)
+{
+ return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
+ "gtk-tree-view-status-pending"));
+}
+
+static TreeViewDragInfo*
+get_info (PsppSheetView *tree_view)
+{
+ return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
+}
+
+static void
+destroy_info (TreeViewDragInfo *di)
+{
+ g_slice_free (TreeViewDragInfo, di);
+}
+
+static TreeViewDragInfo*
+ensure_info (PsppSheetView *tree_view)
+{
+ TreeViewDragInfo *di;
+
+ di = get_info (tree_view);
+
+ if (di == NULL)
+ {
+ di = g_slice_new0 (TreeViewDragInfo);
+
+ g_object_set_data_full (G_OBJECT (tree_view),
+ I_("gtk-tree-view-drag-info"),
+ di,
+ (GDestroyNotify) destroy_info);
+ }
+
+ return di;
+}
+
+static void
+remove_info (PsppSheetView *tree_view)
+{
+ g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"),
NULL);
+}
+
+#if 0
+static gint
+drag_scan_timeout (gpointer data)
+{
+ PsppSheetView *tree_view;
+ gint x, y;
+ GdkModifierType state;
+ GtkTreePath *path = NULL;
+ PsppSheetViewColumn *column = NULL;
+ GdkRectangle visible_rect;
+
+ GDK_THREADS_ENTER ();
+
+ tree_view = PSPP_SHEET_VIEW (data);
+
+ gdk_window_get_pointer (tree_view->priv->bin_window,
+ &x, &y, &state);
+
+ pspp_sheet_view_get_visible_rect (tree_view, &visible_rect);
+
+ /* See if we are near the edge. */
+ if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
+ (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
+ (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
+ (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
+ {
+ pspp_sheet_view_get_path_at_pos (tree_view,
+ tree_view->priv->bin_window,
+ x, y,
+ &path,
+ &column,
+ NULL,
+ NULL);
+
+ if (path != NULL)
+ {
+ pspp_sheet_view_scroll_to_cell (tree_view,
+ path,
+ column,
+ TRUE,
+ 0.5, 0.5);
+
+ gtk_tree_path_free (path);
+ }
+ }
+
+ GDK_THREADS_LEAVE ();
+
+ return TRUE;
+}
+#endif /* 0 */
+
+static void
+add_scroll_timeout (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->scroll_timeout == 0)
+ {
+ tree_view->priv->scroll_timeout =
+ gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
+ }
+}
+
+static void
+remove_scroll_timeout (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->scroll_timeout != 0)
+ {
+ g_source_remove (tree_view->priv->scroll_timeout);
+ tree_view->priv->scroll_timeout = 0;
+ }
+}
+
+static gboolean
+check_model_dnd (GtkTreeModel *model,
+ GType required_iface,
+ const gchar *signal)
+{
+ if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
+ {
+ g_warning ("You must override the default '%s' handler "
+ "on PsppSheetView when using models that don't support "
+ "the %s interface and enabling drag-and-drop. The simplest
way to do this "
+ "is to connect to '%s' and call "
+ "g_signal_stop_emission_by_name() in your signal handler to
prevent "
+ "the default handler from running. Look at the source code "
+ "for the default handler in gtktreeview.c to get an idea what
"
+ "your handler should do. (gtktreeview.c is in the GTK source "
+ "code.) If you're using GTK from a language other than C, "
+ "there may be a more natural way to override default
handlers, e.g. via derivation.",
+ signal, g_type_name (required_iface), signal);
+ return FALSE;
+ }
+ else
+ return TRUE;
+}
+
+static void
+remove_open_timeout (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->open_dest_timeout != 0)
+ {
+ g_source_remove (tree_view->priv->open_dest_timeout);
+ tree_view->priv->open_dest_timeout = 0;
+ }
+}
+
+
+static gint
+open_row_timeout (gpointer data)
+{
+ PsppSheetView *tree_view = data;
+ GtkTreePath *dest_path = NULL;
+ PsppSheetViewDropPosition pos;
+ gboolean result = FALSE;
+
+ pspp_sheet_view_get_drag_dest_row (tree_view,
+ &dest_path,
+ &pos);
+
+ if (dest_path &&
+ (pos == PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER ||
+ pos == PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE))
+ {
+ pspp_sheet_view_expand_row (tree_view, dest_path, FALSE);
+ tree_view->priv->open_dest_timeout = 0;
+
+ gtk_tree_path_free (dest_path);
+ }
+ else
+ {
+ if (dest_path)
+ gtk_tree_path_free (dest_path);
+
+ result = TRUE;
+ }
+
+ return result;
+}
+
+static gboolean
+scroll_row_timeout (gpointer data)
+{
+ PsppSheetView *tree_view = data;
+
+ pspp_sheet_view_vertical_autoscroll (tree_view);
+
+ if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
+ pspp_sheet_view_update_rubber_band (tree_view);
+
+ return TRUE;
+}
+
+/* Returns TRUE if event should not be propagated to parent widgets */
+static gboolean
+set_destination_row (PsppSheetView *tree_view,
+ GdkDragContext *context,
+ /* coordinates relative to the widget */
+ gint x,
+ gint y,
+ GdkDragAction *suggested_action,
+ GdkAtom *target)
+{
+ GtkTreePath *path = NULL;
+ PsppSheetViewDropPosition pos;
+ PsppSheetViewDropPosition old_pos;
+ TreeViewDragInfo *di;
+ GtkWidget *widget;
+ GtkTreePath *old_dest_path = NULL;
+ gboolean can_drop = FALSE;
+
+ *suggested_action = 0;
+ *target = GDK_NONE;
+
+ widget = GTK_WIDGET (tree_view);
+
+ di = get_info (tree_view);
+
+ if (di == NULL || y - TREE_VIEW_HEADER_HEIGHT (tree_view) < 0)
+ {
+ /* someone unset us as a drag dest, note that if
+ * we return FALSE drag_leave isn't called
+ */
+
+ pspp_sheet_view_set_drag_dest_row (tree_view,
+ NULL,
+ PSPP_SHEET_VIEW_DROP_BEFORE);
+
+ remove_scroll_timeout (PSPP_SHEET_VIEW (widget));
+ remove_open_timeout (PSPP_SHEET_VIEW (widget));
+
+ return FALSE; /* no longer a drop site */
+ }
+
+ *target = gtk_drag_dest_find_target (widget, context,
+ gtk_drag_dest_get_target_list (widget));
+ if (*target == GDK_NONE)
+ {
+ return FALSE;
+ }
+
+ if (!pspp_sheet_view_get_dest_row_at_pos (tree_view,
+ x, y,
+ &path,
+ &pos))
+ {
+ gint n_children;
+ GtkTreeModel *model;
+
+ remove_open_timeout (tree_view);
+
+ /* the row got dropped on empty space, let's setup a special case
+ */
+
+ if (path)
+ gtk_tree_path_free (path);
+
+ model = pspp_sheet_view_get_model (tree_view);
+
+ n_children = gtk_tree_model_iter_n_children (model, NULL);
+ if (n_children)
+ {
+ pos = PSPP_SHEET_VIEW_DROP_AFTER;
+ path = gtk_tree_path_new_from_indices (n_children - 1, -1);
+ }
+ else
+ {
+ pos = PSPP_SHEET_VIEW_DROP_BEFORE;
+ path = gtk_tree_path_new_from_indices (0, -1);
+ }
+
+ can_drop = TRUE;
+
+ goto out;
+ }
+
+ g_assert (path);
+
+ /* If we left the current row's "open" zone, unset the timeout for
+ * opening the row
+ */
+ pspp_sheet_view_get_drag_dest_row (tree_view,
+ &old_dest_path,
+ &old_pos);
+
+ if (old_dest_path &&
+ (gtk_tree_path_compare (path, old_dest_path) != 0 ||
+ !(pos == PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER ||
+ pos == PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE)))
+ remove_open_timeout (tree_view);
+
+ if (old_dest_path)
+ gtk_tree_path_free (old_dest_path);
+
+ if (TRUE /* FIXME if the location droppable predicate */)
+ {
+ can_drop = TRUE;
+ }
+
+out:
+ if (can_drop)
+ {
+ GtkWidget *source_widget;
+
+ *suggested_action = context->suggested_action;
+ source_widget = gtk_drag_get_source_widget (context);
+
+ if (source_widget == widget)
+ {
+ /* Default to MOVE, unless the user has
+ * pressed ctrl or shift to affect available actions
+ */
+ if ((context->actions & GDK_ACTION_MOVE) != 0)
+ *suggested_action = GDK_ACTION_MOVE;
+ }
+
+ pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
+ path, pos);
+ }
+ else
+ {
+ /* can't drop here */
+ remove_open_timeout (tree_view);
+
+ pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
+ NULL,
+ PSPP_SHEET_VIEW_DROP_BEFORE);
+ }
+
+ if (path)
+ gtk_tree_path_free (path);
+
+ return TRUE;
+}
+
+static GtkTreePath*
+get_logical_dest_row (PsppSheetView *tree_view,
+ gboolean *path_down_mode,
+ gboolean *drop_append_mode)
+{
+ /* adjust path to point to the row the drop goes in front of */
+ GtkTreePath *path = NULL;
+ PsppSheetViewDropPosition pos;
+
+ g_return_val_if_fail (path_down_mode != NULL, NULL);
+ g_return_val_if_fail (drop_append_mode != NULL, NULL);
+
+ *path_down_mode = FALSE;
+ *drop_append_mode = 0;
+
+ pspp_sheet_view_get_drag_dest_row (tree_view, &path, &pos);
+
+ if (path == NULL)
+ return NULL;
+
+ if (pos == PSPP_SHEET_VIEW_DROP_BEFORE)
+ ; /* do nothing */
+ else if (pos == PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE ||
+ pos == PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER)
+ *path_down_mode = TRUE;
+ else
+ {
+ GtkTreeIter iter;
+ GtkTreeModel *model = pspp_sheet_view_get_model (tree_view);
+
+ g_assert (pos == PSPP_SHEET_VIEW_DROP_AFTER);
+
+ if (!gtk_tree_model_get_iter (model, &iter, path) ||
+ !gtk_tree_model_iter_next (model, &iter))
+ *drop_append_mode = 1;
+ else
+ {
+ *drop_append_mode = 0;
+ gtk_tree_path_next (path);
+ }
+ }
+
+ return path;
+}
+
+static gboolean
+pspp_sheet_view_maybe_begin_dragging_row (PsppSheetView *tree_view,
+ GdkEventMotion *event)
+{
+ GtkWidget *widget = GTK_WIDGET (tree_view);
+ GdkDragContext *context;
+ TreeViewDragInfo *di;
+ GtkTreePath *path = NULL;
+ gint button;
+ gint cell_x, cell_y;
+ GtkTreeModel *model;
+ gboolean retval = FALSE;
+
+ di = get_info (tree_view);
+
+ if (di == NULL || !di->source_set)
+ goto out;
+
+ if (tree_view->priv->pressed_button < 0)
+ goto out;
+
+ if (!gtk_drag_check_threshold (widget,
+ tree_view->priv->press_start_x,
+ tree_view->priv->press_start_y,
+ event->x, event->y))
+ goto out;
+
+ model = pspp_sheet_view_get_model (tree_view);
+
+ if (model == NULL)
+ goto out;
+
+ button = tree_view->priv->pressed_button;
+ tree_view->priv->pressed_button = -1;
+
+ pspp_sheet_view_get_path_at_pos (tree_view,
+ tree_view->priv->press_start_x,
+ tree_view->priv->press_start_y,
+ &path,
+ NULL,
+ &cell_x,
+ &cell_y);
+
+ if (path == NULL)
+ goto out;
+
+ if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
+ !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
+ path))
+ goto out;
+
+ if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
+ goto out;
+
+ /* Now we can begin the drag */
+
+ retval = TRUE;
+
+ context = gtk_drag_begin (widget,
+ gtk_drag_source_get_target_list (widget),
+ di->source_actions,
+ button,
+ (GdkEvent*)event);
+
+ set_source_row (context, model, path);
+
+ out:
+ if (path)
+ gtk_tree_path_free (path);
+
+ return retval;
+}
+
+
+static void
+pspp_sheet_view_drag_begin (GtkWidget *widget,
+ GdkDragContext *context)
+{
+ PsppSheetView *tree_view;
+ GtkTreePath *path = NULL;
+ gint cell_x, cell_y;
+ GdkPixmap *row_pix;
+ TreeViewDragInfo *di;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ /* if the user uses a custom DND source impl, we don't set the icon here */
+ di = get_info (tree_view);
+
+ if (di == NULL || !di->source_set)
+ return;
+
+ pspp_sheet_view_get_path_at_pos (tree_view,
+ tree_view->priv->press_start_x,
+ tree_view->priv->press_start_y,
+ &path,
+ NULL,
+ &cell_x,
+ &cell_y);
+
+ g_return_if_fail (path != NULL);
+
+ row_pix = pspp_sheet_view_create_row_drag_icon (tree_view,
+ path);
+
+ gtk_drag_set_icon_pixmap (context,
+ gdk_drawable_get_colormap (row_pix),
+ row_pix,
+ NULL,
+ /* the + 1 is for the black border in the icon */
+ tree_view->priv->press_start_x + 1,
+ cell_y + 1);
+
+ g_object_unref (row_pix);
+ gtk_tree_path_free (path);
+}
+
+static void
+pspp_sheet_view_drag_end (GtkWidget *widget,
+ GdkDragContext *context)
+{
+ /* do nothing */
+}
+
+/* Default signal implementations for the drag signals */
+static void
+pspp_sheet_view_drag_data_get (GtkWidget *widget,
+ GdkDragContext *context,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint time)
+{
+ PsppSheetView *tree_view;
+ GtkTreeModel *model;
+ TreeViewDragInfo *di;
+ GtkTreePath *source_row;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ model = pspp_sheet_view_get_model (tree_view);
+
+ if (model == NULL)
+ return;
+
+ di = get_info (PSPP_SHEET_VIEW (widget));
+
+ if (di == NULL)
+ return;
+
+ source_row = get_source_row (context);
+
+ if (source_row == NULL)
+ return;
+
+ /* We can implement the GTK_TREE_MODEL_ROW target generically for
+ * any model; for DragSource models there are some other targets
+ * we also support.
+ */
+
+ if (GTK_IS_TREE_DRAG_SOURCE (model) &&
+ gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
+ source_row,
+ selection_data))
+ goto done;
+
+ /* If drag_data_get does nothing, try providing row data. */
+ if (selection_data->target == gdk_atom_intern_static_string
("GTK_TREE_MODEL_ROW"))
+ {
+ gtk_tree_set_row_drag_data (selection_data,
+ model,
+ source_row);
+ }
+
+ done:
+ gtk_tree_path_free (source_row);
+}
+
+
+static void
+pspp_sheet_view_drag_data_delete (GtkWidget *widget,
+ GdkDragContext *context)
+{
+ TreeViewDragInfo *di;
+ GtkTreeModel *model;
+ PsppSheetView *tree_view;
+ GtkTreePath *source_row;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+ model = pspp_sheet_view_get_model (tree_view);
+
+ if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
+ return;
+
+ di = get_info (tree_view);
+
+ if (di == NULL)
+ return;
+
+ source_row = get_source_row (context);
+
+ if (source_row == NULL)
+ return;
+
+ gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
+ source_row);
+
+ gtk_tree_path_free (source_row);
+
+ set_source_row (context, NULL, NULL);
+}
+
+static void
+pspp_sheet_view_drag_leave (GtkWidget *widget,
+ GdkDragContext *context,
+ guint time)
+{
+ /* unset any highlight row */
+ pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
+ NULL,
+ PSPP_SHEET_VIEW_DROP_BEFORE);
+
+ remove_scroll_timeout (PSPP_SHEET_VIEW (widget));
+ remove_open_timeout (PSPP_SHEET_VIEW (widget));
+}
+
+
+static gboolean
+pspp_sheet_view_drag_motion (GtkWidget *widget,
+ GdkDragContext *context,
+ /* coordinates relative to the widget */
+ gint x,
+ gint y,
+ guint time)
+{
+ gboolean empty;
+ GtkTreePath *path = NULL;
+ PsppSheetViewDropPosition pos;
+ PsppSheetView *tree_view;
+ GdkDragAction suggested_action = 0;
+ GdkAtom target;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ if (!set_destination_row (tree_view, context, x, y, &suggested_action,
&target))
+ return FALSE;
+
+ pspp_sheet_view_get_drag_dest_row (tree_view, &path, &pos);
+
+ /* we only know this *after* set_desination_row */
+ empty = tree_view->priv->empty_view_drop;
+
+ if (path == NULL && !empty)
+ {
+ /* Can't drop here. */
+ gdk_drag_status (context, 0, time);
+ }
+ else
+ {
+ if (tree_view->priv->open_dest_timeout == 0 &&
+ (pos == PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER ||
+ pos == PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE))
+ {
+ tree_view->priv->open_dest_timeout =
+ gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout,
tree_view);
+ }
+ else
+ {
+ add_scroll_timeout (tree_view);
+ }
+
+ if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
+ {
+ /* Request data so we can use the source row when
+ * determining whether to accept the drop
+ */
+ set_status_pending (context, suggested_action);
+ gtk_drag_get_data (widget, context, target, time);
+ }
+ else
+ {
+ set_status_pending (context, 0);
+ gdk_drag_status (context, suggested_action, time);
+ }
+ }
+
+ if (path)
+ gtk_tree_path_free (path);
+
+ return TRUE;
+}
+
+
+static gboolean
+pspp_sheet_view_drag_drop (GtkWidget *widget,
+ GdkDragContext *context,
+ /* coordinates relative to the widget */
+ gint x,
+ gint y,
+ guint time)
+{
+ PsppSheetView *tree_view;
+ GtkTreePath *path;
+ GdkDragAction suggested_action = 0;
+ GdkAtom target = GDK_NONE;
+ TreeViewDragInfo *di;
+ GtkTreeModel *model;
+ gboolean path_down_mode;
+ gboolean drop_append_mode;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ model = pspp_sheet_view_get_model (tree_view);
+
+ remove_scroll_timeout (PSPP_SHEET_VIEW (widget));
+ remove_open_timeout (PSPP_SHEET_VIEW (widget));
+
+ di = get_info (tree_view);
+
+ if (di == NULL)
+ return FALSE;
+
+ if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
+ return FALSE;
+
+ if (!set_destination_row (tree_view, context, x, y, &suggested_action,
&target))
+ return FALSE;
+
+ path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
+
+ if (target != GDK_NONE && path != NULL)
+ {
+ /* in case a motion had requested drag data, change things so we
+ * treat drag data receives as a drop.
+ */
+ set_status_pending (context, 0);
+ set_dest_row (context, model, path,
+ path_down_mode, tree_view->priv->empty_view_drop,
+ drop_append_mode);
+ }
+
+ if (path)
+ gtk_tree_path_free (path);
+
+ /* Unset this thing */
+ pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
+ NULL,
+ PSPP_SHEET_VIEW_DROP_BEFORE);
+
+ if (target != GDK_NONE)
+ {
+ gtk_drag_get_data (widget, context, target, time);
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+static void
+pspp_sheet_view_drag_data_received (GtkWidget *widget,
+ GdkDragContext *context,
+ /* coordinates relative to the widget */
+ gint x,
+ gint y,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint time)
+{
+ GtkTreePath *path;
+ TreeViewDragInfo *di;
+ gboolean accepted = FALSE;
+ GtkTreeModel *model;
+ PsppSheetView *tree_view;
+ GtkTreePath *dest_row;
+ GdkDragAction suggested_action;
+ gboolean path_down_mode;
+ gboolean drop_append_mode;
+
+ tree_view = PSPP_SHEET_VIEW (widget);
+
+ model = pspp_sheet_view_get_model (tree_view);
+
+ if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
+ return;
+
+ di = get_info (tree_view);
+
+ if (di == NULL)
+ return;
+
+ suggested_action = get_status_pending (context);
+
+ if (suggested_action)
+ {
+ /* We are getting this data due to a request in drag_motion,
+ * rather than due to a request in drag_drop, so we are just
+ * supposed to call drag_status, not actually paste in the
+ * data.
+ */
+ path = get_logical_dest_row (tree_view, &path_down_mode,
+ &drop_append_mode);
+
+ if (path == NULL)
+ suggested_action = 0;
+ else if (path_down_mode)
+ gtk_tree_path_down (path);
+
+ if (suggested_action)
+ {
+ if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
+ path,
+ selection_data))
+ {
+ if (path_down_mode)
+ {
+ path_down_mode = FALSE;
+ gtk_tree_path_up (path);
+
+ if (!gtk_tree_drag_dest_row_drop_possible
(GTK_TREE_DRAG_DEST (model),
+ path,
+ selection_data))
+ suggested_action = 0;
+ }
+ else
+ suggested_action = 0;
+ }
+ }
+
+ gdk_drag_status (context, suggested_action, time);
+
+ if (path)
+ gtk_tree_path_free (path);
+
+ /* If you can't drop, remove user drop indicator until the next motion */
+ if (suggested_action == 0)
+ pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
+ NULL,
+ PSPP_SHEET_VIEW_DROP_BEFORE);
+
+ return;
+ }
+
+ dest_row = get_dest_row (context, &path_down_mode);
+
+ if (dest_row == NULL)
+ return;
+
+ if (selection_data->length >= 0)
+ {
+ if (path_down_mode)
+ {
+ gtk_tree_path_down (dest_row);
+ if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST
(model),
+ dest_row, selection_data))
+ gtk_tree_path_up (dest_row);
+ }
+ }
+
+ if (selection_data->length >= 0)
+ {
+ if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
+ dest_row,
+ selection_data))
+ accepted = TRUE;
+ }
+
+ gtk_drag_finish (context,
+ accepted,
+ (context->action == GDK_ACTION_MOVE),
+ time);
+
+ if (gtk_tree_path_get_depth (dest_row) == 1
+ && gtk_tree_path_get_indices (dest_row)[0] == 0)
+ {
+ /* special special case drag to "0", scroll to first item */
+ if (!tree_view->priv->scroll_to_path)
+ pspp_sheet_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0,
0.0);
+ }
+
+ gtk_tree_path_free (dest_row);
+
+ /* drop dest_row */
+ set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
+}
+
+
+
+/* GtkContainer Methods
+ */
+
+
+static void
+pspp_sheet_view_remove (GtkContainer *container,
+ GtkWidget *widget)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (container);
+ PsppSheetViewChild *child = NULL;
+ GList *tmp_list;
+
+ tmp_list = tree_view->priv->children;
+ while (tmp_list)
+ {
+ child = tmp_list->data;
+ if (child->widget == widget)
+ {
+ gtk_widget_unparent (widget);
+
+ tree_view->priv->children = g_list_remove_link
(tree_view->priv->children, tmp_list);
+ g_list_free_1 (tmp_list);
+ g_slice_free (PsppSheetViewChild, child);
+ return;
+ }
+
+ tmp_list = tmp_list->next;
+ }
+
+ tmp_list = tree_view->priv->columns;
+
+ while (tmp_list)
+ {
+ PsppSheetViewColumn *column;
+ column = tmp_list->data;
+ if (column->button == widget)
+ {
+ gtk_widget_unparent (widget);
+ return;
+ }
+ tmp_list = tmp_list->next;
+ }
+}
+
+static void
+pspp_sheet_view_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (container);
+ PsppSheetViewChild *child = NULL;
+ PsppSheetViewColumn *column;
+ GList *tmp_list;
+
+ tmp_list = tree_view->priv->children;
+ while (tmp_list)
+ {
+ child = tmp_list->data;
+ tmp_list = tmp_list->next;
+
+ (* callback) (child->widget, callback_data);
+ }
+ if (include_internals == FALSE)
+ return;
+
+ for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list =
tmp_list->next)
+ {
+ column = tmp_list->data;
+
+ if (column->button)
+ (* callback) (column->button, callback_data);
+ }
+}
+
+/* Returns TRUE if the treeview contains no "special" (editable or activatable)
+ * cells. If so we draw one big row-spanning focus rectangle.
+ */
+static gboolean
+pspp_sheet_view_has_special_cell (PsppSheetView *tree_view)
+{
+ GList *list;
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ if (!((PsppSheetViewColumn *)list->data)->visible)
+ continue;
+ if (_pspp_sheet_view_column_count_special_cells (list->data))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+column_sizing_notify (GObject *object,
+ GParamSpec *pspec,
+ gpointer data)
+{
+ PsppSheetViewColumn *c = PSPP_SHEET_VIEW_COLUMN (object);
+
+ if (pspp_sheet_view_column_get_sizing (c) != PSPP_SHEET_VIEW_COLUMN_FIXED)
+ /* disable fixed height mode */
+ g_object_set (data, "fixed-height-mode", FALSE, NULL);
+}
+
+/**
+ * pspp_sheet_view_set_fixed_height_mode:
+ * @tree_view: a #PsppSheetView
+ * @enable: %TRUE to enable fixed height mode
+ *
+ * Enables or disables the fixed height mode of @tree_view.
+ * Fixed height mode speeds up #PsppSheetView by assuming that all
+ * rows have the same height.
+ * Only enable this option if all rows are the same height and all
+ * columns are of type %PSPP_SHEET_VIEW_COLUMN_FIXED.
+ *
+ * Since: 2.6
+ **/
+void
+pspp_sheet_view_set_fixed_height_mode (PsppSheetView *tree_view,
+ gboolean enable)
+{
+ GList *l;
+
+ enable = enable != FALSE;
+
+ if (enable == tree_view->priv->fixed_height_mode)
+ return;
+
+ if (!enable)
+ {
+ tree_view->priv->fixed_height_mode = 0;
+ tree_view->priv->fixed_height = -1;
+
+ /* force a revalidation */
+ install_presize_handler (tree_view);
+ }
+ else
+ {
+ /* make sure all columns are of type FIXED */
+ for (l = tree_view->priv->columns; l; l = l->next)
+ {
+ PsppSheetViewColumn *c = l->data;
+
+ g_return_if_fail (pspp_sheet_view_column_get_sizing (c) ==
PSPP_SHEET_VIEW_COLUMN_FIXED);
+ }
+
+ /* yes, we really have to do this is in a separate loop */
+ for (l = tree_view->priv->columns; l; l = l->next)
+ g_signal_connect (l->data, "notify::sizing",
+ G_CALLBACK (column_sizing_notify), tree_view);
+
+ tree_view->priv->fixed_height_mode = 1;
+ tree_view->priv->fixed_height = -1;
+
+ if (tree_view->priv->tree)
+ initialize_fixed_height_mode (tree_view);
+ }
+
+ g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
+}
+
+/**
+ * pspp_sheet_view_get_fixed_height_mode:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns whether fixed height mode is turned on for @tree_view.
+ *
+ * Return value: %TRUE if @tree_view is in fixed height mode
+ *
+ * Since: 2.6
+ **/
+gboolean
+pspp_sheet_view_get_fixed_height_mode (PsppSheetView *tree_view)
+{
+ return tree_view->priv->fixed_height_mode;
+}
+
+/* Returns TRUE if the focus is within the headers, after the focus operation
is
+ * done
+ */
+static gboolean
+pspp_sheet_view_header_focus (PsppSheetView *tree_view,
+ GtkDirectionType dir,
+ gboolean clamp_column_visible)
+{
+ GtkWidget *focus_child;
+
+ GList *last_column, *first_column;
+ GList *tmp_list;
+ gboolean rtl;
+
+ if (! PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE))
+ return FALSE;
+
+ focus_child = GTK_CONTAINER (tree_view)->focus_child;
+
+ first_column = tree_view->priv->columns;
+ while (first_column)
+ {
+ if (gtk_widget_get_can_focus (PSPP_SHEET_VIEW_COLUMN
(first_column->data)->button) &&
+ PSPP_SHEET_VIEW_COLUMN (first_column->data)->visible &&
+ (PSPP_SHEET_VIEW_COLUMN (first_column->data)->clickable ||
+ PSPP_SHEET_VIEW_COLUMN (first_column->data)->reorderable))
+ break;
+ first_column = first_column->next;
+ }
+
+ /* No headers are visible, or are focusable. We can't focus in or out.
+ */
+ if (first_column == NULL)
+ return FALSE;
+
+ last_column = g_list_last (tree_view->priv->columns);
+ while (last_column)
+ {
+ if (gtk_widget_get_can_focus (PSPP_SHEET_VIEW_COLUMN
(last_column->data)->button) &&
+ PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible &&
+ (PSPP_SHEET_VIEW_COLUMN (last_column->data)->clickable ||
+ PSPP_SHEET_VIEW_COLUMN (last_column->data)->reorderable))
+ break;
+ last_column = last_column->prev;
+ }
+
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+
+ switch (dir)
+ {
+ case GTK_DIR_TAB_BACKWARD:
+ case GTK_DIR_TAB_FORWARD:
+ case GTK_DIR_UP:
+ case GTK_DIR_DOWN:
+ if (focus_child == NULL)
+ {
+ if (tree_view->priv->focus_column != NULL &&
+ gtk_widget_get_can_focus (tree_view->priv->focus_column->button))
+ focus_child = tree_view->priv->focus_column->button;
+ else
+ focus_child = PSPP_SHEET_VIEW_COLUMN (first_column->data)->button;
+ gtk_widget_grab_focus (focus_child);
+ break;
+ }
+ return FALSE;
+
+ case GTK_DIR_LEFT:
+ case GTK_DIR_RIGHT:
+ if (focus_child == NULL)
+ {
+ if (tree_view->priv->focus_column != NULL)
+ focus_child = tree_view->priv->focus_column->button;
+ else if (dir == GTK_DIR_LEFT)
+ focus_child = PSPP_SHEET_VIEW_COLUMN (last_column->data)->button;
+ else
+ focus_child = PSPP_SHEET_VIEW_COLUMN (first_column->data)->button;
+ gtk_widget_grab_focus (focus_child);
+ break;
+ }
+
+ if (gtk_widget_child_focus (focus_child, dir))
+ {
+ /* The focus moves inside the button. */
+ /* This is probably a great example of bad UI */
+ break;
+ }
+
+ /* We need to move the focus among the row of buttons. */
+ for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list =
tmp_list->next)
+ if (PSPP_SHEET_VIEW_COLUMN (tmp_list->data)->button == focus_child)
+ break;
+
+ if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT :
GTK_DIR_LEFT))
+ || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT :
GTK_DIR_RIGHT)))
+ {
+ gtk_widget_error_bell (GTK_WIDGET (tree_view));
+ break;
+ }
+
+ while (tmp_list)
+ {
+ PsppSheetViewColumn *column;
+
+ if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
+ tmp_list = tmp_list->next;
+ else
+ tmp_list = tmp_list->prev;
+
+ if (tmp_list == NULL)
+ {
+ g_warning ("Internal button not found");
+ break;
+ }
+ column = tmp_list->data;
+ if (column->button &&
+ column->visible &&
+ gtk_widget_get_can_focus (column->button))
+ {
+ focus_child = column->button;
+ gtk_widget_grab_focus (column->button);
+ break;
+ }
+ }
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ /* if focus child is non-null, we assume it's been set to the current focus
child
+ */
+ if (focus_child)
+ {
+ for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list =
tmp_list->next)
+ if (PSPP_SHEET_VIEW_COLUMN (tmp_list->data)->button == focus_child)
+ {
+ tree_view->priv->focus_column = PSPP_SHEET_VIEW_COLUMN
(tmp_list->data);
+ break;
+ }
+
+ if (clamp_column_visible)
+ {
+ pspp_sheet_view_clamp_column_visible (tree_view,
+ tree_view->priv->focus_column,
+ FALSE);
+ }
+ }
+
+ return (focus_child != NULL);
+}
+
+/* This function returns in 'path' the first focusable path, if the given path
+ * is already focusable, it's the returned one.
+ */
+static gboolean
+search_first_focusable_path (PsppSheetView *tree_view,
+ GtkTreePath **path,
+ gboolean search_forward,
+ GtkRBTree **new_tree,
+ GtkRBNode **new_node)
+{
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+
+ if (!path || !*path)
+ return FALSE;
+
+ _pspp_sheet_view_find_node (tree_view, *path, &tree, &node);
+
+ if (!tree || !node)
+ return FALSE;
+
+ while (node && row_is_separator (tree_view, NULL, *path))
+ {
+ if (search_forward)
+ _pspp_rbtree_next_full (tree, node, &tree, &node);
+ else
+ _pspp_rbtree_prev_full (tree, node, &tree, &node);
+
+ if (*path)
+ gtk_tree_path_free (*path);
+
+ if (node)
+ *path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ else
+ *path = NULL;
+ }
+
+ if (new_tree)
+ *new_tree = tree;
+
+ if (new_node)
+ *new_node = node;
+
+ return (*path != NULL);
+}
+
+static gint
+pspp_sheet_view_focus (GtkWidget *widget,
+ GtkDirectionType direction)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GtkContainer *container = GTK_CONTAINER (widget);
+ GtkWidget *focus_child;
+
+ if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
+ return FALSE;
+
+ focus_child = container->focus_child;
+
+ pspp_sheet_view_stop_editing (PSPP_SHEET_VIEW (widget), FALSE);
+ /* Case 1. Headers currently have focus. */
+ if (focus_child)
+ {
+ switch (direction)
+ {
+ case GTK_DIR_LEFT:
+ case GTK_DIR_RIGHT:
+ pspp_sheet_view_header_focus (tree_view, direction, TRUE);
+ return TRUE;
+ case GTK_DIR_TAB_BACKWARD:
+ case GTK_DIR_UP:
+ return FALSE;
+ case GTK_DIR_TAB_FORWARD:
+ case GTK_DIR_DOWN:
+ gtk_widget_grab_focus (widget);
+ return TRUE;
+ default:
+ g_assert_not_reached ();
+ return FALSE;
+ }
+ }
+
+ /* Case 2. We don't have focus at all. */
+ if (!gtk_widget_has_focus (widget))
+ {
+ if (!pspp_sheet_view_header_focus (tree_view, direction, FALSE))
+ gtk_widget_grab_focus (widget);
+ return TRUE;
+ }
+
+ /* Case 3. We have focus already. */
+ if (direction == GTK_DIR_TAB_BACKWARD)
+ return (pspp_sheet_view_header_focus (tree_view, direction, FALSE));
+ else if (direction == GTK_DIR_TAB_FORWARD)
+ return FALSE;
+
+ /* Other directions caught by the keybindings */
+ gtk_widget_grab_focus (widget);
+ return TRUE;
+}
+
+static void
+pspp_sheet_view_grab_focus (GtkWidget *widget)
+{
+ GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->grab_focus (widget);
+
+ pspp_sheet_view_focus_to_cursor (PSPP_SHEET_VIEW (widget));
+}
+
+static void
+pspp_sheet_view_style_set (GtkWidget *widget,
+ GtkStyle *previous_style)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+ GList *list;
+ PsppSheetViewColumn *column;
+
+ if (gtk_widget_get_realized (widget))
+ {
+ gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
+ gdk_window_set_background (tree_view->priv->bin_window,
&widget->style->base[widget->state]);
+ gtk_style_set_background (widget->style, tree_view->priv->header_window,
GTK_STATE_NORMAL);
+
+ pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
+ pspp_sheet_view_set_enable_tree_lines (tree_view,
tree_view->priv->tree_lines_enabled);
+ }
+
+ gtk_widget_style_get (widget,
+ "expander-size", &tree_view->priv->expander_size,
+ NULL);
+ tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ column = list->data;
+ _pspp_sheet_view_column_cell_set_dirty (column, TRUE);
+ }
+
+ tree_view->priv->fixed_height = -1;
+ _pspp_rbtree_mark_invalid (tree_view->priv->tree);
+
+ gtk_widget_queue_resize (widget);
+}
+
+
+static void
+pspp_sheet_view_set_focus_child (GtkContainer *container,
+ GtkWidget *child)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (container);
+ GList *list;
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ if (PSPP_SHEET_VIEW_COLUMN (list->data)->button == child)
+ {
+ tree_view->priv->focus_column = PSPP_SHEET_VIEW_COLUMN (list->data);
+ break;
+ }
+ }
+
+ GTK_CONTAINER_CLASS (pspp_sheet_view_parent_class)->set_focus_child
(container, child);
+}
+
+static void
+pspp_sheet_view_set_adjustments (PsppSheetView *tree_view,
+ GtkAdjustment *hadj,
+ GtkAdjustment *vadj)
+{
+ gboolean need_adjust = FALSE;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (hadj)
+ g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
+ else
+ hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+ if (vadj)
+ g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
+ else
+ vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+
+ if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
+ {
+ g_signal_handlers_disconnect_by_func (tree_view->priv->hadjustment,
+ pspp_sheet_view_adjustment_changed,
+ tree_view);
+ g_object_unref (tree_view->priv->hadjustment);
+ }
+
+ if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
+ {
+ g_signal_handlers_disconnect_by_func (tree_view->priv->vadjustment,
+ pspp_sheet_view_adjustment_changed,
+ tree_view);
+ g_object_unref (tree_view->priv->vadjustment);
+ }
+
+ if (tree_view->priv->hadjustment != hadj)
+ {
+ tree_view->priv->hadjustment = hadj;
+ g_object_ref_sink (tree_view->priv->hadjustment);
+
+ g_signal_connect (tree_view->priv->hadjustment, "value-changed",
+ G_CALLBACK (pspp_sheet_view_adjustment_changed),
+ tree_view);
+ need_adjust = TRUE;
+ }
+
+ if (tree_view->priv->vadjustment != vadj)
+ {
+ tree_view->priv->vadjustment = vadj;
+ g_object_ref_sink (tree_view->priv->vadjustment);
+
+ g_signal_connect (tree_view->priv->vadjustment, "value-changed",
+ G_CALLBACK (pspp_sheet_view_adjustment_changed),
+ tree_view);
+ need_adjust = TRUE;
+ }
+
+ if (need_adjust)
+ pspp_sheet_view_adjustment_changed (NULL, tree_view);
+}
+
+
+static gboolean
+pspp_sheet_view_real_move_cursor (PsppSheetView *tree_view,
+ GtkMovementStep step,
+ gint count)
+{
+ GdkModifierType state;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+ g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
+ step == GTK_MOVEMENT_VISUAL_POSITIONS ||
+ step == GTK_MOVEMENT_DISPLAY_LINES ||
+ step == GTK_MOVEMENT_PAGES ||
+ step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
+
+ if (tree_view->priv->tree == NULL)
+ return FALSE;
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return FALSE;
+
+ pspp_sheet_view_stop_editing (tree_view, FALSE);
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+
+ if (gtk_get_current_event_state (&state))
+ {
+ if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
+ tree_view->priv->ctrl_pressed = TRUE;
+ if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
+ tree_view->priv->shift_pressed = TRUE;
+ }
+ /* else we assume not pressed */
+
+ switch (step)
+ {
+ /* currently we make no distinction. When we go bi-di, we need to */
+ case GTK_MOVEMENT_LOGICAL_POSITIONS:
+ case GTK_MOVEMENT_VISUAL_POSITIONS:
+ pspp_sheet_view_move_cursor_left_right (tree_view, count);
+ break;
+ case GTK_MOVEMENT_DISPLAY_LINES:
+ pspp_sheet_view_move_cursor_up_down (tree_view, count);
+ break;
+ case GTK_MOVEMENT_PAGES:
+ pspp_sheet_view_move_cursor_page_up_down (tree_view, count);
+ break;
+ case GTK_MOVEMENT_BUFFER_ENDS:
+ pspp_sheet_view_move_cursor_start_end (tree_view, count);
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+
+ tree_view->priv->ctrl_pressed = FALSE;
+ tree_view->priv->shift_pressed = FALSE;
+
+ return TRUE;
+}
+
+static void
+pspp_sheet_view_put (PsppSheetView *tree_view,
+ GtkWidget *child_widget,
+ /* in bin_window coordinates */
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ PsppSheetViewChild *child;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (GTK_IS_WIDGET (child_widget));
+
+ child = g_slice_new (PsppSheetViewChild);
+
+ child->widget = child_widget;
+ child->x = x;
+ child->y = y;
+ child->width = width;
+ child->height = height;
+
+ tree_view->priv->children = g_list_append (tree_view->priv->children, child);
+
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
+
+ gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
+}
+
+void
+_pspp_sheet_view_child_move_resize (PsppSheetView *tree_view,
+ GtkWidget *widget,
+ /* in tree coordinates */
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ PsppSheetViewChild *child = NULL;
+ GList *list;
+ GdkRectangle allocation;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ for (list = tree_view->priv->children; list; list = list->next)
+ {
+ if (((PsppSheetViewChild *)list->data)->widget == widget)
+ {
+ child = list->data;
+ break;
+ }
+ }
+ if (child == NULL)
+ return;
+
+ allocation.x = child->x = x;
+ allocation.y = child->y = y;
+ allocation.width = child->width = width;
+ allocation.height = child->height = height;
+
+ if (gtk_widget_get_realized (widget))
+ gtk_widget_size_allocate (widget, &allocation);
+}
+
+
+/* TreeModel Callbacks
+ */
+
+static void
+pspp_sheet_view_row_changed (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
+{
+ PsppSheetView *tree_view = (PsppSheetView *)data;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gboolean free_path = FALSE;
+ GList *list;
+ GtkTreePath *cursor_path;
+
+ g_return_if_fail (path != NULL || iter != NULL);
+
+ if (tree_view->priv->cursor != NULL)
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ else
+ cursor_path = NULL;
+
+ if (tree_view->priv->edited_column &&
+ (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
+ pspp_sheet_view_stop_editing (tree_view, TRUE);
+
+ if (cursor_path != NULL)
+ gtk_tree_path_free (cursor_path);
+
+ if (path == NULL)
+ {
+ path = gtk_tree_model_get_path (model, iter);
+ free_path = TRUE;
+ }
+ else if (iter == NULL)
+ gtk_tree_model_get_iter (model, iter, path);
+
+ if (_pspp_sheet_view_find_node (tree_view,
+ path,
+ &tree,
+ &node))
+ /* We aren't actually showing the node */
+ goto done;
+
+ if (tree == NULL)
+ goto done;
+
+ if (tree_view->priv->fixed_height_mode
+ && tree_view->priv->fixed_height >= 0)
+ {
+ _pspp_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ pspp_sheet_view_node_queue_redraw (tree_view, tree, node);
+ }
+ else
+ {
+ _pspp_rbtree_node_mark_invalid (tree, node);
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ PsppSheetViewColumn *column;
+
+ column = list->data;
+ if (! column->visible)
+ continue;
+
+ if (column->column_type == PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ {
+ _pspp_sheet_view_column_cell_set_dirty (column, TRUE);
+ }
+ }
+ }
+
+ done:
+ if (!tree_view->priv->fixed_height_mode &&
+ gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ install_presize_handler (tree_view);
+ if (free_path)
+ gtk_tree_path_free (path);
+}
+
+static void
+pspp_sheet_view_row_inserted (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
+{
+ PsppSheetView *tree_view = (PsppSheetView *) data;
+ gint *indices;
+ GtkRBTree *tmptree, *tree;
+ GtkRBNode *tmpnode = NULL;
+ gint depth;
+ gint i = 0;
+ gint height;
+ gboolean free_path = FALSE;
+ gboolean node_visible = TRUE;
+
+ g_return_if_fail (path != NULL || iter != NULL);
+
+ if (tree_view->priv->fixed_height_mode
+ && tree_view->priv->fixed_height >= 0)
+ height = tree_view->priv->fixed_height;
+ else
+ height = 0;
+
+ if (path == NULL)
+ {
+ path = gtk_tree_model_get_path (model, iter);
+ free_path = TRUE;
+ }
+ else if (iter == NULL)
+ gtk_tree_model_get_iter (model, iter, path);
+
+ if (tree_view->priv->tree == NULL)
+ tree_view->priv->tree = _pspp_rbtree_new ();
+
+ tmptree = tree = tree_view->priv->tree;
+
+ /* Update all row-references */
+ gtk_tree_row_reference_inserted (G_OBJECT (data), path);
+ depth = gtk_tree_path_get_depth (path);
+ indices = gtk_tree_path_get_indices (path);
+
+ /* First, find the parent tree */
+ while (i < depth - 1)
+ {
+ if (tmptree == NULL)
+ {
+ /* We aren't showing the node */
+ node_visible = FALSE;
+ goto done;
+ }
+
+ tmpnode = _pspp_rbtree_find_count (tmptree, indices[i] + 1);
+ if (tmpnode == NULL)
+ {
+ g_warning ("A node was inserted with a parent that's not in the
tree.\n" \
+ "This possibly means that a GtkTreeModel inserted a child
node\n" \
+ "before the parent was inserted.");
+ goto done;
+ }
+ else if (!PSPP_RBNODE_FLAG_SET (tmpnode, PSPP_RBNODE_IS_PARENT))
+ {
+ /* FIXME enforce correct behavior on model, probably */
+ /* In theory, the model should have emitted has_child_toggled here.
We
+ * try to catch it anyway, just to be safe, in case the model hasn't.
+ */
+ GtkTreePath *tmppath = _pspp_sheet_view_find_path (tree_view,
+ tree,
+ tmpnode);
+ pspp_sheet_view_row_has_child_toggled (model, tmppath, NULL, data);
+ gtk_tree_path_free (tmppath);
+ goto done;
+ }
+
+ tmptree = tmpnode->children;
+ tree = tmptree;
+ i++;
+ }
+
+ if (tree == NULL)
+ {
+ node_visible = FALSE;
+ goto done;
+ }
+
+ /* ref the node */
+ gtk_tree_model_ref_node (tree_view->priv->model, iter);
+ if (indices[depth - 1] == 0)
+ {
+ tmpnode = _pspp_rbtree_find_count (tree, 1);
+ tmpnode = _pspp_rbtree_insert_before (tree, tmpnode, height, FALSE);
+ }
+ else
+ {
+ tmpnode = _pspp_rbtree_find_count (tree, indices[depth - 1]);
+ tmpnode = _pspp_rbtree_insert_after (tree, tmpnode, height, FALSE);
+ }
+
+ done:
+ if (height > 0)
+ {
+ if (tree)
+ _pspp_rbtree_node_mark_valid (tree, tmpnode);
+
+ if (node_visible && node_is_visible (tree_view, tree, tmpnode))
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ else
+ gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
+ }
+ else
+ install_presize_handler (tree_view);
+ if (free_path)
+ gtk_tree_path_free (path);
+}
+
+static void
+pspp_sheet_view_row_has_child_toggled (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
+{
+ PsppSheetView *tree_view = (PsppSheetView *)data;
+ GtkTreeIter real_iter;
+ gboolean has_child;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gboolean free_path = FALSE;
+
+ g_return_if_fail (path != NULL || iter != NULL);
+
+ if (iter)
+ real_iter = *iter;
+
+ if (path == NULL)
+ {
+ path = gtk_tree_model_get_path (model, iter);
+ free_path = TRUE;
+ }
+ else if (iter == NULL)
+ gtk_tree_model_get_iter (model, &real_iter, path);
+
+ if (_pspp_sheet_view_find_node (tree_view,
+ path,
+ &tree,
+ &node))
+ /* We aren't actually showing the node */
+ goto done;
+
+ if (tree == NULL)
+ goto done;
+
+ has_child = gtk_tree_model_iter_has_child (model, &real_iter);
+ /* Sanity check.
+ */
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_PARENT) == has_child)
+ goto done;
+
+ if (has_child)
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_IS_PARENT);
+ else
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_IS_PARENT);
+
+ if (has_child && PSPP_SHEET_VIEW_FLAG_SET (tree_view,
PSPP_SHEET_VIEW_IS_LIST))
+ {
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IS_LIST);
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_SHOW_EXPANDERS))
+ {
+ GList *list;
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ if (PSPP_SHEET_VIEW_COLUMN (list->data)->visible)
+ {
+ PSPP_SHEET_VIEW_COLUMN (list->data)->dirty = TRUE;
+ _pspp_sheet_view_column_cell_set_dirty (PSPP_SHEET_VIEW_COLUMN
(list->data), TRUE);
+ break;
+ }
+ }
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ }
+ else
+ {
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, NULL);
+ }
+
+ done:
+ if (free_path)
+ gtk_tree_path_free (path);
+}
+
+static void
+count_children_helper (GtkRBTree *tree,
+ GtkRBNode *node,
+ gpointer data)
+{
+ if (node->children)
+ _pspp_rbtree_traverse (node->children, node->children->root, G_POST_ORDER,
count_children_helper, data);
+ (*((gint *)data))++;
+}
+
+static void
+check_selection_helper (GtkRBTree *tree,
+ GtkRBNode *node,
+ gpointer data)
+{
+ gint *value = (gint *)data;
+
+ *value = PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED);
+
+ if (node->children && !*value)
+ _pspp_rbtree_traverse (node->children, node->children->root, G_POST_ORDER,
check_selection_helper, data);
+}
+
+static void
+pspp_sheet_view_row_deleted (GtkTreeModel *model,
+ GtkTreePath *path,
+ gpointer data)
+{
+ PsppSheetView *tree_view = (PsppSheetView *)data;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ GList *list;
+ gint selection_changed = FALSE;
+
+ g_return_if_fail (path != NULL);
+
+ gtk_tree_row_reference_deleted (G_OBJECT (data), path);
+
+ if (_pspp_sheet_view_find_node (tree_view, path, &tree, &node))
+ return;
+
+ if (tree == NULL)
+ return;
+
+ /* check if the selection has been changed */
+ _pspp_rbtree_traverse (tree, node, G_POST_ORDER,
+ check_selection_helper, &selection_changed);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ if (((PsppSheetViewColumn *)list->data)->visible &&
+ ((PsppSheetViewColumn *)list->data)->column_type ==
PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ _pspp_sheet_view_column_cell_set_dirty ((PsppSheetViewColumn
*)list->data, TRUE);
+
+ /* Ensure we don't have a dangling pointer to a dead node */
+ ensure_unprelighted (tree_view);
+
+ /* Cancel editting if we've started */
+ pspp_sheet_view_stop_editing (tree_view, TRUE);
+
+ /* If we have a node expanded/collapsed timeout, remove it */
+ remove_expand_collapse_timeout (tree_view);
+
+ if (tree_view->priv->destroy_count_func)
+ {
+ gint child_count = 0;
+ if (node->children)
+ _pspp_rbtree_traverse (node->children, node->children->root,
G_POST_ORDER, count_children_helper, &child_count);
+ tree_view->priv->destroy_count_func (tree_view, path, child_count,
tree_view->priv->destroy_count_data);
+ }
+
+ if (tree->root->count == 1)
+ {
+ if (tree_view->priv->tree == tree)
+ tree_view->priv->tree = NULL;
+
+ _pspp_rbtree_remove (tree);
+ }
+ else
+ {
+ _pspp_rbtree_remove_node (tree, node);
+ }
+
+ if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
+ {
+ gtk_tree_row_reference_free (tree_view->priv->top_row);
+ tree_view->priv->top_row = NULL;
+ }
+
+ install_scroll_sync_handler (tree_view);
+
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+
+ if (selection_changed)
+ g_signal_emit_by_name (tree_view->priv->selection, "changed");
+}
+
+static void
+pspp_sheet_view_rows_reordered (GtkTreeModel *model,
+ GtkTreePath *parent,
+ GtkTreeIter *iter,
+ gint *new_order,
+ gpointer data)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (data);
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gint len;
+
+ len = gtk_tree_model_iter_n_children (model, iter);
+
+ if (len < 2)
+ return;
+
+ gtk_tree_row_reference_reordered (G_OBJECT (data),
+ parent,
+ iter,
+ new_order);
+
+ if (_pspp_sheet_view_find_node (tree_view,
+ parent,
+ &tree,
+ &node))
+ return;
+
+ /* We need to special case the parent path */
+ if (tree == NULL)
+ tree = tree_view->priv->tree;
+ else
+ tree = node->children;
+
+ if (tree == NULL)
+ return;
+
+ if (tree_view->priv->edited_column)
+ pspp_sheet_view_stop_editing (tree_view, TRUE);
+
+ /* we need to be unprelighted */
+ ensure_unprelighted (tree_view);
+
+ /* clear the timeout */
+ cancel_arrow_animation (tree_view);
+
+ _pspp_rbtree_reorder (tree, new_order, len);
+
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+
+ pspp_sheet_view_dy_to_top_row (tree_view);
+}
+
+
+/* Internal tree functions
+ */
+
+
+static void
+pspp_sheet_view_get_background_xrange (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ PsppSheetViewColumn *column,
+ gint *x1,
+ gint *x2)
+{
+ PsppSheetViewColumn *tmp_column = NULL;
+ gint total_width;
+ GList *list;
+ gboolean rtl;
+
+ if (x1)
+ *x1 = 0;
+
+ if (x2)
+ *x2 = 0;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+
+ total_width = 0;
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list;
+ list = (rtl ? list->prev : list->next))
+ {
+ tmp_column = list->data;
+
+ if (tmp_column == column)
+ break;
+
+ if (tmp_column->visible)
+ total_width += tmp_column->width;
+ }
+
+ if (tmp_column != column)
+ {
+ g_warning (G_STRLOC": passed-in column isn't in the tree");
+ return;
+ }
+
+ if (x1)
+ *x1 = total_width;
+
+ if (x2)
+ {
+ if (column->visible)
+ *x2 = total_width + column->width;
+ else
+ *x2 = total_width; /* width of 0 */
+ }
+}
+static void
+pspp_sheet_view_get_arrow_xrange (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ gint *x1,
+ gint *x2)
+{
+ gint x_offset = 0;
+ GList *list;
+ PsppSheetViewColumn *tmp_column = NULL;
+ gint total_width;
+ gboolean indent_expanders;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+
+ total_width = 0;
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list;
+ list = (rtl ? list->prev : list->next))
+ {
+ tmp_column = list->data;
+
+ if (pspp_sheet_view_is_expander_column (tree_view, tmp_column))
+ {
+ if (rtl)
+ x_offset = total_width + tmp_column->width -
tree_view->priv->expander_size;
+ else
+ x_offset = total_width;
+ break;
+ }
+
+ if (tmp_column->visible)
+ total_width += tmp_column->width;
+ }
+
+ gtk_widget_style_get (GTK_WIDGET (tree_view),
+ "indent-expanders", &indent_expanders,
+ NULL);
+
+ if (indent_expanders)
+ {
+ if (rtl)
+ x_offset -= tree_view->priv->expander_size * _pspp_rbtree_get_depth
(tree);
+ else
+ x_offset += tree_view->priv->expander_size * _pspp_rbtree_get_depth
(tree);
+ }
+
+ *x1 = x_offset;
+
+ if (tmp_column && tmp_column->visible)
+ /* +1 because x2 isn't included in the range. */
+ *x2 = *x1 + tree_view->priv->expander_size + 1;
+ else
+ *x2 = *x1;
+}
+
+static void
+pspp_sheet_view_build_tree (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkTreeIter *iter,
+ gint depth,
+ gboolean recurse)
+{
+ GtkRBNode *temp = NULL;
+ GtkTreePath *path = NULL;
+ gboolean is_list = PSPP_SHEET_VIEW_FLAG_SET (tree_view,
PSPP_SHEET_VIEW_IS_LIST);
+
+ do
+ {
+ gtk_tree_model_ref_node (tree_view->priv->model, iter);
+ temp = _pspp_rbtree_insert_after (tree, temp, 0, FALSE);
+
+ if (tree_view->priv->fixed_height > 0)
+ {
+ if (PSPP_RBNODE_FLAG_SET (temp, PSPP_RBNODE_INVALID))
+ {
+ _pspp_rbtree_node_set_height (tree, temp,
tree_view->priv->fixed_height);
+ _pspp_rbtree_node_mark_valid (tree, temp);
+ }
+ }
+
+ if (is_list)
+ continue;
+
+ if (recurse)
+ {
+ GtkTreeIter child;
+
+ if (!path)
+ path = gtk_tree_model_get_path (tree_view->priv->model, iter);
+ else
+ gtk_tree_path_next (path);
+
+ if (gtk_tree_model_iter_children (tree_view->priv->model, &child,
iter))
+ {
+ gboolean expand;
+
+ g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0,
iter, path, &expand);
+
+ if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
+ && !expand)
+ {
+ temp->children = _pspp_rbtree_new ();
+ temp->children->parent_tree = tree;
+ temp->children->parent_node = temp;
+ pspp_sheet_view_build_tree (tree_view, temp->children,
&child, depth + 1, recurse);
+ }
+ }
+ }
+
+ if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
+ {
+ if ((temp->flags&PSPP_RBNODE_IS_PARENT) != PSPP_RBNODE_IS_PARENT)
+ temp->flags ^= PSPP_RBNODE_IS_PARENT;
+ }
+ }
+ while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
+
+ if (path)
+ gtk_tree_path_free (path);
+}
+
+/* Make sure the node is visible vertically */
+static void
+pspp_sheet_view_clamp_node_visible (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ gint node_dy, height;
+ GtkTreePath *path = NULL;
+
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ return;
+
+ /* just return if the node is visible, avoiding a costly expose */
+ node_dy = _pspp_rbtree_node_find_offset (tree, node);
+ height = ROW_HEIGHT (tree_view, PSPP_RBNODE_GET_HEIGHT (node));
+ if (! PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_INVALID)
+ && node_dy >= tree_view->priv->vadjustment->value
+ && node_dy + height <= (tree_view->priv->vadjustment->value
+ + tree_view->priv->vadjustment->page_size))
+ return;
+
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ if (path)
+ {
+ /* We process updates because we want to clear old selected items when
we scroll.
+ * if this is removed, we get a "selection streak" at the bottom. */
+ gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
+ pspp_sheet_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
+ gtk_tree_path_free (path);
+ }
+}
+
+static void
+pspp_sheet_view_clamp_column_visible (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column,
+ gboolean focus_to_cell)
+{
+ gint x, width;
+
+ if (column == NULL)
+ return;
+
+ x = column->button->allocation.x;
+ width = column->button->allocation.width;
+
+ if (width > tree_view->priv->hadjustment->page_size)
+ {
+ /* The column is larger than the horizontal page size. If the
+ * column has cells which can be focussed individually, then we make
+ * sure the cell which gets focus is fully visible (if even the
+ * focus cell is bigger than the page size, we make sure the
+ * left-hand side of the cell is visible).
+ *
+ * If the column does not have those so-called special cells, we
+ * make sure the left-hand side of the column is visible.
+ */
+
+ if (focus_to_cell && pspp_sheet_view_has_special_cell (tree_view))
+ {
+ GtkTreePath *cursor_path;
+ GdkRectangle background_area, cell_area, focus_area;
+
+ cursor_path = gtk_tree_row_reference_get_path
(tree_view->priv->cursor);
+
+ pspp_sheet_view_get_cell_area (tree_view,
+ cursor_path, column, &cell_area);
+ pspp_sheet_view_get_background_area (tree_view,
+ cursor_path, column,
+ &background_area);
+
+ gtk_tree_path_free (cursor_path);
+
+ _pspp_sheet_view_column_get_focus_area (column,
+ &background_area,
+ &cell_area,
+ &focus_area);
+
+ x = focus_area.x;
+ width = focus_area.width;
+
+ if (width < tree_view->priv->hadjustment->page_size)
+ {
+ if ((tree_view->priv->hadjustment->value +
tree_view->priv->hadjustment->page_size) < (x + width))
+ gtk_adjustment_set_value (tree_view->priv->hadjustment,
+ x + width -
tree_view->priv->hadjustment->page_size);
+ else if (tree_view->priv->hadjustment->value > x)
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
+ }
+ }
+
+ gtk_adjustment_set_value (tree_view->priv->hadjustment,
+ CLAMP (x,
+ tree_view->priv->hadjustment->lower,
+ tree_view->priv->hadjustment->upper
+ -
tree_view->priv->hadjustment->page_size));
+ }
+ else
+ {
+ if ((tree_view->priv->hadjustment->value +
tree_view->priv->hadjustment->page_size) < (x + width))
+ gtk_adjustment_set_value (tree_view->priv->hadjustment,
+ x + width -
tree_view->priv->hadjustment->page_size);
+ else if (tree_view->priv->hadjustment->value > x)
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
+ }
+}
+
+/* This function could be more efficient. I'll optimize it if profiling seems
+ * to imply that it is important */
+GtkTreePath *
+_pspp_sheet_view_find_path (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ GtkTreePath *path;
+ GtkRBTree *tmp_tree;
+ GtkRBNode *tmp_node, *last;
+ gint count;
+
+ path = gtk_tree_path_new ();
+
+ g_return_val_if_fail (node != NULL, path);
+ g_return_val_if_fail (node != tree->nil, path);
+
+ count = 1 + node->left->count;
+
+ last = node;
+ tmp_node = node->parent;
+ tmp_tree = tree;
+ while (tmp_tree)
+ {
+ while (tmp_node != tmp_tree->nil)
+ {
+ if (tmp_node->right == last)
+ count += 1 + tmp_node->left->count;
+ last = tmp_node;
+ tmp_node = tmp_node->parent;
+ }
+ gtk_tree_path_prepend_index (path, count - 1);
+ last = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ if (last)
+ {
+ count = 1 + last->left->count;
+ tmp_node = last->parent;
+ }
+ }
+ return path;
+}
+
+/* Returns TRUE if we ran out of tree before finding the path. If the path is
+ * invalid (ie. points to a node that's not in the tree), *tree and *node are
+ * both set to NULL.
+ */
+gboolean
+_pspp_sheet_view_find_node (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ GtkRBTree **tree,
+ GtkRBNode **node)
+{
+ GtkRBNode *tmpnode = NULL;
+ GtkRBTree *tmptree = tree_view->priv->tree;
+ gint *indices = gtk_tree_path_get_indices (path);
+ gint depth = gtk_tree_path_get_depth (path);
+ gint i = 0;
+
+ *node = NULL;
+ *tree = NULL;
+
+ if (depth == 0 || tmptree == NULL)
+ return FALSE;
+ do
+ {
+ tmpnode = _pspp_rbtree_find_count (tmptree, indices[i] + 1);
+ ++i;
+ if (tmpnode == NULL)
+ {
+ *tree = NULL;
+ *node = NULL;
+ return FALSE;
+ }
+ if (i >= depth)
+ {
+ *tree = tmptree;
+ *node = tmpnode;
+ return FALSE;
+ }
+ *tree = tmptree;
+ *node = tmpnode;
+ tmptree = tmpnode->children;
+ if (tmptree == NULL)
+ return TRUE;
+ }
+ while (1);
+}
+
+static gboolean
+pspp_sheet_view_is_expander_column (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column)
+{
+ GList *list;
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IS_LIST))
+ return FALSE;
+
+ if (tree_view->priv->expander_column != NULL)
+ {
+ if (tree_view->priv->expander_column == column)
+ return TRUE;
+ return FALSE;
+ }
+ else
+ {
+ for (list = tree_view->priv->columns;
+ list;
+ list = list->next)
+ if (((PsppSheetViewColumn *)list->data)->visible)
+ break;
+ if (list && list->data == column)
+ return TRUE;
+ }
+ return FALSE;
+}
+
+static void
+pspp_sheet_view_add_move_binding (GtkBindingSet *binding_set,
+ guint keyval,
+ guint modmask,
+ gboolean add_shifted_binding,
+ GtkMovementStep step,
+ gint count)
+{
+
+ gtk_binding_entry_add_signal (binding_set, keyval, modmask,
+ "move-cursor", 2,
+ G_TYPE_ENUM, step,
+ G_TYPE_INT, count);
+
+ if (add_shifted_binding)
+ gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
+ "move-cursor", 2,
+ G_TYPE_ENUM, step,
+ G_TYPE_INT, count);
+
+ if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
+ return;
+
+ gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK |
GDK_SHIFT_MASK,
+ "move-cursor", 2,
+ G_TYPE_ENUM, step,
+ G_TYPE_INT, count);
+
+ gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
+ "move-cursor", 2,
+ G_TYPE_ENUM, step,
+ G_TYPE_INT, count);
+}
+
+static gint
+pspp_sheet_view_unref_tree_helper (GtkTreeModel *model,
+ GtkTreeIter *iter,
+ GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ gint retval = FALSE;
+ do
+ {
+ g_return_val_if_fail (node != NULL, FALSE);
+
+ if (node->children)
+ {
+ GtkTreeIter child;
+ GtkRBTree *new_tree;
+ GtkRBNode *new_node;
+
+ new_tree = node->children;
+ new_node = new_tree->root;
+
+ while (new_node && new_node->left != new_tree->nil)
+ new_node = new_node->left;
+
+ if (!gtk_tree_model_iter_children (model, &child, iter))
+ return FALSE;
+
+ retval = retval || pspp_sheet_view_unref_tree_helper (model, &child,
new_tree, new_node);
+ }
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ retval = TRUE;
+ gtk_tree_model_unref_node (model, iter);
+ node = _pspp_rbtree_next (tree, node);
+ }
+ while (gtk_tree_model_iter_next (model, iter));
+
+ return retval;
+}
+
+static gint
+pspp_sheet_view_unref_and_check_selection_tree (PsppSheetView *tree_view,
+ GtkRBTree *tree)
+{
+ GtkTreeIter iter;
+ GtkTreePath *path;
+ GtkRBNode *node;
+ gint retval;
+
+ if (!tree)
+ return FALSE;
+
+ node = tree->root;
+ while (node && node->left != tree->nil)
+ node = node->left;
+
+ g_return_val_if_fail (node != NULL, FALSE);
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
+ &iter, path);
+ retval = pspp_sheet_view_unref_tree_helper (GTK_TREE_MODEL
(tree_view->priv->model), &iter, tree, node);
+ gtk_tree_path_free (path);
+
+ return retval;
+}
+
+static void
+pspp_sheet_view_set_column_drag_info (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column)
+{
+ PsppSheetViewColumn *left_column;
+ PsppSheetViewColumn *cur_column = NULL;
+ PsppSheetViewColumnReorder *reorder;
+ gboolean rtl;
+ GList *tmp_list;
+ gint left;
+
+ /* We want to precalculate the motion list such that we know what column
slots
+ * are available.
+ */
+ left_column = NULL;
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+
+ /* First, identify all possible drop spots */
+ if (rtl)
+ tmp_list = g_list_last (tree_view->priv->columns);
+ else
+ tmp_list = g_list_first (tree_view->priv->columns);
+
+ while (tmp_list)
+ {
+ cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
+ tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
+
+ if (cur_column->visible == FALSE)
+ continue;
+
+ /* If it's not the column moving and func tells us to skip over the
column, we continue. */
+ if (left_column != column && cur_column != column &&
+ tree_view->priv->column_drop_func &&
+ ! tree_view->priv->column_drop_func (tree_view, column, left_column,
cur_column, tree_view->priv->column_drop_func_data))
+ {
+ left_column = cur_column;
+ continue;
+ }
+ reorder = g_slice_new0 (PsppSheetViewColumnReorder);
+ reorder->left_column = left_column;
+ left_column = reorder->right_column = cur_column;
+
+ tree_view->priv->column_drag_info = g_list_append
(tree_view->priv->column_drag_info, reorder);
+ }
+
+ /* Add the last one */
+ if (tree_view->priv->column_drop_func == NULL ||
+ ((left_column != column) &&
+ tree_view->priv->column_drop_func (tree_view, column, left_column,
NULL, tree_view->priv->column_drop_func_data)))
+ {
+ reorder = g_slice_new0 (PsppSheetViewColumnReorder);
+ reorder->left_column = left_column;
+ reorder->right_column = NULL;
+ tree_view->priv->column_drag_info = g_list_append
(tree_view->priv->column_drag_info, reorder);
+ }
+
+ /* We quickly check to see if it even makes sense to reorder columns. */
+ /* If there is nothing that can be moved, then we return */
+
+ if (tree_view->priv->column_drag_info == NULL)
+ return;
+
+ /* We know there are always 2 slots possbile, as you can always return
column. */
+ /* If that's all there is, return */
+ if (tree_view->priv->column_drag_info->next == NULL ||
+ (tree_view->priv->column_drag_info->next->next == NULL &&
+ ((PsppSheetViewColumnReorder
*)tree_view->priv->column_drag_info->data)->right_column == column &&
+ ((PsppSheetViewColumnReorder
*)tree_view->priv->column_drag_info->next->data)->left_column == column))
+ {
+ for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list =
tmp_list->next)
+ g_slice_free (PsppSheetViewColumnReorder, tmp_list->data);
+ g_list_free (tree_view->priv->column_drag_info);
+ tree_view->priv->column_drag_info = NULL;
+ return;
+ }
+ /* We fill in the ranges for the columns, now that we've isolated them */
+ left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
+
+ for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list =
tmp_list->next)
+ {
+ reorder = (PsppSheetViewColumnReorder *) tmp_list->data;
+
+ reorder->left_align = left;
+ if (tmp_list->next != NULL)
+ {
+ g_assert (tmp_list->next->data);
+ left = reorder->right_align =
(reorder->right_column->button->allocation.x +
+
reorder->right_column->button->allocation.width +
+ ((PsppSheetViewColumnReorder
*)tmp_list->next->data)->left_column->button->allocation.x)/2;
+ }
+ else
+ {
+ gint width;
+
+ gdk_drawable_get_size (tree_view->priv->header_window, &width, NULL);
+ reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER
(tree_view);
+ }
+ }
+}
+
+void
+_pspp_sheet_view_column_start_drag (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column)
+{
+ GdkEvent *send_event;
+ GtkAllocation allocation;
+ gint x, y, width, height;
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
+ GdkDisplay *display = gdk_screen_get_display (screen);
+
+ g_return_if_fail (tree_view->priv->column_drag_info == NULL);
+ g_return_if_fail (tree_view->priv->cur_reorder == NULL);
+
+ pspp_sheet_view_set_column_drag_info (tree_view, column);
+
+ if (tree_view->priv->column_drag_info == NULL)
+ return;
+
+ if (tree_view->priv->drag_window == NULL)
+ {
+ GdkWindowAttr attributes;
+ guint attributes_mask;
+
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.x = column->button->allocation.x;
+ attributes.y = 0;
+ attributes.width = column->button->allocation.width;
+ attributes.height = column->button->allocation.height;
+ attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
+ attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
+ attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK |
GDK_POINTER_MOTION_MASK;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+ tree_view->priv->drag_window = gdk_window_new
(tree_view->priv->bin_window,
+ &attributes,
+ attributes_mask);
+ gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET
(tree_view));
+ }
+
+ gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
+ gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
+
+ gtk_grab_remove (column->button);
+
+ send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
+ send_event->crossing.send_event = TRUE;
+ send_event->crossing.window = g_object_ref (GTK_BUTTON
(column->button)->event_window);
+ send_event->crossing.subwindow = NULL;
+ send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
+ send_event->crossing.time = GDK_CURRENT_TIME;
+
+ gtk_propagate_event (column->button, send_event);
+ gdk_event_free (send_event);
+
+ send_event = gdk_event_new (GDK_BUTTON_RELEASE);
+ send_event->button.window = g_object_ref (gdk_screen_get_root_window
(screen));
+ send_event->button.send_event = TRUE;
+ send_event->button.time = GDK_CURRENT_TIME;
+ send_event->button.x = -1;
+ send_event->button.y = -1;
+ send_event->button.axes = NULL;
+ send_event->button.state = 0;
+ send_event->button.button = 1;
+ send_event->button.device = gdk_display_get_core_pointer (display);
+ send_event->button.x_root = 0;
+ send_event->button.y_root = 0;
+
+ gtk_propagate_event (column->button, send_event);
+ gdk_event_free (send_event);
+
+ /* Kids, don't try this at home */
+ g_object_ref (column->button);
+ gtk_container_remove (GTK_CONTAINER (tree_view), column->button);
+ gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
+ gtk_widget_set_parent (column->button, GTK_WIDGET (tree_view));
+ g_object_unref (column->button);
+
+ tree_view->priv->drag_column_x = column->button->allocation.x;
+ allocation = column->button->allocation;
+ allocation.x = 0;
+ gtk_widget_size_allocate (column->button, &allocation);
+ gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
+
+ tree_view->priv->drag_column = column;
+ gdk_window_show (tree_view->priv->drag_window);
+
+ gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
+ gdk_drawable_get_size (tree_view->priv->header_window, &width, &height);
+
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ while (gtk_events_pending ())
+ gtk_main_iteration ();
+
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG);
+ gdk_pointer_grab (tree_view->priv->drag_window,
+ FALSE,
+ GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
+ NULL, NULL, GDK_CURRENT_TIME);
+ gdk_keyboard_grab (tree_view->priv->drag_window,
+ FALSE,
+ GDK_CURRENT_TIME);
+}
+
+static void
+pspp_sheet_view_queue_draw_arrow (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ const GdkRectangle *clip_rect)
+{
+ GdkRectangle rect;
+
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ return;
+
+ rect.x = 0;
+ rect.width = MAX (tree_view->priv->expander_size, MAX
(tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width));
+
+ rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
+ rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
+
+ if (clip_rect)
+ {
+ GdkRectangle new_rect;
+
+ gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
+
+ gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect,
TRUE);
+ }
+ else
+ {
+ gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
+ }
+}
+
+void
+_pspp_sheet_view_queue_draw_node (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ const GdkRectangle *clip_rect)
+{
+ GdkRectangle rect;
+
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ return;
+
+ rect.x = 0;
+ rect.width = MAX (tree_view->priv->width, GTK_WIDGET
(tree_view)->allocation.width);
+
+ rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
+ rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
+
+ if (clip_rect)
+ {
+ GdkRectangle new_rect;
+
+ gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
+
+ gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect,
TRUE);
+ }
+ else
+ {
+ gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
+ }
+}
+
+static void
+pspp_sheet_view_queue_draw_path (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ const GdkRectangle *clip_rect)
+{
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+
+ _pspp_sheet_view_find_node (tree_view, path, &tree, &node);
+
+ if (tree)
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, clip_rect);
+}
+
+/* x and y are the mouse position
+ */
+static void
+pspp_sheet_view_draw_arrow (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ /* in bin_window coordinates */
+ gint x,
+ gint y)
+{
+ GdkRectangle area;
+ GtkStateType state;
+ GtkWidget *widget;
+ gint x_offset = 0;
+ gint x2;
+ gint vertical_separator;
+ gint expander_size;
+ GtkExpanderStyle expander_style;
+
+ widget = GTK_WIDGET (tree_view);
+
+ gtk_widget_style_get (widget,
+ "vertical-separator", &vertical_separator,
+ NULL);
+ expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
+
+ if (! PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_PARENT))
+ return;
+
+ pspp_sheet_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
+
+ area.x = x_offset;
+ area.y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
+ area.width = expander_size + 2;
+ area.height = MAX (CELL_HEIGHT (node, vertical_separator), (expander_size -
vertical_separator));
+
+ if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE)
+ {
+ state = GTK_STATE_INSENSITIVE;
+ }
+ else if (node == tree_view->priv->button_pressed_node)
+ {
+ if (x >= area.x && x <= (area.x + area.width) &&
+ y >= area.y && y <= (area.y + area.height))
+ state = GTK_STATE_ACTIVE;
+ else
+ state = GTK_STATE_NORMAL;
+ }
+ else
+ {
+ if (node == tree_view->priv->prelight_node &&
+ PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_ARROW_PRELIT))
+ state = GTK_STATE_PRELIGHT;
+ else
+ state = GTK_STATE_NORMAL;
+ }
+
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SEMI_EXPANDED))
+ expander_style = GTK_EXPANDER_SEMI_EXPANDED;
+ else if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SEMI_COLLAPSED))
+ expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
+ else if (node->children != NULL)
+ expander_style = GTK_EXPANDER_EXPANDED;
+ else
+ expander_style = GTK_EXPANDER_COLLAPSED;
+
+ gtk_paint_expander (widget->style,
+ tree_view->priv->bin_window,
+ state,
+ &area,
+ widget,
+ "treeview",
+ area.x + area.width / 2,
+ area.y + area.height / 2,
+ expander_style);
+}
+
+static void
+pspp_sheet_view_focus_to_cursor (PsppSheetView *tree_view)
+
+{
+ GtkTreePath *cursor_path;
+
+ if ((tree_view->priv->tree == NULL) ||
+ (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
+ return;
+
+ cursor_path = NULL;
+ if (tree_view->priv->cursor)
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+
+ if (cursor_path == NULL)
+ {
+ /* Consult the selection before defaulting to the
+ * first focusable element
+ */
+ GList *selected_rows;
+ GtkTreeModel *model;
+ PsppSheetSelection *selection;
+
+ selection = pspp_sheet_view_get_selection (tree_view);
+ selected_rows = pspp_sheet_selection_get_selected_rows (selection,
&model);
+
+ if (selected_rows)
+ {
+ cursor_path = gtk_tree_path_copy((const GtkTreePath
*)(selected_rows->data));
+ g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
+ g_list_free (selected_rows);
+ }
+ else
+ {
+ cursor_path = gtk_tree_path_new_first ();
+ search_first_focusable_path (tree_view, &cursor_path,
+ TRUE, NULL, NULL);
+ }
+
+ gtk_tree_row_reference_free (tree_view->priv->cursor);
+ tree_view->priv->cursor = NULL;
+
+ if (cursor_path)
+ {
+ if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, FALSE,
FALSE);
+ else
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE,
FALSE);
+ }
+ }
+
+ if (cursor_path)
+ {
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
+
+ pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL);
+ gtk_tree_path_free (cursor_path);
+
+ if (tree_view->priv->focus_column == NULL)
+ {
+ GList *list;
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ if (PSPP_SHEET_VIEW_COLUMN (list->data)->visible)
+ {
+ tree_view->priv->focus_column = PSPP_SHEET_VIEW_COLUMN
(list->data);
+ break;
+ }
+ }
+ }
+ }
+}
+
+static void
+pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view,
+ gint count)
+{
+ gint selection_count;
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
+ GtkRBTree *new_cursor_tree = NULL;
+ GtkRBNode *new_cursor_node = NULL;
+ GtkTreePath *cursor_path = NULL;
+ gboolean grab_focus = TRUE;
+ gboolean selectable;
+
+ if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return;
+
+ cursor_path = NULL;
+ if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ /* FIXME: we lost the cursor; should we get the first? */
+ return;
+
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ _pspp_sheet_view_find_node (tree_view, cursor_path,
+ &cursor_tree, &cursor_node);
+
+ if (cursor_tree == NULL)
+ /* FIXME: we lost the cursor; should we get the first? */
+ return;
+
+ selection_count = pspp_sheet_selection_count_selected_rows
(tree_view->priv->selection);
+ selectable = _pspp_sheet_selection_row_is_selectable
(tree_view->priv->selection,
+ cursor_node,
+ cursor_path);
+
+ if (selection_count == 0
+ && tree_view->priv->selection->type != GTK_SELECTION_NONE
+ && !tree_view->priv->ctrl_pressed
+ && selectable)
+ {
+ /* Don't move the cursor, but just select the current node */
+ new_cursor_tree = cursor_tree;
+ new_cursor_node = cursor_node;
+ }
+ else
+ {
+ if (count == -1)
+ _pspp_rbtree_prev_full (cursor_tree, cursor_node,
+ &new_cursor_tree, &new_cursor_node);
+ else
+ _pspp_rbtree_next_full (cursor_tree, cursor_node,
+ &new_cursor_tree, &new_cursor_node);
+ }
+
+ gtk_tree_path_free (cursor_path);
+
+ if (new_cursor_node)
+ {
+ cursor_path = _pspp_sheet_view_find_path (tree_view,
+ new_cursor_tree, new_cursor_node);
+
+ search_first_focusable_path (tree_view, &cursor_path,
+ (count != -1),
+ &new_cursor_tree,
+ &new_cursor_node);
+
+ if (cursor_path)
+ gtk_tree_path_free (cursor_path);
+ }
+
+ /*
+ * If the list has only one item and multi-selection is set then select
+ * the row (if not yet selected).
+ */
+ if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE &&
+ new_cursor_node == NULL)
+ {
+ if (count == -1)
+ _pspp_rbtree_next_full (cursor_tree, cursor_node,
+ &new_cursor_tree, &new_cursor_node);
+ else
+ _pspp_rbtree_prev_full (cursor_tree, cursor_node,
+ &new_cursor_tree, &new_cursor_node);
+
+ if (new_cursor_node == NULL
+ && !PSPP_RBNODE_FLAG_SET (cursor_node, PSPP_RBNODE_IS_SELECTED))
+ {
+ new_cursor_node = cursor_node;
+ new_cursor_tree = cursor_tree;
+ }
+ else
+ {
+ new_cursor_node = NULL;
+ }
+ }
+
+ if (new_cursor_node)
+ {
+ cursor_path = _pspp_sheet_view_find_path (tree_view, new_cursor_tree,
new_cursor_node);
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
+ gtk_tree_path_free (cursor_path);
+ }
+ else
+ {
+ pspp_sheet_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+
+ if (!tree_view->priv->shift_pressed)
+ {
+ if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
+ count < 0 ?
+ GTK_DIR_UP : GTK_DIR_DOWN))
+ {
+ GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET
(tree_view));
+
+ if (toplevel)
+ gtk_widget_child_focus (toplevel,
+ count < 0 ?
+ GTK_DIR_TAB_BACKWARD :
+ GTK_DIR_TAB_FORWARD);
+
+ grab_focus = FALSE;
+ }
+ }
+ else
+ {
+ gtk_widget_error_bell (GTK_WIDGET (tree_view));
+ }
+ }
+
+ if (grab_focus)
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+}
+
+static void
+pspp_sheet_view_move_cursor_page_up_down (PsppSheetView *tree_view,
+ gint count)
+{
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
+ GtkTreePath *old_cursor_path = NULL;
+ GtkTreePath *cursor_path = NULL;
+ GtkRBTree *start_cursor_tree = NULL;
+ GtkRBNode *start_cursor_node = NULL;
+ gint y;
+ gint window_y;
+ gint vertical_separator;
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return;
+
+ if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ old_cursor_path = gtk_tree_row_reference_get_path
(tree_view->priv->cursor);
+ else
+ /* This is sorta weird. Focus in should give us a cursor */
+ return;
+
+ gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator",
&vertical_separator, NULL);
+ _pspp_sheet_view_find_node (tree_view, old_cursor_path,
+ &cursor_tree, &cursor_node);
+
+ if (cursor_tree == NULL)
+ {
+ /* FIXME: we lost the cursor. Should we try to get one? */
+ gtk_tree_path_free (old_cursor_path);
+ return;
+ }
+ g_return_if_fail (cursor_node != NULL);
+
+ y = _pspp_rbtree_node_find_offset (cursor_tree, cursor_node);
+ window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
+ y += tree_view->priv->cursor_offset;
+ y += count * (int)tree_view->priv->vadjustment->page_increment;
+ y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower,
(gint)tree_view->priv->vadjustment->upper - vertical_separator);
+
+ if (y >= tree_view->priv->height)
+ y = tree_view->priv->height - 1;
+
+ tree_view->priv->cursor_offset =
+ _pspp_rbtree_find_offset (tree_view->priv->tree, y,
+ &cursor_tree, &cursor_node);
+
+ if (tree_view->priv->cursor_offset > BACKGROUND_HEIGHT (cursor_node))
+ {
+ _pspp_rbtree_next_full (cursor_tree, cursor_node,
+ &cursor_tree, &cursor_node);
+ tree_view->priv->cursor_offset -= BACKGROUND_HEIGHT (cursor_node);
+ }
+
+ y -= tree_view->priv->cursor_offset;
+ cursor_path = _pspp_sheet_view_find_path (tree_view, cursor_tree,
cursor_node);
+
+ start_cursor_tree = cursor_tree;
+ start_cursor_node = cursor_node;
+
+ if (! search_first_focusable_path (tree_view, &cursor_path,
+ (count != -1),
+ &cursor_tree, &cursor_node))
+ {
+ /* It looks like we reached the end of the view without finding
+ * a focusable row. We will step backwards to find the last
+ * focusable row.
+ */
+ cursor_tree = start_cursor_tree;
+ cursor_node = start_cursor_node;
+ cursor_path = _pspp_sheet_view_find_path (tree_view, cursor_tree,
cursor_node);
+
+ search_first_focusable_path (tree_view, &cursor_path,
+ (count == -1),
+ &cursor_tree, &cursor_node);
+ }
+
+ if (!cursor_path)
+ goto cleanup;
+
+ /* update y */
+ y = _pspp_rbtree_node_find_offset (cursor_tree, cursor_node);
+
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
+
+ y -= window_y;
+ pspp_sheet_view_scroll_to_point (tree_view, -1, y);
+ pspp_sheet_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+ _pspp_sheet_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
+
+ if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
+ gtk_widget_error_bell (GTK_WIDGET (tree_view));
+
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+
+cleanup:
+ gtk_tree_path_free (old_cursor_path);
+ gtk_tree_path_free (cursor_path);
+}
+
+static void
+pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view,
+ gint count)
+{
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
+ GtkTreePath *cursor_path = NULL;
+ PsppSheetViewColumn *column;
+ GtkTreeIter iter;
+ GList *list;
+ gboolean found_column = FALSE;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return;
+
+ if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ else
+ return;
+
+ _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_tree,
&cursor_node);
+ if (cursor_tree == NULL)
+ return;
+ if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) ==
FALSE)
+ {
+ gtk_tree_path_free (cursor_path);
+ return;
+ }
+ gtk_tree_path_free (cursor_path);
+
+ list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns);
+ if (tree_view->priv->focus_column)
+ {
+ for (; list; list = (rtl ? list->prev : list->next))
+ {
+ if (list->data == tree_view->priv->focus_column)
+ break;
+ }
+ }
+
+ while (list)
+ {
+ gboolean left, right;
+
+ column = list->data;
+ if (column->visible == FALSE)
+ goto loop_end;
+
+ pspp_sheet_view_column_cell_set_cell_data (column,
+ tree_view->priv->model,
+ &iter,
+ PSPP_RBNODE_FLAG_SET
(cursor_node, PSPP_RBNODE_IS_PARENT),
+
cursor_node->children?TRUE:FALSE);
+
+ if (rtl)
+ {
+ right = list->prev ? TRUE : FALSE;
+ left = list->next ? TRUE : FALSE;
+ }
+ else
+ {
+ left = list->prev ? TRUE : FALSE;
+ right = list->next ? TRUE : FALSE;
+ }
+
+ if (_pspp_sheet_view_column_cell_focus (column, count, left, right))
+ {
+ tree_view->priv->focus_column = column;
+ found_column = TRUE;
+ break;
+ }
+ loop_end:
+ if (count == 1)
+ list = rtl ? list->prev : list->next;
+ else
+ list = rtl ? list->next : list->prev;
+ }
+
+ if (found_column)
+ {
+ if (!pspp_sheet_view_has_special_cell (tree_view))
+ _pspp_sheet_view_queue_draw_node (tree_view,
+ cursor_tree,
+ cursor_node,
+ NULL);
+ g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ }
+ else
+ {
+ gtk_widget_error_bell (GTK_WIDGET (tree_view));
+ }
+
+ pspp_sheet_view_clamp_column_visible (tree_view,
+ tree_view->priv->focus_column, TRUE);
+}
+
+static void
+pspp_sheet_view_move_cursor_start_end (PsppSheetView *tree_view,
+ gint count)
+{
+ GtkRBTree *cursor_tree;
+ GtkRBNode *cursor_node;
+ GtkTreePath *path;
+ GtkTreePath *old_path;
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return;
+
+ g_return_if_fail (tree_view->priv->tree != NULL);
+
+ pspp_sheet_view_get_cursor (tree_view, &old_path, NULL);
+
+ cursor_tree = tree_view->priv->tree;
+ cursor_node = cursor_tree->root;
+
+ if (count == -1)
+ {
+ while (cursor_node && cursor_node->left != cursor_tree->nil)
+ cursor_node = cursor_node->left;
+
+ /* Now go forward to find the first focusable row. */
+ path = _pspp_sheet_view_find_path (tree_view, cursor_tree, cursor_node);
+ search_first_focusable_path (tree_view, &path,
+ TRUE, &cursor_tree, &cursor_node);
+ }
+ else
+ {
+ do
+ {
+ while (cursor_node && cursor_node->right != cursor_tree->nil)
+ cursor_node = cursor_node->right;
+ if (cursor_node->children == NULL)
+ break;
+
+ cursor_tree = cursor_node->children;
+ cursor_node = cursor_tree->root;
+ }
+ while (1);
+
+ /* Now go backwards to find last focusable row. */
+ path = _pspp_sheet_view_find_path (tree_view, cursor_tree, cursor_node);
+ search_first_focusable_path (tree_view, &path,
+ FALSE, &cursor_tree, &cursor_node);
+ }
+
+ if (!path)
+ goto cleanup;
+
+ if (gtk_tree_path_compare (old_path, path))
+ {
+ pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ }
+ else
+ {
+ gtk_widget_error_bell (GTK_WIDGET (tree_view));
+ }
+
+cleanup:
+ gtk_tree_path_free (old_path);
+ gtk_tree_path_free (path);
+}
+
+static gboolean
+pspp_sheet_view_real_select_all (PsppSheetView *tree_view)
+{
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return FALSE;
+
+ if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
+ return FALSE;
+
+ pspp_sheet_selection_select_all (tree_view->priv->selection);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_real_unselect_all (PsppSheetView *tree_view)
+{
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return FALSE;
+
+ if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
+ return FALSE;
+
+ pspp_sheet_selection_unselect_all (tree_view->priv->selection);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view,
+ gboolean start_editing)
+{
+ GtkRBTree *new_tree = NULL;
+ GtkRBNode *new_node = NULL;
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
+ GtkTreePath *cursor_path = NULL;
+ GtkTreeSelectMode mode = 0;
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return FALSE;
+
+ if (tree_view->priv->cursor)
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+
+ if (cursor_path == NULL)
+ return FALSE;
+
+ _pspp_sheet_view_find_node (tree_view, cursor_path,
+ &cursor_tree, &cursor_node);
+
+ if (cursor_tree == NULL)
+ {
+ gtk_tree_path_free (cursor_path);
+ return FALSE;
+ }
+
+ if (!tree_view->priv->shift_pressed && start_editing &&
+ tree_view->priv->focus_column)
+ {
+ if (pspp_sheet_view_start_editing (tree_view, cursor_path))
+ {
+ gtk_tree_path_free (cursor_path);
+ return TRUE;
+ }
+ }
+
+ if (tree_view->priv->ctrl_pressed)
+ mode |= GTK_TREE_SELECT_MODE_TOGGLE;
+ if (tree_view->priv->shift_pressed)
+ mode |= GTK_TREE_SELECT_MODE_EXTEND;
+
+ _pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
+ cursor_node,
+ cursor_tree,
+ cursor_path,
+ mode,
+ FALSE);
+
+ /* We bail out if the original (tree, node) don't exist anymore after
+ * handling the selection-changed callback. We do return TRUE because
+ * the key press has been handled at this point.
+ */
+ _pspp_sheet_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
+
+ if (cursor_tree != new_tree || cursor_node != new_node)
+ return FALSE;
+
+ pspp_sheet_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ _pspp_sheet_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
+
+ if (!tree_view->priv->shift_pressed)
+ pspp_sheet_view_row_activated (tree_view, cursor_path,
+ tree_view->priv->focus_column);
+
+ gtk_tree_path_free (cursor_path);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_real_toggle_cursor_row (PsppSheetView *tree_view)
+{
+ GtkRBTree *new_tree = NULL;
+ GtkRBNode *new_node = NULL;
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
+ GtkTreePath *cursor_path = NULL;
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return FALSE;
+
+ cursor_path = NULL;
+ if (tree_view->priv->cursor)
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+
+ if (cursor_path == NULL)
+ return FALSE;
+
+ _pspp_sheet_view_find_node (tree_view, cursor_path,
+ &cursor_tree, &cursor_node);
+ if (cursor_tree == NULL)
+ {
+ gtk_tree_path_free (cursor_path);
+ return FALSE;
+ }
+
+ _pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
+ cursor_node,
+ cursor_tree,
+ cursor_path,
+ GTK_TREE_SELECT_MODE_TOGGLE,
+ FALSE);
+
+ /* We bail out if the original (tree, node) don't exist anymore after
+ * handling the selection-changed callback. We do return TRUE because
+ * the key press has been handled at this point.
+ */
+ _pspp_sheet_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
+
+ if (cursor_tree != new_tree || cursor_node != new_node)
+ return FALSE;
+
+ pspp_sheet_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL);
+ gtk_tree_path_free (cursor_path);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_real_expand_collapse_cursor_row (PsppSheetView *tree_view,
+ gboolean logical,
+ gboolean expand,
+ gboolean open_all)
+{
+ GtkTreePath *cursor_path = NULL;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ return FALSE;
+
+ cursor_path = NULL;
+ if (tree_view->priv->cursor)
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+
+ if (cursor_path == NULL)
+ return FALSE;
+
+ if (_pspp_sheet_view_find_node (tree_view, cursor_path, &tree, &node))
+ return FALSE;
+
+ /* Don't handle the event if we aren't an expander */
+ if (!((node->flags & PSPP_RBNODE_IS_PARENT) == PSPP_RBNODE_IS_PARENT))
+ return FALSE;
+
+ if (!logical
+ && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
+ expand = !expand;
+
+ if (expand)
+ pspp_sheet_view_real_expand_row (tree_view, cursor_path, tree, node,
open_all, TRUE);
+ else
+ pspp_sheet_view_real_collapse_row (tree_view, cursor_path, tree, node,
TRUE);
+
+ gtk_tree_path_free (cursor_path);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_real_select_cursor_parent (PsppSheetView *tree_view)
+{
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
+ GtkTreePath *cursor_path = NULL;
+ GdkModifierType state;
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ goto out;
+
+ cursor_path = NULL;
+ if (tree_view->priv->cursor)
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+
+ if (cursor_path == NULL)
+ goto out;
+
+ _pspp_sheet_view_find_node (tree_view, cursor_path,
+ &cursor_tree, &cursor_node);
+ if (cursor_tree == NULL)
+ {
+ gtk_tree_path_free (cursor_path);
+ goto out;
+ }
+
+ if (cursor_tree->parent_node)
+ {
+ pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL);
+ cursor_node = cursor_tree->parent_node;
+ cursor_tree = cursor_tree->parent_tree;
+
+ gtk_tree_path_up (cursor_path);
+
+ if (gtk_get_current_event_state (&state))
+ {
+ if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
+ tree_view->priv->ctrl_pressed = TRUE;
+ }
+
+ pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
+ pspp_sheet_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL);
+ gtk_tree_path_free (cursor_path);
+
+ tree_view->priv->ctrl_pressed = FALSE;
+
+ return TRUE;
+ }
+
+ out:
+
+ tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
+ return FALSE;
+}
+
+static gboolean
+pspp_sheet_view_search_entry_flush_timeout (PsppSheetView *tree_view)
+{
+ pspp_sheet_view_search_dialog_hide (tree_view->priv->search_window,
tree_view);
+ tree_view->priv->typeselect_flush_timeout = 0;
+
+ return FALSE;
+}
+
+/* Cut and paste from gtkwindow.c */
+static void
+send_focus_change (GtkWidget *widget,
+ gboolean in)
+{
+ GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+
+ g_object_ref (widget);
+
+ if (in)
+ GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
+ else
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
+
+ fevent->focus_change.type = GDK_FOCUS_CHANGE;
+ fevent->focus_change.window = g_object_ref (widget->window);
+ fevent->focus_change.in = in;
+
+ gtk_widget_event (widget, fevent);
+
+ g_object_notify (G_OBJECT (widget), "has-focus");
+
+ g_object_unref (widget);
+ gdk_event_free (fevent);
+}
+
+static void
+pspp_sheet_view_ensure_interactive_directory (PsppSheetView *tree_view)
+{
+ GtkWidget *frame, *vbox, *toplevel;
+ GdkScreen *screen;
+
+ if (tree_view->priv->search_custom_entry_set)
+ return;
+
+ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
+ screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
+
+ if (tree_view->priv->search_window != NULL)
+ {
+ if (GTK_WINDOW (toplevel)->group)
+ gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
+ GTK_WINDOW
(tree_view->priv->search_window));
+ else if (GTK_WINDOW (tree_view->priv->search_window)->group)
+ gtk_window_group_remove_window (GTK_WINDOW
(tree_view->priv->search_window)->group,
+ GTK_WINDOW
(tree_view->priv->search_window));
+ gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window),
screen);
+ return;
+ }
+
+ tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
+ gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
+
+ if (GTK_WINDOW (toplevel)->group)
+ gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
+ GTK_WINDOW (tree_view->priv->search_window));
+
+ gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
+ GDK_WINDOW_TYPE_HINT_UTILITY);
+ gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
+ g_signal_connect (tree_view->priv->search_window, "delete-event",
+ G_CALLBACK (pspp_sheet_view_search_delete_event),
+ tree_view);
+ g_signal_connect (tree_view->priv->search_window, "key-press-event",
+ G_CALLBACK (pspp_sheet_view_search_key_press_event),
+ tree_view);
+ g_signal_connect (tree_view->priv->search_window, "button-press-event",
+ G_CALLBACK (pspp_sheet_view_search_button_press_event),
+ tree_view);
+ g_signal_connect (tree_view->priv->search_window, "scroll-event",
+ G_CALLBACK (pspp_sheet_view_search_scroll_event),
+ tree_view);
+
+ frame = gtk_frame_new (NULL);
+ gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
+ gtk_widget_show (frame);
+ gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_widget_show (vbox);
+ gtk_container_add (GTK_CONTAINER (frame), vbox);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
+
+ /* add entry */
+ tree_view->priv->search_entry = gtk_entry_new ();
+ gtk_widget_show (tree_view->priv->search_entry);
+ g_signal_connect (tree_view->priv->search_entry, "populate-popup",
+ G_CALLBACK (pspp_sheet_view_search_disable_popdown),
+ tree_view);
+ g_signal_connect (tree_view->priv->search_entry,
+ "activate", G_CALLBACK (pspp_sheet_view_search_activate),
+ tree_view);
+ g_signal_connect (GTK_ENTRY (tree_view->priv->search_entry)->im_context,
+ "preedit-changed",
+ G_CALLBACK (pspp_sheet_view_search_preedit_changed),
+ tree_view);
+ gtk_container_add (GTK_CONTAINER (vbox),
+ tree_view->priv->search_entry);
+
+ gtk_widget_realize (tree_view->priv->search_entry);
+}
+
+/* Pops up the interactive search entry. If keybinding is TRUE then the user
+ * started this by typing the start_interactive_search keybinding. Otherwise,
it came from
+ */
+static gboolean
+pspp_sheet_view_real_start_interactive_search (PsppSheetView *tree_view,
+ gboolean keybinding)
+{
+ /* We only start interactive search if we have focus or the columns
+ * have focus. If one of our children have focus, we don't want to
+ * start the search.
+ */
+ GList *list;
+ gboolean found_focus = FALSE;
+ GtkWidgetClass *entry_parent_class;
+
+ if (!tree_view->priv->enable_search && !keybinding)
+ return FALSE;
+
+ if (tree_view->priv->search_custom_entry_set)
+ return FALSE;
+
+ if (tree_view->priv->search_window != NULL &&
+ gtk_widget_get_visible (tree_view->priv->search_window))
+ return TRUE;
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ PsppSheetViewColumn *column;
+
+ column = list->data;
+ if (! column->visible)
+ continue;
+
+ if (gtk_widget_has_focus (column->button))
+ {
+ found_focus = TRUE;
+ break;
+ }
+ }
+
+ if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
+ found_focus = TRUE;
+
+ if (!found_focus)
+ return FALSE;
+
+ if (tree_view->priv->search_column < 0)
+ return FALSE;
+
+ pspp_sheet_view_ensure_interactive_directory (tree_view);
+
+ if (keybinding)
+ gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
+
+ /* done, show it */
+ tree_view->priv->search_position_func (tree_view,
tree_view->priv->search_window, tree_view->priv->search_position_user_data);
+ gtk_widget_show (tree_view->priv->search_window);
+ if (tree_view->priv->search_entry_changed_id == 0)
+ {
+ tree_view->priv->search_entry_changed_id =
+ g_signal_connect (tree_view->priv->search_entry, "changed",
+ G_CALLBACK (pspp_sheet_view_search_init),
+ tree_view);
+ }
+
+ tree_view->priv->typeselect_flush_timeout =
+ gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
+ tree_view);
+
+ /* Grab focus will select all the text. We don't want that to happen, so we
+ * call the parent instance and bypass the selection change. This is
probably
+ * really non-kosher. */
+ entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS
(tree_view->priv->search_entry));
+ (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
+
+ /* send focus-in event */
+ send_focus_change (tree_view->priv->search_entry, TRUE);
+
+ /* search first matching iter */
+ pspp_sheet_view_search_init (tree_view->priv->search_entry, tree_view);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_start_interactive_search (PsppSheetView *tree_view)
+{
+ return pspp_sheet_view_real_start_interactive_search (tree_view, TRUE);
+}
+
+/* this function returns the new width of the column being resized given
+ * the column and x position of the cursor; the x cursor position is passed
+ * in as a pointer and automagicly corrected if it's beyond min/max limits
+ */
+static gint
+pspp_sheet_view_new_column_width (PsppSheetView *tree_view,
+ gint i,
+ gint *x)
+{
+ PsppSheetViewColumn *column;
+ gint width;
+ gboolean rtl;
+
+ /* first translate the x position from widget->window
+ * to clist->clist_window
+ */
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+ column = g_list_nth (tree_view->priv->columns, i)->data;
+ width = rtl ? (column->button->allocation.x +
column->button->allocation.width - *x) : (*x - column->button->allocation.x);
+
+ /* Clamp down the value */
+ if (column->min_width == -1)
+ width = MAX (column->button->requisition.width,
+ width);
+ else
+ width = MAX (column->min_width,
+ width);
+ if (column->max_width != -1)
+ width = MIN (width, column->max_width);
+
+ *x = rtl ? (column->button->allocation.x + column->button->allocation.width
- width) : (column->button->allocation.x + width);
+
+ return width;
+}
+
+
+/* FIXME this adjust_allocation is a big cut-and-paste from
+ * GtkCList, needs to be some "official" way to do this
+ * factored out.
+ */
+typedef struct
+{
+ GdkWindow *window;
+ int dx;
+ int dy;
+} ScrollData;
+
+/* The window to which widget->window is relative */
+#define ALLOCATION_WINDOW(widget) \
+ (!gtk_widget_get_has_window (widget) ? \
+ (widget)->window : \
+ gdk_window_get_parent ((widget)->window))
+
+static void
+adjust_allocation_recurse (GtkWidget *widget,
+ gpointer data)
+{
+ ScrollData *scroll_data = data;
+
+ /* Need to really size allocate instead of just poking
+ * into widget->allocation if the widget is not realized.
+ * FIXME someone figure out why this was.
+ */
+ if (!gtk_widget_get_realized (widget))
+ {
+ if (gtk_widget_get_visible (widget))
+ {
+ GdkRectangle tmp_rectangle = widget->allocation;
+ tmp_rectangle.x += scroll_data->dx;
+ tmp_rectangle.y += scroll_data->dy;
+
+ gtk_widget_size_allocate (widget, &tmp_rectangle);
+ }
+ }
+ else
+ {
+ if (ALLOCATION_WINDOW (widget) == scroll_data->window)
+ {
+ widget->allocation.x += scroll_data->dx;
+ widget->allocation.y += scroll_data->dy;
+
+ if (GTK_IS_CONTAINER (widget))
+ gtk_container_forall (GTK_CONTAINER (widget),
+ adjust_allocation_recurse,
+ data);
+ }
+ }
+}
+
+static void
+adjust_allocation (GtkWidget *widget,
+ int dx,
+ int dy)
+{
+ ScrollData scroll_data;
+
+ if (gtk_widget_get_realized (widget))
+ scroll_data.window = ALLOCATION_WINDOW (widget);
+ else
+ scroll_data.window = NULL;
+
+ scroll_data.dx = dx;
+ scroll_data.dy = dy;
+
+ adjust_allocation_recurse (widget, &scroll_data);
+}
+
+/* Callbacks */
+static void
+pspp_sheet_view_adjustment_changed (GtkAdjustment *adjustment,
+ PsppSheetView *tree_view)
+{
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ {
+ gint dy;
+
+ gdk_window_move (tree_view->priv->bin_window,
+ - tree_view->priv->hadjustment->value,
+ TREE_VIEW_HEADER_HEIGHT (tree_view));
+ gdk_window_move (tree_view->priv->header_window,
+ - tree_view->priv->hadjustment->value,
+ 0);
+ dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
+ if (dy)
+ {
+ update_prelight (tree_view,
+ tree_view->priv->event_last_x,
+ tree_view->priv->event_last_y - dy);
+
+ if (tree_view->priv->edited_column &&
+ GTK_IS_WIDGET (tree_view->priv->edited_column->editable_widget))
+ {
+ GList *list;
+ GtkWidget *widget;
+ PsppSheetViewChild *child = NULL;
+
+ widget = GTK_WIDGET
(tree_view->priv->edited_column->editable_widget);
+ adjust_allocation (widget, 0, dy);
+
+ for (list = tree_view->priv->children; list; list = list->next)
+ {
+ child = (PsppSheetViewChild *)list->data;
+ if (child->widget == widget)
+ {
+ child->y += dy;
+ break;
+ }
+ }
+ }
+ }
+ gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
+
+ if (tree_view->priv->dy != (int) tree_view->priv->vadjustment->value)
+ {
+ /* update our dy and top_row */
+ tree_view->priv->dy = (int) tree_view->priv->vadjustment->value;
+
+ if (!tree_view->priv->in_top_row_to_dy)
+ pspp_sheet_view_dy_to_top_row (tree_view);
+ }
+
+ gdk_window_process_updates (tree_view->priv->header_window, TRUE);
+ gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
+ }
+}
+
+
+
+/* Public methods
+ */
+
+/**
+ * pspp_sheet_view_new:
+ *
+ * Creates a new #PsppSheetView widget.
+ *
+ * Return value: A newly created #PsppSheetView widget.
+ **/
+GtkWidget *
+pspp_sheet_view_new (void)
+{
+ return g_object_new (PSPP_TYPE_SHEET_VIEW, NULL);
+}
+
+/**
+ * pspp_sheet_view_new_with_model:
+ * @model: the model.
+ *
+ * Creates a new #PsppSheetView widget with the model initialized to @model.
+ *
+ * Return value: A newly created #PsppSheetView widget.
+ **/
+GtkWidget *
+pspp_sheet_view_new_with_model (GtkTreeModel *model)
+{
+ return g_object_new (PSPP_TYPE_SHEET_VIEW, "model", model, NULL);
+}
+
+/* Public Accessors
+ */
+
+/**
+ * pspp_sheet_view_get_model:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns the model the #PsppSheetView is based on. Returns %NULL if the
+ * model is unset.
+ *
+ * Return value: A #GtkTreeModel, or %NULL if none is currently being used.
+ **/
+GtkTreeModel *
+pspp_sheet_view_get_model (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ return tree_view->priv->model;
+}
+
+/**
+ * pspp_sheet_view_set_model:
+ * @tree_view: A #GtkTreeNode.
+ * @model: (allow-none): The model.
+ *
+ * Sets the model for a #PsppSheetView. If the @tree_view already has a model
+ * set, it will remove it before setting the new model. If @model is %NULL,
+ * then it will unset the old model.
+ **/
+void
+pspp_sheet_view_set_model (PsppSheetView *tree_view,
+ GtkTreeModel *model)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
+
+ if (model == tree_view->priv->model)
+ return;
+
+ if (tree_view->priv->scroll_to_path)
+ {
+ gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
+ tree_view->priv->scroll_to_path = NULL;
+ }
+
+ if (tree_view->priv->model)
+ {
+ GList *tmplist = tree_view->priv->columns;
+
+ pspp_sheet_view_unref_and_check_selection_tree (tree_view,
tree_view->priv->tree);
+ pspp_sheet_view_stop_editing (tree_view, TRUE);
+
+ remove_expand_collapse_timeout (tree_view);
+
+ g_signal_handlers_disconnect_by_func (tree_view->priv->model,
+ pspp_sheet_view_row_changed,
+ tree_view);
+ g_signal_handlers_disconnect_by_func (tree_view->priv->model,
+ pspp_sheet_view_row_inserted,
+ tree_view);
+ g_signal_handlers_disconnect_by_func (tree_view->priv->model,
+
pspp_sheet_view_row_has_child_toggled,
+ tree_view);
+ g_signal_handlers_disconnect_by_func (tree_view->priv->model,
+ pspp_sheet_view_row_deleted,
+ tree_view);
+ g_signal_handlers_disconnect_by_func (tree_view->priv->model,
+ pspp_sheet_view_rows_reordered,
+ tree_view);
+
+ for (; tmplist; tmplist = tmplist->next)
+ _pspp_sheet_view_column_unset_model (tmplist->data,
+ tree_view->priv->model);
+
+ if (tree_view->priv->tree)
+ pspp_sheet_view_free_rbtree (tree_view);
+
+ gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
+ tree_view->priv->drag_dest_row = NULL;
+ gtk_tree_row_reference_free (tree_view->priv->cursor);
+ tree_view->priv->cursor = NULL;
+ gtk_tree_row_reference_free (tree_view->priv->anchor);
+ tree_view->priv->anchor = NULL;
+ gtk_tree_row_reference_free (tree_view->priv->top_row);
+ tree_view->priv->top_row = NULL;
+ gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
+ tree_view->priv->scroll_to_path = NULL;
+
+ tree_view->priv->scroll_to_column = NULL;
+
+ g_object_unref (tree_view->priv->model);
+
+ tree_view->priv->search_column = -1;
+ tree_view->priv->fixed_height_check = 0;
+ tree_view->priv->fixed_height = -1;
+ tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
+ }
+
+ tree_view->priv->model = model;
+
+ if (tree_view->priv->model)
+ {
+ gint i;
+ GtkTreePath *path;
+ GtkTreeIter iter;
+ GtkTreeModelFlags flags;
+
+ if (tree_view->priv->search_column == -1)
+ {
+ for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
+ {
+ GType type = gtk_tree_model_get_column_type (model, i);
+
+ if (g_value_type_transformable (type, G_TYPE_STRING))
+ {
+ tree_view->priv->search_column = i;
+ break;
+ }
+ }
+ }
+
+ g_object_ref (tree_view->priv->model);
+ g_signal_connect (tree_view->priv->model,
+ "row-changed",
+ G_CALLBACK (pspp_sheet_view_row_changed),
+ tree_view);
+ g_signal_connect (tree_view->priv->model,
+ "row-inserted",
+ G_CALLBACK (pspp_sheet_view_row_inserted),
+ tree_view);
+ g_signal_connect (tree_view->priv->model,
+ "row-has-child-toggled",
+ G_CALLBACK (pspp_sheet_view_row_has_child_toggled),
+ tree_view);
+ g_signal_connect (tree_view->priv->model,
+ "row-deleted",
+ G_CALLBACK (pspp_sheet_view_row_deleted),
+ tree_view);
+ g_signal_connect (tree_view->priv->model,
+ "rows-reordered",
+ G_CALLBACK (pspp_sheet_view_rows_reordered),
+ tree_view);
+
+ flags = gtk_tree_model_get_flags (tree_view->priv->model);
+ if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_IS_LIST);
+ else
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IS_LIST);
+
+ path = gtk_tree_path_new_first ();
+ if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
+ {
+ tree_view->priv->tree = _pspp_rbtree_new ();
+ pspp_sheet_view_build_tree (tree_view, tree_view->priv->tree, &iter,
1, FALSE);
+ }
+ gtk_tree_path_free (path);
+
+ /* FIXME: do I need to do this? pspp_sheet_view_create_buttons
(tree_view); */
+ install_presize_handler (tree_view);
+ }
+
+ g_object_notify (G_OBJECT (tree_view), "model");
+
+ if (tree_view->priv->selection)
+ _pspp_sheet_selection_emit_changed (tree_view->priv->selection);
+
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+}
+
+/**
+ * pspp_sheet_view_get_selection:
+ * @tree_view: A #PsppSheetView.
+ *
+ * Gets the #PsppSheetSelection associated with @tree_view.
+ *
+ * Return value: A #PsppSheetSelection object.
+ **/
+PsppSheetSelection *
+pspp_sheet_view_get_selection (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ return tree_view->priv->selection;
+}
+
+/**
+ * pspp_sheet_view_get_hadjustment:
+ * @tree_view: A #PsppSheetView
+ *
+ * Gets the #GtkAdjustment currently being used for the horizontal aspect.
+ *
+ * Return value: A #GtkAdjustment object, or %NULL if none is currently being
+ * used.
+ **/
+GtkAdjustment *
+pspp_sheet_view_get_hadjustment (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ if (tree_view->priv->hadjustment == NULL)
+ pspp_sheet_view_set_hadjustment (tree_view, NULL);
+
+ return tree_view->priv->hadjustment;
+}
+
+/**
+ * pspp_sheet_view_set_hadjustment:
+ * @tree_view: A #PsppSheetView
+ * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
+ *
+ * Sets the #GtkAdjustment for the current horizontal aspect.
+ **/
+void
+pspp_sheet_view_set_hadjustment (PsppSheetView *tree_view,
+ GtkAdjustment *adjustment)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ pspp_sheet_view_set_adjustments (tree_view,
+ adjustment,
+ tree_view->priv->vadjustment);
+
+ g_object_notify (G_OBJECT (tree_view), "hadjustment");
+}
+
+/**
+ * pspp_sheet_view_get_vadjustment:
+ * @tree_view: A #PsppSheetView
+ *
+ * Gets the #GtkAdjustment currently being used for the vertical aspect.
+ *
+ * Return value: A #GtkAdjustment object, or %NULL if none is currently being
+ * used.
+ **/
+GtkAdjustment *
+pspp_sheet_view_get_vadjustment (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ if (tree_view->priv->vadjustment == NULL)
+ pspp_sheet_view_set_vadjustment (tree_view, NULL);
+
+ return tree_view->priv->vadjustment;
+}
+
+/**
+ * pspp_sheet_view_set_vadjustment:
+ * @tree_view: A #PsppSheetView
+ * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
+ *
+ * Sets the #GtkAdjustment for the current vertical aspect.
+ **/
+void
+pspp_sheet_view_set_vadjustment (PsppSheetView *tree_view,
+ GtkAdjustment *adjustment)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ pspp_sheet_view_set_adjustments (tree_view,
+ tree_view->priv->hadjustment,
+ adjustment);
+
+ g_object_notify (G_OBJECT (tree_view), "vadjustment");
+}
+
+/* Column and header operations */
+
+/**
+ * pspp_sheet_view_get_headers_visible:
+ * @tree_view: A #PsppSheetView.
+ *
+ * Returns %TRUE if the headers on the @tree_view are visible.
+ *
+ * Return value: Whether the headers are visible or not.
+ **/
+gboolean
+pspp_sheet_view_get_headers_visible (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ return PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE);
+}
+
+/**
+ * pspp_sheet_view_set_headers_visible:
+ * @tree_view: A #PsppSheetView.
+ * @headers_visible: %TRUE if the headers are visible
+ *
+ * Sets the visibility state of the headers.
+ **/
+void
+pspp_sheet_view_set_headers_visible (PsppSheetView *tree_view,
+ gboolean headers_visible)
+{
+ gint x, y;
+ GList *list;
+ PsppSheetViewColumn *column;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ headers_visible = !! headers_visible;
+
+ if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE) ==
headers_visible)
+ return;
+
+ if (headers_visible)
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE);
+ else
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE);
+
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ {
+ gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
+ if (headers_visible)
+ {
+ gdk_window_move_resize (tree_view->priv->bin_window, x, y +
TREE_VIEW_HEADER_HEIGHT (tree_view), tree_view->priv->width, GTK_WIDGET
(tree_view)->allocation.height - + TREE_VIEW_HEADER_HEIGHT (tree_view));
+
+ if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
+ pspp_sheet_view_map_buttons (tree_view);
+ }
+ else
+ {
+ gdk_window_move_resize (tree_view->priv->bin_window, x, y,
tree_view->priv->width, tree_view->priv->height);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ column = list->data;
+ gtk_widget_unmap (column->button);
+ }
+ gdk_window_hide (tree_view->priv->header_window);
+ }
+ }
+
+ tree_view->priv->vadjustment->page_size = GTK_WIDGET
(tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
+ tree_view->priv->vadjustment->page_increment = (GTK_WIDGET
(tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
+ tree_view->priv->vadjustment->lower = 0;
+ tree_view->priv->vadjustment->upper = tree_view->priv->height;
+ gtk_adjustment_changed (tree_view->priv->vadjustment);
+
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+
+ g_object_notify (G_OBJECT (tree_view), "headers-visible");
+}
+
+/**
+ * pspp_sheet_view_columns_autosize:
+ * @tree_view: A #PsppSheetView.
+ *
+ * Resizes all columns to their optimal width. Only works after the
+ * treeview has been realized.
+ **/
+void
+pspp_sheet_view_columns_autosize (PsppSheetView *tree_view)
+{
+ gboolean dirty = FALSE;
+ GList *list;
+ PsppSheetViewColumn *column;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ column = list->data;
+ if (column->column_type == PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ continue;
+ _pspp_sheet_view_column_cell_set_dirty (column, TRUE);
+ dirty = TRUE;
+ }
+
+ if (dirty)
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+}
+
+/**
+ * pspp_sheet_view_set_headers_clickable:
+ * @tree_view: A #PsppSheetView.
+ * @setting: %TRUE if the columns are clickable.
+ *
+ * Allow the column title buttons to be clicked.
+ **/
+void
+pspp_sheet_view_set_headers_clickable (PsppSheetView *tree_view,
+ gboolean setting)
+{
+ GList *list;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ pspp_sheet_view_column_set_clickable (PSPP_SHEET_VIEW_COLUMN (list->data),
setting);
+
+ g_object_notify (G_OBJECT (tree_view), "headers-clickable");
+}
+
+
+/**
+ * pspp_sheet_view_get_headers_clickable:
+ * @tree_view: A #PsppSheetView.
+ *
+ * Returns whether all header columns are clickable.
+ *
+ * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
+ *
+ * Since: 2.10
+ **/
+gboolean
+pspp_sheet_view_get_headers_clickable (PsppSheetView *tree_view)
+{
+ GList *list;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ if (!PSPP_SHEET_VIEW_COLUMN (list->data)->clickable)
+ return FALSE;
+
+ return TRUE;
+}
+
+/**
+ * pspp_sheet_view_set_rules_hint
+ * @tree_view: a #PsppSheetView
+ * @setting: %TRUE if the tree requires reading across rows
+ *
+ * This function tells GTK+ that the user interface for your
+ * application requires users to read across tree rows and associate
+ * cells with one another. By default, GTK+ will then render the tree
+ * with alternating row colors. Do <emphasis>not</emphasis> use it
+ * just because you prefer the appearance of the ruled tree; that's a
+ * question for the theme. Some themes will draw tree rows in
+ * alternating colors even when rules are turned off, and users who
+ * prefer that appearance all the time can choose those themes. You
+ * should call this function only as a <emphasis>semantic</emphasis>
+ * hint to the theme engine that your tree makes alternating colors
+ * useful from a functional standpoint (since it has lots of columns,
+ * generally).
+ *
+ **/
+void
+pspp_sheet_view_set_rules_hint (PsppSheetView *tree_view,
+ gboolean setting)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ setting = setting != FALSE;
+
+ if (tree_view->priv->has_rules != setting)
+ {
+ tree_view->priv->has_rules = setting;
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+ }
+
+ g_object_notify (G_OBJECT (tree_view), "rules-hint");
+}
+
+/**
+ * pspp_sheet_view_get_rules_hint
+ * @tree_view: a #PsppSheetView
+ *
+ * Gets the setting set by pspp_sheet_view_set_rules_hint().
+ *
+ * Return value: %TRUE if rules are useful for the user of this tree
+ **/
+gboolean
+pspp_sheet_view_get_rules_hint (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ return tree_view->priv->has_rules;
+}
+
+/* Public Column functions
+ */
+
+/**
+ * pspp_sheet_view_append_column:
+ * @tree_view: A #PsppSheetView.
+ * @column: The #PsppSheetViewColumn to add.
+ *
+ * Appends @column to the list of columns. If @tree_view has "fixed_height"
+ * mode enabled, then @column must have its "sizing" property set to be
+ * PSPP_SHEET_VIEW_COLUMN_FIXED.
+ *
+ * Return value: The number of columns in @tree_view after appending.
+ **/
+gint
+pspp_sheet_view_append_column (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column), -1);
+ g_return_val_if_fail (column->tree_view == NULL, -1);
+
+ return pspp_sheet_view_insert_column (tree_view, column, -1);
+}
+
+
+/**
+ * pspp_sheet_view_remove_column:
+ * @tree_view: A #PsppSheetView.
+ * @column: The #PsppSheetViewColumn to remove.
+ *
+ * Removes @column from @tree_view.
+ *
+ * Return value: The number of columns in @tree_view after removing.
+ **/
+gint
+pspp_sheet_view_remove_column (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column), -1);
+ g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
+
+ if (tree_view->priv->focus_column == column)
+ tree_view->priv->focus_column = NULL;
+
+ if (tree_view->priv->edited_column == column)
+ {
+ pspp_sheet_view_stop_editing (tree_view, TRUE);
+
+ /* no need to, but just to be sure ... */
+ tree_view->priv->edited_column = NULL;
+ }
+
+ if (tree_view->priv->expander_column == column)
+ tree_view->priv->expander_column = NULL;
+
+ g_signal_handlers_disconnect_by_func (column,
+ G_CALLBACK (column_sizing_notify),
+ tree_view);
+
+ _pspp_sheet_view_column_unset_tree_view (column);
+
+ tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
+ tree_view->priv->n_columns--;
+
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ {
+ GList *list;
+
+ _pspp_sheet_view_column_unrealize_button (column);
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ PsppSheetViewColumn *tmp_column;
+
+ tmp_column = PSPP_SHEET_VIEW_COLUMN (list->data);
+ if (tmp_column->visible)
+ _pspp_sheet_view_column_cell_set_dirty (tmp_column, TRUE);
+ }
+
+ if (tree_view->priv->n_columns == 0 &&
+ pspp_sheet_view_get_headers_visible (tree_view))
+ gdk_window_hide (tree_view->priv->header_window);
+
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ }
+
+ g_object_unref (column);
+ g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
+
+ return tree_view->priv->n_columns;
+}
+
+/**
+ * pspp_sheet_view_insert_column:
+ * @tree_view: A #PsppSheetView.
+ * @column: The #PsppSheetViewColumn to be inserted.
+ * @position: The position to insert @column in.
+ *
+ * This inserts the @column into the @tree_view at @position. If @position is
+ * -1, then the column is inserted at the end. If @tree_view has
+ * "fixed_height" mode enabled, then @column must have its "sizing" property
+ * set to be PSPP_SHEET_VIEW_COLUMN_FIXED.
+ *
+ * Return value: The number of columns in @tree_view after insertion.
+ **/
+gint
+pspp_sheet_view_insert_column (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column,
+ gint position)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column), -1);
+ g_return_val_if_fail (column->tree_view == NULL, -1);
+
+ if (tree_view->priv->fixed_height_mode)
+ g_return_val_if_fail (pspp_sheet_view_column_get_sizing (column)
+ == PSPP_SHEET_VIEW_COLUMN_FIXED, -1);
+
+ g_object_ref_sink (column);
+
+ if (tree_view->priv->n_columns == 0 &&
+ gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
+ pspp_sheet_view_get_headers_visible (tree_view))
+ {
+ gdk_window_show (tree_view->priv->header_window);
+ }
+
+ g_signal_connect (column, "notify::sizing",
+ G_CALLBACK (column_sizing_notify), tree_view);
+
+ tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
+ column, position);
+ tree_view->priv->n_columns++;
+
+ _pspp_sheet_view_column_set_tree_view (column, tree_view);
+
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ {
+ GList *list;
+
+ _pspp_sheet_view_column_realize_button (column);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ column = PSPP_SHEET_VIEW_COLUMN (list->data);
+ if (column->visible)
+ _pspp_sheet_view_column_cell_set_dirty (column, TRUE);
+ }
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ }
+
+ g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
+
+ return tree_view->priv->n_columns;
+}
+
+/**
+ * pspp_sheet_view_insert_column_with_attributes:
+ * @tree_view: A #PsppSheetView
+ * @position: The position to insert the new column in.
+ * @title: The title to set the header to.
+ * @cell: The #GtkCellRenderer.
+ * @Varargs: A %NULL-terminated list of attributes.
+ *
+ * Creates a new #PsppSheetViewColumn and inserts it into the @tree_view at
+ * @position. If @position is -1, then the newly created column is inserted at
+ * the end. The column is initialized with the attributes given. If @tree_view
+ * has "fixed_height" mode enabled, then the new column will have its sizing
+ * property set to be PSPP_SHEET_VIEW_COLUMN_FIXED.
+ *
+ * Return value: The number of columns in @tree_view after insertion.
+ **/
+gint
+pspp_sheet_view_insert_column_with_attributes (PsppSheetView *tree_view,
+ gint position,
+ const gchar *title,
+ GtkCellRenderer *cell,
+ ...)
+{
+ PsppSheetViewColumn *column;
+ gchar *attribute;
+ va_list args;
+ gint column_id;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
+
+ column = pspp_sheet_view_column_new ();
+ if (tree_view->priv->fixed_height_mode)
+ pspp_sheet_view_column_set_sizing (column, PSPP_SHEET_VIEW_COLUMN_FIXED);
+
+ pspp_sheet_view_column_set_title (column, title);
+ pspp_sheet_view_column_pack_start (column, cell, TRUE);
+
+ va_start (args, cell);
+
+ attribute = va_arg (args, gchar *);
+
+ while (attribute != NULL)
+ {
+ column_id = va_arg (args, gint);
+ pspp_sheet_view_column_add_attribute (column, cell, attribute,
column_id);
+ attribute = va_arg (args, gchar *);
+ }
+
+ va_end (args);
+
+ pspp_sheet_view_insert_column (tree_view, column, position);
+
+ return tree_view->priv->n_columns;
+}
+
+/**
+ * pspp_sheet_view_insert_column_with_data_func:
+ * @tree_view: a #PsppSheetView
+ * @position: Position to insert, -1 for append
+ * @title: column title
+ * @cell: cell renderer for column
+ * @func: function to set attributes of cell renderer
+ * @data: data for @func
+ * @dnotify: destroy notifier for @data
+ *
+ * Convenience function that inserts a new column into the #PsppSheetView
+ * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
+ * attributes (normally using data from the model). See also
+ * pspp_sheet_view_column_set_cell_data_func(),
pspp_sheet_view_column_pack_start().
+ * If @tree_view has "fixed_height" mode enabled, then the new column will
have its
+ * "sizing" property set to be PSPP_SHEET_VIEW_COLUMN_FIXED.
+ *
+ * Return value: number of columns in the tree view post-insert
+ **/
+gint
+pspp_sheet_view_insert_column_with_data_func (PsppSheetView
*tree_view,
+ gint
position,
+ const gchar *title,
+ GtkCellRenderer *cell,
+ PsppSheetCellDataFunc func,
+ gpointer data,
+ GDestroyNotify
dnotify)
+{
+ PsppSheetViewColumn *column;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
+
+ column = pspp_sheet_view_column_new ();
+ if (tree_view->priv->fixed_height_mode)
+ pspp_sheet_view_column_set_sizing (column, PSPP_SHEET_VIEW_COLUMN_FIXED);
+
+ pspp_sheet_view_column_set_title (column, title);
+ pspp_sheet_view_column_pack_start (column, cell, TRUE);
+ pspp_sheet_view_column_set_cell_data_func (column, cell, func, data,
dnotify);
+
+ pspp_sheet_view_insert_column (tree_view, column, position);
+
+ return tree_view->priv->n_columns;
+}
+
+/**
+ * pspp_sheet_view_get_column:
+ * @tree_view: A #PsppSheetView.
+ * @n: The position of the column, counting from 0.
+ *
+ * Gets the #PsppSheetViewColumn at the given position in the #tree_view.
+ *
+ * Return value: The #PsppSheetViewColumn, or %NULL if the position is outside
the
+ * range of columns.
+ **/
+PsppSheetViewColumn *
+pspp_sheet_view_get_column (PsppSheetView *tree_view,
+ gint n)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ if (n < 0 || n >= tree_view->priv->n_columns)
+ return NULL;
+
+ if (tree_view->priv->columns == NULL)
+ return NULL;
+
+ return PSPP_SHEET_VIEW_COLUMN (g_list_nth (tree_view->priv->columns,
n)->data);
+}
+
+/**
+ * pspp_sheet_view_get_columns:
+ * @tree_view: A #PsppSheetView
+ *
+ * Returns a #GList of all the #PsppSheetViewColumn s currently in @tree_view.
+ * The returned list must be freed with g_list_free ().
+ *
+ * Return value: (element-type PsppSheetViewColumn) (transfer container): A
list of #PsppSheetViewColumn s
+ **/
+GList *
+pspp_sheet_view_get_columns (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ return g_list_copy (tree_view->priv->columns);
+}
+
+/**
+ * pspp_sheet_view_move_column_after:
+ * @tree_view: A #PsppSheetView
+ * @column: The #PsppSheetViewColumn to be moved.
+ * @base_column: (allow-none): The #PsppSheetViewColumn to be moved relative
to, or %NULL.
+ *
+ * Moves @column to be after to @base_column. If @base_column is %NULL, then
+ * @column is placed in the first position.
+ **/
+void
+pspp_sheet_view_move_column_after (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column,
+ PsppSheetViewColumn *base_column)
+{
+ GList *column_list_el, *base_el = NULL;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ column_list_el = g_list_find (tree_view->priv->columns, column);
+ g_return_if_fail (column_list_el != NULL);
+
+ if (base_column)
+ {
+ base_el = g_list_find (tree_view->priv->columns, base_column);
+ g_return_if_fail (base_el != NULL);
+ }
+
+ if (column_list_el->prev == base_el)
+ return;
+
+ tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns,
column_list_el);
+ if (base_el == NULL)
+ {
+ column_list_el->prev = NULL;
+ column_list_el->next = tree_view->priv->columns;
+ if (column_list_el->next)
+ column_list_el->next->prev = column_list_el;
+ tree_view->priv->columns = column_list_el;
+ }
+ else
+ {
+ column_list_el->prev = base_el;
+ column_list_el->next = base_el->next;
+ if (column_list_el->next)
+ column_list_el->next->prev = column_list_el;
+ base_el->next = column_list_el;
+ }
+
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ {
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ pspp_sheet_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
+ }
+
+ g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
+}
+
+/**
+ * pspp_sheet_view_set_expander_column:
+ * @tree_view: A #PsppSheetView
+ * @column: %NULL, or the column to draw the expander arrow at.
+ *
+ * Sets the column to draw the expander arrow at. It must be in @tree_view.
+ * If @column is %NULL, then the expander arrow is always at the first
+ * visible column.
+ *
+ * If you do not want expander arrow to appear in your tree, set the
+ * expander column to a hidden column.
+ **/
+void
+pspp_sheet_view_set_expander_column (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (column));
+
+ if (tree_view->priv->expander_column != column)
+ {
+ GList *list;
+
+ if (column)
+ {
+ /* Confirm that column is in tree_view */
+ for (list = tree_view->priv->columns; list; list = list->next)
+ if (list->data == column)
+ break;
+ g_return_if_fail (list != NULL);
+ }
+
+ tree_view->priv->expander_column = column;
+ g_object_notify (G_OBJECT (tree_view), "expander-column");
+ }
+}
+
+/**
+ * pspp_sheet_view_get_expander_column:
+ * @tree_view: A #PsppSheetView
+ *
+ * Returns the column that is the current expander column. This
+ * column has the expander arrow drawn next to it.
+ *
+ * Return value: The expander column.
+ **/
+PsppSheetViewColumn *
+pspp_sheet_view_get_expander_column (PsppSheetView *tree_view)
+{
+ GList *list;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ if (pspp_sheet_view_is_expander_column (tree_view, PSPP_SHEET_VIEW_COLUMN
(list->data)))
+ return (PsppSheetViewColumn *) list->data;
+ return NULL;
+}
+
+
+/**
+ * pspp_sheet_view_set_column_drag_function:
+ * @tree_view: A #PsppSheetView.
+ * @func: (allow-none): A function to determine which columns are reorderable,
or %NULL.
+ * @user_data: (allow-none): User data to be passed to @func, or %NULL
+ * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
+ *
+ * Sets a user function for determining where a column may be dropped when
+ * dragged. This function is called on every column pair in turn at the
+ * beginning of a column drag to determine where a drop can take place. The
+ * arguments passed to @func are: the @tree_view, the #PsppSheetViewColumn
being
+ * dragged, the two #PsppSheetViewColumn s determining the drop spot, and
+ * @user_data. If either of the #PsppSheetViewColumn arguments for the drop
spot
+ * are %NULL, then they indicate an edge. If @func is set to be %NULL, then
+ * @tree_view reverts to the default behavior of allowing all columns to be
+ * dropped everywhere.
+ **/
+void
+pspp_sheet_view_set_column_drag_function (PsppSheetView
*tree_view,
+ PsppSheetViewColumnDropFunc func,
+ gpointer user_data,
+ GDestroyNotify destroy)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (tree_view->priv->column_drop_func_data_destroy)
+ tree_view->priv->column_drop_func_data_destroy
(tree_view->priv->column_drop_func_data);
+
+ tree_view->priv->column_drop_func = func;
+ tree_view->priv->column_drop_func_data = user_data;
+ tree_view->priv->column_drop_func_data_destroy = destroy;
+}
+
+/**
+ * pspp_sheet_view_scroll_to_point:
+ * @tree_view: a #PsppSheetView
+ * @tree_x: X coordinate of new top-left pixel of visible area, or -1
+ * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
+ *
+ * Scrolls the tree view such that the top-left corner of the visible
+ * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
+ * in tree coordinates. The @tree_view must be realized before
+ * this function is called. If it isn't, you probably want to be
+ * using pspp_sheet_view_scroll_to_cell().
+ *
+ * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
+ **/
+void
+pspp_sheet_view_scroll_to_point (PsppSheetView *tree_view,
+ gint tree_x,
+ gint tree_y)
+{
+ GtkAdjustment *hadj;
+ GtkAdjustment *vadj;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
+
+ hadj = tree_view->priv->hadjustment;
+ vadj = tree_view->priv->vadjustment;
+
+ if (tree_x != -1)
+ gtk_adjustment_set_value (hadj, CLAMP (tree_x, hadj->lower, hadj->upper -
hadj->page_size));
+ if (tree_y != -1)
+ gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper -
vadj->page_size));
+}
+
+/**
+ * pspp_sheet_view_scroll_to_cell:
+ * @tree_view: A #PsppSheetView.
+ * @path: (allow-none): The path of the row to move to, or %NULL.
+ * @column: (allow-none): The #PsppSheetViewColumn to move horizontally to, or
%NULL.
+ * @use_align: whether to use alignment arguments, or %FALSE.
+ * @row_align: The vertical alignment of the row specified by @path.
+ * @col_align: The horizontal alignment of the column specified by @column.
+ *
+ * Moves the alignments of @tree_view to the position specified by @column and
+ * @path. If @column is %NULL, then no horizontal scrolling occurs. Likewise,
+ * if @path is %NULL no vertical scrolling occurs. At a minimum, one of
@column
+ * or @path need to be non-%NULL. @row_align determines where the row is
+ * placed, and @col_align determines where @column is placed. Both are
expected
+ * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
+ * right/bottom alignment, 0.5 means center.
+ *
+ * If @use_align is %FALSE, then the alignment arguments are ignored, and the
+ * tree does the minimum amount of work to scroll the cell onto the screen.
+ * This means that the cell will be scrolled to the edge closest to its current
+ * position. If the cell is currently visible on the screen, nothing is done.
+ *
+ * This function only works if the model is set, and @path is a valid row on
the
+ * model. If the model changes before the @tree_view is realized, the centered
+ * path will be modified to reflect this change.
+ **/
+void
+pspp_sheet_view_scroll_to_cell (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ PsppSheetViewColumn *column,
+ gboolean use_align,
+ gfloat row_align,
+ gfloat col_align)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (tree_view->priv->model != NULL);
+ g_return_if_fail (tree_view->priv->tree != NULL);
+ g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
+ g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
+ g_return_if_fail (path != NULL || column != NULL);
+
+#if 0
+ g_print ("pspp_sheet_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align:
%d\nrow_align: %f\ncol_align: %f\n",
+ gtk_tree_path_to_string (path), column?"non-null":"null", use_align,
row_align, col_align);
+#endif
+ row_align = CLAMP (row_align, 0.0, 1.0);
+ col_align = CLAMP (col_align, 0.0, 1.0);
+
+
+ /* Note: Despite the benefits that come from having one code path for the
+ * scrolling code, we short-circuit validate_visible_area's immplementation
as
+ * it is much slower than just going to the point.
+ */
+ if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
+ !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
+ /* XXX GTK_WIDGET_ALLOC_NEEDED (tree_view) || */
+ PSPP_RBNODE_FLAG_SET (tree_view->priv->tree->root,
PSPP_RBNODE_DESCENDANTS_INVALID))
+ {
+ if (tree_view->priv->scroll_to_path)
+ gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
+
+ tree_view->priv->scroll_to_path = NULL;
+ tree_view->priv->scroll_to_column = NULL;
+
+ if (path)
+ tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy
(G_OBJECT (tree_view), tree_view->priv->model, path);
+ if (column)
+ tree_view->priv->scroll_to_column = column;
+ tree_view->priv->scroll_to_use_align = use_align;
+ tree_view->priv->scroll_to_row_align = row_align;
+ tree_view->priv->scroll_to_col_align = col_align;
+
+ install_presize_handler (tree_view);
+ }
+ else
+ {
+ GdkRectangle cell_rect;
+ GdkRectangle vis_rect;
+ gint dest_x, dest_y;
+
+ pspp_sheet_view_get_background_area (tree_view, path, column,
&cell_rect);
+ pspp_sheet_view_get_visible_rect (tree_view, &vis_rect);
+
+ cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
+
+ dest_x = vis_rect.x;
+ dest_y = vis_rect.y;
+
+ if (column)
+ {
+ if (use_align)
+ {
+ dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) *
col_align);
+ }
+ else
+ {
+ if (cell_rect.x < vis_rect.x)
+ dest_x = cell_rect.x;
+ if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
+ dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
+ }
+ }
+
+ if (path)
+ {
+ if (use_align)
+ {
+ dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) *
row_align);
+ dest_y = MAX (dest_y, 0);
+ }
+ else
+ {
+ if (cell_rect.y < vis_rect.y)
+ dest_y = cell_rect.y;
+ if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
+ dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
+ }
+ }
+
+ pspp_sheet_view_scroll_to_point (tree_view, dest_x, dest_y);
+ }
+}
+
+/**
+ * pspp_sheet_view_row_activated:
+ * @tree_view: A #PsppSheetView
+ * @path: The #GtkTreePath to be activated.
+ * @column: The #PsppSheetViewColumn to be activated.
+ *
+ * Activates the cell determined by @path and @column.
+ **/
+void
+pspp_sheet_view_row_activated (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ PsppSheetViewColumn *column)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
+}
+
+
+static void
+pspp_sheet_view_expand_all_emission_helper (GtkRBTree *tree,
+ GtkRBNode *node,
+ gpointer data)
+{
+ PsppSheetView *tree_view = data;
+
+ if ((node->flags & PSPP_RBNODE_IS_PARENT) == PSPP_RBNODE_IS_PARENT &&
+ node->children)
+ {
+ GtkTreePath *path;
+ GtkTreeIter iter;
+
+ path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+
+ g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter,
path);
+
+ gtk_tree_path_free (path);
+ }
+
+ if (node->children)
+ _pspp_rbtree_traverse (node->children,
+ node->children->root,
+ G_PRE_ORDER,
+ pspp_sheet_view_expand_all_emission_helper,
+ tree_view);
+}
+
+/**
+ * pspp_sheet_view_expand_all:
+ * @tree_view: A #PsppSheetView.
+ *
+ * Recursively expands all nodes in the @tree_view.
+ **/
+void
+pspp_sheet_view_expand_all (PsppSheetView *tree_view)
+{
+ GtkTreePath *path;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (tree_view->priv->tree == NULL)
+ return;
+
+ path = gtk_tree_path_new_first ();
+ _pspp_sheet_view_find_node (tree_view, path, &tree, &node);
+
+ while (node)
+ {
+ pspp_sheet_view_real_expand_row (tree_view, path, tree, node, TRUE,
FALSE);
+ node = _pspp_rbtree_next (tree, node);
+ gtk_tree_path_next (path);
+ }
+
+ gtk_tree_path_free (path);
+}
+
+/* Timeout to animate the expander during expands and collapses */
+static gboolean
+expand_collapse_timeout (gpointer data)
+{
+ return do_expand_collapse (data);
+}
+
+static void
+add_expand_collapse_timeout (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ gboolean expand)
+{
+ if (tree_view->priv->expand_collapse_timeout != 0)
+ return;
+
+ tree_view->priv->expand_collapse_timeout =
+ gdk_threads_add_timeout (50, expand_collapse_timeout, tree_view);
+ tree_view->priv->expanded_collapsed_tree = tree;
+ tree_view->priv->expanded_collapsed_node = node;
+
+ if (expand)
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_IS_SEMI_COLLAPSED);
+ else
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_IS_SEMI_EXPANDED);
+}
+
+static void
+remove_expand_collapse_timeout (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->expand_collapse_timeout)
+ {
+ g_source_remove (tree_view->priv->expand_collapse_timeout);
+ tree_view->priv->expand_collapse_timeout = 0;
+ }
+
+ if (tree_view->priv->expanded_collapsed_node != NULL)
+ {
+ PSPP_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node,
PSPP_RBNODE_IS_SEMI_EXPANDED);
+ PSPP_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node,
PSPP_RBNODE_IS_SEMI_COLLAPSED);
+
+ tree_view->priv->expanded_collapsed_node = NULL;
+ }
+}
+
+static void
+cancel_arrow_animation (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->expand_collapse_timeout)
+ {
+ while (do_expand_collapse (tree_view));
+
+ remove_expand_collapse_timeout (tree_view);
+ }
+}
+
+static gboolean
+do_expand_collapse (PsppSheetView *tree_view)
+{
+ GtkRBNode *node;
+ GtkRBTree *tree;
+ gboolean expanding;
+ gboolean redraw;
+
+ redraw = FALSE;
+ expanding = TRUE;
+
+ node = tree_view->priv->expanded_collapsed_node;
+ tree = tree_view->priv->expanded_collapsed_tree;
+
+ if (node->children == NULL)
+ expanding = FALSE;
+
+ if (expanding)
+ {
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SEMI_COLLAPSED))
+ {
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_IS_SEMI_COLLAPSED);
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_IS_SEMI_EXPANDED);
+
+ redraw = TRUE;
+
+ }
+ else if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SEMI_EXPANDED))
+ {
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_IS_SEMI_EXPANDED);
+
+ redraw = TRUE;
+ }
+ }
+ else
+ {
+ if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SEMI_EXPANDED))
+ {
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_IS_SEMI_EXPANDED);
+ PSPP_RBNODE_SET_FLAG (node, PSPP_RBNODE_IS_SEMI_COLLAPSED);
+
+ redraw = TRUE;
+ }
+ else if (PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SEMI_COLLAPSED))
+ {
+ PSPP_RBNODE_UNSET_FLAG (node, PSPP_RBNODE_IS_SEMI_COLLAPSED);
+
+ redraw = TRUE;
+
+ }
+ }
+
+ if (redraw)
+ {
+ pspp_sheet_view_queue_draw_arrow (tree_view, tree, node, NULL);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/**
+ * pspp_sheet_view_collapse_all:
+ * @tree_view: A #PsppSheetView.
+ *
+ * Recursively collapses all visible, expanded nodes in @tree_view.
+ **/
+void
+pspp_sheet_view_collapse_all (PsppSheetView *tree_view)
+{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ GtkTreePath *path;
+ gint *indices;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (tree_view->priv->tree == NULL)
+ return;
+
+ path = gtk_tree_path_new ();
+ gtk_tree_path_down (path);
+ indices = gtk_tree_path_get_indices (path);
+
+ tree = tree_view->priv->tree;
+ node = tree->root;
+ while (node && node->left != tree->nil)
+ node = node->left;
+
+ while (node)
+ {
+ if (node->children)
+ pspp_sheet_view_real_collapse_row (tree_view, path, tree, node, FALSE);
+ indices[0]++;
+ node = _pspp_rbtree_next (tree, node);
+ }
+
+ gtk_tree_path_free (path);
+}
+
+/**
+ * pspp_sheet_view_expand_to_path:
+ * @tree_view: A #PsppSheetView.
+ * @path: path to a row.
+ *
+ * Expands the row at @path. This will also expand all parent rows of
+ * @path as necessary.
+ *
+ * Since: 2.2
+ **/
+void
+pspp_sheet_view_expand_to_path (PsppSheetView *tree_view,
+ GtkTreePath *path)
+{
+ gint i, depth;
+ gint *indices;
+ GtkTreePath *tmp;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (path != NULL);
+
+ depth = gtk_tree_path_get_depth (path);
+ indices = gtk_tree_path_get_indices (path);
+
+ tmp = gtk_tree_path_new ();
+ g_return_if_fail (tmp != NULL);
+
+ for (i = 0; i < depth; i++)
+ {
+ gtk_tree_path_append_index (tmp, indices[i]);
+ pspp_sheet_view_expand_row (tree_view, tmp, FALSE);
+ }
+
+ gtk_tree_path_free (tmp);
+}
+
+/* FIXME the bool return values for expand_row and collapse_row are
+ * not analagous; they should be TRUE if the row had children and
+ * was not already in the requested state.
+ */
+
+
+static gboolean
+pspp_sheet_view_real_expand_row (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ gboolean open_all,
+ gboolean animate)
+{
+ GtkTreeIter iter;
+ GtkTreeIter temp;
+ gboolean expand;
+
+ if (animate)
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
+ "gtk-enable-animations", &animate,
+ NULL);
+
+ remove_auto_expand_timeout (tree_view);
+
+ if (node->children && !open_all)
+ return FALSE;
+
+ if (! PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_PARENT))
+ return FALSE;
+
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+ if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
+ return FALSE;
+
+
+ if (node->children && open_all)
+ {
+ gboolean retval = FALSE;
+ GtkTreePath *tmp_path = gtk_tree_path_copy (path);
+
+ gtk_tree_path_append_index (tmp_path, 0);
+ tree = node->children;
+ node = tree->root;
+ while (node->left != tree->nil)
+ node = node->left;
+ /* try to expand the children */
+ do
+ {
+ gboolean t;
+ t = pspp_sheet_view_real_expand_row (tree_view, tmp_path, tree, node,
+ TRUE, animate);
+ if (t)
+ retval = TRUE;
+
+ gtk_tree_path_next (tmp_path);
+ node = _pspp_rbtree_next (tree, node);
+ }
+ while (node != NULL);
+
+ gtk_tree_path_free (tmp_path);
+
+ return retval;
+ }
+
+ g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter,
path, &expand);
+
+ if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
+ return FALSE;
+
+ if (expand)
+ return FALSE;
+
+ node->children = _pspp_rbtree_new ();
+ node->children->parent_tree = tree;
+ node->children->parent_node = node;
+
+ gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
+
+ pspp_sheet_view_build_tree (tree_view,
+ node->children,
+ &temp,
+ gtk_tree_path_get_depth (path) + 1,
+ open_all);
+
+ remove_expand_collapse_timeout (tree_view);
+
+ if (animate)
+ add_expand_collapse_timeout (tree_view, tree, node, TRUE);
+
+ install_presize_handler (tree_view);
+
+ g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
+ if (open_all && node->children)
+ {
+ _pspp_rbtree_traverse (node->children,
+ node->children->root,
+ G_PRE_ORDER,
+ pspp_sheet_view_expand_all_emission_helper,
+ tree_view);
+ }
+ return TRUE;
+}
+
+
+/**
+ * pspp_sheet_view_expand_row:
+ * @tree_view: a #PsppSheetView
+ * @path: path to a row
+ * @open_all: whether to recursively expand, or just expand immediate children
+ *
+ * Opens the row so its children are visible.
+ *
+ * Return value: %TRUE if the row existed and had children
+ **/
+gboolean
+pspp_sheet_view_expand_row (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ gboolean open_all)
+{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+ g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
+ g_return_val_if_fail (path != NULL, FALSE);
+
+ if (_pspp_sheet_view_find_node (tree_view,
+ path,
+ &tree,
+ &node))
+ return FALSE;
+
+ if (tree != NULL)
+ return pspp_sheet_view_real_expand_row (tree_view, path, tree, node,
open_all, FALSE);
+ else
+ return FALSE;
+}
+
+static gboolean
+pspp_sheet_view_real_collapse_row (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ gboolean animate)
+{
+ GtkTreeIter iter;
+ GtkTreeIter children;
+ gboolean collapse;
+ gint x, y;
+ GList *list;
+ GdkWindow *child, *parent;
+
+ if (animate)
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
+ "gtk-enable-animations", &animate,
+ NULL);
+
+ remove_auto_expand_timeout (tree_view);
+
+ if (node->children == NULL)
+ return FALSE;
+
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+
+ g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter,
path, &collapse);
+
+ if (collapse)
+ return FALSE;
+
+ /* if the prelighted node is a child of us, we want to unprelight it. We
have
+ * a chance to prelight the correct node below */
+
+ if (tree_view->priv->prelight_tree)
+ {
+ GtkRBTree *parent_tree;
+ GtkRBNode *parent_node;
+
+ parent_tree = tree_view->priv->prelight_tree->parent_tree;
+ parent_node = tree_view->priv->prelight_tree->parent_node;
+ while (parent_tree)
+ {
+ if (parent_tree == tree && parent_node == node)
+ {
+ ensure_unprelighted (tree_view);
+ break;
+ }
+ parent_node = parent_tree->parent_node;
+ parent_tree = parent_tree->parent_tree;
+ }
+ }
+
+ TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children
(tree_view->priv->model, &children, &iter), FALSE);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ PsppSheetViewColumn *column = list->data;
+
+ if (column->visible == FALSE)
+ continue;
+ if (pspp_sheet_view_column_get_sizing (column) ==
PSPP_SHEET_VIEW_COLUMN_AUTOSIZE)
+ _pspp_sheet_view_column_cell_set_dirty (column, TRUE);
+ }
+
+ if (tree_view->priv->destroy_count_func)
+ {
+ GtkTreePath *child_path;
+ gint child_count = 0;
+ child_path = gtk_tree_path_copy (path);
+ gtk_tree_path_down (child_path);
+ if (node->children)
+ _pspp_rbtree_traverse (node->children, node->children->root,
G_POST_ORDER, count_children_helper, &child_count);
+ tree_view->priv->destroy_count_func (tree_view, child_path, child_count,
tree_view->priv->destroy_count_data);
+ gtk_tree_path_free (child_path);
+ }
+
+ if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ {
+ GtkTreePath *cursor_path = gtk_tree_row_reference_get_path
(tree_view->priv->cursor);
+
+ if (gtk_tree_path_is_ancestor (path, cursor_path))
+ {
+ gtk_tree_row_reference_free (tree_view->priv->cursor);
+ tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT
(tree_view),
+
tree_view->priv->model,
+ path);
+ }
+ gtk_tree_path_free (cursor_path);
+ }
+
+ if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
+ {
+ GtkTreePath *anchor_path = gtk_tree_row_reference_get_path
(tree_view->priv->anchor);
+ if (gtk_tree_path_is_ancestor (path, anchor_path))
+ {
+ gtk_tree_row_reference_free (tree_view->priv->anchor);
+ tree_view->priv->anchor = NULL;
+ }
+ gtk_tree_path_free (anchor_path);
+ }
+
+ /* Stop a pending double click */
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
+
+ remove_expand_collapse_timeout (tree_view);
+
+ if (pspp_sheet_view_unref_and_check_selection_tree (tree_view,
node->children))
+ {
+ _pspp_rbtree_remove (node->children);
+ g_signal_emit_by_name (tree_view->priv->selection, "changed");
+ }
+ else
+ _pspp_rbtree_remove (node->children);
+
+ if (animate)
+ add_expand_collapse_timeout (tree_view, tree, node, FALSE);
+
+ if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
+ {
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ }
+
+ g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
+
+ if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
+ {
+ /* now that we've collapsed all rows, we want to try to set the prelight
+ * again. To do this, we fake a motion event and send it to ourselves. */
+
+ child = tree_view->priv->bin_window;
+ parent = gdk_window_get_parent (child);
+
+ if (gdk_window_get_pointer (parent, &x, &y, NULL) == child)
+ {
+ GdkEventMotion event;
+ gint child_x, child_y;
+
+ gdk_window_get_position (child, &child_x, &child_y);
+
+ event.window = tree_view->priv->bin_window;
+ event.x = x - child_x;
+ event.y = y - child_y;
+
+ /* despite the fact this isn't a real event, I'm almost positive it
will
+ * never trigger a drag event. maybe_drag is the only function that
uses
+ * more than just event.x and event.y. */
+ pspp_sheet_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
+ }
+ }
+
+ return TRUE;
+}
+
+/**
+ * pspp_sheet_view_collapse_row:
+ * @tree_view: a #PsppSheetView
+ * @path: path to a row in the @tree_view
+ *
+ * Collapses a row (hides its child rows, if they exist).
+ *
+ * Return value: %TRUE if the row was collapsed.
+ **/
+gboolean
+pspp_sheet_view_collapse_row (PsppSheetView *tree_view,
+ GtkTreePath *path)
+{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+ g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
+ g_return_val_if_fail (path != NULL, FALSE);
+
+ if (_pspp_sheet_view_find_node (tree_view,
+ path,
+ &tree,
+ &node))
+ return FALSE;
+
+ if (tree == NULL || node->children == NULL)
+ return FALSE;
+
+ return pspp_sheet_view_real_collapse_row (tree_view, path, tree, node,
FALSE);
+}
+
+static void
+pspp_sheet_view_map_expanded_rows_helper (PsppSheetView *tree_view,
+ GtkRBTree *tree,
+ GtkTreePath *path,
+ PsppSheetViewMappingFunc func,
+ gpointer user_data)
+{
+ GtkRBNode *node;
+
+ if (tree == NULL || tree->root == NULL)
+ return;
+
+ node = tree->root;
+
+ while (node && node->left != tree->nil)
+ node = node->left;
+
+ while (node)
+ {
+ if (node->children)
+ {
+ (* func) (tree_view, path, user_data);
+ gtk_tree_path_down (path);
+ pspp_sheet_view_map_expanded_rows_helper (tree_view, node->children,
path, func, user_data);
+ gtk_tree_path_up (path);
+ }
+ gtk_tree_path_next (path);
+ node = _pspp_rbtree_next (tree, node);
+ }
+}
+
+/**
+ * pspp_sheet_view_map_expanded_rows:
+ * @tree_view: A #PsppSheetView
+ * @func: A function to be called
+ * @data: User data to be passed to the function.
+ *
+ * Calls @func on all expanded rows.
+ **/
+void
+pspp_sheet_view_map_expanded_rows (PsppSheetView *tree_view,
+ PsppSheetViewMappingFunc func,
+ gpointer user_data)
+{
+ GtkTreePath *path;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (func != NULL);
+
+ path = gtk_tree_path_new_first ();
+
+ pspp_sheet_view_map_expanded_rows_helper (tree_view,
+ tree_view->priv->tree,
+ path, func, user_data);
+
+ gtk_tree_path_free (path);
+}
+
+/**
+ * pspp_sheet_view_row_expanded:
+ * @tree_view: A #PsppSheetView.
+ * @path: A #GtkTreePath to test expansion state.
+ *
+ * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
+ *
+ * Return value: %TRUE if #path is expanded.
+ **/
+gboolean
+pspp_sheet_view_row_expanded (PsppSheetView *tree_view,
+ GtkTreePath *path)
+{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+ g_return_val_if_fail (path != NULL, FALSE);
+
+ _pspp_sheet_view_find_node (tree_view, path, &tree, &node);
+
+ if (node == NULL)
+ return FALSE;
+
+ return (node->children != NULL);
+}
+
+/**
+ * pspp_sheet_view_get_reorderable:
+ * @tree_view: a #PsppSheetView
+ *
+ * Retrieves whether the user can reorder the tree via drag-and-drop. See
+ * pspp_sheet_view_set_reorderable().
+ *
+ * Return value: %TRUE if the tree can be reordered.
+ **/
+gboolean
+pspp_sheet_view_get_reorderable (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ return tree_view->priv->reorderable;
+}
+
+/**
+ * pspp_sheet_view_set_reorderable:
+ * @tree_view: A #PsppSheetView.
+ * @reorderable: %TRUE, if the tree can be reordered.
+ *
+ * This function is a convenience function to allow you to reorder
+ * models that support the #GtkDragSourceIface and the
+ * #GtkDragDestIface. Both #GtkTreeStore and #GtkListStore support
+ * these. If @reorderable is %TRUE, then the user can reorder the
+ * model by dragging and dropping rows. The developer can listen to
+ * these changes by connecting to the model's row_inserted and
+ * row_deleted signals. The reordering is implemented by setting up
+ * the tree view as a drag source and destination. Therefore, drag and
+ * drop can not be used in a reorderable view for any other purpose.
+ *
+ * This function does not give you any degree of control over the order -- any
+ * reordering is allowed. If more control is needed, you should probably
+ * handle drag and drop manually.
+ **/
+void
+pspp_sheet_view_set_reorderable (PsppSheetView *tree_view,
+ gboolean reorderable)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ reorderable = reorderable != FALSE;
+
+ if (tree_view->priv->reorderable == reorderable)
+ return;
+
+ if (reorderable)
+ {
+ const GtkTargetEntry row_targets[] = {
+ { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
+ };
+
+ pspp_sheet_view_enable_model_drag_source (tree_view,
+ GDK_BUTTON1_MASK,
+ row_targets,
+ G_N_ELEMENTS (row_targets),
+ GDK_ACTION_MOVE);
+ pspp_sheet_view_enable_model_drag_dest (tree_view,
+ row_targets,
+ G_N_ELEMENTS (row_targets),
+ GDK_ACTION_MOVE);
+ }
+ else
+ {
+ pspp_sheet_view_unset_rows_drag_source (tree_view);
+ pspp_sheet_view_unset_rows_drag_dest (tree_view);
+ }
+
+ tree_view->priv->reorderable = reorderable;
+
+ g_object_notify (G_OBJECT (tree_view), "reorderable");
+}
+
+static void
+pspp_sheet_view_real_set_cursor (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ gboolean clear_and_select,
+ gboolean clamp_node)
+{
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+
+ if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ {
+ GtkTreePath *cursor_path;
+ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL);
+ gtk_tree_path_free (cursor_path);
+ }
+
+ gtk_tree_row_reference_free (tree_view->priv->cursor);
+ tree_view->priv->cursor = NULL;
+
+ /* One cannot set the cursor on a separator. Also, if
+ * _pspp_sheet_view_find_node returns TRUE, it ran out of tree
+ * before finding the tree and node belonging to path. The
+ * path maps to a non-existing path and we will silently bail out.
+ * We unset tree and node to avoid further processing.
+ */
+ if (!row_is_separator (tree_view, NULL, path)
+ && _pspp_sheet_view_find_node (tree_view, path, &tree, &node) == FALSE)
+ {
+ tree_view->priv->cursor =
+ gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
+ tree_view->priv->model,
+ path);
+ }
+ else
+ {
+ tree = NULL;
+ node = NULL;
+ }
+
+ if (tree != NULL)
+ {
+ GtkRBTree *new_tree = NULL;
+ GtkRBNode *new_node = NULL;
+
+ if (clear_and_select && !tree_view->priv->ctrl_pressed)
+ {
+ GtkTreeSelectMode mode = 0;
+
+ if (tree_view->priv->ctrl_pressed)
+ mode |= GTK_TREE_SELECT_MODE_TOGGLE;
+ if (tree_view->priv->shift_pressed)
+ mode |= GTK_TREE_SELECT_MODE_EXTEND;
+
+ _pspp_sheet_selection_internal_select_node
(tree_view->priv->selection,
+ node, tree, path, mode,
+ FALSE);
+ }
+
+ /* We have to re-find tree and node here again, somebody might have
+ * cleared the node or the whole tree in the PsppSheetSelection::changed
+ * callback. If the nodes differ we bail out here.
+ */
+ _pspp_sheet_view_find_node (tree_view, path, &new_tree, &new_node);
+
+ if (tree != new_tree || node != new_node)
+ return;
+
+ if (clamp_node)
+ {
+ pspp_sheet_view_clamp_node_visible (tree_view, tree, node);
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, NULL);
+ }
+ }
+
+ g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
+}
+
+/**
+ * pspp_sheet_view_get_cursor:
+ * @tree_view: A #PsppSheetView
+ * @path: (allow-none): A pointer to be filled with the current cursor path,
or %NULL
+ * @focus_column: (allow-none): A pointer to be filled with the current focus
column, or %NULL
+ *
+ * Fills in @path and @focus_column with the current path and focus column. If
+ * the cursor isn't currently set, then address@hidden will be %NULL. If no
column
+ * currently has focus, then address@hidden will be %NULL.
+ *
+ * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
+ * you are done with it.
+ **/
+void
+pspp_sheet_view_get_cursor (PsppSheetView *tree_view,
+ GtkTreePath **path,
+ PsppSheetViewColumn **focus_column)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (path)
+ {
+ if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ else
+ *path = NULL;
+ }
+
+ if (focus_column)
+ {
+ *focus_column = tree_view->priv->focus_column;
+ }
+}
+
+/**
+ * pspp_sheet_view_set_cursor:
+ * @tree_view: A #PsppSheetView
+ * @path: A #GtkTreePath
+ * @focus_column: (allow-none): A #PsppSheetViewColumn, or %NULL
+ * @start_editing: %TRUE if the specified cell should start being edited.
+ *
+ * Sets the current keyboard focus to be at @path, and selects it. This is
+ * useful when you want to focus the user's attention on a particular row. If
+ * @focus_column is not %NULL, then focus is given to the column specified by
+ * it. Additionally, if @focus_column is specified, and @start_editing is
+ * %TRUE, then editing should be started in the specified cell.
+ * This function is often followed by @gtk_widget_grab_focus (@tree_view)
+ * in order to give keyboard focus to the widget. Please note that editing
+ * can only happen when the widget is realized.
+ *
+ * If @path is invalid for @model, the current cursor (if any) will be unset
+ * and the function will return without failing.
+ **/
+void
+pspp_sheet_view_set_cursor (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ PsppSheetViewColumn *focus_column,
+ gboolean start_editing)
+{
+ pspp_sheet_view_set_cursor_on_cell (tree_view, path, focus_column,
+ NULL, start_editing);
+}
+
+/**
+ * pspp_sheet_view_set_cursor_on_cell:
+ * @tree_view: A #PsppSheetView
+ * @path: A #GtkTreePath
+ * @focus_column: (allow-none): A #PsppSheetViewColumn, or %NULL
+ * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
+ * @start_editing: %TRUE if the specified cell should start being edited.
+ *
+ * Sets the current keyboard focus to be at @path, and selects it. This is
+ * useful when you want to focus the user's attention on a particular row. If
+ * @focus_column is not %NULL, then focus is given to the column specified by
+ * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
+ * contains 2 or more editable or activatable cells, then focus is given to
+ * the cell specified by @focus_cell. Additionally, if @focus_column is
+ * specified, and @start_editing is %TRUE, then editing should be started in
+ * the specified cell. This function is often followed by
+ * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
+ * widget. Please note that editing can only happen when the widget is
+ * realized.
+ *
+ * If @path is invalid for @model, the current cursor (if any) will be unset
+ * and the function will return without failing.
+ *
+ * Since: 2.2
+ **/
+void
+pspp_sheet_view_set_cursor_on_cell (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ PsppSheetViewColumn *focus_column,
+ GtkCellRenderer *focus_cell,
+ gboolean start_editing)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (path != NULL);
+ g_return_if_fail (focus_column == NULL || PSPP_IS_SHEET_VIEW_COLUMN
(focus_column));
+
+ if (!tree_view->priv->model)
+ return;
+
+ if (focus_cell)
+ {
+ g_return_if_fail (focus_column);
+ g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
+ }
+
+ /* cancel the current editing, if it exists */
+ if (tree_view->priv->edited_column &&
+ tree_view->priv->edited_column->editable_widget)
+ pspp_sheet_view_stop_editing (tree_view, TRUE);
+
+ pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+
+ if (focus_column && focus_column->visible)
+ {
+ GList *list;
+ gboolean column_in_tree = FALSE;
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ if (list->data == focus_column)
+ {
+ column_in_tree = TRUE;
+ break;
+ }
+ g_return_if_fail (column_in_tree);
+ tree_view->priv->focus_column = focus_column;
+ if (focus_cell)
+ pspp_sheet_view_column_focus_cell (focus_column, focus_cell);
+ if (start_editing)
+ pspp_sheet_view_start_editing (tree_view, path);
+ }
+}
+
+/**
+ * pspp_sheet_view_get_bin_window:
+ * @tree_view: A #PsppSheetView
+ *
+ * Returns the window that @tree_view renders to. This is used primarily to
+ * compare to <literal>event->window</literal> to confirm that the event on
+ * @tree_view is on the right window.
+ *
+ * Return value: A #GdkWindow, or %NULL when @tree_view hasn't been realized
yet
+ **/
+GdkWindow *
+pspp_sheet_view_get_bin_window (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ return tree_view->priv->bin_window;
+}
+
+/**
+ * pspp_sheet_view_get_path_at_pos:
+ * @tree_view: A #PsppSheetView.
+ * @x: The x position to be identified (relative to bin_window).
+ * @y: The y position to be identified (relative to bin_window).
+ * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled
in, or %NULL
+ * @column: (out) (allow-none): A pointer to a #PsppSheetViewColumn pointer to
be filled in, or %NULL
+ * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to
the cell can be placed, or %NULL
+ * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to
the cell can be placed, or %NULL
+ *
+ * Finds the path at the point (@x, @y), relative to bin_window coordinates
+ * (please see pspp_sheet_view_get_bin_window()).
+ * That is, @x and @y are relative to an events coordinates. @x and @y must
+ * come from an event on the @tree_view only where <literal>event->window ==
+ * pspp_sheet_view_get_bin_window (<!-- -->)</literal>. It is primarily for
+ * things like popup menus. If @path is non-%NULL, then it will be filled
+ * with the #GtkTreePath at that point. This path should be freed with
+ * gtk_tree_path_free(). If @column is non-%NULL, then it will be filled
+ * with the column at that point. @cell_x and @cell_y return the coordinates
+ * relative to the cell background (i.e. the @background_area passed to
+ * gtk_cell_renderer_render()). This function is only meaningful if
+ * @tree_view is realized. Therefore this function will always return %FALSE
+ * if @tree_view is not realized or does not have a model.
+ *
+ * For converting widget coordinates (eg. the ones you get from
+ * GtkWidget::query-tooltip), please see
+ * pspp_sheet_view_convert_widget_to_bin_window_coords().
+ *
+ * Return value: %TRUE if a row exists at that coordinate.
+ **/
+gboolean
+pspp_sheet_view_get_path_at_pos (PsppSheetView *tree_view,
+ gint x,
+ gint y,
+ GtkTreePath **path,
+ PsppSheetViewColumn **column,
+ gint *cell_x,
+ gint *cell_y)
+{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gint y_offset;
+
+ g_return_val_if_fail (tree_view != NULL, FALSE);
+
+ if (path)
+ *path = NULL;
+ if (column)
+ *column = NULL;
+
+ if (tree_view->priv->bin_window == NULL)
+ return FALSE;
+
+ if (tree_view->priv->tree == NULL)
+ return FALSE;
+
+ if (x > tree_view->priv->hadjustment->upper)
+ return FALSE;
+
+ if (x < 0 || y < 0)
+ return FALSE;
+
+ if (column || cell_x)
+ {
+ PsppSheetViewColumn *tmp_column;
+ PsppSheetViewColumn *last_column = NULL;
+ GList *list;
+ gint remaining_x = x;
+ gboolean found = FALSE;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL);
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list;
+ list = (rtl ? list->prev : list->next))
+ {
+ tmp_column = list->data;
+
+ if (tmp_column->visible == FALSE)
+ continue;
+
+ last_column = tmp_column;
+ if (remaining_x <= tmp_column->width)
+ {
+ found = TRUE;
+
+ if (column)
+ *column = tmp_column;
+
+ if (cell_x)
+ *cell_x = remaining_x;
+
+ break;
+ }
+ remaining_x -= tmp_column->width;
+ }
+
+ /* If found is FALSE and there is a last_column, then it the remainder
+ * space is in that area
+ */
+ if (!found)
+ {
+ if (last_column)
+ {
+ if (column)
+ *column = last_column;
+
+ if (cell_x)
+ *cell_x = last_column->width + remaining_x;
+ }
+ else
+ {
+ return FALSE;
+ }
+ }
+ }
+
+ y_offset = _pspp_rbtree_find_offset (tree_view->priv->tree,
+ TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
+ &tree, &node);
+
+ if (tree == NULL)
+ return FALSE;
+
+ if (cell_y)
+ *cell_y = y_offset;
+
+ if (path)
+ *path = _pspp_sheet_view_find_path (tree_view, tree, node);
+
+ return TRUE;
+}
+
+
+/**
+ * pspp_sheet_view_get_cell_area:
+ * @tree_view: a #PsppSheetView
+ * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only
horizontal coordinates
+ * @column: (allow-none): a #PsppSheetViewColumn for the column, or %NULL to
get only vertical coordinates
+ * @rect: rectangle to fill with cell rect
+ *
+ * Fills the bounding rectangle in bin_window coordinates for the cell at the
+ * row specified by @path and the column specified by @column. If @path is
+ * %NULL, or points to a path not currently displayed, the @y and @height
fields
+ * of the rectangle will be filled with 0. If @column is %NULL, the @x and
@width
+ * fields will be filled with 0. The sum of all cell rects does not cover the
+ * entire tree; there are extra pixels in between rows, for example. The
+ * returned rectangle is equivalent to the @cell_area passed to
+ * gtk_cell_renderer_render(). This function is only valid if @tree_view is
+ * realized.
+ **/
+void
+pspp_sheet_view_get_cell_area (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ PsppSheetViewColumn *column,
+ GdkRectangle *rect)
+{
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ gint vertical_separator;
+ gint horizontal_separator;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (column));
+ g_return_if_fail (rect != NULL);
+ g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
+
+ gtk_widget_style_get (GTK_WIDGET (tree_view),
+ "vertical-separator", &vertical_separator,
+ "horizontal-separator", &horizontal_separator,
+ NULL);
+
+ rect->x = 0;
+ rect->y = 0;
+ rect->width = 0;
+ rect->height = 0;
+
+ if (column)
+ {
+ rect->x = column->button->allocation.x + horizontal_separator/2;
+ rect->width = column->button->allocation.width - horizontal_separator;
+ }
+
+ if (path)
+ {
+ gboolean ret = _pspp_sheet_view_find_node (tree_view, path, &tree,
&node);
+
+ /* Get vertical coords */
+ if ((!ret && tree == NULL) || ret)
+ return;
+
+ rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
+ rect->height = MAX (CELL_HEIGHT (node, vertical_separator),
tree_view->priv->expander_size - vertical_separator);
+
+ if (column &&
+ pspp_sheet_view_is_expander_column (tree_view, column))
+ {
+ gint depth = gtk_tree_path_get_depth (path);
+ gboolean rtl;
+
+ rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) ==
GTK_TEXT_DIR_RTL;
+
+ if (!rtl)
+ rect->x += (depth - 1) * tree_view->priv->level_indentation;
+ rect->width -= (depth - 1) * tree_view->priv->level_indentation;
+
+ if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
+ {
+ if (!rtl)
+ rect->x += depth * tree_view->priv->expander_size;
+ rect->width -= depth * tree_view->priv->expander_size;
+ }
+
+ rect->width = MAX (rect->width, 0);
+ }
+ }
+}
+
+/**
+ * pspp_sheet_view_get_background_area:
+ * @tree_view: a #PsppSheetView
+ * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only
horizontal coordinates
+ * @column: (allow-none): a #PsppSheetViewColumn for the column, or %NULL to
get only vertical coordiantes
+ * @rect: rectangle to fill with cell background rect
+ *
+ * Fills the bounding rectangle in bin_window coordinates for the cell at the
+ * row specified by @path and the column specified by @column. If @path is
+ * %NULL, or points to a node not found in the tree, the @y and @height fields
of
+ * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
+ * fields will be filled with 0. The returned rectangle is equivalent to the
+ * @background_area passed to gtk_cell_renderer_render(). These background
+ * areas tile to cover the entire bin window. Contrast with the @cell_area,
+ * returned by pspp_sheet_view_get_cell_area(), which returns only the cell
+ * itself, excluding surrounding borders and the tree expander area.
+ *
+ **/
+void
+pspp_sheet_view_get_background_area (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ PsppSheetViewColumn *column,
+ GdkRectangle *rect)
+{
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (column));
+ g_return_if_fail (rect != NULL);
+
+ rect->x = 0;
+ rect->y = 0;
+ rect->width = 0;
+ rect->height = 0;
+
+ if (path)
+ {
+ /* Get vertical coords */
+
+ if (!_pspp_sheet_view_find_node (tree_view, path, &tree, &node) &&
+ tree == NULL)
+ return;
+
+ rect->y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
+
+ rect->height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
+ }
+
+ if (column)
+ {
+ gint x2 = 0;
+
+ pspp_sheet_view_get_background_xrange (tree_view, tree, column,
&rect->x, &x2);
+ rect->width = x2 - rect->x;
+ }
+}
+
+/**
+ * pspp_sheet_view_get_visible_rect:
+ * @tree_view: a #PsppSheetView
+ * @visible_rect: rectangle to fill
+ *
+ * Fills @visible_rect with the currently-visible region of the
+ * buffer, in tree coordinates. Convert to bin_window coordinates with
+ * pspp_sheet_view_convert_tree_to_bin_window_coords().
+ * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
+ * scrollable area of the tree.
+ **/
+void
+pspp_sheet_view_get_visible_rect (PsppSheetView *tree_view,
+ GdkRectangle *visible_rect)
+{
+ GtkWidget *widget;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ widget = GTK_WIDGET (tree_view);
+
+ if (visible_rect)
+ {
+ visible_rect->x = tree_view->priv->hadjustment->value;
+ visible_rect->y = tree_view->priv->vadjustment->value;
+ visible_rect->width = widget->allocation.width;
+ visible_rect->height = widget->allocation.height -
TREE_VIEW_HEADER_HEIGHT (tree_view);
+ }
+}
+
+/**
+ * pspp_sheet_view_widget_to_tree_coords:
+ * @tree_view: a #PsppSheetView
+ * @wx: X coordinate relative to bin_window
+ * @wy: Y coordinate relative to bin_window
+ * @tx: return location for tree X coordinate
+ * @ty: return location for tree Y coordinate
+ *
+ * Converts bin_window coordinates to coordinates for the
+ * tree (the full scrollable area of the tree).
+ *
+ * Deprecated: 2.12: Due to historial reasons the name of this function is
+ * incorrect. For converting coordinates relative to the widget to
+ * bin_window coordinates, please see
+ * pspp_sheet_view_convert_widget_to_bin_window_coords().
+ *
+ **/
+void
+pspp_sheet_view_widget_to_tree_coords (PsppSheetView *tree_view,
+ gint wx,
+ gint wy,
+ gint *tx,
+ gint *ty)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (tx)
+ *tx = wx + tree_view->priv->hadjustment->value;
+ if (ty)
+ *ty = wy + tree_view->priv->dy;
+}
+
+/**
+ * pspp_sheet_view_tree_to_widget_coords:
+ * @tree_view: a #PsppSheetView
+ * @tx: tree X coordinate
+ * @ty: tree Y coordinate
+ * @wx: return location for X coordinate relative to bin_window
+ * @wy: return location for Y coordinate relative to bin_window
+ *
+ * Converts tree coordinates (coordinates in full scrollable area of the tree)
+ * to bin_window coordinates.
+ *
+ * Deprecated: 2.12: Due to historial reasons the name of this function is
+ * incorrect. For converting bin_window coordinates to coordinates relative
+ * to bin_window, please see
+ * pspp_sheet_view_convert_bin_window_to_widget_coords().
+ *
+ **/
+void
+pspp_sheet_view_tree_to_widget_coords (PsppSheetView *tree_view,
+ gint tx,
+ gint ty,
+ gint *wx,
+ gint *wy)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (wx)
+ *wx = tx - tree_view->priv->hadjustment->value;
+ if (wy)
+ *wy = ty - tree_view->priv->dy;
+}
+
+
+/**
+ * pspp_sheet_view_convert_widget_to_tree_coords:
+ * @tree_view: a #PsppSheetView
+ * @wx: X coordinate relative to the widget
+ * @wy: Y coordinate relative to the widget
+ * @tx: return location for tree X coordinate
+ * @ty: return location for tree Y coordinate
+ *
+ * Converts widget coordinates to coordinates for the
+ * tree (the full scrollable area of the tree).
+ *
+ * Since: 2.12
+ **/
+void
+pspp_sheet_view_convert_widget_to_tree_coords (PsppSheetView *tree_view,
+ gint wx,
+ gint wy,
+ gint *tx,
+ gint *ty)
+{
+ gint x, y;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ pspp_sheet_view_convert_widget_to_bin_window_coords (tree_view,
+ wx, wy,
+ &x, &y);
+ pspp_sheet_view_convert_bin_window_to_tree_coords (tree_view,
+ x, y,
+ tx, ty);
+}
+
+/**
+ * pspp_sheet_view_convert_tree_to_widget_coords:
+ * @tree_view: a #PsppSheetView
+ * @tx: X coordinate relative to the tree
+ * @ty: Y coordinate relative to the tree
+ * @wx: return location for widget X coordinate
+ * @wy: return location for widget Y coordinate
+ *
+ * Converts tree coordinates (coordinates in full scrollable area of the tree)
+ * to widget coordinates.
+ *
+ * Since: 2.12
+ **/
+void
+pspp_sheet_view_convert_tree_to_widget_coords (PsppSheetView *tree_view,
+ gint tx,
+ gint ty,
+ gint *wx,
+ gint *wy)
+{
+ gint x, y;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ pspp_sheet_view_convert_tree_to_bin_window_coords (tree_view,
+ tx, ty,
+ &x, &y);
+ pspp_sheet_view_convert_bin_window_to_widget_coords (tree_view,
+ x, y,
+ wx, wy);
+}
+
+/**
+ * pspp_sheet_view_convert_widget_to_bin_window_coords:
+ * @tree_view: a #PsppSheetView
+ * @wx: X coordinate relative to the widget
+ * @wy: Y coordinate relative to the widget
+ * @bx: return location for bin_window X coordinate
+ * @by: return location for bin_window Y coordinate
+ *
+ * Converts widget coordinates to coordinates for the bin_window
+ * (see pspp_sheet_view_get_bin_window()).
+ *
+ * Since: 2.12
+ **/
+void
+pspp_sheet_view_convert_widget_to_bin_window_coords (PsppSheetView *tree_view,
+ gint wx,
+ gint wy,
+ gint *bx,
+ gint *by)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (bx)
+ *bx = wx + tree_view->priv->hadjustment->value;
+ if (by)
+ *by = wy - TREE_VIEW_HEADER_HEIGHT (tree_view);
+}
+
+/**
+ * pspp_sheet_view_convert_bin_window_to_widget_coords:
+ * @tree_view: a #PsppSheetView
+ * @bx: bin_window X coordinate
+ * @by: bin_window Y coordinate
+ * @wx: return location for widget X coordinate
+ * @wy: return location for widget Y coordinate
+ *
+ * Converts bin_window coordinates (see pspp_sheet_view_get_bin_window())
+ * to widget relative coordinates.
+ *
+ * Since: 2.12
+ **/
+void
+pspp_sheet_view_convert_bin_window_to_widget_coords (PsppSheetView *tree_view,
+ gint bx,
+ gint by,
+ gint *wx,
+ gint *wy)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (wx)
+ *wx = bx - tree_view->priv->hadjustment->value;
+ if (wy)
+ *wy = by + TREE_VIEW_HEADER_HEIGHT (tree_view);
+}
+
+/**
+ * pspp_sheet_view_convert_tree_to_bin_window_coords:
+ * @tree_view: a #PsppSheetView
+ * @tx: tree X coordinate
+ * @ty: tree Y coordinate
+ * @bx: return location for X coordinate relative to bin_window
+ * @by: return location for Y coordinate relative to bin_window
+ *
+ * Converts tree coordinates (coordinates in full scrollable area of the tree)
+ * to bin_window coordinates.
+ *
+ * Since: 2.12
+ **/
+void
+pspp_sheet_view_convert_tree_to_bin_window_coords (PsppSheetView *tree_view,
+ gint tx,
+ gint ty,
+ gint *bx,
+ gint *by)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (bx)
+ *bx = tx;
+ if (by)
+ *by = ty - tree_view->priv->dy;
+}
+
+/**
+ * pspp_sheet_view_convert_bin_window_to_tree_coords:
+ * @tree_view: a #PsppSheetView
+ * @bx: X coordinate relative to bin_window
+ * @by: Y coordinate relative to bin_window
+ * @tx: return location for tree X coordinate
+ * @ty: return location for tree Y coordinate
+ *
+ * Converts bin_window coordinates to coordinates for the
+ * tree (the full scrollable area of the tree).
+ *
+ * Since: 2.12
+ **/
+void
+pspp_sheet_view_convert_bin_window_to_tree_coords (PsppSheetView *tree_view,
+ gint bx,
+ gint by,
+ gint *tx,
+ gint *ty)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (tx)
+ *tx = bx;
+ if (ty)
+ *ty = by + tree_view->priv->dy;
+}
+
+
+
+/**
+ * pspp_sheet_view_get_visible_range:
+ * @tree_view: A #PsppSheetView
+ * @start_path: (allow-none): Return location for start of region, or %NULL.
+ * @end_path: (allow-none): Return location for end of region, or %NULL.
+ *
+ * Sets @start_path and @end_path to be the first and last visible path.
+ * Note that there may be invisible paths in between.
+ *
+ * The paths should be freed with gtk_tree_path_free() after use.
+ *
+ * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
+ *
+ * Since: 2.8
+ **/
+gboolean
+pspp_sheet_view_get_visible_range (PsppSheetView *tree_view,
+ GtkTreePath **start_path,
+ GtkTreePath **end_path)
+{
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gboolean retval;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ if (!tree_view->priv->tree)
+ return FALSE;
+
+ retval = TRUE;
+
+ if (start_path)
+ {
+ _pspp_rbtree_find_offset (tree_view->priv->tree,
+ TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
+ &tree, &node);
+ if (node)
+ *start_path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ else
+ retval = FALSE;
+ }
+
+ if (end_path)
+ {
+ gint y;
+
+ if (tree_view->priv->height < tree_view->priv->vadjustment->page_size)
+ y = tree_view->priv->height - 1;
+ else
+ y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view,
tree_view->priv->vadjustment->page_size) - 1;
+
+ _pspp_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
+ if (node)
+ *end_path = _pspp_sheet_view_find_path (tree_view, tree, node);
+ else
+ retval = FALSE;
+ }
+
+ return retval;
+}
+
+static void
+unset_reorderable (PsppSheetView *tree_view)
+{
+ if (tree_view->priv->reorderable)
+ {
+ tree_view->priv->reorderable = FALSE;
+ g_object_notify (G_OBJECT (tree_view), "reorderable");
+ }
+}
+
+/**
+ * pspp_sheet_view_enable_model_drag_source:
+ * @tree_view: a #PsppSheetView
+ * @start_button_mask: Mask of allowed buttons to start drag
+ * @targets: the table of targets that the drag will support
+ * @n_targets: the number of items in @targets
+ * @actions: the bitmask of possible actions for a drag from this
+ * widget
+ *
+ * Turns @tree_view into a drag source for automatic DND. Calling this
+ * method sets #PsppSheetView:reorderable to %FALSE.
+ **/
+void
+pspp_sheet_view_enable_model_drag_source (PsppSheetView
*tree_view,
+ GdkModifierType
start_button_mask,
+ const GtkTargetEntry *targets,
+ gint n_targets,
+ GdkDragAction actions)
+{
+ TreeViewDragInfo *di;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ gtk_drag_source_set (GTK_WIDGET (tree_view),
+ 0,
+ targets,
+ n_targets,
+ actions);
+
+ di = ensure_info (tree_view);
+
+ di->start_button_mask = start_button_mask;
+ di->source_actions = actions;
+ di->source_set = TRUE;
+
+ unset_reorderable (tree_view);
+}
+
+/**
+ * pspp_sheet_view_enable_model_drag_dest:
+ * @tree_view: a #PsppSheetView
+ * @targets: the table of targets that the drag will support
+ * @n_targets: the number of items in @targets
+ * @actions: the bitmask of possible actions for a drag from this
+ * widget
+ *
+ * Turns @tree_view into a drop destination for automatic DND. Calling
+ * this method sets #PsppSheetView:reorderable to %FALSE.
+ **/
+void
+pspp_sheet_view_enable_model_drag_dest (PsppSheetView *tree_view,
+ const GtkTargetEntry *targets,
+ gint n_targets,
+ GdkDragAction actions)
+{
+ TreeViewDragInfo *di;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ gtk_drag_dest_set (GTK_WIDGET (tree_view),
+ 0,
+ targets,
+ n_targets,
+ actions);
+
+ di = ensure_info (tree_view);
+ di->dest_set = TRUE;
+
+ unset_reorderable (tree_view);
+}
+
+/**
+ * pspp_sheet_view_unset_rows_drag_source:
+ * @tree_view: a #PsppSheetView
+ *
+ * Undoes the effect of
+ * pspp_sheet_view_enable_model_drag_source(). Calling this method sets
+ * #PsppSheetView:reorderable to %FALSE.
+ **/
+void
+pspp_sheet_view_unset_rows_drag_source (PsppSheetView *tree_view)
+{
+ TreeViewDragInfo *di;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ di = get_info (tree_view);
+
+ if (di)
+ {
+ if (di->source_set)
+ {
+ gtk_drag_source_unset (GTK_WIDGET (tree_view));
+ di->source_set = FALSE;
+ }
+
+ if (!di->dest_set && !di->source_set)
+ remove_info (tree_view);
+ }
+
+ unset_reorderable (tree_view);
+}
+
+/**
+ * pspp_sheet_view_unset_rows_drag_dest:
+ * @tree_view: a #PsppSheetView
+ *
+ * Undoes the effect of
+ * pspp_sheet_view_enable_model_drag_dest(). Calling this method sets
+ * #PsppSheetView:reorderable to %FALSE.
+ **/
+void
+pspp_sheet_view_unset_rows_drag_dest (PsppSheetView *tree_view)
+{
+ TreeViewDragInfo *di;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ di = get_info (tree_view);
+
+ if (di)
+ {
+ if (di->dest_set)
+ {
+ gtk_drag_dest_unset (GTK_WIDGET (tree_view));
+ di->dest_set = FALSE;
+ }
+
+ if (!di->dest_set && !di->source_set)
+ remove_info (tree_view);
+ }
+
+ unset_reorderable (tree_view);
+}
+
+/**
+ * pspp_sheet_view_set_drag_dest_row:
+ * @tree_view: a #PsppSheetView
+ * @path: (allow-none): The path of the row to highlight, or %NULL.
+ * @pos: Specifies whether to drop before, after or into the row
+ *
+ * Sets the row that is highlighted for feedback.
+ **/
+void
+pspp_sheet_view_set_drag_dest_row (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ PsppSheetViewDropPosition pos)
+{
+ GtkTreePath *current_dest;
+
+ /* Note; this function is exported to allow a custom DND
+ * implementation, so it can't touch TreeViewDragInfo
+ */
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ current_dest = NULL;
+
+ if (tree_view->priv->drag_dest_row)
+ {
+ current_dest = gtk_tree_row_reference_get_path
(tree_view->priv->drag_dest_row);
+ gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
+ }
+
+ /* special case a drop on an empty model */
+ tree_view->priv->empty_view_drop = 0;
+
+ if (pos == PSPP_SHEET_VIEW_DROP_BEFORE && path
+ && gtk_tree_path_get_depth (path) == 1
+ && gtk_tree_path_get_indices (path)[0] == 0)
+ {
+ gint n_children;
+
+ n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
+ NULL);
+
+ if (!n_children)
+ tree_view->priv->empty_view_drop = 1;
+ }
+
+ tree_view->priv->drag_dest_pos = pos;
+
+ if (path)
+ {
+ tree_view->priv->drag_dest_row =
+ gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
tree_view->priv->model, path);
+ pspp_sheet_view_queue_draw_path (tree_view, path, NULL);
+ }
+ else
+ tree_view->priv->drag_dest_row = NULL;
+
+ if (current_dest)
+ {
+ GtkRBTree *tree, *new_tree;
+ GtkRBNode *node, *new_node;
+
+ _pspp_sheet_view_find_node (tree_view, current_dest, &tree, &node);
+ _pspp_sheet_view_queue_draw_node (tree_view, tree, node, NULL);
+
+ if (tree && node)
+ {
+ _pspp_rbtree_next_full (tree, node, &new_tree, &new_node);
+ if (new_tree && new_node)
+ _pspp_sheet_view_queue_draw_node (tree_view, new_tree, new_node,
NULL);
+
+ _pspp_rbtree_prev_full (tree, node, &new_tree, &new_node);
+ if (new_tree && new_node)
+ _pspp_sheet_view_queue_draw_node (tree_view, new_tree, new_node,
NULL);
+ }
+ gtk_tree_path_free (current_dest);
+ }
+}
+
+/**
+ * pspp_sheet_view_get_drag_dest_row:
+ * @tree_view: a #PsppSheetView
+ * @path: (allow-none): Return location for the path of the highlighted row,
or %NULL.
+ * @pos: (allow-none): Return location for the drop position, or %NULL
+ *
+ * Gets information about the row that is highlighted for feedback.
+ **/
+void
+pspp_sheet_view_get_drag_dest_row (PsppSheetView *tree_view,
+ GtkTreePath **path,
+ PsppSheetViewDropPosition *pos)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (path)
+ {
+ if (tree_view->priv->drag_dest_row)
+ *path = gtk_tree_row_reference_get_path
(tree_view->priv->drag_dest_row);
+ else
+ {
+ if (tree_view->priv->empty_view_drop)
+ *path = gtk_tree_path_new_from_indices (0, -1);
+ else
+ *path = NULL;
+ }
+ }
+
+ if (pos)
+ *pos = tree_view->priv->drag_dest_pos;
+}
+
+/**
+ * pspp_sheet_view_get_dest_row_at_pos:
+ * @tree_view: a #PsppSheetView
+ * @drag_x: the position to determine the destination row for
+ * @drag_y: the position to determine the destination row for
+ * @path: (allow-none): Return location for the path of the highlighted row,
or %NULL.
+ * @pos: (allow-none): Return location for the drop position, or %NULL
+ *
+ * Determines the destination row for a given position. @drag_x and
+ * @drag_y are expected to be in widget coordinates. This function is only
+ * meaningful if @tree_view is realized. Therefore this function will always
+ * return %FALSE if @tree_view is not realized or does not have a model.
+ *
+ * Return value: whether there is a row at the given position, %TRUE if this
+ * is indeed the case.
+ **/
+gboolean
+pspp_sheet_view_get_dest_row_at_pos (PsppSheetView *tree_view,
+ gint drag_x,
+ gint drag_y,
+ GtkTreePath **path,
+ PsppSheetViewDropPosition *pos)
+{
+ gint cell_y;
+ gint bin_x, bin_y;
+ gdouble offset_into_row;
+ gdouble third;
+ GdkRectangle cell;
+ PsppSheetViewColumn *column = NULL;
+ GtkTreePath *tmp_path = NULL;
+
+ /* Note; this function is exported to allow a custom DND
+ * implementation, so it can't touch TreeViewDragInfo
+ */
+
+ g_return_val_if_fail (tree_view != NULL, FALSE);
+ g_return_val_if_fail (drag_x >= 0, FALSE);
+ g_return_val_if_fail (drag_y >= 0, FALSE);
+
+ if (path)
+ *path = NULL;
+
+ if (tree_view->priv->bin_window == NULL)
+ return FALSE;
+
+ if (tree_view->priv->tree == NULL)
+ return FALSE;
+
+ /* If in the top third of a row, we drop before that row; if
+ * in the bottom third, drop after that row; if in the middle,
+ * and the row has children, drop into the row.
+ */
+ pspp_sheet_view_convert_widget_to_bin_window_coords (tree_view, drag_x,
drag_y,
+ &bin_x, &bin_y);
+
+ if (!pspp_sheet_view_get_path_at_pos (tree_view,
+ bin_x,
+ bin_y,
+ &tmp_path,
+ &column,
+ NULL,
+ &cell_y))
+ return FALSE;
+
+ pspp_sheet_view_get_background_area (tree_view, tmp_path, column,
+ &cell);
+
+ offset_into_row = cell_y;
+
+ if (path)
+ *path = tmp_path;
+ else
+ gtk_tree_path_free (tmp_path);
+
+ tmp_path = NULL;
+
+ third = cell.height / 3.0;
+
+ if (pos)
+ {
+ if (offset_into_row < third)
+ {
+ *pos = PSPP_SHEET_VIEW_DROP_BEFORE;
+ }
+ else if (offset_into_row < (cell.height / 2.0))
+ {
+ *pos = PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE;
+ }
+ else if (offset_into_row < third * 2.0)
+ {
+ *pos = PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER;
+ }
+ else
+ {
+ *pos = PSPP_SHEET_VIEW_DROP_AFTER;
+ }
+ }
+
+ return TRUE;
+}
+
+
+
+/* KEEP IN SYNC WITH PSPP_SHEET_VIEW_BIN_EXPOSE */
+/**
+ * pspp_sheet_view_create_row_drag_icon:
+ * @tree_view: a #PsppSheetView
+ * @path: a #GtkTreePath in @tree_view
+ *
+ * Creates a #GdkPixmap representation of the row at @path.
+ * This image is used for a drag icon.
+ *
+ * Return value: a newly-allocated pixmap of the drag icon.
+ **/
+GdkPixmap *
+pspp_sheet_view_create_row_drag_icon (PsppSheetView *tree_view,
+ GtkTreePath *path)
+{
+ GtkTreeIter iter;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gint cell_offset;
+ GList *list;
+ GdkRectangle background_area;
+ GdkRectangle expose_area;
+ GtkWidget *widget;
+ gint depth;
+ /* start drawing inside the black outline */
+ gint x = 1, y = 1;
+ GdkDrawable *drawable;
+ gint bin_window_width;
+ gboolean is_separator = FALSE;
+ gboolean rtl;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+ g_return_val_if_fail (path != NULL, NULL);
+
+ widget = GTK_WIDGET (tree_view);
+
+ if (!gtk_widget_get_realized (widget))
+ return NULL;
+
+ depth = gtk_tree_path_get_depth (path);
+
+ _pspp_sheet_view_find_node (tree_view,
+ path,
+ &tree,
+ &node);
+
+ if (tree == NULL)
+ return NULL;
+
+ if (!gtk_tree_model_get_iter (tree_view->priv->model,
+ &iter,
+ path))
+ return NULL;
+
+ is_separator = row_is_separator (tree_view, &iter, NULL);
+
+ cell_offset = x;
+
+ background_area.y = y;
+ background_area.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
+
+ gdk_drawable_get_size (tree_view->priv->bin_window,
+ &bin_window_width, NULL);
+
+ drawable = gdk_pixmap_new (tree_view->priv->bin_window,
+ bin_window_width + 2,
+ background_area.height + 2,
+ -1);
+
+ expose_area.x = 0;
+ expose_area.y = 0;
+ expose_area.width = bin_window_width + 2;
+ expose_area.height = background_area.height + 2;
+
+ gdk_draw_rectangle (drawable,
+ widget->style->base_gc [gtk_widget_get_state (widget)],
+ TRUE,
+ 0, 0,
+ bin_window_width + 2,
+ background_area.height + 2);
+
+ rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
+
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first
(tree_view->priv->columns));
+ list;
+ list = (rtl ? list->prev : list->next))
+ {
+ PsppSheetViewColumn *column = list->data;
+ GdkRectangle cell_area;
+ gint vertical_separator;
+
+ if (!column->visible)
+ continue;
+
+ pspp_sheet_view_column_cell_set_cell_data (column,
tree_view->priv->model, &iter,
+ PSPP_RBNODE_FLAG_SET (node,
PSPP_RBNODE_IS_PARENT),
+ node->children?TRUE:FALSE);
+
+ background_area.x = cell_offset;
+ background_area.width = column->width;
+
+ gtk_widget_style_get (widget,
+ "vertical-separator", &vertical_separator,
+ NULL);
+
+ cell_area = background_area;
+
+ cell_area.y += vertical_separator / 2;
+ cell_area.height -= vertical_separator;
+
+ if (pspp_sheet_view_is_expander_column (tree_view, column))
+ {
+ if (!rtl)
+ cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
+ cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
+
+ if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
+ {
+ if (!rtl)
+ cell_area.x += depth * tree_view->priv->expander_size;
+ cell_area.width -= depth * tree_view->priv->expander_size;
+ }
+ }
+
+ if (pspp_sheet_view_column_cell_is_visible (column))
+ {
+ if (is_separator)
+ gtk_paint_hline (widget->style,
+ drawable,
+ GTK_STATE_NORMAL,
+ &cell_area,
+ widget,
+ NULL,
+ cell_area.x,
+ cell_area.x + cell_area.width,
+ cell_area.y + cell_area.height / 2);
+ else
+ _pspp_sheet_view_column_cell_render (column,
+ drawable,
+ &background_area,
+ &cell_area,
+ &expose_area,
+ 0);
+ }
+ cell_offset += column->width;
+ }
+
+ gdk_draw_rectangle (drawable,
+ widget->style->black_gc,
+ FALSE,
+ 0, 0,
+ bin_window_width + 1,
+ background_area.height + 1);
+
+ return drawable;
+}
+
+
+/**
+ * pspp_sheet_view_set_destroy_count_func:
+ * @tree_view: A #PsppSheetView
+ * @func: (allow-none): Function to be called when a view row is destroyed, or
%NULL
+ * @data: (allow-none): User data to be passed to @func, or %NULL
+ * @destroy: (allow-none): Destroy notifier for @data, or %NULL
+ *
+ * This function should almost never be used. It is meant for private use by
+ * ATK for determining the number of visible children that are removed when the
+ * user collapses a row, or a row is deleted.
+ **/
+void
+pspp_sheet_view_set_destroy_count_func (PsppSheetView *tree_view,
+ PsppSheetDestroyCountFunc func,
+ gpointer data,
+ GDestroyNotify destroy)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (tree_view->priv->destroy_count_destroy)
+ tree_view->priv->destroy_count_destroy
(tree_view->priv->destroy_count_data);
+
+ tree_view->priv->destroy_count_func = func;
+ tree_view->priv->destroy_count_data = data;
+ tree_view->priv->destroy_count_destroy = destroy;
+}
+
+
+/*
+ * Interactive search
+ */
+
+/**
+ * pspp_sheet_view_set_enable_search:
+ * @tree_view: A #PsppSheetView
+ * @enable_search: %TRUE, if the user can search interactively
+ *
+ * If @enable_search is set, then the user can type in text to search through
+ * the tree interactively (this is sometimes called "typeahead find").
+ *
+ * Note that even if this is %FALSE, the user can still initiate a search
+ * using the "start-interactive-search" key binding.
+ */
+void
+pspp_sheet_view_set_enable_search (PsppSheetView *tree_view,
+ gboolean enable_search)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ enable_search = !!enable_search;
+
+ if (tree_view->priv->enable_search != enable_search)
+ {
+ tree_view->priv->enable_search = enable_search;
+ g_object_notify (G_OBJECT (tree_view), "enable-search");
+ }
+}
+
+/**
+ * pspp_sheet_view_get_enable_search:
+ * @tree_view: A #PsppSheetView
+ *
+ * Returns whether or not the tree allows to start interactive searching
+ * by typing in text.
+ *
+ * Return value: whether or not to let the user search interactively
+ */
+gboolean
+pspp_sheet_view_get_enable_search (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ return tree_view->priv->enable_search;
+}
+
+
+/**
+ * pspp_sheet_view_get_search_column:
+ * @tree_view: A #PsppSheetView
+ *
+ * Gets the column searched on by the interactive search code.
+ *
+ * Return value: the column the interactive search code searches in.
+ */
+gint
+pspp_sheet_view_get_search_column (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
+
+ return (tree_view->priv->search_column);
+}
+
+/**
+ * pspp_sheet_view_set_search_column:
+ * @tree_view: A #PsppSheetView
+ * @column: the column of the model to search in, or -1 to disable searching
+ *
+ * Sets @column as the column where the interactive search code should
+ * search in for the current model.
+ *
+ * If the search column is set, users can use the "start-interactive-search"
+ * key binding to bring up search popup. The enable-search property controls
+ * whether simply typing text will also start an interactive search.
+ *
+ * Note that @column refers to a column of the current model. The search
+ * column is reset to -1 when the model is changed.
+ */
+void
+pspp_sheet_view_set_search_column (PsppSheetView *tree_view,
+ gint column)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (column >= -1);
+
+ if (tree_view->priv->search_column == column)
+ return;
+
+ tree_view->priv->search_column = column;
+ g_object_notify (G_OBJECT (tree_view), "search-column");
+}
+
+/**
+ * pspp_sheet_view_get_search_equal_func:
+ * @tree_view: A #PsppSheetView
+ *
+ * Returns the compare function currently in use.
+ *
+ * Return value: the currently used compare function for the search code.
+ */
+
+PsppSheetViewSearchEqualFunc
+pspp_sheet_view_get_search_equal_func (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ return tree_view->priv->search_equal_func;
+}
+
+/**
+ * pspp_sheet_view_set_search_equal_func:
+ * @tree_view: A #PsppSheetView
+ * @search_equal_func: the compare function to use during the search
+ * @search_user_data: (allow-none): user data to pass to @search_equal_func,
or %NULL
+ * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or
%NULL
+ *
+ * Sets the compare function for the interactive search capabilities; note
+ * that somewhat like strcmp() returning 0 for equality
+ * #PsppSheetViewSearchEqualFunc returns %FALSE on matches.
+ **/
+void
+pspp_sheet_view_set_search_equal_func (PsppSheetView *tree_view,
+ PsppSheetViewSearchEqualFunc
search_equal_func,
+ gpointer
search_user_data,
+ GDestroyNotify search_destroy)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (search_equal_func != NULL);
+
+ if (tree_view->priv->search_destroy)
+ tree_view->priv->search_destroy (tree_view->priv->search_user_data);
+
+ tree_view->priv->search_equal_func = search_equal_func;
+ tree_view->priv->search_user_data = search_user_data;
+ tree_view->priv->search_destroy = search_destroy;
+ if (tree_view->priv->search_equal_func == NULL)
+ tree_view->priv->search_equal_func = pspp_sheet_view_search_equal_func;
+}
+
+/**
+ * pspp_sheet_view_get_search_entry:
+ * @tree_view: A #PsppSheetView
+ *
+ * Returns the #GtkEntry which is currently in use as interactive search
+ * entry for @tree_view. In case the built-in entry is being used, %NULL
+ * will be returned.
+ *
+ * Return value: the entry currently in use as search entry.
+ *
+ * Since: 2.10
+ */
+GtkEntry *
+pspp_sheet_view_get_search_entry (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ if (tree_view->priv->search_custom_entry_set)
+ return GTK_ENTRY (tree_view->priv->search_entry);
+
+ return NULL;
+}
+
+/**
+ * pspp_sheet_view_set_search_entry:
+ * @tree_view: A #PsppSheetView
+ * @entry: (allow-none): the entry the interactive search code of @tree_view
should use or %NULL
+ *
+ * Sets the entry which the interactive search code will use for this
+ * @tree_view. This is useful when you want to provide a search entry
+ * in our interface at all time at a fixed position. Passing %NULL for
+ * @entry will make the interactive search code use the built-in popup
+ * entry again.
+ *
+ * Since: 2.10
+ */
+void
+pspp_sheet_view_set_search_entry (PsppSheetView *tree_view,
+ GtkEntry *entry)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
+
+ if (tree_view->priv->search_custom_entry_set)
+ {
+ if (tree_view->priv->search_entry_changed_id)
+ {
+ g_signal_handler_disconnect (tree_view->priv->search_entry,
+
tree_view->priv->search_entry_changed_id);
+ tree_view->priv->search_entry_changed_id = 0;
+ }
+ g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
+ G_CALLBACK
(pspp_sheet_view_search_key_press_event),
+ tree_view);
+
+ g_object_unref (tree_view->priv->search_entry);
+ }
+ else if (tree_view->priv->search_window)
+ {
+ gtk_widget_destroy (tree_view->priv->search_window);
+
+ tree_view->priv->search_window = NULL;
+ }
+
+ if (entry)
+ {
+ tree_view->priv->search_entry = g_object_ref (entry);
+ tree_view->priv->search_custom_entry_set = TRUE;
+
+ if (tree_view->priv->search_entry_changed_id == 0)
+ {
+ tree_view->priv->search_entry_changed_id =
+ g_signal_connect (tree_view->priv->search_entry, "changed",
+ G_CALLBACK (pspp_sheet_view_search_init),
+ tree_view);
+ }
+
+ g_signal_connect (tree_view->priv->search_entry, "key-press-event",
+ G_CALLBACK (pspp_sheet_view_search_key_press_event),
+ tree_view);
+
+ pspp_sheet_view_search_init (tree_view->priv->search_entry, tree_view);
+ }
+ else
+ {
+ tree_view->priv->search_entry = NULL;
+ tree_view->priv->search_custom_entry_set = FALSE;
+ }
+}
+
+/**
+ * pspp_sheet_view_set_search_position_func:
+ * @tree_view: A #PsppSheetView
+ * @func: (allow-none): the function to use to position the search dialog, or
%NULL
+ * to use the default search position function
+ * @data: (allow-none): user data to pass to @func, or %NULL
+ * @destroy: (allow-none): Destroy notifier for @data, or %NULL
+ *
+ * Sets the function to use when positioning the search dialog.
+ *
+ * Since: 2.10
+ **/
+void
+pspp_sheet_view_set_search_position_func (PsppSheetView
*tree_view,
+ PsppSheetViewSearchPositionFunc func,
+ gpointer
user_data,
+ GDestroyNotify destroy)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (tree_view->priv->search_position_destroy)
+ tree_view->priv->search_position_destroy
(tree_view->priv->search_position_user_data);
+
+ tree_view->priv->search_position_func = func;
+ tree_view->priv->search_position_user_data = user_data;
+ tree_view->priv->search_position_destroy = destroy;
+ if (tree_view->priv->search_position_func == NULL)
+ tree_view->priv->search_position_func =
pspp_sheet_view_search_position_func;
+}
+
+/**
+ * pspp_sheet_view_get_search_position_func:
+ * @tree_view: A #PsppSheetView
+ *
+ * Returns the positioning function currently in use.
+ *
+ * Return value: the currently used function for positioning the search dialog.
+ *
+ * Since: 2.10
+ */
+PsppSheetViewSearchPositionFunc
+pspp_sheet_view_get_search_position_func (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ return tree_view->priv->search_position_func;
+}
+
+
+static void
+pspp_sheet_view_search_dialog_hide (GtkWidget *search_dialog,
+ PsppSheetView *tree_view)
+{
+ if (tree_view->priv->disable_popdown)
+ return;
+
+ if (tree_view->priv->search_entry_changed_id)
+ {
+ g_signal_handler_disconnect (tree_view->priv->search_entry,
+ tree_view->priv->search_entry_changed_id);
+ tree_view->priv->search_entry_changed_id = 0;
+ }
+ if (tree_view->priv->typeselect_flush_timeout)
+ {
+ g_source_remove (tree_view->priv->typeselect_flush_timeout);
+ tree_view->priv->typeselect_flush_timeout = 0;
+ }
+
+ if (gtk_widget_get_visible (search_dialog))
+ {
+ /* send focus-in event */
+ send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), FALSE);
+ gtk_widget_hide (search_dialog);
+ gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
+ send_focus_change (GTK_WIDGET (tree_view), TRUE);
+ }
+}
+
+static void
+pspp_sheet_view_search_position_func (PsppSheetView *tree_view,
+ GtkWidget *search_dialog,
+ gpointer user_data)
+{
+ gint x, y;
+ gint tree_x, tree_y;
+ gint tree_width, tree_height;
+ GdkWindow *tree_window = GTK_WIDGET (tree_view)->window;
+ GdkScreen *screen = gdk_drawable_get_screen (tree_window);
+ GtkRequisition requisition;
+ gint monitor_num;
+ GdkRectangle monitor;
+
+ monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
+ gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+
+ gtk_widget_realize (search_dialog);
+
+ gdk_window_get_origin (tree_window, &tree_x, &tree_y);
+ gdk_drawable_get_size (tree_window,
+ &tree_width,
+ &tree_height);
+ gtk_widget_size_request (search_dialog, &requisition);
+
+ if (tree_x + tree_width > gdk_screen_get_width (screen))
+ x = gdk_screen_get_width (screen) - requisition.width;
+ else if (tree_x + tree_width - requisition.width < 0)
+ x = 0;
+ else
+ x = tree_x + tree_width - requisition.width;
+
+ if (tree_y + tree_height + requisition.height > gdk_screen_get_height
(screen))
+ y = gdk_screen_get_height (screen) - requisition.height;
+ else if (tree_y + tree_height < 0) /* isn't really possible ... */
+ y = 0;
+ else
+ y = tree_y + tree_height;
+
+ gtk_window_move (GTK_WINDOW (search_dialog), x, y);
+}
+
+static void
+pspp_sheet_view_search_disable_popdown (GtkEntry *entry,
+ GtkMenu *menu,
+ gpointer data)
+{
+ PsppSheetView *tree_view = (PsppSheetView *)data;
+
+ tree_view->priv->disable_popdown = 1;
+ g_signal_connect (menu, "hide",
+ G_CALLBACK (pspp_sheet_view_search_enable_popdown), data);
+}
+
+/* Because we're visible but offscreen, we just set a flag in the preedit
+ * callback.
+ */
+static void
+pspp_sheet_view_search_preedit_changed (GtkIMContext *im_context,
+ PsppSheetView *tree_view)
+{
+ tree_view->priv->imcontext_changed = 1;
+ if (tree_view->priv->typeselect_flush_timeout)
+ {
+ g_source_remove (tree_view->priv->typeselect_flush_timeout);
+ tree_view->priv->typeselect_flush_timeout =
+ gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
+ tree_view);
+ }
+
+}
+
+static void
+pspp_sheet_view_search_activate (GtkEntry *entry,
+ PsppSheetView *tree_view)
+{
+ GtkTreePath *path;
+ GtkRBNode *node;
+ GtkRBTree *tree;
+
+ pspp_sheet_view_search_dialog_hide (tree_view->priv->search_window,
+ tree_view);
+
+ /* If we have a row selected and it's the cursor row, we activate
+ * the row XXX */
+ if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ {
+ path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+
+ _pspp_sheet_view_find_node (tree_view, path, &tree, &node);
+
+ if (node && PSPP_RBNODE_FLAG_SET (node, PSPP_RBNODE_IS_SELECTED))
+ pspp_sheet_view_row_activated (tree_view, path,
tree_view->priv->focus_column);
+
+ gtk_tree_path_free (path);
+ }
+}
+
+static gboolean
+pspp_sheet_view_real_search_enable_popdown (gpointer data)
+{
+ PsppSheetView *tree_view = (PsppSheetView *)data;
+
+ tree_view->priv->disable_popdown = 0;
+
+ return FALSE;
+}
+
+static void
+pspp_sheet_view_search_enable_popdown (GtkWidget *widget,
+ gpointer data)
+{
+ gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200,
pspp_sheet_view_real_search_enable_popdown, g_object_ref (data),
g_object_unref);
+}
+
+static gboolean
+pspp_sheet_view_search_delete_event (GtkWidget *widget,
+ GdkEventAny *event,
+ PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ pspp_sheet_view_search_dialog_hide (widget, tree_view);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_search_button_press_event (GtkWidget *widget,
+ GdkEventButton *event,
+ PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ pspp_sheet_view_search_dialog_hide (widget, tree_view);
+
+ if (event->window == tree_view->priv->bin_window)
+ pspp_sheet_view_button_press (GTK_WIDGET (tree_view), event);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_search_scroll_event (GtkWidget *widget,
+ GdkEventScroll *event,
+ PsppSheetView *tree_view)
+{
+ gboolean retval = FALSE;
+
+ if (event->direction == GDK_SCROLL_UP)
+ {
+ pspp_sheet_view_search_move (widget, tree_view, TRUE);
+ retval = TRUE;
+ }
+ else if (event->direction == GDK_SCROLL_DOWN)
+ {
+ pspp_sheet_view_search_move (widget, tree_view, FALSE);
+ retval = TRUE;
+ }
+
+ /* renew the flush timeout */
+ if (retval && tree_view->priv->typeselect_flush_timeout
+ && !tree_view->priv->search_custom_entry_set)
+ {
+ g_source_remove (tree_view->priv->typeselect_flush_timeout);
+ tree_view->priv->typeselect_flush_timeout =
+ gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
+ tree_view);
+ }
+
+ return retval;
+}
+
+static gboolean
+pspp_sheet_view_search_key_press_event (GtkWidget *widget,
+ GdkEventKey *event,
+ PsppSheetView *tree_view)
+{
+ gboolean retval = FALSE;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ /* close window and cancel the search */
+ if (!tree_view->priv->search_custom_entry_set
+ && (event->keyval == GDK_Escape ||
+ event->keyval == GDK_Tab ||
+ event->keyval == GDK_KP_Tab ||
+ event->keyval == GDK_ISO_Left_Tab))
+ {
+ pspp_sheet_view_search_dialog_hide (widget, tree_view);
+ return TRUE;
+ }
+
+ /* select previous matching iter */
+ if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
+ {
+ if (!pspp_sheet_view_search_move (widget, tree_view, TRUE))
+ gtk_widget_error_bell (widget);
+
+ retval = TRUE;
+ }
+
+ if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) ==
(GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK))
+ && (event->keyval == GDK_g || event->keyval == GDK_G))
+ {
+ if (!pspp_sheet_view_search_move (widget, tree_view, TRUE))
+ gtk_widget_error_bell (widget);
+
+ retval = TRUE;
+ }
+
+ /* select next matching iter */
+ if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
+ {
+ if (!pspp_sheet_view_search_move (widget, tree_view, FALSE))
+ gtk_widget_error_bell (widget);
+
+ retval = TRUE;
+ }
+
+ if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) ==
GTK_DEFAULT_ACCEL_MOD_MASK)
+ && (event->keyval == GDK_g || event->keyval == GDK_G))
+ {
+ if (!pspp_sheet_view_search_move (widget, tree_view, FALSE))
+ gtk_widget_error_bell (widget);
+
+ retval = TRUE;
+ }
+
+ /* renew the flush timeout */
+ if (retval && tree_view->priv->typeselect_flush_timeout
+ && !tree_view->priv->search_custom_entry_set)
+ {
+ g_source_remove (tree_view->priv->typeselect_flush_timeout);
+ tree_view->priv->typeselect_flush_timeout =
+ gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
+ tree_view);
+ }
+
+ return retval;
+}
+
+/* this function returns FALSE if there is a search string but
+ * nothing was found, and TRUE otherwise.
+ */
+static gboolean
+pspp_sheet_view_search_move (GtkWidget *window,
+ PsppSheetView *tree_view,
+ gboolean up)
+{
+ gboolean ret;
+ gint len;
+ gint count = 0;
+ const gchar *text;
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ PsppSheetSelection *selection;
+
+ text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
+
+ g_return_val_if_fail (text != NULL, FALSE);
+
+ len = strlen (text);
+
+ if (up && tree_view->priv->selected_iter == 1)
+ return strlen (text) < 1;
+
+ len = strlen (text);
+
+ if (len < 1)
+ return TRUE;
+
+ model = pspp_sheet_view_get_model (tree_view);
+ selection = pspp_sheet_view_get_selection (tree_view);
+
+ /* search */
+ pspp_sheet_selection_unselect_all (selection);
+ if (!gtk_tree_model_get_iter_first (model, &iter))
+ return TRUE;
+
+ ret = pspp_sheet_view_search_iter (model, selection, &iter, text,
+ &count, up?((tree_view->priv->selected_iter)
- 1):((tree_view->priv->selected_iter + 1)));
+
+ if (ret)
+ {
+ /* found */
+ tree_view->priv->selected_iter += up?(-1):(1);
+ return TRUE;
+ }
+ else
+ {
+ /* return to old iter */
+ count = 0;
+ gtk_tree_model_get_iter_first (model, &iter);
+ pspp_sheet_view_search_iter (model, selection,
+ &iter, text,
+ &count, tree_view->priv->selected_iter);
+ return FALSE;
+ }
+}
+
+static gboolean
+pspp_sheet_view_search_equal_func (GtkTreeModel *model,
+ gint column,
+ const gchar *key,
+ GtkTreeIter *iter,
+ gpointer search_data)
+{
+ gboolean retval = TRUE;
+ const gchar *str;
+ gchar *normalized_string;
+ gchar *normalized_key;
+ gchar *case_normalized_string = NULL;
+ gchar *case_normalized_key = NULL;
+ GValue value = {0,};
+ GValue transformed = {0,};
+
+ gtk_tree_model_get_value (model, iter, column, &value);
+
+ g_value_init (&transformed, G_TYPE_STRING);
+
+ if (!g_value_transform (&value, &transformed))
+ {
+ g_value_unset (&value);
+ return TRUE;
+ }
+
+ g_value_unset (&value);
+
+ str = g_value_get_string (&transformed);
+ if (!str)
+ {
+ g_value_unset (&transformed);
+ return TRUE;
+ }
+
+ normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
+ normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
+
+ if (normalized_string && normalized_key)
+ {
+ case_normalized_string = g_utf8_casefold (normalized_string, -1);
+ case_normalized_key = g_utf8_casefold (normalized_key, -1);
+
+ if (strncmp (case_normalized_key, case_normalized_string, strlen
(case_normalized_key)) == 0)
+ retval = FALSE;
+ }
+
+ g_value_unset (&transformed);
+ g_free (normalized_key);
+ g_free (normalized_string);
+ g_free (case_normalized_key);
+ g_free (case_normalized_string);
+
+ return retval;
+}
+
+static gboolean
+pspp_sheet_view_search_iter (GtkTreeModel *model,
+ PsppSheetSelection *selection,
+ GtkTreeIter *iter,
+ const gchar *text,
+ gint *count,
+ gint n)
+{
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ GtkTreePath *path;
+
+ PsppSheetView *tree_view = pspp_sheet_selection_get_tree_view (selection);
+
+ path = gtk_tree_model_get_path (model, iter);
+ _pspp_sheet_view_find_node (tree_view, path, &tree, &node);
+
+ do
+ {
+ if (! tree_view->priv->search_equal_func (model,
tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
+ {
+ (*count)++;
+ if (*count == n)
+ {
+ pspp_sheet_view_scroll_to_cell (tree_view, path, NULL,
+ TRUE, 0.5, 0.0);
+ pspp_sheet_selection_select_iter (selection, iter);
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+
+ if (path)
+ gtk_tree_path_free (path);
+
+ return TRUE;
+ }
+ }
+
+ if (node->children)
+ {
+ gboolean has_child;
+ GtkTreeIter tmp;
+
+ tree = node->children;
+ node = tree->root;
+
+ while (node->left != tree->nil)
+ node = node->left;
+
+ tmp = *iter;
+ has_child = gtk_tree_model_iter_children (model, iter, &tmp);
+ gtk_tree_path_down (path);
+
+ /* sanity check */
+ TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
+ }
+ else
+ {
+ gboolean done = FALSE;
+
+ do
+ {
+ node = _pspp_rbtree_next (tree, node);
+
+ if (node)
+ {
+ gboolean has_next;
+
+ has_next = gtk_tree_model_iter_next (model, iter);
+
+ done = TRUE;
+ gtk_tree_path_next (path);
+
+ /* sanity check */
+ TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
+ }
+ else
+ {
+ gboolean has_parent;
+ GtkTreeIter tmp_iter = *iter;
+
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+
+ if (!tree)
+ {
+ if (path)
+ gtk_tree_path_free (path);
+
+ /* we've run out of tree, done with this func */
+ return FALSE;
+ }
+
+ has_parent = gtk_tree_model_iter_parent (model,
+ iter,
+ &tmp_iter);
+ gtk_tree_path_up (path);
+
+ /* sanity check */
+ TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
+ }
+ }
+ while (!done);
+ }
+ }
+ while (1);
+
+ return FALSE;
+}
+
+static void
+pspp_sheet_view_search_init (GtkWidget *entry,
+ PsppSheetView *tree_view)
+{
+ gint ret;
+ gint count = 0;
+ const gchar *text;
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ PsppSheetSelection *selection;
+
+ g_return_if_fail (GTK_IS_ENTRY (entry));
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ text = gtk_entry_get_text (GTK_ENTRY (entry));
+
+ model = pspp_sheet_view_get_model (tree_view);
+ selection = pspp_sheet_view_get_selection (tree_view);
+
+ /* search */
+ pspp_sheet_selection_unselect_all (selection);
+ if (tree_view->priv->typeselect_flush_timeout
+ && !tree_view->priv->search_custom_entry_set)
+ {
+ g_source_remove (tree_view->priv->typeselect_flush_timeout);
+ tree_view->priv->typeselect_flush_timeout =
+ gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
+ tree_view);
+ }
+
+ if (*text == '\0')
+ return;
+
+ if (!gtk_tree_model_get_iter_first (model, &iter))
+ return;
+
+ ret = pspp_sheet_view_search_iter (model, selection,
+ &iter, text,
+ &count, 1);
+
+ if (ret)
+ tree_view->priv->selected_iter = 1;
+}
+
+static void
+pspp_sheet_view_remove_widget (GtkCellEditable *cell_editable,
+ PsppSheetView *tree_view)
+{
+ if (tree_view->priv->edited_column == NULL)
+ return;
+
+ _pspp_sheet_view_column_stop_editing (tree_view->priv->edited_column);
+ tree_view->priv->edited_column = NULL;
+
+ if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+
+ g_signal_handlers_disconnect_by_func (cell_editable,
+ pspp_sheet_view_remove_widget,
+ tree_view);
+
+ gtk_container_remove (GTK_CONTAINER (tree_view),
+ GTK_WIDGET (cell_editable));
+
+ /* FIXME should only redraw a single node */
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+}
+
+static gboolean
+pspp_sheet_view_start_editing (PsppSheetView *tree_view,
+ GtkTreePath *cursor_path)
+{
+ GtkTreeIter iter;
+ GdkRectangle background_area;
+ GdkRectangle cell_area;
+ GtkCellEditable *editable_widget = NULL;
+ gchar *path_string;
+ guint flags = 0; /* can be 0, as the flags are primarily for rendering */
+ gint retval = FALSE;
+ GtkRBTree *cursor_tree;
+ GtkRBNode *cursor_node;
+
+ g_assert (tree_view->priv->focus_column);
+
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
+ return FALSE;
+
+ if (_pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_tree,
&cursor_node) ||
+ cursor_node == NULL)
+ return FALSE;
+
+ path_string = gtk_tree_path_to_string (cursor_path);
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
+
+ validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
+
+ pspp_sheet_view_column_cell_set_cell_data (tree_view->priv->focus_column,
+ tree_view->priv->model,
+ &iter,
+ PSPP_RBNODE_FLAG_SET (cursor_node,
PSPP_RBNODE_IS_PARENT),
+ cursor_node->children?TRUE:FALSE);
+ pspp_sheet_view_get_background_area (tree_view,
+ cursor_path,
+ tree_view->priv->focus_column,
+ &background_area);
+ pspp_sheet_view_get_cell_area (tree_view,
+ cursor_path,
+ tree_view->priv->focus_column,
+ &cell_area);
+
+ if (_pspp_sheet_view_column_cell_event (tree_view->priv->focus_column,
+ &editable_widget,
+ NULL,
+ path_string,
+ &background_area,
+ &cell_area,
+ flags))
+ {
+ retval = TRUE;
+ if (editable_widget != NULL)
+ {
+ gint left, right;
+ GdkRectangle area;
+ GtkCellRenderer *cell;
+
+ area = cell_area;
+ cell = _pspp_sheet_view_column_get_edited_cell
(tree_view->priv->focus_column);
+
+ _pspp_sheet_view_column_get_neighbor_sizes
(tree_view->priv->focus_column, cell, &left, &right);
+
+ area.x += left;
+ area.width -= right + left;
+
+ pspp_sheet_view_real_start_editing (tree_view,
+ tree_view->priv->focus_column,
+ cursor_path,
+ editable_widget,
+ &area,
+ NULL,
+ flags);
+ }
+
+ }
+ g_free (path_string);
+ return retval;
+}
+
+static void
+pspp_sheet_view_real_start_editing (PsppSheetView *tree_view,
+ PsppSheetViewColumn *column,
+ GtkTreePath *path,
+ GtkCellEditable *cell_editable,
+ GdkRectangle *cell_area,
+ GdkEvent *event,
+ guint flags)
+{
+ gint pre_val = tree_view->priv->vadjustment->value;
+ GtkRequisition requisition;
+
+ tree_view->priv->edited_column = column;
+ _pspp_sheet_view_column_start_editing (column, GTK_CELL_EDITABLE
(cell_editable));
+
+ pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ cell_area->y += pre_val - (int)tree_view->priv->vadjustment->value;
+
+ gtk_widget_size_request (GTK_WIDGET (cell_editable), &requisition);
+
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
+
+ if (requisition.height < cell_area->height)
+ {
+ gint diff = cell_area->height - requisition.height;
+ pspp_sheet_view_put (tree_view,
+ GTK_WIDGET (cell_editable),
+ cell_area->x, cell_area->y + diff/2,
+ cell_area->width, requisition.height);
+ }
+ else
+ {
+ pspp_sheet_view_put (tree_view,
+ GTK_WIDGET (cell_editable),
+ cell_area->x, cell_area->y,
+ cell_area->width, cell_area->height);
+ }
+
+ gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (cell_editable),
+ (GdkEvent *)event);
+
+ gtk_widget_grab_focus (GTK_WIDGET (cell_editable));
+ g_signal_connect (cell_editable, "remove-widget",
+ G_CALLBACK (pspp_sheet_view_remove_widget), tree_view);
+}
+
+static void
+pspp_sheet_view_stop_editing (PsppSheetView *tree_view,
+ gboolean cancel_editing)
+{
+ PsppSheetViewColumn *column;
+ GtkCellRenderer *cell;
+
+ if (tree_view->priv->edited_column == NULL)
+ return;
+
+ /*
+ * This is very evil. We need to do this, because
+ * gtk_cell_editable_editing_done may trigger pspp_sheet_view_row_changed
+ * later on. If pspp_sheet_view_row_changed notices
+ * tree_view->priv->edited_column != NULL, it'll call
+ * pspp_sheet_view_stop_editing again. Bad things will happen then.
+ *
+ * Please read that again if you intend to modify anything here.
+ */
+
+ column = tree_view->priv->edited_column;
+ tree_view->priv->edited_column = NULL;
+
+ cell = _pspp_sheet_view_column_get_edited_cell (column);
+ gtk_cell_renderer_stop_editing (cell, cancel_editing);
+
+ if (!cancel_editing)
+ gtk_cell_editable_editing_done (column->editable_widget);
+
+ tree_view->priv->edited_column = column;
+
+ gtk_cell_editable_remove_widget (column->editable_widget);
+}
+
+
+/**
+ * pspp_sheet_view_set_hover_selection:
+ * @tree_view: a #PsppSheetView
+ * @hover: %TRUE to enable hover selection mode
+ *
+ * Enables of disables the hover selection mode of @tree_view.
+ * Hover selection makes the selected row follow the pointer.
+ * Currently, this works only for the selection modes
+ * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+ *
+ * Since: 2.6
+ **/
+void
+pspp_sheet_view_set_hover_selection (PsppSheetView *tree_view,
+ gboolean hover)
+{
+ hover = hover != FALSE;
+
+ if (hover != tree_view->priv->hover_selection)
+ {
+ tree_view->priv->hover_selection = hover;
+
+ g_object_notify (G_OBJECT (tree_view), "hover-selection");
+ }
+}
+
+/**
+ * pspp_sheet_view_get_hover_selection:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns whether hover selection mode is turned on for @tree_view.
+ *
+ * Return value: %TRUE if @tree_view is in hover selection mode
+ *
+ * Since: 2.6
+ **/
+gboolean
+pspp_sheet_view_get_hover_selection (PsppSheetView *tree_view)
+{
+ return tree_view->priv->hover_selection;
+}
+
+/**
+ * pspp_sheet_view_set_hover_expand:
+ * @tree_view: a #PsppSheetView
+ * @expand: %TRUE to enable hover selection mode
+ *
+ * Enables of disables the hover expansion mode of @tree_view.
+ * Hover expansion makes rows expand or collapse if the pointer
+ * moves over them.
+ *
+ * Since: 2.6
+ **/
+void
+pspp_sheet_view_set_hover_expand (PsppSheetView *tree_view,
+ gboolean expand)
+{
+ expand = expand != FALSE;
+
+ if (expand != tree_view->priv->hover_expand)
+ {
+ tree_view->priv->hover_expand = expand;
+
+ g_object_notify (G_OBJECT (tree_view), "hover-expand");
+ }
+}
+
+/**
+ * pspp_sheet_view_get_hover_expand:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns whether hover expansion mode is turned on for @tree_view.
+ *
+ * Return value: %TRUE if @tree_view is in hover expansion mode
+ *
+ * Since: 2.6
+ **/
+gboolean
+pspp_sheet_view_get_hover_expand (PsppSheetView *tree_view)
+{
+ return tree_view->priv->hover_expand;
+}
+
+/**
+ * pspp_sheet_view_set_rubber_banding:
+ * @tree_view: a #PsppSheetView
+ * @enable: %TRUE to enable rubber banding
+ *
+ * Enables or disables rubber banding in @tree_view. If the selection mode
+ * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
+ * multiple rows by dragging the mouse.
+ *
+ * Since: 2.10
+ **/
+void
+pspp_sheet_view_set_rubber_banding (PsppSheetView *tree_view,
+ gboolean enable)
+{
+ enable = enable != FALSE;
+
+ if (enable != tree_view->priv->rubber_banding_enable)
+ {
+ tree_view->priv->rubber_banding_enable = enable;
+
+ g_object_notify (G_OBJECT (tree_view), "rubber-banding");
+ }
+}
+
+/**
+ * pspp_sheet_view_get_rubber_banding:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns whether rubber banding is turned on for @tree_view. If the
+ * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
+ * user to select multiple rows by dragging the mouse.
+ *
+ * Return value: %TRUE if rubber banding in @tree_view is enabled.
+ *
+ * Since: 2.10
+ **/
+gboolean
+pspp_sheet_view_get_rubber_banding (PsppSheetView *tree_view)
+{
+ return tree_view->priv->rubber_banding_enable;
+}
+
+/**
+ * pspp_sheet_view_is_rubber_banding_active:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns whether a rubber banding operation is currently being done
+ * in @tree_view.
+ *
+ * Return value: %TRUE if a rubber banding operation is currently being
+ * done in @tree_view.
+ *
+ * Since: 2.12
+ **/
+gboolean
+pspp_sheet_view_is_rubber_banding_active (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ if (tree_view->priv->rubber_banding_enable
+ && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
+ return TRUE;
+
+ return FALSE;
+}
+
+/**
+ * pspp_sheet_view_get_row_separator_func:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns the current row separator function.
+ *
+ * Return value: the current row separator function.
+ *
+ * Since: 2.6
+ **/
+PsppSheetViewRowSeparatorFunc
+pspp_sheet_view_get_row_separator_func (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
+
+ return tree_view->priv->row_separator_func;
+}
+
+/**
+ * pspp_sheet_view_set_row_separator_func:
+ * @tree_view: a #PsppSheetView
+ * @func: a #PsppSheetViewRowSeparatorFunc
+ * @data: (allow-none): user data to pass to @func, or %NULL
+ * @destroy: (allow-none): destroy notifier for @data, or %NULL
+ *
+ * Sets the row separator function, which is used to determine
+ * whether a row should be drawn as a separator. If the row separator
+ * function is %NULL, no separators are drawn. This is the default value.
+ *
+ * Since: 2.6
+ **/
+void
+pspp_sheet_view_set_row_separator_func (PsppSheetView
*tree_view,
+ PsppSheetViewRowSeparatorFunc func,
+ gpointer data,
+ GDestroyNotify destroy)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (tree_view->priv->row_separator_destroy)
+ tree_view->priv->row_separator_destroy
(tree_view->priv->row_separator_data);
+
+ tree_view->priv->row_separator_func = func;
+ tree_view->priv->row_separator_data = data;
+ tree_view->priv->row_separator_destroy = destroy;
+
+ /* Have the tree recalculate heights */
+ _pspp_rbtree_mark_invalid (tree_view->priv->tree);
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+}
+
+
+static void
+pspp_sheet_view_grab_notify (GtkWidget *widget,
+ gboolean was_grabbed)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+
+ tree_view->priv->in_grab = !was_grabbed;
+
+ if (!was_grabbed)
+ {
+ tree_view->priv->pressed_button = -1;
+
+ if (tree_view->priv->rubber_band_status)
+ pspp_sheet_view_stop_rubber_band (tree_view);
+ }
+}
+
+static void
+pspp_sheet_view_state_changed (GtkWidget *widget,
+ GtkStateType previous_state)
+{
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+
+ if (gtk_widget_get_realized (widget))
+ {
+ gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
+ gdk_window_set_background (tree_view->priv->bin_window,
&widget->style->base[widget->state]);
+ }
+
+ gtk_widget_queue_draw (widget);
+}
+
+/**
+ * pspp_sheet_view_get_grid_lines:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns which grid lines are enabled in @tree_view.
+ *
+ * Return value: a #PsppSheetViewGridLines value indicating which grid lines
+ * are enabled.
+ *
+ * Since: 2.10
+ */
+PsppSheetViewGridLines
+pspp_sheet_view_get_grid_lines (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), 0);
+
+ return tree_view->priv->grid_lines;
+}
+
+/**
+ * pspp_sheet_view_set_grid_lines:
+ * @tree_view: a #PsppSheetView
+ * @grid_lines: a #PsppSheetViewGridLines value indicating which grid lines to
+ * enable.
+ *
+ * Sets which grid lines to draw in @tree_view.
+ *
+ * Since: 2.10
+ */
+void
+pspp_sheet_view_set_grid_lines (PsppSheetView *tree_view,
+ PsppSheetViewGridLines grid_lines)
+{
+ PsppSheetViewPrivate *priv;
+ GtkWidget *widget;
+ PsppSheetViewGridLines old_grid_lines;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ priv = tree_view->priv;
+ widget = GTK_WIDGET (tree_view);
+
+ old_grid_lines = priv->grid_lines;
+ priv->grid_lines = grid_lines;
+
+ if (gtk_widget_get_realized (widget))
+ {
+ if (grid_lines == PSPP_SHEET_VIEW_GRID_LINES_NONE &&
+ priv->grid_line_gc)
+ {
+ g_object_unref (priv->grid_line_gc);
+ priv->grid_line_gc = NULL;
+ }
+
+ if (grid_lines != PSPP_SHEET_VIEW_GRID_LINES_NONE &&
+ !priv->grid_line_gc)
+ {
+ gint line_width;
+ gint8 *dash_list;
+
+ gtk_widget_style_get (widget,
+ "grid-line-width", &line_width,
+ "grid-line-pattern", (gchar *)&dash_list,
+ NULL);
+
+ priv->grid_line_gc = gdk_gc_new (widget->window);
+ gdk_gc_copy (priv->grid_line_gc, widget->style->black_gc);
+
+ gdk_gc_set_line_attributes (priv->grid_line_gc, line_width,
+ GDK_LINE_ON_OFF_DASH,
+ GDK_CAP_BUTT, GDK_JOIN_MITER);
+ gdk_gc_set_dashes (priv->grid_line_gc, 0, dash_list, 2);
+
+ g_free (dash_list);
+ }
+ }
+
+ if (old_grid_lines != grid_lines)
+ {
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+
+ g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
+ }
+}
+
+/**
+ * pspp_sheet_view_get_enable_tree_lines:
+ * @tree_view: a #PsppSheetView.
+ *
+ * Returns whether or not tree lines are drawn in @tree_view.
+ *
+ * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
+ * otherwise.
+ *
+ * Since: 2.10
+ */
+gboolean
+pspp_sheet_view_get_enable_tree_lines (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ return tree_view->priv->tree_lines_enabled;
+}
+
+/**
+ * pspp_sheet_view_set_enable_tree_lines:
+ * @tree_view: a #PsppSheetView
+ * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
+ *
+ * Sets whether to draw lines interconnecting the expanders in @tree_view.
+ * This does not have any visible effects for lists.
+ *
+ * Since: 2.10
+ */
+void
+pspp_sheet_view_set_enable_tree_lines (PsppSheetView *tree_view,
+ gboolean enabled)
+{
+ PsppSheetViewPrivate *priv;
+ GtkWidget *widget;
+ gboolean was_enabled;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ enabled = enabled != FALSE;
+
+ priv = tree_view->priv;
+ widget = GTK_WIDGET (tree_view);
+
+ was_enabled = priv->tree_lines_enabled;
+
+ priv->tree_lines_enabled = enabled;
+
+ if (gtk_widget_get_realized (widget))
+ {
+ if (!enabled && priv->tree_line_gc)
+ {
+ g_object_unref (priv->tree_line_gc);
+ priv->tree_line_gc = NULL;
+ }
+
+ if (enabled && !priv->tree_line_gc)
+ {
+ gint line_width;
+ gint8 *dash_list;
+ gtk_widget_style_get (widget,
+ "tree-line-width", &line_width,
+ "tree-line-pattern", (gchar *)&dash_list,
+ NULL);
+
+ priv->tree_line_gc = gdk_gc_new (widget->window);
+ gdk_gc_copy (priv->tree_line_gc, widget->style->black_gc);
+
+ gdk_gc_set_line_attributes (priv->tree_line_gc, line_width,
+ GDK_LINE_ON_OFF_DASH,
+ GDK_CAP_BUTT, GDK_JOIN_MITER);
+ gdk_gc_set_dashes (priv->tree_line_gc, 0, dash_list, 2);
+
+ g_free (dash_list);
+ }
+ }
+
+ if (was_enabled != enabled)
+ {
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+
+ g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
+ }
+}
+
+
+/**
+ * pspp_sheet_view_set_show_expanders:
+ * @tree_view: a #PsppSheetView
+ * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
+ *
+ * Sets whether to draw and enable expanders and indent child rows in
+ * @tree_view. When disabled there will be no expanders visible in trees
+ * and there will be no way to expand and collapse rows by default. Also
+ * note that hiding the expanders will disable the default indentation. You
+ * can set a custom indentation in this case using
+ * pspp_sheet_view_set_level_indentation().
+ * This does not have any visible effects for lists.
+ *
+ * Since: 2.12
+ */
+void
+pspp_sheet_view_set_show_expanders (PsppSheetView *tree_view,
+ gboolean enabled)
+{
+ gboolean was_enabled;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ enabled = enabled != FALSE;
+ was_enabled = PSPP_SHEET_VIEW_FLAG_SET (tree_view,
PSPP_SHEET_VIEW_SHOW_EXPANDERS);
+
+ if (enabled)
+ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_SHOW_EXPANDERS);
+ else
+ PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_SHOW_EXPANDERS);
+
+ if (enabled != was_enabled)
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+}
+
+/**
+ * pspp_sheet_view_get_show_expanders:
+ * @tree_view: a #PsppSheetView.
+ *
+ * Returns whether or not expanders are drawn in @tree_view.
+ *
+ * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
+ * otherwise.
+ *
+ * Since: 2.12
+ */
+gboolean
+pspp_sheet_view_get_show_expanders (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+
+ return PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_SHOW_EXPANDERS);
+}
+
+/**
+ * pspp_sheet_view_set_level_indentation:
+ * @tree_view: a #PsppSheetView
+ * @indentation: the amount, in pixels, of extra indentation in @tree_view.
+ *
+ * Sets the amount of extra indentation for child levels to use in @tree_view
+ * in addition to the default indentation. The value should be specified in
+ * pixels, a value of 0 disables this feature and in this case only the default
+ * indentation will be used.
+ * This does not have any visible effects for lists.
+ *
+ * Since: 2.12
+ */
+void
+pspp_sheet_view_set_level_indentation (PsppSheetView *tree_view,
+ gint indentation)
+{
+ tree_view->priv->level_indentation = indentation;
+
+ gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+}
+
+/**
+ * pspp_sheet_view_get_level_indentation:
+ * @tree_view: a #PsppSheetView.
+ *
+ * Returns the amount, in pixels, of extra indentation for child levels
+ * in @tree_view.
+ *
+ * Return value: the amount of extra indentation for child levels in
+ * @tree_view. A return value of 0 means that this feature is disabled.
+ *
+ * Since: 2.12
+ */
+gint
+pspp_sheet_view_get_level_indentation (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), 0);
+
+ return tree_view->priv->level_indentation;
+}
+
+/**
+ * pspp_sheet_view_set_tooltip_row:
+ * @tree_view: a #PsppSheetView
+ * @tooltip: a #GtkTooltip
+ * @path: a #GtkTreePath
+ *
+ * Sets the tip area of @tooltip to be the area covered by the row at @path.
+ * See also pspp_sheet_view_set_tooltip_column() for a simpler alternative.
+ * See also gtk_tooltip_set_tip_area().
+ *
+ * Since: 2.12
+ */
+void
+pspp_sheet_view_set_tooltip_row (PsppSheetView *tree_view,
+ GtkTooltip *tooltip,
+ GtkTreePath *path)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
+
+ pspp_sheet_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
+}
+
+/**
+ * pspp_sheet_view_set_tooltip_cell:
+ * @tree_view: a #PsppSheetView
+ * @tooltip: a #GtkTooltip
+ * @path: (allow-none): a #GtkTreePath or %NULL
+ * @column: (allow-none): a #PsppSheetViewColumn or %NULL
+ * @cell: (allow-none): a #GtkCellRenderer or %NULL
+ *
+ * Sets the tip area of @tooltip to the area @path, @column and @cell have
+ * in common. For example if @path is %NULL and @column is set, the tip
+ * area will be set to the full area covered by @column. See also
+ * gtk_tooltip_set_tip_area().
+ *
+ * Note that if @path is not specified and @cell is set and part of a column
+ * containing the expander, the tooltip might not show and hide at the correct
+ * position. In such cases @path must be set to the current node under the
+ * mouse cursor for this function to operate correctly.
+ *
+ * See also pspp_sheet_view_set_tooltip_column() for a simpler alternative.
+ *
+ * Since: 2.12
+ */
+void
+pspp_sheet_view_set_tooltip_cell (PsppSheetView *tree_view,
+ GtkTooltip *tooltip,
+ GtkTreePath *path,
+ PsppSheetViewColumn *column,
+ GtkCellRenderer *cell)
+{
+ GdkRectangle rect;
+
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
+ g_return_if_fail (column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (column));
+ g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
+
+ /* Determine x values. */
+ if (column && cell)
+ {
+ GdkRectangle tmp;
+ gint start, width;
+
+ /* We always pass in path here, whether it is NULL or not.
+ * For cells in expander columns path must be specified so that
+ * we can correctly account for the indentation. This also means
+ * that the tooltip is constrained vertically by the "Determine y
+ * values" code below; this is not a real problem since cells actually
+ * don't stretch vertically in constrast to columns.
+ */
+ pspp_sheet_view_get_cell_area (tree_view, path, column, &tmp);
+ pspp_sheet_view_column_cell_get_position (column, cell, &start, &width);
+
+ pspp_sheet_view_convert_bin_window_to_widget_coords (tree_view,
+ tmp.x + start, 0,
+ &rect.x, NULL);
+ rect.width = width;
+ }
+ else if (column)
+ {
+ GdkRectangle tmp;
+
+ pspp_sheet_view_get_background_area (tree_view, NULL, column, &tmp);
+ pspp_sheet_view_convert_bin_window_to_widget_coords (tree_view,
+ tmp.x, 0,
+ &rect.x, NULL);
+ rect.width = tmp.width;
+ }
+ else
+ {
+ rect.x = 0;
+ rect.width = GTK_WIDGET (tree_view)->allocation.width;
+ }
+
+ /* Determine y values. */
+ if (path)
+ {
+ GdkRectangle tmp;
+
+ pspp_sheet_view_get_background_area (tree_view, path, NULL, &tmp);
+ pspp_sheet_view_convert_bin_window_to_widget_coords (tree_view,
+ 0, tmp.y,
+ NULL, &rect.y);
+ rect.height = tmp.height;
+ }
+ else
+ {
+ rect.y = 0;
+ rect.height = tree_view->priv->vadjustment->page_size;
+ }
+
+ gtk_tooltip_set_tip_area (tooltip, &rect);
+}
+
+/**
+ * pspp_sheet_view_get_tooltip_context:
+ * @tree_view: a #PsppSheetView
+ * @x: the x coordinate (relative to widget coordinates)
+ * @y: the y coordinate (relative to widget coordinates)
+ * @keyboard_tip: whether this is a keyboard tooltip or not
+ * @model: (allow-none): a pointer to receive a #GtkTreeModel or %NULL
+ * @path: (allow-none): a pointer to receive a #GtkTreePath or %NULL
+ * @iter: (allow-none): a pointer to receive a #GtkTreeIter or %NULL
+ *
+ * This function is supposed to be used in a #GtkWidget::query-tooltip
+ * signal handler for #PsppSheetView. The @x, @y and @keyboard_tip values
+ * which are received in the signal handler, should be passed to this
+ * function without modification.
+ *
+ * The return value indicates whether there is a tree view row at the given
+ * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
+ * tooltips the row returned will be the cursor row. When %TRUE, then any of
+ * @model, @path and @iter which have been provided will be set to point to
+ * that row and the corresponding model. @x and @y will always be converted
+ * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
+ *
+ * Return value: whether or not the given tooltip context points to a row.
+ *
+ * Since: 2.12
+ */
+gboolean
+pspp_sheet_view_get_tooltip_context (PsppSheetView *tree_view,
+ gint *x,
+ gint *y,
+ gboolean keyboard_tip,
+ GtkTreeModel **model,
+ GtkTreePath **path,
+ GtkTreeIter *iter)
+{
+ GtkTreePath *tmppath = NULL;
+
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
+ g_return_val_if_fail (x != NULL, FALSE);
+ g_return_val_if_fail (y != NULL, FALSE);
+
+ if (keyboard_tip)
+ {
+ pspp_sheet_view_get_cursor (tree_view, &tmppath, NULL);
+
+ if (!tmppath)
+ return FALSE;
+ }
+ else
+ {
+ pspp_sheet_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
+ x, y);
+
+ if (!pspp_sheet_view_get_path_at_pos (tree_view, *x, *y,
+ &tmppath, NULL, NULL, NULL))
+ return FALSE;
+ }
+
+ if (model)
+ *model = pspp_sheet_view_get_model (tree_view);
+
+ if (iter)
+ gtk_tree_model_get_iter (pspp_sheet_view_get_model (tree_view),
+ iter, tmppath);
+
+ if (path)
+ *path = tmppath;
+ else
+ gtk_tree_path_free (tmppath);
+
+ return TRUE;
+}
+
+static gboolean
+pspp_sheet_view_set_tooltip_query_cb (GtkWidget *widget,
+ gint x,
+ gint y,
+ gboolean keyboard_tip,
+ GtkTooltip *tooltip,
+ gpointer data)
+{
+ GValue value = { 0, };
+ GValue transformed = { 0, };
+ GtkTreeIter iter;
+ GtkTreePath *path;
+ GtkTreeModel *model;
+ PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
+
+ if (!pspp_sheet_view_get_tooltip_context (PSPP_SHEET_VIEW (widget),
+ &x, &y,
+ keyboard_tip,
+ &model, &path, &iter))
+ return FALSE;
+
+ gtk_tree_model_get_value (model, &iter,
+ tree_view->priv->tooltip_column, &value);
+
+ g_value_init (&transformed, G_TYPE_STRING);
+
+ if (!g_value_transform (&value, &transformed))
+ {
+ g_value_unset (&value);
+ gtk_tree_path_free (path);
+
+ return FALSE;
+ }
+
+ g_value_unset (&value);
+
+ if (!g_value_get_string (&transformed))
+ {
+ g_value_unset (&transformed);
+ gtk_tree_path_free (path);
+
+ return FALSE;
+ }
+
+ gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
+ pspp_sheet_view_set_tooltip_row (tree_view, tooltip, path);
+
+ gtk_tree_path_free (path);
+ g_value_unset (&transformed);
+
+ return TRUE;
+}
+
+/**
+ * pspp_sheet_view_set_tooltip_column:
+ * @tree_view: a #PsppSheetView
+ * @column: an integer, which is a valid column number for @tree_view's model
+ *
+ * If you only plan to have simple (text-only) tooltips on full rows, you
+ * can use this function to have #PsppSheetView handle these automatically
+ * for you. @column should be set to the column in @tree_view's model
+ * containing the tooltip texts, or -1 to disable this feature.
+ *
+ * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
+ * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
+ *
+ * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
+ * so &, <, etc have to be escaped in the text.
+ *
+ * Since: 2.12
+ */
+void
+pspp_sheet_view_set_tooltip_column (PsppSheetView *tree_view,
+ gint column)
+{
+ g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+
+ if (column == tree_view->priv->tooltip_column)
+ return;
+
+ if (column == -1)
+ {
+ g_signal_handlers_disconnect_by_func (tree_view,
+
pspp_sheet_view_set_tooltip_query_cb,
+ NULL);
+ gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
+ }
+ else
+ {
+ if (tree_view->priv->tooltip_column == -1)
+ {
+ g_signal_connect (tree_view, "query-tooltip",
+ G_CALLBACK (pspp_sheet_view_set_tooltip_query_cb),
NULL);
+ gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
+ }
+ }
+
+ tree_view->priv->tooltip_column = column;
+ g_object_notify (G_OBJECT (tree_view), "tooltip-column");
+}
+
+/**
+ * pspp_sheet_view_get_tooltip_column:
+ * @tree_view: a #PsppSheetView
+ *
+ * Returns the column of @tree_view's model which is being used for
+ * displaying tooltips on @tree_view's rows.
+ *
+ * Return value: the index of the tooltip column that is currently being
+ * used, or -1 if this is disabled.
+ *
+ * Since: 2.12
+ */
+gint
+pspp_sheet_view_get_tooltip_column (PsppSheetView *tree_view)
+{
+ g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), 0);
+
+ return tree_view->priv->tooltip_column;
+}
+
+gboolean
+_gtk_boolean_handled_accumulator (GSignalInvocationHint *ihint,
+ GValue *return_accu,
+ const GValue *handler_return,
+ gpointer dummy)
+{
+ gboolean continue_emission;
+ gboolean signal_handled;
+
+ signal_handled = g_value_get_boolean (handler_return);
+ g_value_set_boolean (return_accu, signal_handled);
+ continue_emission = !signal_handled;
+
+ return continue_emission;
+}
+
+GType
+pspp_sheet_view_grid_lines_get_type (void)
+{
+ static GType etype = 0;
+ if (G_UNLIKELY(etype == 0)) {
+ static const GEnumValue values[] = {
+ { PSPP_SHEET_VIEW_GRID_LINES_NONE,
"PSPP_SHEET_VIEW_GRID_LINES_NONE", "none" },
+ { PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL,
"PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL", "horizontal" },
+ { PSPP_SHEET_VIEW_GRID_LINES_VERTICAL,
"PSPP_SHEET_VIEW_GRID_LINES_VERTICAL", "vertical" },
+ { PSPP_SHEET_VIEW_GRID_LINES_BOTH,
"PSPP_SHEET_VIEW_GRID_LINES_BOTH", "both" },
+ { 0, NULL, NULL }
+ };
+ etype = g_enum_register_static (g_intern_static_string
("PsppSheetViewGridLines"), values);
+ }
+ return etype;
+}
diff --git a/src/ui/gui/pspp-sheet-view.h b/src/ui/gui/pspp-sheet-view.h
new file mode 100644
index 0000000..b13d92d
--- /dev/null
+++ b/src/ui/gui/pspp-sheet-view.h
@@ -0,0 +1,451 @@
+/* PSPPIRE - a graphical user interface for PSPP.
+ Copyright (C) 2011 Free Software Foundation, Inc.
+
+ 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* gtktreeview.h
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <address@hidden>
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __PSPP_SHEET_VIEW_H__
+#define __PSPP_SHEET_VIEW_H__
+
+#include <gtk/gtk.h>
+#include "ui/gui/pspp-sheet-view-column.h"
+
+G_BEGIN_DECLS
+
+
+typedef enum
+{
+ PSPP_SHEET_VIEW_GRID_LINES_NONE,
+ PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL,
+ PSPP_SHEET_VIEW_GRID_LINES_VERTICAL,
+ PSPP_SHEET_VIEW_GRID_LINES_BOTH
+} PsppSheetViewGridLines;
+
+GType pspp_sheet_view_grid_lines_get_type (void) G_GNUC_CONST;
+#define PSPP_TYPE_SHEET_VIEW_GRID_LINES (pspp_sheet_view_grid_lines_get_type
())
+
+typedef enum
+{
+ /* drop before/after this row */
+ PSPP_SHEET_VIEW_DROP_BEFORE,
+ PSPP_SHEET_VIEW_DROP_AFTER,
+ /* drop as a child of this row (with fallback to before or after
+ * if into is not possible)
+ */
+ PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE,
+ PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER
+} PsppSheetViewDropPosition;
+
+#define PSPP_TYPE_SHEET_VIEW (pspp_sheet_view_get_type ())
+#define PSPP_SHEET_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),
PSPP_TYPE_SHEET_VIEW, PsppSheetView))
+#define PSPP_SHEET_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),
PSPP_TYPE_SHEET_VIEW, PsppSheetViewClass))
+#define PSPP_IS_SHEET_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE
((obj), PSPP_TYPE_SHEET_VIEW))
+#define PSPP_IS_SHEET_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE
((klass), PSPP_TYPE_SHEET_VIEW))
+#define PSPP_SHEET_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),
PSPP_TYPE_SHEET_VIEW, PsppSheetViewClass))
+
+typedef struct _PsppSheetView PsppSheetView;
+typedef struct _PsppSheetViewClass PsppSheetViewClass;
+typedef struct _PsppSheetViewPrivate PsppSheetViewPrivate;
+typedef struct _PsppSheetSelection PsppSheetSelection;
+typedef struct _PsppSheetSelectionClass PsppSheetSelectionClass;
+
+struct _PsppSheetView
+{
+ GtkContainer parent;
+
+ PsppSheetViewPrivate *GSEAL (priv);
+};
+
+struct _PsppSheetViewClass
+{
+ GtkContainerClass parent_class;
+
+ void (* set_scroll_adjustments) (PsppSheetView *tree_view,
+ GtkAdjustment *hadjustment,
+ GtkAdjustment *vadjustment);
+ void (* row_activated) (PsppSheetView *tree_view,
+ GtkTreePath *path,
+ PsppSheetViewColumn *column);
+ gboolean (* test_expand_row) (PsppSheetView *tree_view,
+ GtkTreeIter *iter,
+ GtkTreePath *path);
+ gboolean (* test_collapse_row) (PsppSheetView *tree_view,
+ GtkTreeIter *iter,
+ GtkTreePath *path);
+ void (* row_expanded) (PsppSheetView *tree_view,
+ GtkTreeIter *iter,
+ GtkTreePath *path);
+ void (* row_collapsed) (PsppSheetView *tree_view,
+ GtkTreeIter *iter,
+ GtkTreePath *path);
+ void (* columns_changed) (PsppSheetView *tree_view);
+ void (* cursor_changed) (PsppSheetView *tree_view);
+
+ /* Key Binding signals */
+ gboolean (* move_cursor) (PsppSheetView *tree_view,
+ GtkMovementStep step,
+ gint count);
+ gboolean (* select_all) (PsppSheetView *tree_view);
+ gboolean (* unselect_all) (PsppSheetView *tree_view);
+ gboolean (* select_cursor_row) (PsppSheetView *tree_view,
+ gboolean start_editing);
+ gboolean (* toggle_cursor_row) (PsppSheetView *tree_view);
+ gboolean (* expand_collapse_cursor_row) (PsppSheetView *tree_view,
+ gboolean logical,
+ gboolean expand,
+ gboolean open_all);
+ gboolean (* select_cursor_parent) (PsppSheetView *tree_view);
+ gboolean (* start_interactive_search) (PsppSheetView *tree_view);
+
+ /* Padding for future expansion */
+ void (*_gtk_reserved0) (void);
+ void (*_gtk_reserved1) (void);
+ void (*_gtk_reserved2) (void);
+ void (*_gtk_reserved3) (void);
+ void (*_gtk_reserved4) (void);
+};
+
+
+typedef gboolean (* PsppSheetViewColumnDropFunc) (PsppSheetView
*tree_view,
+ PsppSheetViewColumn
*column,
+ PsppSheetViewColumn
*prev_column,
+ PsppSheetViewColumn
*next_column,
+ gpointer data);
+typedef void (* PsppSheetViewMappingFunc) (PsppSheetView
*tree_view,
+ GtkTreePath *path,
+ gpointer
user_data);
+typedef gboolean (*PsppSheetViewSearchEqualFunc) (GtkTreeModel
*model,
+ gint column,
+ const gchar *key,
+ GtkTreeIter *iter,
+ gpointer
search_data);
+typedef gboolean (*PsppSheetViewRowSeparatorFunc) (GtkTreeModel *model,
+ GtkTreeIter *iter,
+ gpointer data);
+typedef void (*PsppSheetViewSearchPositionFunc) (PsppSheetView *tree_view,
+ GtkWidget *search_dialog,
+ gpointer user_data);
+
+
+/* Creators */
+GType pspp_sheet_view_get_type (void)
G_GNUC_CONST;
+GtkWidget *pspp_sheet_view_new (void);
+GtkWidget *pspp_sheet_view_new_with_model
(GtkTreeModel *model);
+
+/* Accessors */
+GtkTreeModel *pspp_sheet_view_get_model
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_model
(PsppSheetView *tree_view,
+
GtkTreeModel *model);
+PsppSheetSelection *pspp_sheet_view_get_selection
(PsppSheetView *tree_view);
+GtkAdjustment *pspp_sheet_view_get_hadjustment
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_hadjustment
(PsppSheetView *tree_view,
+
GtkAdjustment *adjustment);
+GtkAdjustment *pspp_sheet_view_get_vadjustment
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_vadjustment
(PsppSheetView *tree_view,
+
GtkAdjustment *adjustment);
+gboolean pspp_sheet_view_get_headers_visible
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_headers_visible
(PsppSheetView *tree_view,
+ gboolean
headers_visible);
+void pspp_sheet_view_columns_autosize
(PsppSheetView *tree_view);
+gboolean pspp_sheet_view_get_headers_clickable
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_headers_clickable
(PsppSheetView *tree_view,
+ gboolean
setting);
+void pspp_sheet_view_set_rules_hint
(PsppSheetView *tree_view,
+ gboolean
setting);
+gboolean pspp_sheet_view_get_rules_hint
(PsppSheetView *tree_view);
+
+/* Column funtions */
+gint pspp_sheet_view_append_column
(PsppSheetView *tree_view,
+
PsppSheetViewColumn *column);
+gint pspp_sheet_view_remove_column
(PsppSheetView *tree_view,
+
PsppSheetViewColumn *column);
+gint pspp_sheet_view_insert_column
(PsppSheetView *tree_view,
+
PsppSheetViewColumn *column,
+ gint
position);
+gint pspp_sheet_view_insert_column_with_attributes
(PsppSheetView *tree_view,
+ gint
position,
+ const gchar
*title,
+
GtkCellRenderer *cell,
+ ...)
G_GNUC_NULL_TERMINATED;
+gint pspp_sheet_view_insert_column_with_data_func
(PsppSheetView *tree_view,
+ gint
position,
+ const gchar
*title,
+
GtkCellRenderer *cell,
+
PsppSheetCellDataFunc func,
+ gpointer
data,
+
GDestroyNotify dnotify);
+PsppSheetViewColumn *pspp_sheet_view_get_column
(PsppSheetView *tree_view,
+ gint
n);
+GList *pspp_sheet_view_get_columns
(PsppSheetView *tree_view);
+void pspp_sheet_view_move_column_after
(PsppSheetView *tree_view,
+
PsppSheetViewColumn *column,
+
PsppSheetViewColumn *base_column);
+void pspp_sheet_view_set_expander_column
(PsppSheetView *tree_view,
+
PsppSheetViewColumn *column);
+PsppSheetViewColumn *pspp_sheet_view_get_expander_column
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_column_drag_function
(PsppSheetView *tree_view,
+
PsppSheetViewColumnDropFunc func,
+ gpointer
user_data,
+
GDestroyNotify destroy);
+
+/* Actions */
+void pspp_sheet_view_scroll_to_point
(PsppSheetView *tree_view,
+ gint
tree_x,
+ gint
tree_y);
+void pspp_sheet_view_scroll_to_cell
(PsppSheetView *tree_view,
+ GtkTreePath
*path,
+
PsppSheetViewColumn *column,
+ gboolean
use_align,
+ gfloat
row_align,
+ gfloat
col_align);
+void pspp_sheet_view_row_activated
(PsppSheetView *tree_view,
+ GtkTreePath
*path,
+
PsppSheetViewColumn *column);
+void pspp_sheet_view_expand_all
(PsppSheetView *tree_view);
+void pspp_sheet_view_collapse_all
(PsppSheetView *tree_view);
+void pspp_sheet_view_expand_to_path
(PsppSheetView *tree_view,
+ GtkTreePath
*path);
+gboolean pspp_sheet_view_expand_row
(PsppSheetView *tree_view,
+ GtkTreePath
*path,
+ gboolean
open_all);
+gboolean pspp_sheet_view_collapse_row
(PsppSheetView *tree_view,
+ GtkTreePath
*path);
+void pspp_sheet_view_map_expanded_rows
(PsppSheetView *tree_view,
+
PsppSheetViewMappingFunc func,
+ gpointer
data);
+gboolean pspp_sheet_view_row_expanded
(PsppSheetView *tree_view,
+ GtkTreePath
*path);
+void pspp_sheet_view_set_reorderable
(PsppSheetView *tree_view,
+ gboolean
reorderable);
+gboolean pspp_sheet_view_get_reorderable
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_cursor
(PsppSheetView *tree_view,
+ GtkTreePath
*path,
+
PsppSheetViewColumn *focus_column,
+ gboolean
start_editing);
+void pspp_sheet_view_set_cursor_on_cell
(PsppSheetView *tree_view,
+ GtkTreePath
*path,
+
PsppSheetViewColumn *focus_column,
+
GtkCellRenderer *focus_cell,
+ gboolean
start_editing);
+void pspp_sheet_view_get_cursor
(PsppSheetView *tree_view,
+ GtkTreePath
**path,
+
PsppSheetViewColumn **focus_column);
+
+
+/* Layout information */
+GdkWindow *pspp_sheet_view_get_bin_window
(PsppSheetView *tree_view);
+gboolean pspp_sheet_view_get_path_at_pos
(PsppSheetView *tree_view,
+ gint
x,
+ gint
y,
+ GtkTreePath
**path,
+
PsppSheetViewColumn **column,
+ gint
*cell_x,
+ gint
*cell_y);
+void pspp_sheet_view_get_cell_area
(PsppSheetView *tree_view,
+ GtkTreePath
*path,
+
PsppSheetViewColumn *column,
+
GdkRectangle *rect);
+void pspp_sheet_view_get_background_area
(PsppSheetView *tree_view,
+ GtkTreePath
*path,
+
PsppSheetViewColumn *column,
+
GdkRectangle *rect);
+void pspp_sheet_view_get_visible_rect
(PsppSheetView *tree_view,
+
GdkRectangle *visible_rect);
+
+#ifndef GTK_DISABLE_DEPRECATED
+void pspp_sheet_view_widget_to_tree_coords
(PsppSheetView *tree_view,
+ gint
wx,
+ gint
wy,
+ gint
*tx,
+ gint
*ty);
+void pspp_sheet_view_tree_to_widget_coords
(PsppSheetView *tree_view,
+ gint
tx,
+ gint
ty,
+ gint
*wx,
+ gint
*wy);
+#endif /* !GTK_DISABLE_DEPRECATED */
+gboolean pspp_sheet_view_get_visible_range
(PsppSheetView *tree_view,
+ GtkTreePath
**start_path,
+ GtkTreePath
**end_path);
+
+/* Drag-and-Drop support */
+void pspp_sheet_view_enable_model_drag_source
(PsppSheetView *tree_view,
+
GdkModifierType start_button_mask,
+ const
GtkTargetEntry *targets,
+ gint
n_targets,
+
GdkDragAction actions);
+void pspp_sheet_view_enable_model_drag_dest
(PsppSheetView *tree_view,
+ const
GtkTargetEntry *targets,
+ gint
n_targets,
+
GdkDragAction actions);
+void pspp_sheet_view_unset_rows_drag_source
(PsppSheetView *tree_view);
+void pspp_sheet_view_unset_rows_drag_dest
(PsppSheetView *tree_view);
+
+
+/* These are useful to implement your own custom stuff. */
+void pspp_sheet_view_set_drag_dest_row
(PsppSheetView *tree_view,
+ GtkTreePath
*path,
+
PsppSheetViewDropPosition pos);
+void pspp_sheet_view_get_drag_dest_row
(PsppSheetView *tree_view,
+ GtkTreePath
**path,
+
PsppSheetViewDropPosition *pos);
+gboolean pspp_sheet_view_get_dest_row_at_pos
(PsppSheetView *tree_view,
+ gint
drag_x,
+ gint
drag_y,
+ GtkTreePath
**path,
+
PsppSheetViewDropPosition *pos);
+GdkPixmap *pspp_sheet_view_create_row_drag_icon
(PsppSheetView *tree_view,
+ GtkTreePath
*path);
+
+/* Interactive search */
+void pspp_sheet_view_set_enable_search
(PsppSheetView *tree_view,
+ gboolean
enable_search);
+gboolean pspp_sheet_view_get_enable_search
(PsppSheetView *tree_view);
+gint pspp_sheet_view_get_search_column
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_search_column
(PsppSheetView *tree_view,
+ gint
column);
+PsppSheetViewSearchEqualFunc pspp_sheet_view_get_search_equal_func
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_search_equal_func
(PsppSheetView *tree_view,
+
PsppSheetViewSearchEqualFunc search_equal_func,
+ gpointer
search_user_data,
+ GDestroyNotify
search_destroy);
+
+GtkEntry *pspp_sheet_view_get_search_entry
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_search_entry
(PsppSheetView *tree_view,
+ GtkEntry
*entry);
+PsppSheetViewSearchPositionFunc pspp_sheet_view_get_search_position_func
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_search_position_func
(PsppSheetView *tree_view,
+
PsppSheetViewSearchPositionFunc func,
+ gpointer
data,
+
GDestroyNotify destroy);
+
+/* Convert between the different coordinate systems */
+void pspp_sheet_view_convert_widget_to_tree_coords (PsppSheetView
*tree_view,
+ gint wx,
+ gint wy,
+ gint *tx,
+ gint *ty);
+void pspp_sheet_view_convert_tree_to_widget_coords (PsppSheetView
*tree_view,
+ gint tx,
+ gint ty,
+ gint *wx,
+ gint *wy);
+void pspp_sheet_view_convert_widget_to_bin_window_coords (PsppSheetView
*tree_view,
+ gint wx,
+ gint wy,
+ gint *bx,
+ gint *by);
+void pspp_sheet_view_convert_bin_window_to_widget_coords (PsppSheetView
*tree_view,
+ gint bx,
+ gint by,
+ gint *wx,
+ gint *wy);
+void pspp_sheet_view_convert_tree_to_bin_window_coords (PsppSheetView
*tree_view,
+ gint tx,
+ gint ty,
+ gint *bx,
+ gint *by);
+void pspp_sheet_view_convert_bin_window_to_tree_coords (PsppSheetView
*tree_view,
+ gint bx,
+ gint by,
+ gint *tx,
+ gint *ty);
+
+/* This function should really never be used. It is just for use by ATK.
+ */
+typedef void (* PsppSheetDestroyCountFunc) (PsppSheetView
*tree_view,
+ GtkTreePath *path,
+ gint children,
+ gpointer user_data);
+void pspp_sheet_view_set_destroy_count_func (PsppSheetView
*tree_view,
+ PsppSheetDestroyCountFunc func,
+ gpointer data,
+ GDestroyNotify destroy);
+
+void pspp_sheet_view_set_fixed_height_mode (PsppSheetView
*tree_view,
+ gboolean enable);
+gboolean pspp_sheet_view_get_fixed_height_mode (PsppSheetView
*tree_view);
+void pspp_sheet_view_set_hover_selection (PsppSheetView
*tree_view,
+ gboolean hover);
+gboolean pspp_sheet_view_get_hover_selection (PsppSheetView
*tree_view);
+void pspp_sheet_view_set_hover_expand (PsppSheetView
*tree_view,
+ gboolean expand);
+gboolean pspp_sheet_view_get_hover_expand (PsppSheetView
*tree_view);
+void pspp_sheet_view_set_rubber_banding (PsppSheetView
*tree_view,
+ gboolean enable);
+gboolean pspp_sheet_view_get_rubber_banding (PsppSheetView
*tree_view);
+
+gboolean pspp_sheet_view_is_rubber_banding_active (PsppSheetView
*tree_view);
+
+PsppSheetViewRowSeparatorFunc pspp_sheet_view_get_row_separator_func
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_row_separator_func
(PsppSheetView *tree_view,
+
PsppSheetViewRowSeparatorFunc func,
+ gpointer
data,
+
GDestroyNotify destroy);
+
+PsppSheetViewGridLines pspp_sheet_view_get_grid_lines
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_grid_lines
(PsppSheetView *tree_view,
+
PsppSheetViewGridLines grid_lines);
+gboolean pspp_sheet_view_get_enable_tree_lines
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_enable_tree_lines
(PsppSheetView *tree_view,
+ gboolean
enabled);
+void pspp_sheet_view_set_show_expanders
(PsppSheetView *tree_view,
+ gboolean
enabled);
+gboolean pspp_sheet_view_get_show_expanders
(PsppSheetView *tree_view);
+void pspp_sheet_view_set_level_indentation
(PsppSheetView *tree_view,
+ gint
indentation);
+gint pspp_sheet_view_get_level_indentation
(PsppSheetView *tree_view);
+
+/* Convenience functions for setting tooltips */
+void pspp_sheet_view_set_tooltip_row (PsppSheetView
*tree_view,
+ GtkTooltip *tooltip,
+ GtkTreePath *path);
+void pspp_sheet_view_set_tooltip_cell (PsppSheetView
*tree_view,
+ GtkTooltip *tooltip,
+ GtkTreePath *path,
+ PsppSheetViewColumn *column,
+ GtkCellRenderer *cell);
+gboolean pspp_sheet_view_get_tooltip_context(PsppSheetView
*tree_view,
+ gint *x,
+ gint *y,
+ gboolean keyboard_tip,
+ GtkTreeModel **model,
+ GtkTreePath **path,
+ GtkTreeIter *iter);
+void pspp_sheet_view_set_tooltip_column (PsppSheetView
*tree_view,
+ gint column);
+gint pspp_sheet_view_get_tooltip_column (PsppSheetView
*tree_view);
+
+G_END_DECLS
+
+
+#endif /* __PSPP_SHEET_VIEW_H__ */
--
1.7.2.5
- [PATCH 08/17] pspp-sheet-view: Support rectangular selection, column popup menus., (continued)
- [PATCH 12/17] pspp-sheet-view: Optimize by making column header widgets lazy., Ben Pfaff, 2012/04/22
- [PATCH 15/17] pspp-sheet-view: Add "fixed-height" and "fixed-height-set" properties., Ben Pfaff, 2012/04/22
- [PATCH 17/17] psppire-cell-renderer-button: Add "slash" property., Ben Pfaff, 2012/04/22
- [PATCH 16/17] psppire-cell-renderer-button: New cell renderer for GtkButton., Ben Pfaff, 2012/04/22
- [PATCH 02/17] pspp-sheet-view: Reduce time and memory cost to O(1) in number of rows., Ben Pfaff, 2012/04/22
- [PATCH 01/17] Import GtkTreeView from GTK+ 2.0-2.20.1 renamed as PsppSheetView.,
Ben Pfaff <=
- Re: [PATCH 00/17] Implement PsppSheetView, Ben Pfaff, 2012/04/24