?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Improve some sieve-related translations
[claws.git] / src / gtk / gtksctree.c
blob027300d34b96bc36584dace9bfdc6e8a9ea7bf78
1 /*
2 * Claws Mail -- a GTK based, lightweight, and fast e-mail client
3 * Parts of this file:
4 * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail team
5 *
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>
9 *
10 * Parts of this file from gtkflist.c:
11 * Copyright (C) 1999 The Free Software Foundation
12 * Author: Federico Mena <federico@nuclecu.unam.mx>
13 *
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.
18 *
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.
23 *
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/>.
26 *
27 */
28
29 #include "config.h"
30
31 #include <stdlib.h>
32
33 #include "gtksctree.h"
34 #include "claws-marshal.h"
35 #include "prefs_common.h"
36 #include "utils.h"
37 #include "gtkutils.h"
38
39 #define CLIST_UNFROZEN(clist) (((GtkCMCList*) (clist))->freeze_count == 0)
40 #define CLIST_REFRESH(clist) G_STMT_START { \
41 if (CLIST_UNFROZEN (clist)) \
42 GTK_CMCLIST_GET_CLASS (clist)->refresh ((GtkCMCList*) (clist)); \
43 } G_STMT_END
44 #define CELL_SPACING 1
45 #define CLIST_OPTIMUM_SIZE 64
46 #define COLUMN_INSET 3
47 #define PM_SIZE 8
48 #define TAB_SIZE (PM_SIZE + 6)
49 #define ROW_TOP_YPIXEL(clist, row) (((clist)->row_height * (row)) + \
50 (((row) + 1) * CELL_SPACING) + \
51 (clist)->voffset)
52 #define ROW_FROM_YPIXEL(clist, y) (((y) - (clist)->voffset) / \
53 ((clist)->row_height + CELL_SPACING))
54 #define COLUMN_LEFT_XPIXEL(clist, col) ((clist)->column[(col)].area.x \
55 + (clist)->hoffset)
56 #define COLUMN_LEFT(clist, column) ((clist)->column[(column)].area.x)
57
58 enum {
59 ROW_POPUP_MENU,
60 EMPTY_POPUP_MENU,
61 OPEN_ROW,
62 START_DRAG,
63 LAST_SIGNAL
64 };
65
66 static void gtk_sctree_class_init (GtkSCTreeClass *class);
67 static void gtk_sctree_init (GtkSCTree *sctree);
68
69 static gint gtk_sctree_button_press (GtkWidget *widget, GdkEventButton *event);
70 static gint gtk_sctree_button_release (GtkWidget *widget, GdkEventButton *event);
71 static gint gtk_sctree_motion (GtkWidget *widget, GdkEventMotion *event);
72 static void gtk_sctree_drag_begin (GtkWidget *widget, GdkDragContext *context);
73 static void gtk_sctree_drag_end (GtkWidget *widget, GdkDragContext *context);
74 static void gtk_sctree_drag_data_get (GtkWidget *widget, GdkDragContext *context,
75 GtkSelectionData *data, guint info, guint time);
76 static void gtk_sctree_drag_leave (GtkWidget *widget, GdkDragContext *context, guint time);
77 static gboolean gtk_sctree_drag_motion (GtkWidget *widget, GdkDragContext *context,
78 gint x, gint y, guint time);
79 static gboolean gtk_sctree_drag_drop (GtkWidget *widget, GdkDragContext *context,
80 gint x, gint y, guint time);
81 static void gtk_sctree_drag_data_received (GtkWidget *widget, GdkDragContext *context,
82 gint x, gint y, GtkSelectionData *data,
83 guint info, guint time);
84
85 static void gtk_sctree_clear (GtkCMCList *clist);
86 static void gtk_sctree_real_unselect_all (GtkCMCList *clist);
87
88 static void stree_sort (GtkCMCTree *ctree, GtkCMCTreeNode *node, gpointer data);
89 void gtk_sctree_sort_node (GtkCMCTree *ctree, GtkCMCTreeNode *node);
90 void gtk_sctree_sort_recursive (GtkCMCTree *ctree, GtkCMCTreeNode *node);
91
92 static void gtk_sctree_link (GtkCMCTree *ctree,
93 GtkCMCTreeNode *node,
94 GtkCMCTreeNode *parent,
95 GtkCMCTreeNode *sibling,
96 gboolean update_focus_row);
97
98 static void gtk_sctree_unlink (GtkCMCTree *ctree,
99 GtkCMCTreeNode *node,
100 gboolean update_focus_row);
101
102 static void stree_update_level (GtkCMCTree *ctree,
103 GtkCMCTreeNode *node,
104 gpointer data);
105
106 static GtkCMCTreeNode * gtk_sctree_last_visible (GtkCMCTree *ctree,
107 GtkCMCTreeNode *node);
108 static void gtk_sctree_real_tree_expand (GtkCMCTree *ctree,
109 GtkCMCTreeNode *node);
110 static void gtk_sctree_real_tree_collapse (GtkCMCTree *ctree,
111 GtkCMCTreeNode *node);
112 static void
113 sreal_tree_move (GtkCMCTree *ctree,
114 GtkCMCTreeNode *node,
115 GtkCMCTreeNode *new_parent,
116 GtkCMCTreeNode *new_sibling);
117
118 static GtkCMCTreeClass *parent_class;
119
120 static guint sctree_signals[LAST_SIGNAL];
121
122 /**
123 * gtk_sctree_get_type:
124 * @void:
125 *
126 * Creates the GtkSCTree class and its type information
127 *
128 * Return value: The type ID for GtkSCTreeClass
129 **/
130 GType
131 gtk_sctree_get_type (void)
132 {
133 static GType sctree_type = 0;
134
135 if (!sctree_type) {
136 GTypeInfo sctree_info = {
137 sizeof (GtkSCTreeClass),
138
139 (GBaseInitFunc) NULL,
140 (GBaseFinalizeFunc) NULL,
141
142 (GClassInitFunc) gtk_sctree_class_init,
143 (GClassFinalizeFunc) NULL,
144 NULL, /* class_data */
145
146 sizeof (GtkSCTree),
147 0, /* n_preallocs */
148 (GInstanceInitFunc) gtk_sctree_init,
149
150 (const GTypeValueTable *) NULL /* value table */
151 };
152
153 sctree_type = g_type_register_static (GTK_TYPE_CMCTREE, "GtkSCTree", &sctree_info, (GTypeFlags)0);
154 }
155
156 return sctree_type;
157 }
158
159 static void
160 gtk_sctree_change_focus_row_expansion (GtkCMCTree *ctree,
161 GtkCMCTreeExpansionType action)
162 {
163 GtkCMCList *clist;
164 GtkCMCTreeNode *node;
165
166 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
167
168 clist = GTK_CMCLIST (ctree);
169
170 if (gtkut_pointer_is_grabbed (GTK_WIDGET (ctree)) &&
171 gtk_widget_has_grab (GTK_WIDGET(ctree)))
172 return;
173
174 if (!(node =
175 GTK_CMCTREE_NODE (g_list_nth (clist->row_list, clist->focus_row))) ||
176 GTK_CMCTREE_ROW (node)->is_leaf || !(GTK_CMCTREE_ROW (node)->children))
177 return;
178
179 switch (action)
180 {
181 case GTK_CMCTREE_EXPANSION_EXPAND:
182 if (GTK_SCTREE(ctree)->always_expand_recursively)
183 gtk_cmctree_expand_recursive (ctree, node);
184 else
185 gtk_cmctree_expand (ctree, node);
186
187 break;
188 case GTK_CMCTREE_EXPANSION_EXPAND_RECURSIVE:
189 gtk_cmctree_expand_recursive (ctree, node);
190 break;
191 case GTK_CMCTREE_EXPANSION_COLLAPSE:
192 gtk_cmctree_collapse (ctree, node);
193 break;
194 case GTK_CMCTREE_EXPANSION_COLLAPSE_RECURSIVE:
195 gtk_cmctree_collapse_recursive (ctree, node);
196 break;
197 case GTK_CMCTREE_EXPANSION_TOGGLE:
198 if (GTK_SCTREE(ctree)->always_expand_recursively)
199 gtk_cmctree_toggle_expansion_recursive (ctree, node);
200 else
201 gtk_cmctree_toggle_expansion (ctree, node);
202 break;
203 case GTK_CMCTREE_EXPANSION_TOGGLE_RECURSIVE:
204 gtk_cmctree_toggle_expansion_recursive (ctree, node);
205 break;
206 }
207 }
208
209 static void gtk_sctree_finalize(GObject *object)
210 {
211 GtkSCTree *sctree = GTK_SCTREE(object);
212 g_free(sctree->use_markup);
213 sctree->use_markup = NULL;
214 G_OBJECT_CLASS (parent_class)->finalize (object);
215 }
216
217 /* Standard class initialization function */
218 static void
219 gtk_sctree_class_init (GtkSCTreeClass *klass)
220 {
221 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
222 GtkWidgetClass *widget_class;
223 GtkCMCListClass *clist_class;
224 GtkCMCTreeClass *ctree_class;
225
226 widget_class = (GtkWidgetClass *) klass;
227 clist_class = (GtkCMCListClass *) klass;
228 ctree_class = (GtkCMCTreeClass *) klass;
229
230 parent_class = g_type_class_peek (gtk_cmctree_get_type ());
231
232 sctree_signals[ROW_POPUP_MENU] =
233 g_signal_new ("row_popup_menu",
234 G_TYPE_FROM_CLASS (klass),
235 G_SIGNAL_RUN_FIRST,
236 G_STRUCT_OFFSET (GtkSCTreeClass, row_popup_menu),
237 NULL, NULL,
238 claws_marshal_VOID__POINTER,
239 G_TYPE_NONE, 1,
240 GDK_TYPE_EVENT);
241 sctree_signals[EMPTY_POPUP_MENU] =
242 g_signal_new ("empty_popup_menu",
243 G_TYPE_FROM_CLASS (klass),
244 G_SIGNAL_RUN_FIRST,
245 G_STRUCT_OFFSET (GtkSCTreeClass, empty_popup_menu),
246 NULL, NULL,
247 claws_marshal_VOID__POINTER,
248 G_TYPE_NONE, 1,
249 GDK_TYPE_EVENT);
250 sctree_signals[OPEN_ROW] =
251 g_signal_new ("open_row",
252 G_TYPE_FROM_CLASS (klass),
253 G_SIGNAL_RUN_FIRST,
254 G_STRUCT_OFFSET (GtkSCTreeClass, open_row),
255 NULL, NULL,
256 g_cclosure_marshal_VOID__VOID,
257 G_TYPE_NONE, 0);
258 sctree_signals[START_DRAG] =
259 g_signal_new ("start_drag",
260 G_TYPE_FROM_CLASS (klass),
261 G_SIGNAL_RUN_FIRST,
262 G_STRUCT_OFFSET (GtkSCTreeClass, start_drag),
263 NULL, NULL,
264 claws_marshal_VOID__INT_POINTER,
265 G_TYPE_NONE, 2,
266 G_TYPE_INT,
267 GDK_TYPE_EVENT);
268
269 /* gtk_object_class_add_signals (object_class, sctree_signals, LAST_SIGNAL); */
270
271 clist_class->clear = gtk_sctree_clear;
272 clist_class->unselect_all = gtk_sctree_real_unselect_all;
273 ctree_class->tree_collapse = gtk_sctree_real_tree_collapse;
274 ctree_class->tree_expand = gtk_sctree_real_tree_expand;
275 ctree_class->tree_move = sreal_tree_move;
276 ctree_class->change_focus_row_expansion = gtk_sctree_change_focus_row_expansion;
277
278 widget_class->button_press_event = gtk_sctree_button_press;
279 widget_class->button_release_event = gtk_sctree_button_release;
280 widget_class->motion_notify_event = gtk_sctree_motion;
281 widget_class->drag_begin = gtk_sctree_drag_begin;
282 widget_class->drag_end = gtk_sctree_drag_end;
283 widget_class->drag_data_get = gtk_sctree_drag_data_get;
284 widget_class->drag_leave = gtk_sctree_drag_leave;
285 widget_class->drag_motion = gtk_sctree_drag_motion;
286 widget_class->drag_drop = gtk_sctree_drag_drop;
287 widget_class->drag_data_received = gtk_sctree_drag_data_received;
288
289 gobject_class->finalize = gtk_sctree_finalize;
290 }
291
292 /* Standard object initialization function */
293 static void
294 gtk_sctree_init (GtkSCTree *sctree)
295 {
296 sctree->anchor_row = NULL;
297
298 /* GtkCMCTree does not specify pointer motion by default */
299 gtk_widget_add_events (GTK_WIDGET (sctree), GDK_POINTER_MOTION_MASK);
300 gtk_widget_add_events (GTK_WIDGET (sctree), GDK_POINTER_MOTION_MASK);
301 }
302
303 /* Get information the specified row is selected. */
304
305 static gboolean
306 row_is_selected(GtkSCTree *sctree, gint row)
307 {
308 GtkCMCListRow *clist_row;
309 clist_row = g_list_nth (GTK_CMCLIST(sctree)->row_list, row)->data;
310 return clist_row ? clist_row->state == GTK_STATE_SELECTED : FALSE;
311 }
312
313 /* Selects the rows between the anchor to the specified row, inclusive. */
314 static void
315 select_range (GtkSCTree *sctree, gint row)
316 {
317 gint prev_row;
318 gint min, max;
319 gint i;
320 GList *node;
321 if (sctree->anchor_row == NULL) {
322 prev_row = row;
323 sctree->anchor_row = gtk_cmctree_node_nth(GTK_CMCTREE(sctree), row);
324 } else
325 prev_row = g_list_position(GTK_CMCLIST(sctree)->row_list,
326 (GList *)sctree->anchor_row);
327
328 if (row < prev_row) {
329 min = row;
330 max = prev_row;
331 GTK_CMCLIST(sctree)->focus_row = min;
332 } else {
333 min = prev_row;
334 max = row;
335 }
336 sctree->selecting_range++;
337
338 if (max < min) {
339 int t = min;
340 min = max;
341 max = t;
342 }
343
344 if (max - min > 10)
345 gtk_cmclist_freeze(GTK_CMCLIST(sctree));
346
347 node = g_list_nth((GTK_CMCLIST(sctree))->row_list, min);
348 for (i = min; i < max; i++) {
349 if (node && GTK_CMCTREE_ROW (node)->row.selectable) {
350 g_signal_emit_by_name(G_OBJECT(sctree), "tree_select_row",
351 node, -1);
352 }
353 node = node->next;
354 }
355 if (max - min > 10)
356 gtk_cmclist_thaw(GTK_CMCLIST(sctree));
357
358
359 sctree->selecting_range--;
360 gtk_cmclist_select_row (GTK_CMCLIST (sctree), max, -1);
361 }
362
363 /* Handles row selection according to the specified modifier state */
364 /* in certain cases, we arrive here from a function knowing the GtkCMCTreeNode, and having
365 * already slowly found row using g_list_position. In which case, _node will be non-NULL
366 * to avoid this function having to slowly find it with g_list_nth. */
367 static void
368 select_row (GtkSCTree *sctree, gint row, gint col, guint state, GtkCMCTreeNode *_node)
369 {
370 gboolean range, additive;
371 cm_return_if_fail (sctree != NULL);
372 cm_return_if_fail (GTK_IS_SCTREE (sctree));
373
374 range = ((state & GDK_SHIFT_MASK) != 0) &&
375 (GTK_CMCLIST(sctree)->selection_mode != GTK_SELECTION_SINGLE) &&
376 (GTK_CMCLIST(sctree)->selection_mode != GTK_SELECTION_BROWSE);
377 additive = ((state & GDK_CONTROL_MASK) != 0) &&
378 (GTK_CMCLIST(sctree)->selection_mode != GTK_SELECTION_SINGLE) &&
379 (GTK_CMCLIST(sctree)->selection_mode != GTK_SELECTION_BROWSE);
380
381 if (!range && !additive && sctree->force_additive_sel)
382 additive = TRUE;
383
384 GTK_CMCLIST(sctree)->focus_row = row;
385
386 if (!additive) {
387 gtk_cmclist_unselect_all (GTK_CMCLIST (sctree));
388 }
389
390 if (!range) {
391 GtkCMCTreeNode *node;
392
393 node = _node ? _node : gtk_cmctree_node_nth (GTK_CMCTREE(sctree), row);
394
395 /*No need to manage overlapped list*/
396 if (additive) {
397 if (row_is_selected(sctree, row))
398 gtk_cmclist_unselect_row (GTK_CMCLIST (sctree), row, col);
399 else
400 g_signal_emit_by_name
401 (G_OBJECT (sctree),
402 "tree_select_row", node, col);
403 } else {
404 g_signal_emit_by_name
405 (G_OBJECT (sctree),
406 "tree_select_row", node, col);
407 }
408 sctree->anchor_row = node;
409 } else
410 select_range (sctree, row);
411 }
412
413 static gboolean
414 sctree_is_hot_spot (GtkSCTree *sctree,
415 GtkCMCTreeNode *node,
416 gint row,
417 gint x,
418 gint y)
419 {
420 GtkCMCTreeRow *tree_row;
421 GtkCMCList *clist;
422 GtkCMCTree *ctree;
423 gint xl, xmax;
424 gint yu;
425 gint hotspot_size;
426
427 cm_return_val_if_fail (GTK_IS_SCTREE (sctree), FALSE);
428 cm_return_val_if_fail (node != NULL, FALSE);
429
430 clist = GTK_CMCLIST (sctree);
431 ctree = GTK_CMCTREE (sctree);
432
433 if (!clist->column[ctree->tree_column].visible ||
434 ctree->expander_style == GTK_CMCTREE_EXPANDER_NONE)
435 return FALSE;
436
437 tree_row = GTK_CMCTREE_ROW (node);
438 if (!tree_row->children)
439 return FALSE;
440
441 hotspot_size = clist->row_height-2;
442 if (hotspot_size > clist->column[ctree->tree_column].area.width - 2)
443 hotspot_size = clist->column[ctree->tree_column].area.width - 2;
444
445 if (!GTK_CMCLIST_ROW_HEIGHT_SET(GTK_CMCLIST(clist)))
446 yu = (ROW_TOP_YPIXEL (clist, row) + (clist->row_height - hotspot_size) / 2 -
447 (clist->row_height - 1) % 2);
448 else
449 yu = (ROW_TOP_YPIXEL (clist, row) + (clist->row_height/2 - hotspot_size) / 2 -
450 (clist->row_height/2 - 1) % 2);
451
452 #ifndef GENERIC_UMPC
453 if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT)
454 xl = clist->column[ctree->tree_column].area.x +
455 clist->column[ctree->tree_column].area.width - 1 + clist->hoffset -
456 (tree_row->level - 1) * ctree->tree_indent - hotspot_size;
457 else
458 xl = clist->column[ctree->tree_column].area.x + clist->hoffset +
459 (tree_row->level - 1) * ctree->tree_indent;
460
461 xmax = xl + hotspot_size;
462 #else
463 if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT) {
464 xl = clist->column[ctree->tree_column].area.x +
465 clist->column[ctree->tree_column].area.width - 1 + clist->hoffset -
466 (tree_row->level - 1) * ctree->tree_indent - hotspot_size;
467 xmax = xl + hotspot_size;
468 } else if (ctree->tree_column == 0) {
469 xl = clist->column[ctree->tree_column].area.x + clist->hoffset;
470 xmax = clist->column[ctree->tree_column].area.x + clist->hoffset +
471 (tree_row->level - 1) * ctree->tree_indent +
472 hotspot_size;
473 } else {
474 xl = clist->column[ctree->tree_column].area.x + clist->hoffset +
475 (tree_row->level - 1) * ctree->tree_indent;
476 xmax = xl + hotspot_size;
477 }
478 #endif
479 return (x >= xl && x <= xmax && y >= yu && y <= yu + hotspot_size);
480 }
481
482 gboolean
483 gtk_sctree_is_hot_spot (GtkSCTree *ctree,
484 gint x,
485 gint y)
486 {
487 GtkCMCTreeNode *node;
488 gint column;
489 gint row;
490
491 cm_return_val_if_fail (GTK_IS_SCTREE (ctree), FALSE);
492
493 if (gtk_cmclist_get_selection_info (GTK_CMCLIST (ctree), x, y, &row, &column))
494 if ((node = GTK_CMCTREE_NODE(g_list_nth (GTK_CMCLIST (ctree)->row_list, row))))
495 return sctree_is_hot_spot (ctree, node, row, x, y);
496
497 return FALSE;
498 }
499
500 /* Our handler for button_press events. We override all of GtkCMCList's broken
501 * behavior.
502 */
503 static gint
504 gtk_sctree_button_press (GtkWidget *widget, GdkEventButton *event)
505 {
506 GtkSCTree *sctree;
507 GtkCMCList *clist;
508 gboolean on_row;
509 gint row;
510 gint col;
511 gint retval;
512
513 cm_return_val_if_fail (widget != NULL, FALSE);
514 cm_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
515 cm_return_val_if_fail (event != NULL, FALSE);
516
517 sctree = GTK_SCTREE (widget);
518 clist = GTK_CMCLIST (widget);
519 retval = FALSE;
520
521 if (event->window != clist->clist_window)
522 return (* GTK_WIDGET_CLASS (parent_class)->button_press_event) (widget, event);
523
524 on_row = gtk_cmclist_get_selection_info (clist, event->x, event->y, &row, &col);
525
526 if (on_row && !gtk_widget_has_focus(widget))
527 gtk_widget_grab_focus (widget);
528
529 if (gtk_sctree_is_hot_spot (GTK_SCTREE(sctree), event->x, event->y)) {
530 GtkCMCTreeNode *node = gtk_cmctree_node_nth(GTK_CMCTREE(sctree), row);
531 if (GTK_CMCTREE_ROW (node)->expanded)
532 gtk_cmctree_collapse(GTK_CMCTREE(sctree), node);
533 else if (GTK_SCTREE(sctree)->always_expand_recursively)
534 gtk_cmctree_expand_recursive (GTK_CMCTREE(sctree), node);
535 else
536 gtk_cmctree_expand(GTK_CMCTREE(sctree), node);
537 return TRUE;
538 }
539
540 switch (event->type) {
541 case GDK_BUTTON_PRESS:
542 if (event->button == 1 || event->button == 2) {
543 if (event->button == 2)
544 event->state &= ~(GDK_SHIFT_MASK | GDK_CONTROL_MASK);
545 if (on_row) {
546 /* Save the mouse info for DnD */
547 sctree->dnd_press_button = event->button;
548 sctree->dnd_press_x = event->x;
549 sctree->dnd_press_y = event->y;
550
551 /* Handle selection */
552 if ((row_is_selected (sctree, row)
553 && !(event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)))
554 || ((event->state & GDK_CONTROL_MASK)
555 && !(event->state & GDK_SHIFT_MASK))) {
556 sctree->dnd_select_pending = TRUE;
557 sctree->dnd_select_pending_state = event->state;
558 sctree->dnd_select_pending_row = row;
559 } else {
560 select_row (sctree, row, col, event->state, NULL);
561 }
562 } else {
563 gtk_cmclist_unselect_all (clist);
564 }
565
566 retval = TRUE;
567 } else if (event->button == 3) {
568 /* Emit *_popup_menu signal*/
569 if (on_row) {
570 if (!row_is_selected(sctree,row))
571 select_row (sctree, row, col, 0, NULL);
572 g_signal_emit (G_OBJECT (sctree),
573 sctree_signals[ROW_POPUP_MENU],
574 0, event);
575 } else {
576 gtk_cmclist_unselect_all(clist);
577 g_signal_emit (G_OBJECT (sctree),
578 sctree_signals[EMPTY_POPUP_MENU],
579 0, event);
580 }
581 retval = TRUE;
582 }
583
584 break;
585
586 case GDK_2BUTTON_PRESS:
587 if (event->button != 1)
588 break;
589
590 sctree->dnd_select_pending = FALSE;
591 sctree->dnd_select_pending_state = 0;
592
593 if (on_row)
594 g_signal_emit (G_OBJECT (sctree),
595 sctree_signals[OPEN_ROW], 0);
596
597 retval = TRUE;
598 break;
599
600 default:
601 break;
602 }
603
604 return retval;
605 }
606
607 /* Our handler for button_release events. We override all of GtkCMCList's broken
608 * behavior.
609 */
610 static gint
611 gtk_sctree_button_release (GtkWidget *widget, GdkEventButton *event)
612 {
613 GtkSCTree *sctree;
614 GtkCMCList *clist;
615 gint on_row;
616 gint row, col;
617 gint retval;
618
619 cm_return_val_if_fail (widget != NULL, FALSE);
620 cm_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
621 cm_return_val_if_fail (event != NULL, FALSE);
622
623 sctree = GTK_SCTREE (widget);
624 clist = GTK_CMCLIST (widget);
625 retval = FALSE;
626
627 if (event->window != clist->clist_window)
628 return (* GTK_WIDGET_CLASS (parent_class)->button_release_event) (widget, event);
629
630 on_row = gtk_cmclist_get_selection_info (clist, event->x, event->y, &row, &col);
631
632 if (!(event->button == 1 || event->button == 2))
633 return FALSE;
634
635 sctree->dnd_press_button = 0;
636 sctree->dnd_press_x = 0;
637 sctree->dnd_press_y = 0;
638
639 if (on_row) {
640 if (sctree->dnd_select_pending) {
641 select_row (sctree, row, col, sctree->dnd_select_pending_state, NULL);
642 sctree->dnd_select_pending = FALSE;
643 sctree->dnd_select_pending_state = 0;
644 }
645
646 retval = TRUE;
647 }
648
649 return retval;
650 }
651
652 /* Our handler for motion_notify events. We override all of GtkCMCList's broken
653 * behavior.
654 */
655 static gint
656 gtk_sctree_motion (GtkWidget *widget, GdkEventMotion *event)
657 {
658 GtkSCTree *sctree;
659 GtkCMCList *clist;
660
661 cm_return_val_if_fail (widget != NULL, FALSE);
662 cm_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
663 cm_return_val_if_fail (event != NULL, FALSE);
664
665 sctree = GTK_SCTREE (widget);
666 clist = GTK_CMCLIST (widget);
667
668 if (event->window != clist->clist_window)
669 return (* GTK_WIDGET_CLASS (parent_class)->motion_notify_event) (widget, event);
670
671 if (!((sctree->dnd_press_button == 1 && (event->state & GDK_BUTTON1_MASK))
672 || (sctree->dnd_press_button == 2 && (event->state & GDK_BUTTON2_MASK))))
673 return FALSE;
674
675 /* This is the same threshold value that is used in gtkdnd.c */
676
677 #ifndef GENERIC_UMPC
678 #define THRESHOLD 3
679 #else
680 #define THRESHOLD 8
681 #endif
682 if (MAX (ABS (sctree->dnd_press_x - event->x),
683 ABS (sctree->dnd_press_y - event->y)) <= THRESHOLD)
684 return FALSE;
685
686 /* Handle any pending selections */
687
688 if (sctree->dnd_select_pending) {
689 if (!row_is_selected(sctree,sctree->dnd_select_pending_row))
690 select_row (sctree,
691 sctree->dnd_select_pending_row,
692 -1,
693 sctree->dnd_select_pending_state,
694 NULL);
695
696 sctree->dnd_select_pending = FALSE;
697 sctree->dnd_select_pending_state = 0;
698 }
699
700 g_signal_emit (G_OBJECT (sctree),
701 sctree_signals[START_DRAG],
702 0,
703 sctree->dnd_press_button,
704 event);
705 return TRUE;
706 }
707
708 /* We override the drag_begin signal to do nothing */
709 static void
710 gtk_sctree_drag_begin (GtkWidget *widget, GdkDragContext *context)
711 {
712 /* nothing */
713 }
714
715 /* We override the drag_end signal to do nothing */
716 static void
717 gtk_sctree_drag_end (GtkWidget *widget, GdkDragContext *context)
718 {
719 /* nothing */
720 }
721
722 /* We override the drag_data_get signal to do nothing */
723 static void
724 gtk_sctree_drag_data_get (GtkWidget *widget, GdkDragContext *context,
725 GtkSelectionData *data, guint info, guint time)
726 {
727 /* nothing */
728 }
729
730 /* We override the drag_leave signal to do nothing */
731 static void
732 gtk_sctree_drag_leave (GtkWidget *widget, GdkDragContext *context, guint time)
733 {
734 /* nothing */
735 }
736
737 /* We override the drag_motion signal to do nothing */
738 static gboolean
739 gtk_sctree_drag_motion (GtkWidget *widget, GdkDragContext *context,
740 gint x, gint y, guint time)
741 {
742 return FALSE;
743 }
744
745 /* We override the drag_drop signal to do nothing */
746 static gboolean
747 gtk_sctree_drag_drop (GtkWidget *widget, GdkDragContext *context,
748 gint x, gint y, guint time)
749 {
750 return FALSE;
751 }
752
753 /* We override the drag_data_received signal to do nothing */
754 static void
755 gtk_sctree_drag_data_received (GtkWidget *widget, GdkDragContext *context,
756 gint x, gint y, GtkSelectionData *data,
757 guint info, guint time)
758 {
759 /* nothing */
760 }
761
762 /* Our handler for the clear signal of the clist. We have to reset the anchor
763 * to null.
764 */
765 static void
766 gtk_sctree_clear (GtkCMCList *clist)
767 {
768 GtkSCTree *sctree;
769
770 cm_return_if_fail (clist != NULL);
771 cm_return_if_fail (GTK_IS_SCTREE (clist));
772
773 sctree = GTK_SCTREE (clist);
774 sctree->anchor_row = NULL;
775
776 if (((GtkCMCListClass *)parent_class)->clear)
777 (* ((GtkCMCListClass *)parent_class)->clear) (clist);
778 }
779
780 static void
781 gtk_sctree_real_unselect_all (GtkCMCList *clist)
782 {
783 GtkSCTree *sctree;
784 gboolean should_freeze = FALSE;
785
786 cm_return_if_fail (clist != NULL);
787 cm_return_if_fail (GTK_IS_SCTREE (clist));
788
789 sctree = GTK_SCTREE (clist);
790
791 if (sc_g_list_bigger(GTK_CMCLIST(sctree)->selection, 10)) {
792 should_freeze = TRUE;
793 sctree->selecting_range++;
794 gtk_cmclist_freeze (GTK_CMCLIST (sctree));
795 }
796
797 if (((GtkCMCListClass *)parent_class)->unselect_all)
798 (* ((GtkCMCListClass *)parent_class)->unselect_all) (clist);
799
800 if (should_freeze) {
801 gtk_cmclist_thaw (GTK_CMCLIST (sctree));
802 sctree->selecting_range--;
803 }
804 }
805
806 static void
807 gtk_sctree_column_auto_resize (GtkCMCList *clist,
808 GtkCMCListRow *clist_row,
809 gint column,
810 gint old_width)
811 {
812 /* resize column if needed for auto_resize */
813 GtkRequisition requisition;
814
815 if (!clist->column[column].auto_resize ||
816 GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
817 return;
818
819 if (clist_row)
820 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
821 column, &requisition);
822 else
823 requisition.width = 0;
824
825 if (requisition.width > clist->column[column].width)
826 gtk_cmclist_set_column_width (clist, column, requisition.width);
827 else if (requisition.width < old_width &&
828 old_width == clist->column[column].width)
829 {
830 GList *list;
831 GtkRequisition button_req;
832 gint new_width;
833
834 /* run a "gtk_cmclist_optimal_column_width" but break, if
835 * the column doesn't shrink */
836 if (GTK_CMCLIST_SHOW_TITLES (clist) && clist->column[column].button)
837 {
838 gtk_widget_get_requisition (clist->column[column].button, &button_req);
839 new_width = (button_req.width -
840 (CELL_SPACING + (2 * COLUMN_INSET)));
841 }
842 else
843 new_width = 0;
844
845 for (list = clist->row_list; list; list = list->next)
846 {
847 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
848 (clist, GTK_CMCLIST_ROW (list), column, &requisition);
849 new_width = MAX (new_width, requisition.width);
850 if (new_width == clist->column[column].width)
851 break;
852 }
853 if (new_width < clist->column[column].width)
854 gtk_cmclist_set_column_width (clist, column, new_width);
855 }
856 }
857
858 static void
859 gtk_sctree_auto_resize_columns (GtkCMCList *clist)
860 {
861 gint i;
862
863 if (GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
864 return;
865
866 for (i = 0; i < clist->columns; i++)
867 gtk_sctree_column_auto_resize (clist, NULL, i, clist->column[i].width);
868 }
869
870 static void
871 gtk_sctree_real_tree_collapse (GtkCMCTree *ctree,
872 GtkCMCTreeNode *node)
873 {
874 GtkCMCList *clist;
875 GtkCMCTreeNode *work;
876 GtkRequisition requisition;
877 gboolean visible;
878 gint level;
879
880 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
881
882 if (!node || !GTK_CMCTREE_ROW (node)->expanded ||
883 GTK_CMCTREE_ROW (node)->is_leaf)
884 return;
885
886 clist = GTK_CMCLIST (ctree);
887
888 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
889
890 GTK_CMCTREE_ROW (node)->expanded = FALSE;
891 level = GTK_CMCTREE_ROW (node)->level;
892
893 visible = gtk_cmctree_is_viewable (ctree, node);
894 /* get cell width if tree_column is auto resized */
895 if (visible && clist->column[ctree->tree_column].auto_resize &&
896 !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
897 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
898 (clist, &GTK_CMCTREE_ROW (node)->row, ctree->tree_column, &requisition);
899
900 /* unref/unset opened pixbuf */
901 if (GTK_CMCELL_PIXTEXT
902 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf)
903 {
904 g_object_unref
905 (GTK_CMCELL_PIXTEXT
906 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf);
907
908 GTK_CMCELL_PIXTEXT
909 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf = NULL;
910 }
911
912 /* set/ref closed pixbuf */
913 if (GTK_CMCTREE_ROW (node)->pixbuf_closed)
914 {
915 GTK_CMCELL_PIXTEXT
916 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf =
917 g_object_ref (GTK_CMCTREE_ROW (node)->pixbuf_closed);
918 }
919
920 work = GTK_CMCTREE_ROW (node)->children;
921 if (work)
922 {
923 gint tmp = 0;
924 gint row;
925 GList *list;
926
927 while (work && GTK_CMCTREE_ROW (work)->level > level)
928 {
929 work = GTK_CMCTREE_NODE_NEXT (work);
930 tmp++;
931 }
932
933 if (work)
934 {
935 list = (GList *)node;
936 list->next = (GList *)work;
937 list = (GList *)GTK_CMCTREE_NODE_PREV (work);
938 list->next = NULL;
939 list = (GList *)work;
940 list->prev = (GList *)node;
941 }
942 else
943 {
944 list = (GList *)node;
945 list->next = NULL;
946 clist->row_list_end = (GList *)node;
947 }
948
949 if (visible)
950 {
951 /* resize auto_resize columns if needed */
952 gtk_sctree_auto_resize_columns (clist);
953
954 if (!GTK_SCTREE(clist)->sorting) {
955 row = g_list_position (clist->row_list, (GList *)node);
956 if (row < clist->focus_row)
957 clist->focus_row -= tmp;
958 }
959 clist->rows -= tmp;
960 CLIST_REFRESH (clist);
961 }
962 }
963 else if (visible && clist->column[ctree->tree_column].auto_resize &&
964 !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
965 /* resize tree_column if needed */
966 gtk_sctree_column_auto_resize (clist, &GTK_CMCTREE_ROW (node)->row, ctree->tree_column,
967 requisition.width);
968
969 }
970
971
972 GtkWidget *gtk_sctree_new_with_titles (gint columns, gint tree_column,
973 gchar *titles[])
974 {
975 GtkWidget *widget;
976
977 cm_return_val_if_fail (columns > 0, NULL);
978 cm_return_val_if_fail (tree_column >= 0, NULL);
979
980 if (tree_column >= columns) {
981 g_warning("wrong tree column");
982 tree_column = 0;
983 print_backtrace();
984 }
985
986 widget = gtk_widget_new (TYPE_GTK_SCTREE,
987 "n_columns", columns,
988 "tree_column", tree_column,
989 NULL);
990 if (titles) {
991 GtkCMCList *clist = GTK_CMCLIST (widget);
992 guint i;
993
994 for (i = 0; i < columns; i++)
995 gtk_cmclist_set_column_title (clist, i, titles[i]);
996 gtk_cmclist_column_titles_show (clist);
997 }
998
999 GTK_SCTREE(widget)->show_stripes = TRUE;
1000 GTK_SCTREE(widget)->always_expand_recursively = TRUE;
1001 GTK_SCTREE(widget)->force_additive_sel = FALSE;
1002
1003 GTK_SCTREE(widget)->use_markup = g_new0(gboolean, columns);
1004
1005 return widget;
1006 }
1007
1008 void gtk_sctree_set_use_markup (GtkSCTree *sctree,
1009 int column,
1010 gboolean markup)
1011 {
1012 gint columns = 0;
1013 GValue value = { 0 };
1014
1015 cm_return_if_fail(GTK_IS_SCTREE(sctree));
1016
1017 g_value_init (&value, G_TYPE_INT);
1018 g_object_get_property (G_OBJECT (sctree), "n-columns", &value);
1019 columns = g_value_get_int (&value);
1020 g_value_unset (&value);
1021
1022 cm_return_if_fail(column < columns);
1023
1024 sctree->use_markup[column] = markup;
1025 }
1026
1027 void gtk_sctree_select (GtkSCTree *sctree, GtkCMCTreeNode *node)
1028 {
1029 select_row(sctree,
1030 g_list_position(GTK_CMCLIST(sctree)->row_list, (GList *)node),
1031 -1, 0, node);
1032 }
1033
1034 void gtk_sctree_select_with_state (GtkSCTree *sctree, GtkCMCTreeNode *node, int state)
1035 {
1036 select_row(sctree,
1037 g_list_position(GTK_CMCLIST(sctree)->row_list, (GList *)node),
1038 -1, state, node);
1039 }
1040
1041 void gtk_sctree_unselect_all (GtkSCTree *sctree)
1042 {
1043 gtk_cmclist_unselect_all(GTK_CMCLIST(sctree));
1044 sctree->anchor_row = NULL;
1045 }
1046
1047 void gtk_sctree_set_anchor_row (GtkSCTree *sctree, GtkCMCTreeNode *node)
1048 {
1049 sctree->anchor_row = node;
1050 }
1051
1052 void gtk_sctree_remove_node (GtkSCTree *sctree, GtkCMCTreeNode *node)
1053 {
1054 if (sctree->anchor_row == node)
1055 sctree->anchor_row = NULL;
1056 gtk_cmctree_remove_node(GTK_CMCTREE(sctree), node);
1057 }
1058
1059 void gtk_sctree_set_stripes(GtkSCTree *sctree, gboolean show_stripes)
1060 {
1061 sctree->show_stripes = show_stripes;
1062 }
1063
1064 void gtk_sctree_set_recursive_expand(GtkSCTree *sctree, gboolean rec_exp)
1065 {
1066 sctree->always_expand_recursively = rec_exp;
1067 }
1068
1069 /***********************************************************
1070 * Tree sorting functions *
1071 ***********************************************************/
1072
1073 static void sink(GtkCMCList *clist, GPtrArray *numbers, gint root, gint bottom)
1074 {
1075 gint j, k ;
1076 GtkCMCTreeNode *temp;
1077
1078 j = 2 * root;
1079 k = j + 1;
1080
1081 /* find the maximum element of numbers[root],
1082 numbers[2*root] and numbers[2*root+1] */
1083 if (j <= bottom) {
1084 if (clist->compare( clist, GTK_CMCTREE_ROW (g_ptr_array_index(numbers, root)),
1085 GTK_CMCTREE_ROW(g_ptr_array_index( numbers, j))) >= 0)
1086 j = root;
1087 if (k <= bottom)
1088 if (clist->compare( clist, GTK_CMCTREE_ROW (g_ptr_array_index(numbers, k)),
1089 GTK_CMCTREE_ROW (g_ptr_array_index( numbers, j))) > 0)
1090 j = k;
1091 /* if numbers[root] wasn't the maximum element then
1092 sink again */
1093 if (root != j) {
1094 temp = g_ptr_array_index( numbers,root);
1095 g_ptr_array_index( numbers, root) = g_ptr_array_index( numbers, j);
1096 g_ptr_array_index( numbers, j) = temp;
1097 sink( clist, numbers, j, bottom);
1098 }
1099 }
1100 }
1101
1102 static void heap_sort(GtkCMCList *clist, GPtrArray *numbers, gint array_size)
1103 {
1104 gint i;
1105 GtkCMCTreeNode *temp;
1106
1107 /* build the Heap */
1108 for (i = (array_size / 2); i >= 1; i--)
1109 sink( clist, numbers, i, array_size);
1110 /* output the Heap */
1111 for (i = array_size; i >= 2; i--) {
1112 temp = g_ptr_array_index( numbers, 1);
1113 g_ptr_array_index( numbers, 1) = g_ptr_array_index( numbers, i);
1114 g_ptr_array_index( numbers, i) = temp;
1115 sink( clist, numbers, 1, i-1);
1116 }
1117 }
1118
1119 static void
1120 stree_sort (GtkCMCTree *ctree,
1121 GtkCMCTreeNode *node,
1122 gpointer data)
1123 {
1124 GtkCMCTreeNode *list_start, *work, *next;
1125 GPtrArray *row_array, *viewable_array;
1126 GtkCMCList *clist;
1127 gint i;
1128
1129 clist = GTK_CMCLIST (ctree);
1130
1131 if (node)
1132 work = GTK_CMCTREE_ROW (node)->children;
1133 else
1134 work = GTK_CMCTREE_NODE (clist->row_list);
1135
1136 row_array = g_ptr_array_new();
1137 viewable_array = g_ptr_array_new();
1138
1139 if (work) {
1140 g_ptr_array_add( row_array, NULL);
1141 while (work) {
1142 /* add all rows to row_array */
1143 g_ptr_array_add( row_array, work);
1144 if (GTK_CMCTREE_ROW (work)->parent && gtk_cmctree_is_viewable( ctree, work))
1145 g_ptr_array_add( viewable_array, GTK_CMCTREE_ROW (work)->parent);
1146 next = GTK_CMCTREE_ROW (work)->sibling;
1147 gtk_sctree_unlink( ctree, work, FALSE);
1148 work = next;
1149 }
1150
1151 heap_sort( clist, row_array, (row_array->len)-1);
1152
1153 if (node)
1154 list_start = GTK_CMCTREE_ROW (node)->children;
1155 else
1156 list_start = GTK_CMCTREE_NODE (clist->row_list);
1157
1158 if (clist->sort_type == GTK_SORT_ASCENDING) {
1159 for (i=(row_array->len)-1; i>=1; i--) {
1160 work = g_ptr_array_index( row_array, i);
1161 gtk_sctree_link( ctree, work, node, list_start, FALSE);
1162 list_start = work;
1163 /* insert work at the beginning of the list */
1164 }
1165 } else {
1166 for (i=1; i<row_array->len; i++) {
1167 work = g_ptr_array_index( row_array, i);
1168 gtk_sctree_link( ctree, work, node, list_start, FALSE);
1169 list_start = work;
1170 /* insert work at the beginning of the list */
1171 }
1172 }
1173
1174 for (i=0; i<viewable_array->len; i++) {
1175 gtk_cmctree_expand( ctree, g_ptr_array_index( viewable_array, i));
1176 }
1177
1178 }
1179 g_ptr_array_free( row_array, TRUE);
1180 g_ptr_array_free( viewable_array, TRUE);
1181 }
1182
1183 void
1184 gtk_sctree_sort_recursive (GtkCMCTree *ctree,
1185 GtkCMCTreeNode *node)
1186 {
1187 GtkCMCList *clist;
1188 GtkCMCTreeNode *focus_node = NULL;
1189
1190 cm_return_if_fail (ctree != NULL);
1191 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
1192
1193 clist = GTK_CMCLIST (ctree);
1194
1195 gtk_cmclist_freeze (clist);
1196
1197 if (clist->selection_mode == GTK_SELECTION_MULTIPLE) {
1198 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1199
1200 g_list_free (clist->undo_selection);
1201 g_list_free (clist->undo_unselection);
1202 clist->undo_selection = NULL;
1203 clist->undo_unselection = NULL;
1204 }
1205
1206 if (!node || (node && gtk_cmctree_is_viewable (ctree, node)))
1207 focus_node = GTK_CMCTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
1208
1209 GTK_SCTREE(ctree)->sorting = TRUE;
1210
1211 gtk_cmctree_post_recursive (ctree, node, GTK_CMCTREE_FUNC (stree_sort), NULL);
1212
1213 if (!node)
1214 stree_sort (ctree, NULL, NULL);
1215
1216 GTK_SCTREE(ctree)->sorting = FALSE;
1217
1218 if (focus_node) {
1219 clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
1220 clist->undo_anchor = clist->focus_row;
1221 }
1222
1223 gtk_cmclist_thaw (clist);
1224 }
1225
1226 void
1227 gtk_sctree_sort_node (GtkCMCTree *ctree,
1228 GtkCMCTreeNode *node)
1229 {
1230 GtkCMCList *clist;
1231 GtkCMCTreeNode *focus_node = NULL;
1232
1233 cm_return_if_fail (ctree != NULL);
1234 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
1235
1236 clist = GTK_CMCLIST (ctree);
1237
1238 gtk_cmclist_freeze (clist);
1239
1240 if (clist->selection_mode == GTK_SELECTION_MULTIPLE) {
1241 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1242
1243 g_list_free (clist->undo_selection);
1244 g_list_free (clist->undo_unselection);
1245 clist->undo_selection = NULL;
1246 clist->undo_unselection = NULL;
1247 }
1248
1249 if (!node || (node && gtk_cmctree_is_viewable (ctree, node)))
1250 focus_node = GTK_CMCTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
1251
1252 GTK_SCTREE(ctree)->sorting = TRUE;
1253
1254 stree_sort (ctree, node, NULL);
1255
1256 GTK_SCTREE(ctree)->sorting = FALSE;
1257
1258 if (focus_node) {
1259 clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
1260 clist->undo_anchor = clist->focus_row;
1261 }
1262
1263 gtk_cmclist_thaw (clist);
1264 }
1265
1266 /************************************************************************/
1267
1268 static void
1269 gtk_sctree_unlink (GtkCMCTree *ctree,
1270 GtkCMCTreeNode *node,
1271 gboolean update_focus_row)
1272 {
1273 GtkCMCList *clist;
1274 gint rows;
1275 gint level;
1276 gint visible;
1277 GtkCMCTreeNode *work;
1278 GtkCMCTreeNode *parent;
1279 GList *list;
1280
1281 cm_return_if_fail (ctree != NULL);
1282 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
1283 cm_return_if_fail (node != NULL);
1284
1285 clist = GTK_CMCLIST (ctree);
1286
1287 if (update_focus_row && clist->selection_mode == GTK_SELECTION_MULTIPLE) {
1288 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1289
1290 g_list_free (clist->undo_selection);
1291 g_list_free (clist->undo_unselection);
1292 clist->undo_selection = NULL;
1293 clist->undo_unselection = NULL;
1294 }
1295
1296 visible = gtk_cmctree_is_viewable (ctree, node);
1297
1298 /* clist->row_list_end unlinked ? */
1299 if (visible && (GTK_CMCTREE_NODE_NEXT (node) == NULL ||
1300 (GTK_CMCTREE_ROW (node)->children && gtk_cmctree_is_ancestor (ctree, node,
1301 GTK_CMCTREE_NODE (clist->row_list_end)))))
1302 clist->row_list_end = (GList *) (GTK_CMCTREE_NODE_PREV (node));
1303
1304 /* update list */
1305 rows = 0;
1306 level = GTK_CMCTREE_ROW (node)->level;
1307 work = GTK_CMCTREE_NODE_NEXT (node);
1308 while (work && GTK_CMCTREE_ROW (work)->level > level) {
1309 work = GTK_CMCTREE_NODE_NEXT (work);
1310 rows++;
1311 }
1312
1313 if (visible) {
1314 clist->rows -= (rows + 1);
1315
1316 if (update_focus_row) {
1317 gint pos;
1318 pos = g_list_position (clist->row_list, (GList *)node);
1319 if (pos + rows < clist->focus_row)
1320 clist->focus_row -= (rows + 1);
1321 else if (pos <= clist->focus_row) {
1322 if (!GTK_CMCTREE_ROW (node)->sibling)
1323 clist->focus_row = MAX (pos - 1, 0);
1324 else
1325 clist->focus_row = pos;
1326
1327 clist->focus_row = MIN (clist->focus_row, clist->rows - 1);
1328 }
1329 clist->undo_anchor = clist->focus_row;
1330 }
1331 }
1332
1333 if (work) {
1334 list = (GList *)GTK_CMCTREE_NODE_PREV (work);
1335 list->next = NULL;
1336 list = (GList *)work;
1337 list->prev = (GList *)GTK_CMCTREE_NODE_PREV (node);
1338 }
1339
1340 if (GTK_CMCTREE_NODE_PREV (node) &&
1341 GTK_CMCTREE_NODE_NEXT (GTK_CMCTREE_NODE_PREV (node)) == node) {
1342 list = (GList *)GTK_CMCTREE_NODE_PREV (node);
1343 list->next = (GList *)work;
1344 }
1345
1346 /* update tree */
1347 parent = GTK_CMCTREE_ROW (node)->parent;
1348 if (parent) {
1349 if (GTK_CMCTREE_ROW (parent)->children == node) {
1350 GTK_CMCTREE_ROW (parent)->children = GTK_CMCTREE_ROW (node)->sibling;
1351 }
1352 else {
1353 GtkCMCTreeNode *sibling;
1354
1355 sibling = GTK_CMCTREE_ROW (parent)->children;
1356 while (GTK_CMCTREE_ROW (sibling)->sibling != node)
1357 sibling = GTK_CMCTREE_ROW (sibling)->sibling;
1358 GTK_CMCTREE_ROW (sibling)->sibling = GTK_CMCTREE_ROW (node)->sibling;
1359 }
1360 }
1361 else {
1362 if (clist->row_list == (GList *)node)
1363 clist->row_list = (GList *) (GTK_CMCTREE_ROW (node)->sibling);
1364 else {
1365 GtkCMCTreeNode *sibling;
1366
1367 sibling = GTK_CMCTREE_NODE (clist->row_list);
1368 while (GTK_CMCTREE_ROW (sibling)->sibling != node)
1369 sibling = GTK_CMCTREE_ROW (sibling)->sibling;
1370 GTK_CMCTREE_ROW (sibling)->sibling = GTK_CMCTREE_ROW (node)->sibling;
1371 }
1372 }
1373 }
1374
1375 static void
1376 gtk_sctree_link (GtkCMCTree *ctree,
1377 GtkCMCTreeNode *node,
1378 GtkCMCTreeNode *parent,
1379 GtkCMCTreeNode *sibling,
1380 gboolean update_focus_row)
1381 {
1382 GtkCMCList *clist;
1383 GList *list_end;
1384 GList *list;
1385 GList *work;
1386 gboolean visible = FALSE;
1387 gint rows = 0;
1388
1389 if (sibling)
1390 cm_return_if_fail (GTK_CMCTREE_ROW (sibling)->parent == parent);
1391 cm_return_if_fail (node != NULL);
1392 cm_return_if_fail (node != sibling);
1393 cm_return_if_fail (node != parent);
1394
1395 clist = GTK_CMCLIST (ctree);
1396
1397 if (update_focus_row && clist->selection_mode == GTK_SELECTION_MULTIPLE) {
1398 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1399
1400 g_list_free (clist->undo_selection);
1401 g_list_free (clist->undo_unselection);
1402 clist->undo_selection = NULL;
1403 clist->undo_unselection = NULL;
1404 }
1405
1406 for (rows = 1, list_end = (GList *)node; list_end->next;
1407 list_end = list_end->next)
1408 rows++;
1409
1410 GTK_CMCTREE_ROW (node)->parent = parent;
1411 GTK_CMCTREE_ROW (node)->sibling = sibling;
1412
1413 if (!parent || (parent && (gtk_cmctree_is_viewable (ctree, parent) &&
1414 GTK_CMCTREE_ROW (parent)->expanded))) {
1415 visible = TRUE;
1416 clist->rows += rows;
1417 }
1418
1419 if (parent)
1420 work = (GList *)(GTK_CMCTREE_ROW (parent)->children);
1421 else
1422 work = clist->row_list;
1423
1424 if (sibling) {
1425 if (work != (GList *)sibling) {
1426 while (GTK_CMCTREE_ROW (work)->sibling != sibling)
1427 work = (GList *)(GTK_CMCTREE_ROW (work)->sibling);
1428 GTK_CMCTREE_ROW (work)->sibling = node;
1429 }
1430
1431 if (sibling == GTK_CMCTREE_NODE (clist->row_list))
1432 clist->row_list = (GList *) node;
1433 if (GTK_CMCTREE_NODE_PREV (sibling) &&
1434 GTK_CMCTREE_NODE_NEXT (GTK_CMCTREE_NODE_PREV (sibling)) == sibling) {
1435 list = (GList *)GTK_CMCTREE_NODE_PREV (sibling);
1436 list->next = (GList *)node;
1437 }
1438
1439 list = (GList *)node;
1440 list->prev = (GList *)GTK_CMCTREE_NODE_PREV (sibling);
1441 list_end->next = (GList *)sibling;
1442 list = (GList *)sibling;
1443 list->prev = list_end;
1444 if (parent && GTK_CMCTREE_ROW (parent)->children == sibling)
1445 GTK_CMCTREE_ROW (parent)->children = node;
1446 }
1447 else {
1448 if (work) {
1449 /* find sibling */
1450 while (GTK_CMCTREE_ROW (work)->sibling)
1451 work = (GList *)(GTK_CMCTREE_ROW (work)->sibling);
1452 GTK_CMCTREE_ROW (work)->sibling = node;
1453
1454 /* find last visible child of sibling */
1455 work = (GList *) gtk_sctree_last_visible (ctree,
1456 GTK_CMCTREE_NODE (work));
1457
1458 list_end->next = work->next;
1459 if (work->next)
1460 work->next->prev = list_end;
1461 work->next = (GList *)node;
1462 list = (GList *)node;
1463 list->prev = work;
1464 }
1465 else {
1466 if (parent) {
1467 GTK_CMCTREE_ROW (parent)->children = node;
1468 list = (GList *)node;
1469 list->prev = (GList *)parent;
1470 if (GTK_CMCTREE_ROW (parent)->expanded) {
1471 list_end->next = (GList *)GTK_CMCTREE_NODE_NEXT (parent);
1472 if (GTK_CMCTREE_NODE_NEXT(parent)) {
1473 list = (GList *)GTK_CMCTREE_NODE_NEXT (parent);
1474 list->prev = list_end;
1475 }
1476 list = (GList *)parent;
1477 list->next = (GList *)node;
1478 }
1479 else
1480 list_end->next = NULL;
1481 }
1482 else {
1483 clist->row_list = (GList *)node;
1484 list = (GList *)node;
1485 list->prev = NULL;
1486 list_end->next = NULL;
1487 }
1488 }
1489 }
1490
1491 gtk_cmctree_pre_recursive (ctree, node, stree_update_level, NULL);
1492
1493 if (clist->row_list_end == NULL ||
1494 clist->row_list_end->next == (GList *)node)
1495 clist->row_list_end = list_end;
1496
1497 if (visible && update_focus_row) {
1498 gint pos;
1499 pos = g_list_position (clist->row_list, (GList *)node);
1500
1501 if (pos <= clist->focus_row) {
1502 clist->focus_row += rows;
1503 clist->undo_anchor = clist->focus_row;
1504 }
1505 }
1506 }
1507
1508 static void
1509 stree_update_level (GtkCMCTree *ctree,
1510 GtkCMCTreeNode *node,
1511 gpointer data)
1512 {
1513 if (!node)
1514 return;
1515
1516 if (GTK_CMCTREE_ROW (node)->parent)
1517 GTK_CMCTREE_ROW (node)->level =
1518 GTK_CMCTREE_ROW (GTK_CMCTREE_ROW (node)->parent)->level + 1;
1519 else
1520 GTK_CMCTREE_ROW (node)->level = 1;
1521 }
1522
1523 static GtkCMCTreeNode *
1524 gtk_sctree_last_visible (GtkCMCTree *ctree,
1525 GtkCMCTreeNode *node)
1526 {
1527 GtkCMCTreeNode *work;
1528
1529 if (!node)
1530 return NULL;
1531
1532 work = GTK_CMCTREE_ROW (node)->children;
1533
1534 if (!work || !GTK_CMCTREE_ROW (node)->expanded)
1535 return node;
1536
1537 while (GTK_CMCTREE_ROW (work)->sibling)
1538 work = GTK_CMCTREE_ROW (work)->sibling;
1539
1540 return gtk_sctree_last_visible (ctree, work);
1541 }
1542
1543 static void
1544 sset_node_info (GtkCMCTree *ctree,
1545 GtkCMCTreeNode *node,
1546 const gchar *text,
1547 guint8 spacing,
1548 GdkPixbuf *pixbuf_closed,
1549 GdkPixbuf *pixbuf_opened,
1550 gboolean is_leaf,
1551 gboolean expanded)
1552 {
1553 if (GTK_CMCTREE_ROW (node)->pixbuf_opened)
1554 {
1555 g_object_unref (GTK_CMCTREE_ROW (node)->pixbuf_opened);
1556 }
1557 if (GTK_CMCTREE_ROW (node)->pixbuf_closed)
1558 {
1559 g_object_unref (GTK_CMCTREE_ROW (node)->pixbuf_closed);
1560 }
1561
1562 GTK_CMCTREE_ROW (node)->pixbuf_opened = NULL;
1563 GTK_CMCTREE_ROW (node)->pixbuf_closed = NULL;
1564
1565 if (pixbuf_closed)
1566 {
1567 GTK_CMCTREE_ROW (node)->pixbuf_closed = g_object_ref (pixbuf_closed);
1568 }
1569 if (pixbuf_opened)
1570 {
1571 GTK_CMCTREE_ROW (node)->pixbuf_opened = g_object_ref (pixbuf_opened);
1572 }
1573
1574 GTK_CMCTREE_ROW (node)->is_leaf = is_leaf;
1575 GTK_CMCTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
1576
1577 if (GTK_CMCTREE_ROW (node)->expanded)
1578 gtk_cmctree_node_set_pixtext (ctree, node, ctree->tree_column,
1579 text, spacing, pixbuf_opened);
1580 else
1581 gtk_cmctree_node_set_pixtext (ctree, node, ctree->tree_column,
1582 text, spacing, pixbuf_closed);
1583 }
1584
1585 static GtkCMCTreeRow *
1586 srow_new (GtkCMCTree *ctree)
1587 {
1588 GtkCMCList *clist;
1589 GtkCMCTreeRow *ctree_row;
1590 int i;
1591
1592 clist = GTK_CMCLIST (ctree);
1593 ctree_row = g_slice_new (GtkCMCTreeRow);
1594 ctree_row->row.cell = g_slice_alloc (sizeof (GtkCMCell) * clist->columns);
1595 for (i = 0; i < clist->columns; i++)
1596 {
1597 ctree_row->row.cell[i].type = GTK_CMCELL_EMPTY;
1598 ctree_row->row.cell[i].vertical = 0;
1599 ctree_row->row.cell[i].horizontal = 0;
1600 ctree_row->row.cell[i].style = NULL;
1601 }
1602
1603 GTK_CMCELL_PIXTEXT (ctree_row->row.cell[ctree->tree_column])->text = NULL;
1604
1605 ctree_row->row.fg_set = FALSE;
1606 ctree_row->row.bg_set = FALSE;
1607 ctree_row->row.style = NULL;
1608 ctree_row->row.selectable = TRUE;
1609 ctree_row->row.state = GTK_STATE_NORMAL;
1610 ctree_row->row.data = NULL;
1611 ctree_row->row.destroy = NULL;
1612
1613 ctree_row->level = 0;
1614 ctree_row->expanded = FALSE;
1615 ctree_row->parent = NULL;
1616 ctree_row->sibling = NULL;
1617 ctree_row->children = NULL;
1618 ctree_row->pixbuf_closed = NULL;
1619 ctree_row->pixbuf_opened = NULL;
1620
1621 return ctree_row;
1622 }
1623
1624 static void
1625 srow_delete (GtkCMCTree *ctree,
1626 GtkCMCTreeRow *ctree_row)
1627 {
1628 GtkCMCList *clist;
1629 gint i;
1630
1631 clist = GTK_CMCLIST (ctree);
1632
1633 for (i = 0; i < clist->columns; i++)
1634 {
1635 GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
1636 (clist, &(ctree_row->row), i, GTK_CMCELL_EMPTY, NULL, 0, NULL);
1637 if (ctree_row->row.cell[i].style)
1638 {
1639 if (gtk_widget_get_realized (GTK_WIDGET(ctree)))
1640 gtk_style_detach (ctree_row->row.cell[i].style);
1641 g_object_unref (ctree_row->row.cell[i].style);
1642 }
1643 }
1644
1645 if (ctree_row->row.style)
1646 {
1647 if (gtk_widget_get_realized (GTK_WIDGET(ctree)))
1648 gtk_style_detach (ctree_row->row.style);
1649 g_object_unref (ctree_row->row.style);
1650 }
1651
1652 if (ctree_row->pixbuf_closed)
1653 {
1654 g_object_unref (ctree_row->pixbuf_closed);
1655 }
1656
1657 if (ctree_row->pixbuf_opened)
1658 {
1659 g_object_unref (ctree_row->pixbuf_opened);
1660 }
1661
1662 if (ctree_row->row.destroy)
1663 {
1664 GDestroyNotify dnotify = ctree_row->row.destroy;
1665 gpointer ddata = ctree_row->row.data;
1666
1667 ctree_row->row.destroy = NULL;
1668 ctree_row->row.data = NULL;
1669
1670 dnotify (ddata);
1671 }
1672
1673 g_slice_free1 (sizeof (GtkCMCell) * clist->columns, ctree_row->row.cell);
1674 g_slice_free (GtkCMCTreeRow, ctree_row);
1675 }
1676
1677 static void
1678 stree_delete_row (GtkCMCTree *ctree,
1679 GtkCMCTreeNode *node,
1680 gpointer data)
1681 {
1682 srow_delete (ctree, GTK_CMCTREE_ROW (node));
1683 g_list_free_1 ((GList *)node);
1684 }
1685
1686 static void
1687 gtk_sctree_real_tree_expand (GtkCMCTree *ctree,
1688 GtkCMCTreeNode *node)
1689 {
1690 GtkCMCList *clist;
1691 GtkCMCTreeNode *work;
1692 GtkRequisition requisition;
1693 gboolean visible;
1694
1695 cm_return_if_fail (GTK_IS_CMCTREE (ctree));
1696
1697 if (!node || GTK_CMCTREE_ROW (node)->expanded || GTK_CMCTREE_ROW (node)->is_leaf)
1698 return;
1699
1700 clist = GTK_CMCLIST (ctree);
1701
1702 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1703
1704 GTK_CMCTREE_ROW (node)->expanded = TRUE;
1705
1706 visible = gtk_cmctree_is_viewable (ctree, node);
1707 /* get cell width if tree_column is auto resized */
1708 if (visible && clist->column[ctree->tree_column].auto_resize &&
1709 !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
1710 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
1711 (clist, &GTK_CMCTREE_ROW (node)->row, ctree->tree_column, &requisition);
1712
1713 /* unref/unset closed pixbuf */
1714 if (GTK_CMCELL_PIXTEXT
1715 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf)
1716 {
1717 g_object_unref
1718 (GTK_CMCELL_PIXTEXT
1719 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf);
1720
1721 GTK_CMCELL_PIXTEXT
1722 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf = NULL;
1723 }
1724
1725 /* set/ref opened pixbuf */
1726 if (GTK_CMCTREE_ROW (node)->pixbuf_opened)
1727 {
1728 GTK_CMCELL_PIXTEXT
1729 (GTK_CMCTREE_ROW (node)->row.cell[ctree->tree_column])->pixbuf =
1730 g_object_ref (GTK_CMCTREE_ROW (node)->pixbuf_opened);
1731 }
1732
1733
1734 work = GTK_CMCTREE_ROW (node)->children;
1735 if (work)
1736 {
1737 GList *list = (GList *)work;
1738 gint *cell_width = NULL;
1739 gint tmp = 0;
1740 gint row;
1741 gint i;
1742
1743 if (visible && !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
1744 {
1745 cell_width = g_new0 (gint, clist->columns);
1746 if (clist->column[ctree->tree_column].auto_resize)
1747 cell_width[ctree->tree_column] = requisition.width;
1748
1749 while (work)
1750 {
1751 /* search maximum cell widths of auto_resize columns */
1752 for (i = 0; i < clist->columns; i++)
1753 if (clist->column[i].auto_resize)
1754 {
1755 GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
1756 (clist, &GTK_CMCTREE_ROW (work)->row, i, &requisition);
1757 cell_width[i] = MAX (requisition.width, cell_width[i]);
1758 }
1759
1760 list = (GList *)work;
1761 work = GTK_CMCTREE_NODE_NEXT (work);
1762 tmp++;
1763 }
1764 }
1765 else
1766 while (work)
1767 {
1768 list = (GList *)work;
1769 work = GTK_CMCTREE_NODE_NEXT (work);
1770 tmp++;
1771 }
1772
1773 list->next = (GList *)GTK_CMCTREE_NODE_NEXT (node);
1774
1775 if (GTK_CMCTREE_NODE_NEXT (node))
1776 {
1777 GList *tmp_list;
1778
1779 if (clist->row_list_end == list)
1780 clist->row_list_end = g_list_last(list);
1781
1782 tmp_list = (GList *)GTK_CMCTREE_NODE_NEXT (node);
1783 tmp_list->prev = list;
1784 }
1785 else
1786 clist->row_list_end = list;
1787
1788 list = (GList *)node;
1789 list->next = (GList *)(GTK_CMCTREE_ROW (node)->children);
1790
1791 if (visible && !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
1792 {
1793 /* resize auto_resize columns if needed */
1794 for (i = 0; i < clist->columns; i++)
1795 if (clist->column[i].auto_resize &&
1796 cell_width[i] > clist->column[i].width)
1797 gtk_cmclist_set_column_width (clist, i, cell_width[i]);
1798 g_free (cell_width);
1799
1800 if (!GTK_SCTREE(ctree)->sorting) {
1801 /* update focus_row position */
1802 row = g_list_position (clist->row_list, (GList *)node);
1803 if (row < clist->focus_row)
1804 clist->focus_row += tmp;
1805 }
1806 clist->rows += tmp;
1807 CLIST_REFRESH (clist);
1808 }
1809 }
1810 else if (visible && clist->column[ctree->tree_column].auto_resize)
1811 /* resize tree_column if needed */
1812 gtk_sctree_column_auto_resize (clist, &GTK_CMCTREE_ROW (node)->row, ctree->tree_column,
1813 requisition.width);
1814
1815 }
1816
1817 GtkCMCTreeNode *
1818 gtk_sctree_insert_node (GtkCMCTree *ctree,
1819 GtkCMCTreeNode *parent,
1820 GtkCMCTreeNode *sibling,
1821 gchar *text[],
1822 guint8 spacing,
1823 GdkPixbuf *pixbuf_closed,
1824 GdkPixbuf *pixbuf_opened,
1825 gboolean is_leaf,
1826 gboolean expanded)
1827 {
1828 GtkCMCList *clist;
1829 GtkCMCTreeRow *new_row;
1830 GtkCMCTreeNode *node;
1831 GList *list;
1832 gint i;
1833
1834 cm_return_val_if_fail (GTK_IS_CMCTREE (ctree), NULL);
1835 if (sibling)
1836 cm_return_val_if_fail (GTK_CMCTREE_ROW (sibling)->parent == parent, NULL);
1837
1838 if (parent && GTK_CMCTREE_ROW (parent)->is_leaf)
1839 return NULL;
1840
1841 clist = GTK_CMCLIST (ctree);
1842
1843 /* create the row */
1844 new_row = srow_new (ctree);
1845 list = g_list_alloc ();
1846 list->data = new_row;
1847 node = GTK_CMCTREE_NODE (list);
1848
1849 if (text)
1850 for (i = 0; i < clist->columns; i++)
1851 if (text[i] && i != ctree->tree_column)
1852 GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
1853 (clist, &(new_row->row), i, GTK_CMCELL_TEXT, text[i], 0, NULL);
1854
1855 sset_node_info (ctree, node, text ?
1856 text[ctree->tree_column] : NULL, spacing, pixbuf_closed,
1857 pixbuf_opened, is_leaf, expanded);
1858
1859 /* sorted insertion */
1860 if (GTK_CMCLIST_AUTO_SORT (clist))
1861 {
1862 if (parent)
1863 sibling = GTK_CMCTREE_ROW (parent)->children;
1864 else
1865 sibling = GTK_CMCTREE_NODE (clist->row_list);
1866
1867 while (sibling && clist->compare
1868 (clist, GTK_CMCTREE_ROW (node), GTK_CMCTREE_ROW (sibling)) > 0)
1869 sibling = GTK_CMCTREE_ROW (sibling)->sibling;
1870 }
1871
1872 gtk_sctree_link (ctree, node, parent, sibling, FALSE);
1873
1874 if (text && !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist) &&
1875 gtk_cmctree_is_viewable (ctree, node))
1876 {
1877 for (i = 0; i < clist->columns; i++)
1878 if (clist->column[i].auto_resize)
1879 gtk_sctree_column_auto_resize (clist, &(new_row->row), i, 0);
1880 }
1881
1882 if (clist->rows == 1)
1883 {
1884 clist->focus_row = 0;
1885 if (clist->selection_mode == GTK_SELECTION_BROWSE)
1886 gtk_sctree_select (GTK_SCTREE(ctree), node);
1887 }
1888
1889
1890 CLIST_REFRESH (clist);
1891
1892 return node;
1893 }
1894
1895 GtkCMCTreeNode *
1896 gtk_sctree_insert_gnode (GtkCMCTree *ctree,
1897 GtkCMCTreeNode *parent,
1898 GtkCMCTreeNode *sibling,
1899 GNode *gnode,
1900 GtkCMCTreeGNodeFunc func,
1901 gpointer data)
1902 {
1903 GtkCMCList *clist;
1904 GtkCMCTreeNode *cnode = NULL;
1905 GtkCMCTreeNode *child = NULL;
1906 GtkCMCTreeNode *new_child;
1907 GList *list;
1908 GNode *work;
1909 guint depth = 1;
1910
1911 cm_return_val_if_fail (GTK_IS_CMCTREE (ctree), NULL);
1912 cm_return_val_if_fail (gnode != NULL, NULL);
1913 cm_return_val_if_fail (func != NULL, NULL);
1914 if (sibling)
1915 cm_return_val_if_fail (GTK_CMCTREE_ROW (sibling)->parent == parent, NULL);
1916
1917 clist = GTK_CMCLIST (ctree);
1918
1919 if (parent)
1920 depth = GTK_CMCTREE_ROW (parent)->level + 1;
1921
1922 list = g_list_alloc ();
1923 list->data = srow_new (ctree);
1924 cnode = GTK_CMCTREE_NODE (list);
1925
1926 gtk_cmclist_freeze (clist);
1927
1928 sset_node_info (ctree, cnode, "", 0, NULL, NULL, TRUE, FALSE);
1929
1930 if (!func (ctree, depth, gnode, cnode, data))
1931 {
1932 stree_delete_row (ctree, cnode, NULL);
1933 gtk_cmclist_thaw (clist);
1934 return NULL;
1935 }
1936
1937 if (GTK_CMCLIST_AUTO_SORT (clist))
1938 {
1939 if (parent)
1940 sibling = GTK_CMCTREE_ROW (parent)->children;
1941 else
1942 sibling = GTK_CMCTREE_NODE (clist->row_list);
1943
1944 while (sibling && clist->compare
1945 (clist, GTK_CMCTREE_ROW (cnode), GTK_CMCTREE_ROW (sibling)) > 0)
1946 sibling = GTK_CMCTREE_ROW (sibling)->sibling;
1947 }
1948
1949 gtk_sctree_link (ctree, cnode, parent, sibling, FALSE);
1950
1951 for (work = g_node_last_child (gnode); work; work = work->prev)
1952 {
1953 new_child = gtk_sctree_insert_gnode (ctree, cnode, child,
1954 work, func, data);
1955 if (new_child)
1956 child = new_child;
1957 }
1958
1959 gtk_cmclist_thaw (clist);
1960
1961 return cnode;
1962 }
1963
1964 static void
1965 sreal_tree_move (GtkCMCTree *ctree,
1966 GtkCMCTreeNode *node,
1967 GtkCMCTreeNode *new_parent,
1968 GtkCMCTreeNode *new_sibling)
1969 {
1970 GtkCMCList *clist;
1971 GtkCMCTreeNode *work;
1972 gboolean visible = FALSE;
1973
1974 cm_return_if_fail (ctree != NULL);
1975 cm_return_if_fail (node != NULL);
1976 cm_return_if_fail (!new_sibling ||
1977 GTK_CMCTREE_ROW (new_sibling)->parent == new_parent);
1978
1979 if (new_parent && GTK_CMCTREE_ROW (new_parent)->is_leaf)
1980 return;
1981
1982 /* new_parent != child of child */
1983 for (work = new_parent; work; work = GTK_CMCTREE_ROW (work)->parent)
1984 if (work == node)
1985 return;
1986
1987 clist = GTK_CMCLIST (ctree);
1988
1989 visible = gtk_cmctree_is_viewable (ctree, node);
1990
1991 if (clist->selection_mode == GTK_SELECTION_MULTIPLE)
1992 {
1993 GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
1994
1995 g_list_free (clist->undo_selection);
1996 g_list_free (clist->undo_unselection);
1997 clist->undo_selection = NULL;
1998 clist->undo_unselection = NULL;
1999 }
2000
2001 if (GTK_CMCLIST_AUTO_SORT (clist))
2002 {
2003 if (new_parent == GTK_CMCTREE_ROW (node)->parent)
2004 return;
2005
2006 if (new_parent)
2007 new_sibling = GTK_CMCTREE_ROW (new_parent)->children;
2008 else
2009 new_sibling = GTK_CMCTREE_NODE (clist->row_list);
2010
2011 while (new_sibling && clist->compare
2012 (clist, GTK_CMCTREE_ROW (node), GTK_CMCTREE_ROW (new_sibling)) > 0)
2013 new_sibling = GTK_CMCTREE_ROW (new_sibling)->sibling;
2014 }
2015
2016 if (new_parent == GTK_CMCTREE_ROW (node)->parent &&
2017 new_sibling == GTK_CMCTREE_ROW (node)->sibling)
2018 return;
2019
2020 gtk_cmclist_freeze (clist);
2021
2022 work = NULL;
2023
2024 if (!GTK_SCTREE(ctree)->sorting && gtk_cmctree_is_viewable (ctree, node))
2025 work = GTK_CMCTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
2026
2027 gtk_sctree_unlink (ctree, node, FALSE);
2028 gtk_sctree_link (ctree, node, new_parent, new_sibling, FALSE);
2029
2030 if (!GTK_SCTREE(ctree)->sorting && work)
2031 {
2032 while (work && !gtk_cmctree_is_viewable (ctree, work))
2033 work = GTK_CMCTREE_ROW (work)->parent;
2034 clist->focus_row = g_list_position (clist->row_list, (GList *)work);
2035 clist->undo_anchor = clist->focus_row;
2036 }
2037
2038 if (clist->column[ctree->tree_column].auto_resize &&
2039 !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist) &&
2040 (visible || gtk_cmctree_is_viewable (ctree, node)))
2041 gtk_cmclist_set_column_width
2042 (clist, ctree->tree_column,
2043 gtk_cmclist_optimal_column_width (clist, ctree->tree_column));
2044
2045 gtk_cmclist_thaw (clist);
2046 }
2047
2048 void gtk_sctree_set_column_tooltip (GtkSCTree *sctree,
2049 int column,
2050 const gchar *tip)
2051 {
2052 CLAWS_SET_TIP(GTK_CMCLIST(sctree)->column[column].button,
2053 tip);
2054 }
2055