2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
4 * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail team
6 * Parts of this file from gtk/gtkctree.c and gtk/gtkclist.c:
7 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball, Josh MacDonald,
8 * Copyright (C) 1997-1998 Jay Painter <jpaint@serv.net><jpaint@gimp.org>
10 * Parts of this file from gtkflist.c:
11 * Copyright (C) 1999 The Free Software Foundation
12 * Author: Federico Mena <federico@nuclecu.unam.mx>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 3 of the License, or
17 * (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program. If not, see <http://www.gnu.org/licenses/>.
31 #include "gtksctree.h"
32 #include "claws-marshal.h"
33 #include "prefs_common.h"
37 #define CLIST_UNFROZEN(clist) (((GtkCMCList*) (clist))->freeze_count == 0)
38 #define CLIST_REFRESH(clist) G_STMT_START { \
39 if (CLIST_UNFROZEN (clist)) \
40 GTK_CMCLIST_GET_CLASS (clist)->refresh ((GtkCMCList*) (clist)); \
42 #define CELL_SPACING 1
43 #define CLIST_OPTIMUM_SIZE 64
44 #define COLUMN_INSET 3
46 #define TAB_SIZE (PM_SIZE + 6)
47 #define ROW_TOP_YPIXEL(clist, row) (((clist)->row_height * (row)) + \
48 (((row) + 1) * CELL_SPACING) + \
50 #define ROW_FROM_YPIXEL(clist, y) (((y) - (clist)->voffset) / \
51 ((clist)->row_height + CELL_SPACING))
52 #define COLUMN_LEFT_XPIXEL(clist, col) ((clist)->column[(col)].area.x \
54 #define COLUMN_LEFT(clist, column) ((clist)->column[(column)].area.x)
64 static void gtk_sctree_class_init (GtkSCTreeClass *class);
65 static void gtk_sctree_init (GtkSCTree *sctree);
67 static gint gtk_sctree_button_press (GtkWidget *widget, GdkEventButton *event);
68 static gint gtk_sctree_button_release (GtkWidget *widget, GdkEventButton *event);
69 static gint gtk_sctree_motion (GtkWidget *widget, GdkEventMotion *event);
70 static void gtk_sctree_drag_begin (GtkWidget *widget, GdkDragContext *context);
71 static void gtk_sctree_drag_end (GtkWidget *widget, GdkDragContext *context);
72 static void gtk_sctree_drag_data_get (GtkWidget *widget, GdkDragContext *context,
73 GtkSelectionData *data, guint info, guint time);
74 static void gtk_sctree_drag_leave (GtkWidget *widget, GdkDragContext *context, guint time);
75 static gboolean gtk_sctree_drag_motion (GtkWidget *widget, GdkDragContext *context,
76 gint x, gint y, guint time);
77 static gboolean gtk_sctree_drag_drop (GtkWidget *widget, GdkDragContext *context,
78 gint x, gint y, guint time);
79 static void gtk_sctree_drag_data_received (GtkWidget *widget, GdkDragContext *context,
80 gint x, gint y, GtkSelectionData *data,
81 guint info, guint time);
83 static void gtk_sctree_clear (GtkCMCList *clist);
84 static void gtk_sctree_real_unselect_all (GtkCMCList *clist);
86 static void stree_sort (GtkCMCTree *ctree, GtkCMCTreeNode *node, gpointer data);
87 void gtk_sctree_sort_node (GtkCMCTree *ctree, GtkCMCTreeNode *node);
88 void gtk_sctree_sort_recursive (GtkCMCTree *ctree, GtkCMCTreeNode *node);
90 static void gtk_sctree_link (GtkCMCTree *ctree,
92 GtkCMCTreeNode *parent,
93 GtkCMCTreeNode *sibling,
94 gboolean update_focus_row);
96 static void gtk_sctree_unlink (GtkCMCTree *ctree,
98 gboolean update_focus_row);
100 static void stree_update_level (GtkCMCTree *ctree,
101 GtkCMCTreeNode *node,
104 static GtkCMCTreeNode * gtk_sctree_last_visible (GtkCMCTree *ctree,
105 GtkCMCTreeNode *node);
106 static void gtk_sctree_real_tree_expand (GtkCMCTree *ctree,
107 GtkCMCTreeNode *node);
108 static void gtk_sctree_real_tree_collapse (GtkCMCTree *ctree,
109 GtkCMCTreeNode *node);
111 sreal_tree_move (GtkCMCTree *ctree,
112 GtkCMCTreeNode *node,
113 GtkCMCTreeNode *new_parent,
114 GtkCMCTreeNode *new_sibling);
116 static GtkCMCTreeClass *parent_class;
118 static guint sctree_signals[LAST_SIGNAL];
121 * gtk_sctree_get_type:
124 * Creates the GtkSCTree class and its type information
126 * Return value: The type ID for GtkSCTreeClass
129 gtk_sctree_get_type (void)
131 static GType sctree_type = 0;
134 GTypeInfo sctree_info = {
135 sizeof (GtkSCTreeClass),
137 (GBaseInitFunc) NULL,
138 (GBaseFinalizeFunc) NULL,
140 (GClassInitFunc) gtk_sctree_class_init,
141 (GClassFinalizeFunc) NULL,
142 NULL, /* class_data */
146 (GInstanceInitFunc) gtk_sctree_init,
149 sctree_type = g_type_register_static (GTK_TYPE_CMCTREE, "GtkSCTree", &sctree_info, (GTypeFlags)0);
156 gtk_sctree_change_focus_row_expansion (GtkCMCTree *ctree,
157 GtkCMCTreeExpansionType action)
160 GtkCMCTreeNode *node;
162 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
164 clist = GTK_CMCLIST (ctree);
166 if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (ctree))) &&
167 gtk_widget_has_grab (GTK_WIDGET(ctree)))
171 GTK_CMCTREE_NODE (g_list_nth (clist->row_list, clist->focus_row))) ||
172 GTK_CMCTREE_ROW (node)->is_leaf || !(GTK_CMCTREE_ROW (node)->children))
177 case GTK_CMCTREE_EXPANSION_EXPAND:
178 if (GTK_SCTREE(ctree)->always_expand_recursively)
179 gtk_cmctree_expand_recursive (ctree, node);
181 gtk_cmctree_expand (ctree, node);
184 case GTK_CMCTREE_EXPANSION_EXPAND_RECURSIVE:
185 gtk_cmctree_expand_recursive (ctree, node);
187 case GTK_CMCTREE_EXPANSION_COLLAPSE:
188 gtk_cmctree_collapse (ctree, node);
190 case GTK_CMCTREE_EXPANSION_COLLAPSE_RECURSIVE:
191 gtk_cmctree_collapse_recursive (ctree, node);
193 case GTK_CMCTREE_EXPANSION_TOGGLE:
194 if (GTK_SCTREE(ctree)->always_expand_recursively)
195 gtk_cmctree_toggle_expansion_recursive (ctree, node);
197 gtk_cmctree_toggle_expansion (ctree, node);
199 case GTK_CMCTREE_EXPANSION_TOGGLE_RECURSIVE:
200 gtk_cmctree_toggle_expansion_recursive (ctree, node);
205 static void gtk_sctree_finalize(GObject *object)
207 GtkSCTree *sctree = GTK_SCTREE(object);
208 g_free(sctree->use_markup);
209 sctree->use_markup = NULL;
210 G_OBJECT_CLASS (parent_class)->finalize (object);
213 /* Standard class initialization function */
215 gtk_sctree_class_init (GtkSCTreeClass *klass)
217 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
218 GtkWidgetClass *widget_class;
219 GtkCMCListClass *clist_class;
220 GtkCMCTreeClass *ctree_class;
222 widget_class = (GtkWidgetClass *) klass;
223 clist_class = (GtkCMCListClass *) klass;
224 ctree_class = (GtkCMCTreeClass *) klass;
226 parent_class = g_type_class_peek (gtk_cmctree_get_type ());
228 sctree_signals[ROW_POPUP_MENU] =
229 g_signal_new ("row_popup_menu",
230 G_TYPE_FROM_CLASS (klass),
232 G_STRUCT_OFFSET (GtkSCTreeClass, row_popup_menu),
234 claws_marshal_VOID__POINTER,
237 sctree_signals[EMPTY_POPUP_MENU] =
238 g_signal_new ("empty_popup_menu",
239 G_TYPE_FROM_CLASS (klass),
241 G_STRUCT_OFFSET (GtkSCTreeClass, empty_popup_menu),
243 claws_marshal_VOID__POINTER,
246 sctree_signals[OPEN_ROW] =
247 g_signal_new ("open_row",
248 G_TYPE_FROM_CLASS (klass),
250 G_STRUCT_OFFSET (GtkSCTreeClass, open_row),
252 g_cclosure_marshal_VOID__VOID,
254 sctree_signals[START_DRAG] =
255 g_signal_new ("start_drag",
256 G_TYPE_FROM_CLASS (klass),
258 G_STRUCT_OFFSET (GtkSCTreeClass, start_drag),
260 claws_marshal_VOID__INT_POINTER,
265 /* gtk_object_class_add_signals (object_class, sctree_signals, LAST_SIGNAL); */
267 clist_class->clear = gtk_sctree_clear;
268 clist_class->unselect_all = gtk_sctree_real_unselect_all;
269 ctree_class->tree_collapse = gtk_sctree_real_tree_collapse;
270 ctree_class->tree_expand = gtk_sctree_real_tree_expand;
271 ctree_class->tree_move = sreal_tree_move;
272 ctree_class->change_focus_row_expansion = gtk_sctree_change_focus_row_expansion;
274 widget_class->button_press_event = gtk_sctree_button_press;
275 widget_class->button_release_event = gtk_sctree_button_release;
276 widget_class->motion_notify_event = gtk_sctree_motion;
277 widget_class->drag_begin = gtk_sctree_drag_begin;
278 widget_class->drag_end = gtk_sctree_drag_end;
279 widget_class->drag_data_get = gtk_sctree_drag_data_get;
280 widget_class->drag_leave = gtk_sctree_drag_leave;
281 widget_class->drag_motion = gtk_sctree_drag_motion;
282 widget_class->drag_drop = gtk_sctree_drag_drop;
283 widget_class->drag_data_received = gtk_sctree_drag_data_received;
285 gobject_class->finalize = gtk_sctree_finalize;
288 /* Standard object initialization function */
290 gtk_sctree_init (GtkSCTree *sctree)
292 sctree->anchor_row = NULL;
294 /* GtkCMCTree does not specify pointer motion by default */
295 gtk_widget_add_events (GTK_WIDGET (sctree), GDK_POINTER_MOTION_MASK);
296 gtk_widget_add_events (GTK_WIDGET (sctree), GDK_POINTER_MOTION_MASK);
299 /* Get information the specified row is selected. */
302 row_is_selected(GtkSCTree *sctree, gint row)
304 GtkCMCListRow *clist_row;
305 clist_row = g_list_nth (GTK_CMCLIST(sctree)->row_list, row)->data;
306 return clist_row ? clist_row->state == GTK_STATE_SELECTED : FALSE;
309 /* Selects the rows between the anchor to the specified row, inclusive. */
311 select_range (GtkSCTree *sctree, gint row)
317 if (sctree->anchor_row == NULL) {
319 sctree->anchor_row = gtk_cmctree_node_nth(GTK_CMCTREE(sctree), row);
321 prev_row = g_list_position(GTK_CMCLIST(sctree)->row_list,
322 (GList *)sctree->anchor_row);
324 if (row < prev_row) {
327 GTK_CMCLIST(sctree)->focus_row = max;
332 sctree->selecting_range++;
341 gtk_cmclist_freeze(GTK_CMCLIST(sctree));
343 node = g_list_nth((GTK_CMCLIST(sctree))->row_list, min);
344 for (i = min; i < max; i++) {
345 if (node && GTK_CMCTREE_ROW (node)->row.selectable) {
346 g_signal_emit_by_name(G_OBJECT(sctree), "tree_select_row",
352 gtk_cmclist_thaw(GTK_CMCLIST(sctree));
355 sctree->selecting_range--;
356 gtk_cmclist_select_row (GTK_CMCLIST (sctree), max, -1);
359 /* Handles row selection according to the specified modifier state */
360 /* in certain cases, we arrive here from a function knowing the GtkCMCTreeNode, and having
361 * already slowly found row using g_list_position. In which case, _node will be non-NULL
362 * to avoid this function having to slowly find it with g_list_nth. */
364 select_row (GtkSCTree *sctree, gint row, gint col, guint state, GtkCMCTreeNode *_node)
366 gboolean range, additive;
367 cm_return_if_fail (sctree != NULL);
368 cm_return_if_fail (GTK_IS_SCTREE (sctree));
370 range = ((state & GDK_SHIFT_MASK) != 0) &&
371 (GTK_CMCLIST(sctree)->selection_mode != GTK_SELECTION_SINGLE) &&
372 (GTK_CMCLIST(sctree)->selection_mode != GTK_SELECTION_BROWSE);
373 additive = ((state & GDK_CONTROL_MASK) != 0) &&
374 (GTK_CMCLIST(sctree)->selection_mode != GTK_SELECTION_SINGLE) &&
375 (GTK_CMCLIST(sctree)->selection_mode != GTK_SELECTION_BROWSE);
377 if (!range && !additive && sctree->force_additive_sel)
380 GTK_CMCLIST(sctree)->focus_row = row;
383 gtk_cmclist_unselect_all (GTK_CMCLIST (sctree));
387 GtkCMCTreeNode *node;
389 node = _node ? _node : gtk_cmctree_node_nth (GTK_CMCTREE(sctree), row);
391 /*No need to manage overlapped list*/
393 if (row_is_selected(sctree, row))
394 gtk_cmclist_unselect_row (GTK_CMCLIST (sctree), row, col);
396 g_signal_emit_by_name
398 "tree_select_row", node, col);
400 g_signal_emit_by_name
402 "tree_select_row", node, col);
404 sctree->anchor_row = node;
406 select_range (sctree, row);
410 sctree_is_hot_spot (GtkSCTree *sctree,
411 GtkCMCTreeNode *node,
416 GtkCMCTreeRow *tree_row;
423 cm_return_val_if_fail (GTK_IS_SCTREE (sctree), FALSE);
424 cm_return_val_if_fail (node != NULL, FALSE);
426 clist = GTK_CMCLIST (sctree);
427 ctree = GTK_CMCTREE (sctree);
429 if (!clist->column[ctree->tree_column].visible ||
430 ctree->expander_style == GTK_CMCTREE_EXPANDER_NONE)
433 tree_row = GTK_CMCTREE_ROW (node);
435 hotspot_size = clist->row_height-2;
436 if (hotspot_size > clist->column[ctree->tree_column].area.width - 2)
437 hotspot_size = clist->column[ctree->tree_column].area.width - 2;
439 if (!GTK_CMCLIST_ROW_HEIGHT_SET(GTK_CMCLIST(clist)))
440 yu = (ROW_TOP_YPIXEL (clist, row) + (clist->row_height - hotspot_size) / 2 -
441 (clist->row_height - 1) % 2);
443 yu = (ROW_TOP_YPIXEL (clist, row) + (clist->row_height/2 - hotspot_size) / 2 -
444 (clist->row_height/2 - 1) % 2);
447 if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT)
448 xl = clist->column[ctree->tree_column].area.x +
449 clist->column[ctree->tree_column].area.width - 1 + clist->hoffset -
450 (tree_row->level - 1) * ctree->tree_indent - hotspot_size;
452 xl = clist->column[ctree->tree_column].area.x + clist->hoffset +
453 (tree_row->level - 1) * ctree->tree_indent;
455 xmax = xl + hotspot_size;
457 if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT) {
458 xl = clist->column[ctree->tree_column].area.x +
459 clist->column[ctree->tree_column].area.width - 1 + clist->hoffset -
460 (tree_row->level - 1) * ctree->tree_indent - hotspot_size;
461 xmax = xl + hotspot_size;
462 } else if (ctree->tree_column == 0) {
463 xl = clist->column[ctree->tree_column].area.x + clist->hoffset;
464 xmax = clist->column[ctree->tree_column].area.x + clist->hoffset +
465 (tree_row->level - 1) * ctree->tree_indent +
468 xl = clist->column[ctree->tree_column].area.x + clist->hoffset +
469 (tree_row->level - 1) * ctree->tree_indent;
470 xmax = xl + hotspot_size;
473 return (x >= xl && x <= xmax && y >= yu && y <= yu + hotspot_size);
477 gtk_sctree_is_hot_spot (GtkSCTree *ctree,
481 GtkCMCTreeNode *node;
485 cm_return_val_if_fail (GTK_IS_SCTREE (ctree), FALSE);
487 if (gtk_cmclist_get_selection_info (GTK_CMCLIST (ctree), x, y, &row, &column))
488 if ((node = GTK_CMCTREE_NODE(g_list_nth (GTK_CMCLIST (ctree)->row_list, row))))
489 return sctree_is_hot_spot (ctree, node, row, x, y);
494 /* Our handler for button_press events. We override all of GtkCMCList's broken
498 gtk_sctree_button_press (GtkWidget *widget, GdkEventButton *event)
507 cm_return_val_if_fail (widget != NULL, FALSE);
508 cm_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
509 cm_return_val_if_fail (event != NULL, FALSE);
511 sctree = GTK_SCTREE (widget);
512 clist = GTK_CMCLIST (widget);
515 if (event->window != clist->clist_window)
516 return (* GTK_WIDGET_CLASS (parent_class)->button_press_event) (widget, event);
518 on_row = gtk_cmclist_get_selection_info (clist, event->x, event->y, &row, &col);
520 if (on_row && !gtk_widget_has_focus(widget))
521 gtk_widget_grab_focus (widget);
523 if (gtk_sctree_is_hot_spot (GTK_SCTREE(sctree), event->x, event->y)) {
524 GtkCMCTreeNode *node = gtk_cmctree_node_nth(GTK_CMCTREE(sctree), row);
525 if (GTK_CMCTREE_ROW (node)->expanded)
526 gtk_cmctree_collapse(GTK_CMCTREE(sctree), node);
527 else if (GTK_SCTREE(sctree)->always_expand_recursively)
528 gtk_cmctree_expand_recursive (GTK_CMCTREE(sctree), node);
530 gtk_cmctree_expand(GTK_CMCTREE(sctree), node);
534 switch (event->type) {
535 case GDK_BUTTON_PRESS:
536 if (event->button == 1 || event->button == 2) {
537 if (event->button == 2)
538 event->state &= ~(GDK_SHIFT_MASK | GDK_CONTROL_MASK);
540 /* Save the mouse info for DnD */
541 sctree->dnd_press_button = event->button;
542 sctree->dnd_press_x = event->x;
543 sctree->dnd_press_y = event->y;
545 /* Handle selection */
546 if ((row_is_selected (sctree, row)
547 && !(event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)))
548 || ((event->state & GDK_CONTROL_MASK)
549 && !(event->state & GDK_SHIFT_MASK))) {
550 sctree->dnd_select_pending = TRUE;
551 sctree->dnd_select_pending_state = event->state;
552 sctree->dnd_select_pending_row = row;
554 select_row (sctree, row, col, event->state, NULL);
557 gtk_cmclist_unselect_all (clist);
561 } else if (event->button == 3) {
562 /* Emit *_popup_menu signal*/
564 if (!row_is_selected(sctree,row))
565 select_row (sctree, row, col, 0, NULL);
566 g_signal_emit (G_OBJECT (sctree),
567 sctree_signals[ROW_POPUP_MENU],
570 gtk_cmclist_unselect_all(clist);
571 g_signal_emit (G_OBJECT (sctree),
572 sctree_signals[EMPTY_POPUP_MENU],
580 case GDK_2BUTTON_PRESS:
581 if (event->button != 1)
584 sctree->dnd_select_pending = FALSE;
585 sctree->dnd_select_pending_state = 0;
588 g_signal_emit (G_OBJECT (sctree),
589 sctree_signals[OPEN_ROW], 0);
601 /* Our handler for button_release events. We override all of GtkCMCList's broken
605 gtk_sctree_button_release (GtkWidget *widget, GdkEventButton *event)
613 cm_return_val_if_fail (widget != NULL, FALSE);
614 cm_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
615 cm_return_val_if_fail (event != NULL, FALSE);
617 sctree = GTK_SCTREE (widget);
618 clist = GTK_CMCLIST (widget);
621 if (event->window != clist->clist_window)
622 return (* GTK_WIDGET_CLASS (parent_class)->button_release_event) (widget, event);
624 on_row = gtk_cmclist_get_selection_info (clist, event->x, event->y, &row, &col);
626 if (!(event->button == 1 || event->button == 2))
629 sctree->dnd_press_button = 0;
630 sctree->dnd_press_x = 0;
631 sctree->dnd_press_y = 0;
634 if (sctree->dnd_select_pending) {
635 select_row (sctree, row, col, sctree->dnd_select_pending_state, NULL);
636 sctree->dnd_select_pending = FALSE;
637 sctree->dnd_select_pending_state = 0;
646 /* Our handler for motion_notify events. We override all of GtkCMCList's broken
650 gtk_sctree_motion (GtkWidget *widget, GdkEventMotion *event)
655 cm_return_val_if_fail (widget != NULL, FALSE);
656 cm_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
657 cm_return_val_if_fail (event != NULL, FALSE);
659 sctree = GTK_SCTREE (widget);
660 clist = GTK_CMCLIST (widget);
662 if (event->window != clist->clist_window)
663 return (* GTK_WIDGET_CLASS (parent_class)->motion_notify_event) (widget, event);
665 if (!((sctree->dnd_press_button == 1 && (event->state & GDK_BUTTON1_MASK))
666 || (sctree->dnd_press_button == 2 && (event->state & GDK_BUTTON2_MASK))))
669 /* This is the same threshold value that is used in gtkdnd.c */
676 if (MAX (ABS (sctree->dnd_press_x - event->x),
677 ABS (sctree->dnd_press_y - event->y)) <= THRESHOLD)
680 /* Handle any pending selections */
682 if (sctree->dnd_select_pending) {
683 if (!row_is_selected(sctree,sctree->dnd_select_pending_row))
685 sctree->dnd_select_pending_row,
687 sctree->dnd_select_pending_state,
690 sctree->dnd_select_pending = FALSE;
691 sctree->dnd_select_pending_state = 0;
694 g_signal_emit (G_OBJECT (sctree),
695 sctree_signals[START_DRAG],
697 sctree->dnd_press_button,
702 /* We override the drag_begin signal to do nothing */
704 gtk_sctree_drag_begin (GtkWidget *widget, GdkDragContext *context)
709 /* We override the drag_end signal to do nothing */
711 gtk_sctree_drag_end (GtkWidget *widget, GdkDragContext *context)
716 /* We override the drag_data_get signal to do nothing */
718 gtk_sctree_drag_data_get (GtkWidget *widget, GdkDragContext *context,
719 GtkSelectionData *data, guint info, guint time)
724 /* We override the drag_leave signal to do nothing */
726 gtk_sctree_drag_leave (GtkWidget *widget, GdkDragContext *context, guint time)
731 /* We override the drag_motion signal to do nothing */
733 gtk_sctree_drag_motion (GtkWidget *widget, GdkDragContext *context,
734 gint x, gint y, guint time)
739 /* We override the drag_drop signal to do nothing */
741 gtk_sctree_drag_drop (GtkWidget *widget, GdkDragContext *context,
742 gint x, gint y, guint time)
747 /* We override the drag_data_received signal to do nothing */
749 gtk_sctree_drag_data_received (GtkWidget *widget, GdkDragContext *context,
750 gint x, gint y, GtkSelectionData *data,
751 guint info, guint time)
756 /* Our handler for the clear signal of the clist. We have to reset the anchor
760 gtk_sctree_clear (GtkCMCList *clist)
764 cm_return_if_fail (clist != NULL);
765 cm_return_if_fail (GTK_IS_SCTREE (clist));
767 sctree = GTK_SCTREE (clist);
768 sctree->anchor_row = NULL;
770 if (((GtkCMCListClass *)parent_class)->clear)
771 (* ((GtkCMCListClass *)parent_class)->clear) (clist);
775 gtk_sctree_real_unselect_all (GtkCMCList *clist)
778 gboolean should_freeze = FALSE;
780 cm_return_if_fail (clist != NULL);
781 cm_return_if_fail (GTK_IS_SCTREE (clist));
783 sctree = GTK_SCTREE (clist);
785 if (sc_g_list_bigger(GTK_CMCLIST(sctree)->selection, 10)) {
786 should_freeze = TRUE;
787 sctree->selecting_range++;
788 gtk_cmclist_freeze (GTK_CMCLIST (sctree));
791 if (((GtkCMCListClass *)parent_class)->unselect_all)
792 (* ((GtkCMCListClass *)parent_class)->unselect_all) (clist);
795 gtk_cmclist_thaw (GTK_CMCLIST (sctree));
796 sctree->selecting_range--;
801 gtk_sctree_column_auto_resize (GtkCMCList *clist,
802 GtkCMCListRow *clist_row,
806 /* resize column if needed for auto_resize */
807 GtkRequisition requisition;
809 if (!clist->column[column].auto_resize ||
810 GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
814 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
815 column, &requisition);
817 requisition.width = 0;
819 if (requisition.width > clist->column[column].width)
820 gtk_cmclist_set_column_width (clist, column, requisition.width);
821 else if (requisition.width < old_width &&
822 old_width == clist->column[column].width)
825 GtkRequisition button_req;
828 /* run a "gtk_cmclist_optimal_column_width" but break, if
829 * the column doesn't shrink */
830 if (GTK_CMCLIST_SHOW_TITLES (clist) && clist->column[column].button)
832 gtk_widget_get_requisition (clist->column[column].button, &button_req);
833 new_width = (button_req.width -
834 (CELL_SPACING + (2 * COLUMN_INSET)));
839 for (list = clist->row_list; list; list = list->next)
841 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
842 (clist, GTK_CMCLIST_ROW (list), column, &requisition);
843 new_width = MAX (new_width, requisition.width);
844 if (new_width == clist->column[column].width)
847 if (new_width < clist->column[column].width)
848 gtk_cmclist_set_column_width (clist, column, new_width);
853 gtk_sctree_auto_resize_columns (GtkCMCList *clist)
857 if (GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
860 for (i = 0; i < clist->columns; i++)
861 gtk_sctree_column_auto_resize (clist, NULL, i, clist->column[i].width);
865 gtk_sctree_real_tree_collapse (GtkCMCTree *ctree,
866 GtkCMCTreeNode *node)
869 GtkCMCTreeNode *work;
870 GtkRequisition requisition;
874 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
876 if (!node || !GTK_CMCTREE_ROW (node)->expanded ||
877 GTK_CMCTREE_ROW (node)->is_leaf)
880 clist = GTK_CMCLIST (ctree);
882 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
884 GTK_CMCTREE_ROW (node)->expanded = FALSE;
885 level = GTK_CMCTREE_ROW (node)->level;
887 visible = gtk_cmctree_is_viewable (ctree, node);
888 /* get cell width if tree_column is auto resized */
889 if (visible && clist->column[ctree->tree_column].auto_resize &&
890 !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
891 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
892 (clist, >K_CMCTREE_ROW (node)->row, ctree->tree_column, &requisition);
894 /* unref/unset opened pixbuf */
895 if (GTK_CMCELL_PIXTEXT
896 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf)
900 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf);
903 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf = NULL;
906 /* set/ref closed pixbuf */
907 if (GTK_CMCTREE_ROW (node)->pixbuf_closed)
910 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf =
911 g_object_ref (GTK_CMCTREE_ROW (node)->pixbuf_closed);
914 work = GTK_CMCTREE_ROW (node)->children;
921 while (work && GTK_CMCTREE_ROW (work)->level > level)
923 work = GTK_CMCTREE_NODE_NEXT (work);
929 list = (GList *)node;
930 list->next = (GList *)work;
931 list = (GList *)GTK_CMCTREE_NODE_PREV (work);
933 list = (GList *)work;
934 list->prev = (GList *)node;
938 list = (GList *)node;
940 clist->row_list_end = (GList *)node;
945 /* resize auto_resize columns if needed */
946 gtk_sctree_auto_resize_columns (clist);
948 if (!GTK_SCTREE(clist)->sorting) {
949 row = g_list_position (clist->row_list, (GList *)node);
950 if (row < clist->focus_row)
951 clist->focus_row -= tmp;
954 CLIST_REFRESH (clist);
957 else if (visible && clist->column[ctree->tree_column].auto_resize &&
958 !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
959 /* resize tree_column if needed */
960 gtk_sctree_column_auto_resize (clist, >K_CMCTREE_ROW (node)->row, ctree->tree_column,
966 GtkWidget *gtk_sctree_new_with_titles (gint columns, gint tree_column,
971 cm_return_val_if_fail (columns > 0, NULL);
972 cm_return_val_if_fail (tree_column >= 0, NULL);
974 if (tree_column >= columns) {
975 g_warning("Wrong tree column");
980 widget = gtk_widget_new (TYPE_GTK_SCTREE,
981 "n_columns", columns,
982 "tree_column", tree_column,
985 GtkCMCList *clist = GTK_CMCLIST (widget);
988 for (i = 0; i < columns; i++)
989 gtk_cmclist_set_column_title (clist, i, titles[i]);
990 gtk_cmclist_column_titles_show (clist);
993 GTK_SCTREE(widget)->show_stripes = TRUE;
994 GTK_SCTREE(widget)->always_expand_recursively = TRUE;
995 GTK_SCTREE(widget)->force_additive_sel = FALSE;
997 GTK_SCTREE(widget)->use_markup = g_new0(gboolean, columns);
1002 void gtk_sctree_set_use_markup (GtkSCTree *sctree,
1007 GValue value = { 0 };
1009 cm_return_if_fail(GTK_IS_SCTREE(sctree));
1011 g_value_init (&value, G_TYPE_INT);
1012 g_object_get_property (G_OBJECT (sctree), "n-columns", &value);
1013 columns = g_value_get_int (&value);
1014 g_value_unset (&value);
1016 cm_return_if_fail(column < columns);
1018 sctree->use_markup[column] = markup;
1021 void gtk_sctree_select (GtkSCTree *sctree, GtkCMCTreeNode *node)
1024 g_list_position(GTK_CMCLIST(sctree)->row_list, (GList *)node),
1028 void gtk_sctree_select_with_state (GtkSCTree *sctree, GtkCMCTreeNode *node, int state)
1031 g_list_position(GTK_CMCLIST(sctree)->row_list, (GList *)node),
1035 void gtk_sctree_unselect_all (GtkSCTree *sctree)
1037 gtk_cmclist_unselect_all(GTK_CMCLIST(sctree));
1038 sctree->anchor_row = NULL;
1041 void gtk_sctree_set_anchor_row (GtkSCTree *sctree, GtkCMCTreeNode *node)
1043 sctree->anchor_row = node;
1046 void gtk_sctree_remove_node (GtkSCTree *sctree, GtkCMCTreeNode *node)
1048 if (sctree->anchor_row == node)
1049 sctree->anchor_row = NULL;
1050 gtk_cmctree_remove_node(GTK_CMCTREE(sctree), node);
1053 void gtk_sctree_set_stripes(GtkSCTree *sctree, gboolean show_stripes)
1055 sctree->show_stripes = show_stripes;
1058 void gtk_sctree_set_recursive_expand(GtkSCTree *sctree, gboolean rec_exp)
1060 sctree->always_expand_recursively = rec_exp;
1063 /***********************************************************
1064 * Tree sorting functions *
1065 ***********************************************************/
1067 static void sink(GtkCMCList *clist, GPtrArray *numbers, gint root, gint bottom)
1070 GtkCMCTreeNode *temp;
1075 /* find the maximum element of numbers[root],
1076 numbers[2*root] and numbers[2*root+1] */
1078 if (clist->compare( clist, GTK_CMCTREE_ROW (g_ptr_array_index(numbers, root)),
1079 GTK_CMCTREE_ROW(g_ptr_array_index( numbers, j))) >= 0)
1082 if (clist->compare( clist, GTK_CMCTREE_ROW (g_ptr_array_index(numbers, k)),
1083 GTK_CMCTREE_ROW (g_ptr_array_index( numbers, j))) > 0)
1085 /* if numbers[root] wasn't the maximum element then
1088 temp = g_ptr_array_index( numbers,root);
1089 g_ptr_array_index( numbers, root) = g_ptr_array_index( numbers, j);
1090 g_ptr_array_index( numbers, j) = temp;
1091 sink( clist, numbers, j, bottom);
1096 static void heap_sort(GtkCMCList *clist, GPtrArray *numbers, gint array_size)
1099 GtkCMCTreeNode *temp;
1101 /* build the Heap */
1102 for (i = (array_size / 2); i >= 1; i--)
1103 sink( clist, numbers, i, array_size);
1104 /* output the Heap */
1105 for (i = array_size; i >= 2; i--) {
1106 temp = g_ptr_array_index( numbers, 1);
1107 g_ptr_array_index( numbers, 1) = g_ptr_array_index( numbers, i);
1108 g_ptr_array_index( numbers, i) = temp;
1109 sink( clist, numbers, 1, i-1);
1114 stree_sort (GtkCMCTree *ctree,
1115 GtkCMCTreeNode *node,
1118 GtkCMCTreeNode *list_start, *work, *next;
1119 GPtrArray *row_array, *viewable_array;
1123 clist = GTK_CMCLIST (ctree);
1126 work = GTK_CMCTREE_ROW (node)->children;
1128 work = GTK_CMCTREE_NODE (clist->row_list);
1130 row_array = g_ptr_array_new();
1131 viewable_array = g_ptr_array_new();
1134 g_ptr_array_add( row_array, NULL);
1136 /* add all rows to row_array */
1137 g_ptr_array_add( row_array, work);
1138 if (GTK_CMCTREE_ROW (work)->parent && gtk_cmctree_is_viewable( ctree, work))
1139 g_ptr_array_add( viewable_array, GTK_CMCTREE_ROW (work)->parent);
1140 next = GTK_CMCTREE_ROW (work)->sibling;
1141 gtk_sctree_unlink( ctree, work, FALSE);
1145 heap_sort( clist, row_array, (row_array->len)-1);
1148 list_start = GTK_CMCTREE_ROW (node)->children;
1150 list_start = GTK_CMCTREE_NODE (clist->row_list);
1152 if (clist->sort_type == GTK_SORT_ASCENDING) {
1153 for (i=(row_array->len)-1; i>=1; i--) {
1154 work = g_ptr_array_index( row_array, i);
1155 gtk_sctree_link( ctree, work, node, list_start, FALSE);
1157 /* insert work at the beginning of the list */
1160 for (i=1; i<row_array->len; i++) {
1161 work = g_ptr_array_index( row_array, i);
1162 gtk_sctree_link( ctree, work, node, list_start, FALSE);
1164 /* insert work at the beginning of the list */
1168 for (i=0; i<viewable_array->len; i++) {
1169 gtk_cmctree_expand( ctree, g_ptr_array_index( viewable_array, i));
1173 g_ptr_array_free( row_array, TRUE);
1174 g_ptr_array_free( viewable_array, TRUE);
1178 gtk_sctree_sort_recursive (GtkCMCTree *ctree,
1179 GtkCMCTreeNode *node)
1182 GtkCMCTreeNode *focus_node = NULL;
1184 cm_return_if_fail (ctree != NULL);
1185 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
1187 clist = GTK_CMCLIST (ctree);
1189 gtk_cmclist_freeze (clist);
1191 if (clist->selection_mode == GTK_SELECTION_MULTIPLE) {
1192 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1194 g_list_free (clist->undo_selection);
1195 g_list_free (clist->undo_unselection);
1196 clist->undo_selection = NULL;
1197 clist->undo_unselection = NULL;
1200 if (!node || (node && gtk_cmctree_is_viewable (ctree, node)))
1201 focus_node = GTK_CMCTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
1203 GTK_SCTREE(ctree)->sorting = TRUE;
1205 gtk_cmctree_post_recursive (ctree, node, GTK_CMCTREE_FUNC (stree_sort), NULL);
1208 stree_sort (ctree, NULL, NULL);
1210 GTK_SCTREE(ctree)->sorting = FALSE;
1213 clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
1214 clist->undo_anchor = clist->focus_row;
1217 gtk_cmclist_thaw (clist);
1221 gtk_sctree_sort_node (GtkCMCTree *ctree,
1222 GtkCMCTreeNode *node)
1225 GtkCMCTreeNode *focus_node = NULL;
1227 cm_return_if_fail (ctree != NULL);
1228 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
1230 clist = GTK_CMCLIST (ctree);
1232 gtk_cmclist_freeze (clist);
1234 if (clist->selection_mode == GTK_SELECTION_MULTIPLE) {
1235 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1237 g_list_free (clist->undo_selection);
1238 g_list_free (clist->undo_unselection);
1239 clist->undo_selection = NULL;
1240 clist->undo_unselection = NULL;
1243 if (!node || (node && gtk_cmctree_is_viewable (ctree, node)))
1244 focus_node = GTK_CMCTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
1246 GTK_SCTREE(ctree)->sorting = TRUE;
1248 stree_sort (ctree, node, NULL);
1250 GTK_SCTREE(ctree)->sorting = FALSE;
1253 clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
1254 clist->undo_anchor = clist->focus_row;
1257 gtk_cmclist_thaw (clist);
1260 /************************************************************************/
1263 gtk_sctree_unlink (GtkCMCTree *ctree,
1264 GtkCMCTreeNode *node,
1265 gboolean update_focus_row)
1271 GtkCMCTreeNode *work;
1272 GtkCMCTreeNode *parent;
1275 cm_return_if_fail (ctree != NULL);
1276 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
1277 cm_return_if_fail (node != NULL);
1279 clist = GTK_CMCLIST (ctree);
1281 if (update_focus_row && clist->selection_mode == GTK_SELECTION_MULTIPLE) {
1282 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1284 g_list_free (clist->undo_selection);
1285 g_list_free (clist->undo_unselection);
1286 clist->undo_selection = NULL;
1287 clist->undo_unselection = NULL;
1290 visible = gtk_cmctree_is_viewable (ctree, node);
1292 /* clist->row_list_end unlinked ? */
1293 if (visible && (GTK_CMCTREE_NODE_NEXT (node) == NULL ||
1294 (GTK_CMCTREE_ROW (node)->children && gtk_cmctree_is_ancestor (ctree, node,
1295 GTK_CMCTREE_NODE (clist->row_list_end)))))
1296 clist->row_list_end = (GList *) (GTK_CMCTREE_NODE_PREV (node));
1300 level = GTK_CMCTREE_ROW (node)->level;
1301 work = GTK_CMCTREE_NODE_NEXT (node);
1302 while (work && GTK_CMCTREE_ROW (work)->level > level) {
1303 work = GTK_CMCTREE_NODE_NEXT (work);
1308 clist->rows -= (rows + 1);
1310 if (update_focus_row) {
1312 pos = g_list_position (clist->row_list, (GList *)node);
1313 if (pos + rows < clist->focus_row)
1314 clist->focus_row -= (rows + 1);
1315 else if (pos <= clist->focus_row) {
1316 if (!GTK_CMCTREE_ROW (node)->sibling)
1317 clist->focus_row = MAX (pos - 1, 0);
1319 clist->focus_row = pos;
1321 clist->focus_row = MIN (clist->focus_row, clist->rows - 1);
1323 clist->undo_anchor = clist->focus_row;
1328 list = (GList *)GTK_CMCTREE_NODE_PREV (work);
1330 list = (GList *)work;
1331 list->prev = (GList *)GTK_CMCTREE_NODE_PREV (node);
1334 if (GTK_CMCTREE_NODE_PREV (node) &&
1335 GTK_CMCTREE_NODE_NEXT (GTK_CMCTREE_NODE_PREV (node)) == node) {
1336 list = (GList *)GTK_CMCTREE_NODE_PREV (node);
1337 list->next = (GList *)work;
1341 parent = GTK_CMCTREE_ROW (node)->parent;
1343 if (GTK_CMCTREE_ROW (parent)->children == node) {
1344 GTK_CMCTREE_ROW (parent)->children = GTK_CMCTREE_ROW (node)->sibling;
1347 GtkCMCTreeNode *sibling;
1349 sibling = GTK_CMCTREE_ROW (parent)->children;
1350 while (GTK_CMCTREE_ROW (sibling)->sibling != node)
1351 sibling = GTK_CMCTREE_ROW (sibling)->sibling;
1352 GTK_CMCTREE_ROW (sibling)->sibling = GTK_CMCTREE_ROW (node)->sibling;
1356 if (clist->row_list == (GList *)node)
1357 clist->row_list = (GList *) (GTK_CMCTREE_ROW (node)->sibling);
1359 GtkCMCTreeNode *sibling;
1361 sibling = GTK_CMCTREE_NODE (clist->row_list);
1362 while (GTK_CMCTREE_ROW (sibling)->sibling != node)
1363 sibling = GTK_CMCTREE_ROW (sibling)->sibling;
1364 GTK_CMCTREE_ROW (sibling)->sibling = GTK_CMCTREE_ROW (node)->sibling;
1370 gtk_sctree_link (GtkCMCTree *ctree,
1371 GtkCMCTreeNode *node,
1372 GtkCMCTreeNode *parent,
1373 GtkCMCTreeNode *sibling,
1374 gboolean update_focus_row)
1380 gboolean visible = FALSE;
1384 cm_return_if_fail (GTK_CMCTREE_ROW (sibling)->parent == parent);
1385 cm_return_if_fail (node != NULL);
1386 cm_return_if_fail (node != sibling);
1387 cm_return_if_fail (node != parent);
1389 clist = GTK_CMCLIST (ctree);
1391 if (update_focus_row && clist->selection_mode == GTK_SELECTION_MULTIPLE) {
1392 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1394 g_list_free (clist->undo_selection);
1395 g_list_free (clist->undo_unselection);
1396 clist->undo_selection = NULL;
1397 clist->undo_unselection = NULL;
1400 for (rows = 1, list_end = (GList *)node; list_end->next;
1401 list_end = list_end->next)
1404 GTK_CMCTREE_ROW (node)->parent = parent;
1405 GTK_CMCTREE_ROW (node)->sibling = sibling;
1407 if (!parent || (parent && (gtk_cmctree_is_viewable (ctree, parent) &&
1408 GTK_CMCTREE_ROW (parent)->expanded))) {
1410 clist->rows += rows;
1414 work = (GList *)(GTK_CMCTREE_ROW (parent)->children);
1416 work = clist->row_list;
1419 if (work != (GList *)sibling) {
1420 while (GTK_CMCTREE_ROW (work)->sibling != sibling)
1421 work = (GList *)(GTK_CMCTREE_ROW (work)->sibling);
1422 GTK_CMCTREE_ROW (work)->sibling = node;
1425 if (sibling == GTK_CMCTREE_NODE (clist->row_list))
1426 clist->row_list = (GList *) node;
1427 if (GTK_CMCTREE_NODE_PREV (sibling) &&
1428 GTK_CMCTREE_NODE_NEXT (GTK_CMCTREE_NODE_PREV (sibling)) == sibling) {
1429 list = (GList *)GTK_CMCTREE_NODE_PREV (sibling);
1430 list->next = (GList *)node;
1433 list = (GList *)node;
1434 list->prev = (GList *)GTK_CMCTREE_NODE_PREV (sibling);
1435 list_end->next = (GList *)sibling;
1436 list = (GList *)sibling;
1437 list->prev = list_end;
1438 if (parent && GTK_CMCTREE_ROW (parent)->children == sibling)
1439 GTK_CMCTREE_ROW (parent)->children = node;
1444 while (GTK_CMCTREE_ROW (work)->sibling)
1445 work = (GList *)(GTK_CMCTREE_ROW (work)->sibling);
1446 GTK_CMCTREE_ROW (work)->sibling = node;
1448 /* find last visible child of sibling */
1449 work = (GList *) gtk_sctree_last_visible (ctree,
1450 GTK_CMCTREE_NODE (work));
1452 list_end->next = work->next;
1454 list = work->next->prev = list_end;
1455 work->next = (GList *)node;
1456 list = (GList *)node;
1461 GTK_CMCTREE_ROW (parent)->children = node;
1462 list = (GList *)node;
1463 list->prev = (GList *)parent;
1464 if (GTK_CMCTREE_ROW (parent)->expanded) {
1465 list_end->next = (GList *)GTK_CMCTREE_NODE_NEXT (parent);
1466 if (GTK_CMCTREE_NODE_NEXT(parent)) {
1467 list = (GList *)GTK_CMCTREE_NODE_NEXT (parent);
1468 list->prev = list_end;
1470 list = (GList *)parent;
1471 list->next = (GList *)node;
1474 list_end->next = NULL;
1477 clist->row_list = (GList *)node;
1478 list = (GList *)node;
1480 list_end->next = NULL;
1485 gtk_cmctree_pre_recursive (ctree, node, stree_update_level, NULL);
1487 if (clist->row_list_end == NULL ||
1488 clist->row_list_end->next == (GList *)node)
1489 clist->row_list_end = list_end;
1491 if (visible && update_focus_row) {
1493 pos = g_list_position (clist->row_list, (GList *)node);
1495 if (pos <= clist->focus_row) {
1496 clist->focus_row += rows;
1497 clist->undo_anchor = clist->focus_row;
1503 stree_update_level (GtkCMCTree *ctree,
1504 GtkCMCTreeNode *node,
1510 if (GTK_CMCTREE_ROW (node)->parent)
1511 GTK_CMCTREE_ROW (node)->level =
1512 GTK_CMCTREE_ROW (GTK_CMCTREE_ROW (node)->parent)->level + 1;
1514 GTK_CMCTREE_ROW (node)->level = 1;
1517 static GtkCMCTreeNode *
1518 gtk_sctree_last_visible (GtkCMCTree *ctree,
1519 GtkCMCTreeNode *node)
1521 GtkCMCTreeNode *work;
1526 work = GTK_CMCTREE_ROW (node)->children;
1528 if (!work || !GTK_CMCTREE_ROW (node)->expanded)
1531 while (GTK_CMCTREE_ROW (work)->sibling)
1532 work = GTK_CMCTREE_ROW (work)->sibling;
1534 return gtk_sctree_last_visible (ctree, work);
1538 sset_node_info (GtkCMCTree *ctree,
1539 GtkCMCTreeNode *node,
1542 GdkPixbuf *pixbuf_closed,
1543 GdkPixbuf *pixbuf_opened,
1547 if (GTK_CMCTREE_ROW (node)->pixbuf_opened)
1549 g_object_unref (GTK_CMCTREE_ROW (node)->pixbuf_opened);
1551 if (GTK_CMCTREE_ROW (node)->pixbuf_closed)
1553 g_object_unref (GTK_CMCTREE_ROW (node)->pixbuf_closed);
1556 GTK_CMCTREE_ROW (node)->pixbuf_opened = NULL;
1557 GTK_CMCTREE_ROW (node)->pixbuf_closed = NULL;
1561 GTK_CMCTREE_ROW (node)->pixbuf_closed = g_object_ref (pixbuf_closed);
1565 GTK_CMCTREE_ROW (node)->pixbuf_opened = g_object_ref (pixbuf_opened);
1568 GTK_CMCTREE_ROW (node)->is_leaf = is_leaf;
1569 GTK_CMCTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
1571 if (GTK_CMCTREE_ROW (node)->expanded)
1572 gtk_cmctree_node_set_pixtext (ctree, node, ctree->tree_column,
1573 text, spacing, pixbuf_opened);
1575 gtk_cmctree_node_set_pixtext (ctree, node, ctree->tree_column,
1576 text, spacing, pixbuf_closed);
1579 static GtkCMCTreeRow *
1580 srow_new (GtkCMCTree *ctree)
1583 GtkCMCTreeRow *ctree_row;
1586 clist = GTK_CMCLIST (ctree);
1587 #if GLIB_CHECK_VERSION(2,10,0)
1588 ctree_row = g_slice_new (GtkCMCTreeRow);
1589 ctree_row->row.cell = g_slice_alloc (sizeof (GtkCMCell) * clist->columns);
1591 ctree_row = g_chunk_new (GtkCMCTreeRow, (GMemChunk *)clist->row_mem_chunk);
1592 ctree_row->row.cell = g_chunk_new (GtkCMCell, (GMemChunk *)clist->cell_mem_chunk);
1594 for (i = 0; i < clist->columns; i++)
1596 ctree_row->row.cell[i].type = GTK_CMCELL_EMPTY;
1597 ctree_row->row.cell[i].vertical = 0;
1598 ctree_row->row.cell[i].horizontal = 0;
1599 ctree_row->row.cell[i].style = NULL;
1602 GTK_CMCELL_PIXTEXT (ctree_row->row.cell[ctree->tree_column])->text = NULL;
1604 ctree_row->row.fg_set = FALSE;
1605 ctree_row->row.bg_set = FALSE;
1606 ctree_row->row.style = NULL;
1607 ctree_row->row.selectable = TRUE;
1608 ctree_row->row.state = GTK_STATE_NORMAL;
1609 ctree_row->row.data = NULL;
1610 ctree_row->row.destroy = NULL;
1612 ctree_row->level = 0;
1613 ctree_row->expanded = FALSE;
1614 ctree_row->parent = NULL;
1615 ctree_row->sibling = NULL;
1616 ctree_row->children = NULL;
1617 ctree_row->pixbuf_closed = NULL;
1618 ctree_row->pixbuf_opened = NULL;
1624 srow_delete (GtkCMCTree *ctree,
1625 GtkCMCTreeRow *ctree_row)
1630 clist = GTK_CMCLIST (ctree);
1632 for (i = 0; i < clist->columns; i++)
1634 GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
1635 (clist, &(ctree_row->row), i, GTK_CMCELL_EMPTY, NULL, 0, NULL);
1636 if (ctree_row->row.cell[i].style)
1638 if (gtk_widget_get_realized (GTK_WIDGET(ctree)))
1639 gtk_style_detach (ctree_row->row.cell[i].style);
1640 g_object_unref (ctree_row->row.cell[i].style);
1644 if (ctree_row->row.style)
1646 if (gtk_widget_get_realized (GTK_WIDGET(ctree)))
1647 gtk_style_detach (ctree_row->row.style);
1648 g_object_unref (ctree_row->row.style);
1651 if (ctree_row->pixbuf_closed)
1653 g_object_unref (ctree_row->pixbuf_closed);
1656 if (ctree_row->pixbuf_opened)
1658 g_object_unref (ctree_row->pixbuf_opened);
1661 if (ctree_row->row.destroy)
1663 GDestroyNotify dnotify = ctree_row->row.destroy;
1664 gpointer ddata = ctree_row->row.data;
1666 ctree_row->row.destroy = NULL;
1667 ctree_row->row.data = NULL;
1672 #if GLIB_CHECK_VERSION(2,10,0)
1673 g_slice_free1 (sizeof (GtkCMCell) * clist->columns, ctree_row->row.cell);
1674 g_slice_free (GtkCMCTreeRow, ctree_row);
1676 g_mem_chunk_free ((GMemChunk *)clist->cell_mem_chunk, ctree_row->row.cell);
1677 g_mem_chunk_free ((GMemChunk *)clist->row_mem_chunk, ctree_row);
1682 stree_delete_row (GtkCMCTree *ctree,
1683 GtkCMCTreeNode *node,
1686 srow_delete (ctree, GTK_CMCTREE_ROW (node));
1687 g_list_free_1 ((GList *)node);
1691 gtk_sctree_real_tree_expand (GtkCMCTree *ctree,
1692 GtkCMCTreeNode *node)
1695 GtkCMCTreeNode *work;
1696 GtkRequisition requisition;
1699 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
1701 if (!node || GTK_CMCTREE_ROW (node)->expanded || GTK_CMCTREE_ROW (node)->is_leaf)
1704 clist = GTK_CMCLIST (ctree);
1706 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1708 GTK_CMCTREE_ROW (node)->expanded = TRUE;
1710 visible = gtk_cmctree_is_viewable (ctree, node);
1711 /* get cell width if tree_column is auto resized */
1712 if (visible && clist->column[ctree->tree_column].auto_resize &&
1713 !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
1714 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
1715 (clist, >K_CMCTREE_ROW (node)->row, ctree->tree_column, &requisition);
1717 /* unref/unset closed pixbuf */
1718 if (GTK_CMCELL_PIXTEXT
1719 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf)
1723 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf);
1726 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf = NULL;
1729 /* set/ref opened pixbuf */
1730 if (GTK_CMCTREE_ROW (node)->pixbuf_opened)
1733 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf =
1734 g_object_ref (GTK_CMCTREE_ROW (node)->pixbuf_opened);
1738 work = GTK_CMCTREE_ROW (node)->children;
1741 GList *list = (GList *)work;
1742 gint *cell_width = NULL;
1747 if (visible && !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
1749 cell_width = g_new0 (gint, clist->columns);
1750 if (clist->column[ctree->tree_column].auto_resize)
1751 cell_width[ctree->tree_column] = requisition.width;
1755 /* search maximum cell widths of auto_resize columns */
1756 for (i = 0; i < clist->columns; i++)
1757 if (clist->column[i].auto_resize)
1759 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
1760 (clist, >K_CMCTREE_ROW (work)->row, i, &requisition);
1761 cell_width[i] = MAX (requisition.width, cell_width[i]);
1764 list = (GList *)work;
1765 work = GTK_CMCTREE_NODE_NEXT (work);
1772 list = (GList *)work;
1773 work = GTK_CMCTREE_NODE_NEXT (work);
1777 list->next = (GList *)GTK_CMCTREE_NODE_NEXT (node);
1779 if (GTK_CMCTREE_NODE_NEXT (node))
1783 if (clist->row_list_end == list)
1784 clist->row_list_end = g_list_last(list);
1786 tmp_list = (GList *)GTK_CMCTREE_NODE_NEXT (node);
1787 tmp_list->prev = list;
1790 clist->row_list_end = list;
1792 list = (GList *)node;
1793 list->next = (GList *)(GTK_CMCTREE_ROW (node)->children);
1795 if (visible && !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
1797 /* resize auto_resize columns if needed */
1798 for (i = 0; i < clist->columns; i++)
1799 if (clist->column[i].auto_resize &&
1800 cell_width[i] > clist->column[i].width)
1801 gtk_cmclist_set_column_width (clist, i, cell_width[i]);
1802 g_free (cell_width);
1804 if (!GTK_SCTREE(ctree)->sorting) {
1805 /* update focus_row position */
1806 row = g_list_position (clist->row_list, (GList *)node);
1807 if (row < clist->focus_row)
1808 clist->focus_row += tmp;
1811 CLIST_REFRESH (clist);
1814 else if (visible && clist->column[ctree->tree_column].auto_resize)
1815 /* resize tree_column if needed */
1816 gtk_sctree_column_auto_resize (clist, >K_CMCTREE_ROW (node)->row, ctree->tree_column,
1822 gtk_sctree_insert_node (GtkCMCTree *ctree,
1823 GtkCMCTreeNode *parent,
1824 GtkCMCTreeNode *sibling,
1827 GdkPixbuf *pixbuf_closed,
1828 GdkPixbuf *pixbuf_opened,
1833 GtkCMCTreeRow *new_row;
1834 GtkCMCTreeNode *node;
1838 cm_return_val_if_fail (GTK_IS_CMCTREE (ctree), NULL);
1840 cm_return_val_if_fail (GTK_CMCTREE_ROW (sibling)->parent == parent, NULL);
1842 if (parent && GTK_CMCTREE_ROW (parent)->is_leaf)
1845 clist = GTK_CMCLIST (ctree);
1847 /* create the row */
1848 new_row = srow_new (ctree);
1849 list = g_list_alloc ();
1850 list->data = new_row;
1851 node = GTK_CMCTREE_NODE (list);
1854 for (i = 0; i < clist->columns; i++)
1855 if (text[i] && i != ctree->tree_column)
1856 GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
1857 (clist, &(new_row->row), i, GTK_CMCELL_TEXT, text[i], 0, NULL);
1859 sset_node_info (ctree, node, text ?
1860 text[ctree->tree_column] : NULL, spacing, pixbuf_closed,
1861 pixbuf_opened, is_leaf, expanded);
1863 /* sorted insertion */
1864 if (GTK_CMCLIST_AUTO_SORT (clist))
1867 sibling = GTK_CMCTREE_ROW (parent)->children;
1869 sibling = GTK_CMCTREE_NODE (clist->row_list);
1871 while (sibling && clist->compare
1872 (clist, GTK_CMCTREE_ROW (node), GTK_CMCTREE_ROW (sibling)) > 0)
1873 sibling = GTK_CMCTREE_ROW (sibling)->sibling;
1876 gtk_sctree_link (ctree, node, parent, sibling, FALSE);
1878 if (text && !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist) &&
1879 gtk_cmctree_is_viewable (ctree, node))
1881 for (i = 0; i < clist->columns; i++)
1882 if (clist->column[i].auto_resize)
1883 gtk_sctree_column_auto_resize (clist, &(new_row->row), i, 0);
1886 if (clist->rows == 1)
1888 clist->focus_row = 0;
1889 if (clist->selection_mode == GTK_SELECTION_BROWSE)
1890 gtk_sctree_select (GTK_SCTREE(ctree), node);
1894 CLIST_REFRESH (clist);
1900 gtk_sctree_insert_gnode (GtkCMCTree *ctree,
1901 GtkCMCTreeNode *parent,
1902 GtkCMCTreeNode *sibling,
1904 GtkCMCTreeGNodeFunc func,
1908 GtkCMCTreeNode *cnode = NULL;
1909 GtkCMCTreeNode *child = NULL;
1910 GtkCMCTreeNode *new_child;
1915 cm_return_val_if_fail (GTK_IS_CMCTREE (ctree), NULL);
1916 cm_return_val_if_fail (gnode != NULL, NULL);
1917 cm_return_val_if_fail (func != NULL, NULL);
1919 cm_return_val_if_fail (GTK_CMCTREE_ROW (sibling)->parent == parent, NULL);
1921 clist = GTK_CMCLIST (ctree);
1924 depth = GTK_CMCTREE_ROW (parent)->level + 1;
1926 list = g_list_alloc ();
1927 list->data = srow_new (ctree);
1928 cnode = GTK_CMCTREE_NODE (list);
1930 gtk_cmclist_freeze (clist);
1932 sset_node_info (ctree, cnode, "", 0, NULL, NULL, TRUE, FALSE);
1934 if (!func (ctree, depth, gnode, cnode, data))
1936 stree_delete_row (ctree, cnode, NULL);
1937 gtk_cmclist_thaw (clist);
1941 if (GTK_CMCLIST_AUTO_SORT (clist))
1944 sibling = GTK_CMCTREE_ROW (parent)->children;
1946 sibling = GTK_CMCTREE_NODE (clist->row_list);
1948 while (sibling && clist->compare
1949 (clist, GTK_CMCTREE_ROW (cnode), GTK_CMCTREE_ROW (sibling)) > 0)
1950 sibling = GTK_CMCTREE_ROW (sibling)->sibling;
1953 gtk_sctree_link (ctree, cnode, parent, sibling, FALSE);
1955 for (work = g_node_last_child (gnode); work; work = work->prev)
1957 new_child = gtk_sctree_insert_gnode (ctree, cnode, child,
1963 gtk_cmclist_thaw (clist);
1969 sreal_tree_move (GtkCMCTree *ctree,
1970 GtkCMCTreeNode *node,
1971 GtkCMCTreeNode *new_parent,
1972 GtkCMCTreeNode *new_sibling)
1975 GtkCMCTreeNode *work;
1976 gboolean visible = FALSE;
1978 cm_return_if_fail (ctree != NULL);
1979 cm_return_if_fail (node != NULL);
1980 cm_return_if_fail (!new_sibling ||
1981 GTK_CMCTREE_ROW (new_sibling)->parent == new_parent);
1983 if (new_parent && GTK_CMCTREE_ROW (new_parent)->is_leaf)
1986 /* new_parent != child of child */
1987 for (work = new_parent; work; work = GTK_CMCTREE_ROW (work)->parent)
1991 clist = GTK_CMCLIST (ctree);
1993 visible = gtk_cmctree_is_viewable (ctree, node);
1995 if (clist->selection_mode == GTK_SELECTION_MULTIPLE)
1997 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1999 g_list_free (clist->undo_selection);
2000 g_list_free (clist->undo_unselection);
2001 clist->undo_selection = NULL;
2002 clist->undo_unselection = NULL;
2005 if (GTK_CMCLIST_AUTO_SORT (clist))
2007 if (new_parent == GTK_CMCTREE_ROW (node)->parent)
2011 new_sibling = GTK_CMCTREE_ROW (new_parent)->children;
2013 new_sibling = GTK_CMCTREE_NODE (clist->row_list);
2015 while (new_sibling && clist->compare
2016 (clist, GTK_CMCTREE_ROW (node), GTK_CMCTREE_ROW (new_sibling)) > 0)
2017 new_sibling = GTK_CMCTREE_ROW (new_sibling)->sibling;
2020 if (new_parent == GTK_CMCTREE_ROW (node)->parent &&
2021 new_sibling == GTK_CMCTREE_ROW (node)->sibling)
2024 gtk_cmclist_freeze (clist);
2028 if (!GTK_SCTREE(ctree)->sorting && gtk_cmctree_is_viewable (ctree, node))
2029 work = GTK_CMCTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
2031 gtk_sctree_unlink (ctree, node, FALSE);
2032 gtk_sctree_link (ctree, node, new_parent, new_sibling, FALSE);
2034 if (!GTK_SCTREE(ctree)->sorting && work)
2036 while (work && !gtk_cmctree_is_viewable (ctree, work))
2037 work = GTK_CMCTREE_ROW (work)->parent;
2038 clist->focus_row = g_list_position (clist->row_list, (GList *)work);
2039 clist->undo_anchor = clist->focus_row;
2042 if (clist->column[ctree->tree_column].auto_resize &&
2043 !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist) &&
2044 (visible || gtk_cmctree_is_viewable (ctree, node)))
2045 gtk_cmclist_set_column_width
2046 (clist, ctree->tree_column,
2047 gtk_cmclist_optimal_column_width (clist, ctree->tree_column));
2049 gtk_cmclist_thaw (clist);
2052 void gtk_sctree_set_column_tooltip (GtkSCTree *sctree,
2056 #if !(GTK_CHECK_VERSION(2,12,0))
2058 if (!sctree->tooltips)
2059 sctree->tooltips = gtk_tooltips_new();
2060 tips = sctree->tooltips;
2063 CLAWS_SET_TIP(GTK_CMCLIST(sctree)->column[column].button,