2007-04-23 [colin] 2.9.1cvs17
[claws.git] / src / gtk / gtksctree.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Parts of this file:
4  * Copyright (C) 1999-2007 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 2 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, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
27  */
28
29 #include <stdlib.h>
30
31 #include "gtksctree.h"
32 #include "claws-marshal.h"
33 #include "stock_pixmap.h"
34 #include "prefs_common.h"
35 #include "utils.h"
36
37 #define CLIST_UNFROZEN(clist)     (((GtkCList*) (clist))->freeze_count == 0)
38 #define CLIST_REFRESH(clist)    G_STMT_START { \
39   if (CLIST_UNFROZEN (clist)) \
40     GTK_CLIST_GET_CLASS (clist)->refresh ((GtkCList*) (clist)); \
41 } G_STMT_END
42 #define CELL_SPACING               1
43 #define CLIST_OPTIMUM_SIZE         64
44 #define COLUMN_INSET               3
45 #define PM_SIZE                    8
46 #define TAB_SIZE                   (PM_SIZE + 6)
47 #define ROW_TOP_YPIXEL(clist, row) (((clist)->row_height * (row)) + \
48                                     (((row) + 1) * CELL_SPACING) + \
49                                     (clist)->voffset)
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 \
53                                     + (clist)->hoffset)
54 #define COLUMN_LEFT(clist, column) ((clist)->column[(column)].area.x)
55
56 enum {
57         ROW_POPUP_MENU,
58         EMPTY_POPUP_MENU,
59         OPEN_ROW,
60         START_DRAG,
61         LAST_SIGNAL
62 };
63
64 static GdkPixmap *emptyxpm = NULL;
65 static GdkBitmap *emptyxpmmask = NULL;
66
67 static void gtk_sctree_class_init (GtkSCTreeClass *class);
68 static void gtk_sctree_init (GtkSCTree *sctree);
69
70 static gint gtk_sctree_button_press (GtkWidget *widget, GdkEventButton *event);
71 static gint gtk_sctree_button_release (GtkWidget *widget, GdkEventButton *event);
72 static gint gtk_sctree_motion (GtkWidget *widget, GdkEventMotion *event);
73 static void gtk_sctree_drag_begin (GtkWidget *widget, GdkDragContext *context);
74 static void gtk_sctree_drag_end (GtkWidget *widget, GdkDragContext *context);
75 static void gtk_sctree_drag_data_get (GtkWidget *widget, GdkDragContext *context,
76                                      GtkSelectionData *data, guint info, guint time);
77 static void gtk_sctree_drag_leave (GtkWidget *widget, GdkDragContext *context, guint time);
78 static gboolean gtk_sctree_drag_motion (GtkWidget *widget, GdkDragContext *context,
79                                        gint x, gint y, guint time);
80 static gboolean gtk_sctree_drag_drop (GtkWidget *widget, GdkDragContext *context,
81                                      gint x, gint y, guint time);
82 static void gtk_sctree_drag_data_received (GtkWidget *widget, GdkDragContext *context,
83                                           gint x, gint y, GtkSelectionData *data,
84                                           guint info, guint time);
85
86 static void gtk_sctree_clear (GtkCList *clist);
87 static void gtk_sctree_real_unselect_all (GtkCList *clist);
88 static void gtk_sctree_collapse (GtkCTree *ctree, GtkCTreeNode *node);
89        
90 static void stree_sort (GtkCTree *ctree, GtkCTreeNode  *node, gpointer data);
91 void gtk_sctree_sort_node (GtkCTree *ctree, GtkCTreeNode *node);
92 void gtk_sctree_sort_recursive (GtkCTree *ctree, GtkCTreeNode *node);
93
94 static void gtk_sctree_link (GtkCTree *ctree,
95                         GtkCTreeNode  *node,
96                         GtkCTreeNode  *parent,
97                         GtkCTreeNode  *sibling,
98                         gboolean       update_focus_row);
99
100 static void gtk_sctree_unlink (GtkCTree      *ctree, 
101                         GtkCTreeNode  *node,
102                         gboolean       update_focus_row);
103
104 static void stree_update_level (GtkCTree      *ctree, 
105                         GtkCTreeNode  *node, 
106                         gpointer       data);
107
108 static GtkCTreeNode * gtk_sctree_last_visible (GtkCTree     *ctree,
109                                               GtkCTreeNode *node);
110 static void gtk_sctree_real_tree_expand            (GtkCTree      *ctree,
111                                                  GtkCTreeNode  *node);
112 static void
113 sreal_tree_move (GtkCTree     *ctree,
114                 GtkCTreeNode *node,
115                 GtkCTreeNode *new_parent, 
116                 GtkCTreeNode *new_sibling);
117
118 static GtkCTreeClass *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
151                 sctree_type = g_type_register_static (GTK_TYPE_CTREE, "GtkSCTree", &sctree_info, (GTypeFlags)0);
152         }
153
154         return sctree_type;
155 }
156
157 static gint
158 gtk_sctree_draw_cell_pixmap (GdkWindow    *window,
159                   GdkRectangle *clip_rectangle,
160                   GdkGC        *fg_gc,
161                   GdkPixmap    *pixmap,
162                   GdkBitmap    *mask,
163                   gint          x,
164                   gint          y,
165                   gint          width,
166                   gint          height)
167 {
168   gint xsrc = 0;
169   gint ysrc = 0;
170
171   if (mask)
172     {
173       gdk_gc_set_clip_mask (fg_gc, mask);
174       gdk_gc_set_clip_origin (fg_gc, x, y);
175     }
176   if (x < clip_rectangle->x)
177     {
178       xsrc = clip_rectangle->x - x;
179       width -= xsrc;
180       x = clip_rectangle->x;
181     }
182   if (x + width > clip_rectangle->x + clip_rectangle->width)
183     width = clip_rectangle->x + clip_rectangle->width - x;
184
185   if (y < clip_rectangle->y)
186     {
187       ysrc = clip_rectangle->y - y;
188       height -= ysrc;
189       y = clip_rectangle->y;
190     }
191   if (y + height > clip_rectangle->y + clip_rectangle->height)
192     height = clip_rectangle->y + clip_rectangle->height - y;
193
194   if (width > 0 && height > 0)
195     gdk_draw_pixmap (window, fg_gc, pixmap, xsrc, ysrc, x, y, width, height);
196
197   if (mask)
198     {
199       gdk_gc_set_clip_rectangle (fg_gc, NULL);
200       gdk_gc_set_clip_origin (fg_gc, 0, 0);
201     }
202
203   return x + MAX (width, 0);
204 }
205
206 static void
207 gtk_sctree_get_cell_style (GtkCList     *clist,
208                 GtkCListRow  *clist_row,
209                 gint          state,
210                 gint          row,
211                 gint          column,
212                 GtkStyle    **style,
213                 GdkGC       **fg_gc,
214                 GdkGC       **bg_gc)
215 {
216   gint fg_state;
217
218   if ((state == GTK_STATE_NORMAL) &&
219       (GTK_WIDGET (clist)->state == GTK_STATE_INSENSITIVE))
220     fg_state = GTK_STATE_INSENSITIVE;
221   else
222     fg_state = state;
223
224   if (clist_row->cell[column].style)
225     {
226       if (style)
227         *style = clist_row->cell[column].style;
228       if (fg_gc)
229         *fg_gc = clist_row->cell[column].style->fg_gc[fg_state];
230       if (bg_gc) {
231         if (state == GTK_STATE_SELECTED)
232           *bg_gc = clist_row->cell[column].style->bg_gc[state];
233       }
234     }
235   else if (clist_row->style)
236     {
237       if (style)
238         *style = clist_row->style;
239       if (fg_gc)
240         *fg_gc = clist_row->style->fg_gc[fg_state];
241       if (bg_gc) {
242         if (state == GTK_STATE_SELECTED)
243           *bg_gc = clist_row->style->bg_gc[state];
244         else
245           *bg_gc = clist_row->bg_set ? 
246                 clist->bg_gc : clist_row->style->base_gc[state];
247       }
248     }
249   else
250     {
251       if (style)
252         *style = GTK_WIDGET (clist)->style;
253       if (fg_gc)
254         *fg_gc = GTK_WIDGET (clist)->style->fg_gc[fg_state];
255       if (bg_gc) {
256         if (state == GTK_STATE_SELECTED)
257           *bg_gc = GTK_WIDGET (clist)->style->bg_gc[state];
258         else
259           *bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
260       }
261
262       if (state != GTK_STATE_SELECTED)
263         {
264           if (fg_gc && clist_row->fg_set)
265             *fg_gc = clist->fg_gc;
266           if (bg_gc && clist_row->bg_set)
267             *bg_gc = clist->bg_gc;
268         }
269     }
270 }
271
272 static gint
273 gtk_sctree_draw_expander (GtkCTree     *ctree,
274                          GtkCTreeRow  *ctree_row,
275                          GtkStyle     *style,
276                          GdkRectangle *clip_rectangle,
277                          gint          x)
278 {
279   GtkCList *clist;
280   GdkPoint points[3];
281   gint justification_factor;
282   gint y;
283
284  if (ctree->expander_style == GTK_CTREE_EXPANDER_NONE)
285    return x;
286
287   clist = GTK_CLIST (ctree);
288   if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT)
289     justification_factor = -1;
290   else
291     justification_factor = 1;
292   y = (clip_rectangle->y + (clip_rectangle->height - PM_SIZE) / 2 -
293        (clip_rectangle->height + 1) % 2);
294
295   if (!ctree_row->children)
296     {
297       switch (ctree->expander_style)
298         {
299         case GTK_CTREE_EXPANDER_NONE:
300           return x;
301         case GTK_CTREE_EXPANDER_TRIANGLE:
302           return x + justification_factor * (PM_SIZE + 3);
303         case GTK_CTREE_EXPANDER_SQUARE:
304         case GTK_CTREE_EXPANDER_CIRCULAR:
305           return x + justification_factor * (PM_SIZE + 1);
306         }
307     }
308
309   gdk_gc_set_clip_rectangle (style->fg_gc[GTK_STATE_NORMAL], clip_rectangle);
310   gdk_gc_set_clip_rectangle (style->base_gc[GTK_STATE_NORMAL], clip_rectangle);
311
312   switch (ctree->expander_style)
313     {
314     case GTK_CTREE_EXPANDER_NONE:
315       break;
316     case GTK_CTREE_EXPANDER_TRIANGLE:
317       if (ctree_row->expanded)
318         {
319           points[0].x = x;
320           points[0].y = y + (PM_SIZE + 2) / 6;
321           points[1].x = points[0].x + justification_factor * (PM_SIZE + 2);
322           points[1].y = points[0].y;
323           points[2].x = (points[0].x +
324                          justification_factor * (PM_SIZE + 2) / 2);
325           points[2].y = y + 2 * (PM_SIZE + 2) / 3;
326         }
327       else
328         {
329           points[0].x = x + justification_factor * ((PM_SIZE + 2) / 6 + 2);
330           points[0].y = y - 1;
331           points[1].x = points[0].x;
332           points[1].y = points[0].y + (PM_SIZE + 2);
333           points[2].x = (points[0].x +
334                          justification_factor * (2 * (PM_SIZE + 2) / 3 - 1));
335           points[2].y = points[0].y + (PM_SIZE + 2) / 2;
336         }
337
338       gdk_draw_polygon (clist->clist_window, style->base_gc[GTK_STATE_NORMAL],
339                         TRUE, points, 3);
340       gdk_draw_polygon (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL],
341                         FALSE, points, 3);
342
343       x += justification_factor * (PM_SIZE + 3);
344       break;
345     case GTK_CTREE_EXPANDER_SQUARE:
346     case GTK_CTREE_EXPANDER_CIRCULAR:
347       if (justification_factor == -1)
348         x += justification_factor * (PM_SIZE + 1);
349
350       if (ctree->expander_style == GTK_CTREE_EXPANDER_CIRCULAR)
351         {
352           gdk_draw_arc (clist->clist_window, style->base_gc[GTK_STATE_NORMAL],
353                         TRUE, x, y, PM_SIZE, PM_SIZE, 0, 360 * 64);
354           gdk_draw_arc (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL],
355                         FALSE, x, y, PM_SIZE, PM_SIZE, 0, 360 * 64);
356         }
357       else
358         {
359           gdk_draw_rectangle (clist->clist_window,
360                               style->base_gc[GTK_STATE_NORMAL], TRUE,
361                               x, y, PM_SIZE, PM_SIZE);
362           gdk_draw_rectangle (clist->clist_window,
363                               style->fg_gc[GTK_STATE_NORMAL], FALSE,
364                               x, y, PM_SIZE, PM_SIZE);
365         }
366
367       gdk_draw_line (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL], 
368                      x + 2, y + PM_SIZE / 2, x + PM_SIZE - 2, y + PM_SIZE / 2);
369
370       if (!ctree_row->expanded)
371         gdk_draw_line (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL],
372                        x + PM_SIZE / 2, y + 2,
373                        x + PM_SIZE / 2, y + PM_SIZE - 2);
374
375       if (justification_factor == 1)
376         x += justification_factor * (PM_SIZE + 1);
377       break;
378     }
379
380   gdk_gc_set_clip_rectangle (style->fg_gc[GTK_STATE_NORMAL], NULL);
381   gdk_gc_set_clip_rectangle (style->base_gc[GTK_STATE_NORMAL], NULL);
382
383   return x;
384 }
385
386 static gint
387 gtk_sctree_draw_lines (GtkCTree     *ctree,
388                       GtkCTreeRow  *ctree_row,
389                       gint          row,
390                       gint          column,
391                       gint          state,
392                       GdkRectangle *clip_rectangle,
393                       GdkRectangle *cell_rectangle,
394                       GdkRectangle *crect,
395                       GdkRectangle *area,
396                       GtkStyle     *style)
397 {
398   GtkCList *clist;
399   GtkCTreeNode *node;
400   GtkCTreeNode *parent;
401   GdkRectangle tree_rectangle;
402   GdkRectangle tc_rectangle;
403   GdkGC *bg_gc;
404   gint offset;
405   gint offset_x;
406   gint offset_y;
407   gint xcenter;
408   gint ycenter;
409   gint next_level;
410   gint column_right;
411   gint column_left;
412   gint justify_right;
413   gint justification_factor;
414   
415   clist = GTK_CLIST (ctree);
416   ycenter = clip_rectangle->y + (clip_rectangle->height / 2);
417   justify_right = (clist->column[column].justification == GTK_JUSTIFY_RIGHT);
418
419   if (justify_right)
420     {
421       offset = (clip_rectangle->x + clip_rectangle->width - 1 -
422                 ctree->tree_indent * (ctree_row->level - 1));
423       justification_factor = -1;
424     }
425   else
426     {
427       offset = clip_rectangle->x + ctree->tree_indent * (ctree_row->level - 1);
428       justification_factor = 1;
429     }
430
431   switch (ctree->line_style)
432     {
433     case GTK_CTREE_LINES_NONE:
434       break;
435     case GTK_CTREE_LINES_TABBED:
436       xcenter = offset + justification_factor * TAB_SIZE;
437
438       column_right = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) +
439                       clist->column[ctree->tree_column].area.width +
440                       COLUMN_INSET);
441       column_left = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) -
442                      COLUMN_INSET - CELL_SPACING);
443
444       if (area)
445         {
446           tree_rectangle.y = crect->y;
447           tree_rectangle.height = crect->height;
448
449           if (justify_right)
450             {
451               tree_rectangle.x = xcenter;
452               tree_rectangle.width = column_right - xcenter;
453             }
454           else
455             {
456               tree_rectangle.x = column_left;
457               tree_rectangle.width = xcenter - column_left;
458             }
459
460           if (!gdk_rectangle_intersect (area, &tree_rectangle, &tc_rectangle))
461             {
462               offset += justification_factor * 3;
463               break;
464             }
465         }
466
467       gdk_gc_set_clip_rectangle (ctree->lines_gc, crect);
468
469       next_level = ctree_row->level;
470
471       if (!ctree_row->sibling || (ctree_row->children && ctree_row->expanded))
472         {
473           node = gtk_ctree_find_node_ptr (ctree, ctree_row);
474           if (GTK_CTREE_NODE_NEXT (node))
475             next_level = GTK_CTREE_ROW (GTK_CTREE_NODE_NEXT (node))->level;
476           else
477             next_level = 0;
478         }
479
480       if (ctree->tree_indent > 0)
481         {
482           node = ctree_row->parent;
483           while (node)
484             {
485               xcenter -= (justification_factor * ctree->tree_indent);
486
487               if ((justify_right && xcenter < column_left) ||
488                   (!justify_right && xcenter > column_right))
489                 {
490                   node = GTK_CTREE_ROW (node)->parent;
491                   continue;
492                 }
493
494               tree_rectangle.y = cell_rectangle->y;
495               tree_rectangle.height = cell_rectangle->height;
496               if (justify_right)
497                 {
498                   tree_rectangle.x = MAX (xcenter - ctree->tree_indent + 1,
499                                           column_left);
500                   tree_rectangle.width = MIN (xcenter - column_left,
501                                               ctree->tree_indent);
502                 }
503               else
504                 {
505                   tree_rectangle.x = xcenter;
506                   tree_rectangle.width = MIN (column_right - xcenter,
507                                               ctree->tree_indent);
508                 }
509
510               if (!area || gdk_rectangle_intersect (area, &tree_rectangle,
511                                                     &tc_rectangle))
512                 {
513                   gtk_sctree_get_cell_style (clist, &GTK_CTREE_ROW (node)->row,
514                                   state, row, column, NULL, NULL, &bg_gc);
515
516                   if (bg_gc == clist->bg_gc)
517                     gdk_gc_set_foreground
518                       (clist->bg_gc, &GTK_CTREE_ROW (node)->row.background);
519
520                   if (!area)
521                     gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
522                                         tree_rectangle.x,
523                                         tree_rectangle.y,
524                                         tree_rectangle.width,
525                                         tree_rectangle.height);
526                   else 
527                     gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
528                                         tc_rectangle.x,
529                                         tc_rectangle.y,
530                                         tc_rectangle.width,
531                                         tc_rectangle.height);
532                 }
533               if (next_level > GTK_CTREE_ROW (node)->level)
534                 gdk_draw_line (clist->clist_window, ctree->lines_gc,
535                                xcenter, crect->y,
536                                xcenter, crect->y + crect->height);
537               else
538                 {
539                   gint width;
540
541                   offset_x = MIN (ctree->tree_indent, 2 * TAB_SIZE);
542                   width = offset_x / 2 + offset_x % 2;
543
544                   parent = GTK_CTREE_ROW (node)->parent;
545
546                   tree_rectangle.y = ycenter;
547                   tree_rectangle.height = (cell_rectangle->y - ycenter +
548                                            cell_rectangle->height);
549
550                   if (justify_right)
551                     {
552                       tree_rectangle.x = MAX(xcenter + 1 - width, column_left);
553                       tree_rectangle.width = MIN (xcenter + 1 - column_left,
554                                                   width);
555                     }
556                   else
557                     {
558                       tree_rectangle.x = xcenter;
559                       tree_rectangle.width = MIN (column_right - xcenter,
560                                                   width);
561                     }
562
563                   if (!area ||
564                       gdk_rectangle_intersect (area, &tree_rectangle,
565                                                &tc_rectangle))
566                     {
567                       if (parent)
568                         {
569                           gtk_sctree_get_cell_style (clist, &GTK_CTREE_ROW (parent)->row,
570                                           state, row, column, NULL, NULL, &bg_gc);
571                           if (bg_gc == clist->bg_gc)
572                             gdk_gc_set_foreground
573                               (clist->bg_gc,
574                                &GTK_CTREE_ROW (parent)->row.background);
575                         }
576                       else if (state == GTK_STATE_SELECTED)
577                         bg_gc = style->base_gc[state];
578                       else
579                         bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
580
581                       if (!area)
582                         gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
583                                             tree_rectangle.x,
584                                             tree_rectangle.y,
585                                             tree_rectangle.width,
586                                             tree_rectangle.height);
587                       else
588                         gdk_draw_rectangle (clist->clist_window,
589                                             bg_gc, TRUE,
590                                             tc_rectangle.x,
591                                             tc_rectangle.y,
592                                             tc_rectangle.width,
593                                             tc_rectangle.height);
594                     }
595
596                   gtk_sctree_get_cell_style (clist, &GTK_CTREE_ROW (node)->row,
597                                   state, row, column, NULL, NULL, &bg_gc);
598                   if (bg_gc == clist->bg_gc)
599                     gdk_gc_set_foreground
600                       (clist->bg_gc, &GTK_CTREE_ROW (node)->row.background);
601
602                   gdk_gc_set_clip_rectangle (bg_gc, crect);
603                   gdk_draw_arc (clist->clist_window, bg_gc, TRUE,
604                                 xcenter - (justify_right * offset_x),
605                                 cell_rectangle->y,
606                                 offset_x, clist->row_height,
607                                 (180 + (justify_right * 90)) * 64, 90 * 64);
608                   gdk_gc_set_clip_rectangle (bg_gc, NULL);
609
610                   gdk_draw_line (clist->clist_window, ctree->lines_gc, 
611                                  xcenter, cell_rectangle->y, xcenter, ycenter);
612
613                   if (justify_right)
614                     gdk_draw_arc (clist->clist_window, ctree->lines_gc, FALSE,
615                                   xcenter - offset_x, cell_rectangle->y,
616                                   offset_x, clist->row_height,
617                                   270 * 64, 90 * 64);
618                   else
619                     gdk_draw_arc (clist->clist_window, ctree->lines_gc, FALSE,
620                                   xcenter, cell_rectangle->y,
621                                   offset_x, clist->row_height,
622                                   180 * 64, 90 * 64);
623                 }
624               node = GTK_CTREE_ROW (node)->parent;
625             }
626         }
627
628       if (state != GTK_STATE_SELECTED)
629         {
630           tree_rectangle.y = clip_rectangle->y;
631           tree_rectangle.height = clip_rectangle->height;
632           tree_rectangle.width = COLUMN_INSET + CELL_SPACING +
633             MIN (clist->column[ctree->tree_column].area.width + COLUMN_INSET,
634                  TAB_SIZE);
635
636           if (justify_right)
637             tree_rectangle.x = MAX (xcenter + 1, column_left);
638           else
639             tree_rectangle.x = column_left;
640
641           if (!area)
642             gdk_draw_rectangle (clist->clist_window,
643                                 GTK_WIDGET
644                                 (ctree)->style->base_gc[GTK_STATE_NORMAL],
645                                 TRUE,
646                                 tree_rectangle.x,
647                                 tree_rectangle.y,
648                                 tree_rectangle.width,
649                                 tree_rectangle.height);
650           else if (gdk_rectangle_intersect (area, &tree_rectangle,
651                                             &tc_rectangle))
652             gdk_draw_rectangle (clist->clist_window,
653                                 GTK_WIDGET
654                                 (ctree)->style->base_gc[GTK_STATE_NORMAL],
655                                 TRUE,
656                                 tc_rectangle.x,
657                                 tc_rectangle.y,
658                                 tc_rectangle.width,
659                                 tc_rectangle.height);
660         }
661
662       xcenter = offset + (justification_factor * ctree->tree_indent / 2);
663
664       gtk_sctree_get_cell_style (clist, &ctree_row->row, state, row, column, NULL, NULL,
665                       &bg_gc);
666       if (bg_gc == clist->bg_gc)
667         gdk_gc_set_foreground (clist->bg_gc, &ctree_row->row.background);
668
669       gdk_gc_set_clip_rectangle (bg_gc, crect);
670       if (ctree_row->is_leaf)
671         {
672           GdkPoint points[6];
673
674           points[0].x = offset + justification_factor * TAB_SIZE;
675           points[0].y = cell_rectangle->y;
676
677           points[1].x = points[0].x - justification_factor * 4;
678           points[1].y = points[0].y;
679
680           points[2].x = points[1].x - justification_factor * 2;
681           points[2].y = points[1].y + 3;
682
683           points[3].x = points[2].x;
684           points[3].y = points[2].y + clist->row_height - 5;
685
686           points[4].x = points[3].x + justification_factor * 2;
687           points[4].y = points[3].y + 3;
688
689           points[5].x = points[4].x + justification_factor * 4;
690           points[5].y = points[4].y;
691
692           gdk_draw_polygon (clist->clist_window, bg_gc, TRUE, points, 6);
693           gdk_draw_lines (clist->clist_window, ctree->lines_gc, points, 6);
694         }
695       else 
696         {
697           gdk_draw_arc (clist->clist_window, bg_gc, TRUE,
698                         offset - (justify_right * 2 * TAB_SIZE),
699                         cell_rectangle->y,
700                         2 * TAB_SIZE, clist->row_height,
701                         (90 + (180 * justify_right)) * 64, 180 * 64);
702           gdk_draw_arc (clist->clist_window, ctree->lines_gc, FALSE,
703                         offset - (justify_right * 2 * TAB_SIZE),
704                         cell_rectangle->y,
705                         2 * TAB_SIZE, clist->row_height,
706                         (90 + (180 * justify_right)) * 64, 180 * 64);
707         }
708       gdk_gc_set_clip_rectangle (bg_gc, NULL);
709       gdk_gc_set_clip_rectangle (ctree->lines_gc, NULL);
710
711       offset += justification_factor * 3;
712       break;
713     default:
714       xcenter = offset + justification_factor * PM_SIZE / 2;
715
716       if (area)
717         {
718           tree_rectangle.y = crect->y;
719           tree_rectangle.height = crect->height;
720
721           if (justify_right)
722             {
723               tree_rectangle.x = xcenter - PM_SIZE / 2 - 2;
724               tree_rectangle.width = (clip_rectangle->x +
725                                       clip_rectangle->width -tree_rectangle.x);
726             }
727           else
728             {
729               tree_rectangle.x = clip_rectangle->x + PM_SIZE / 2;
730               tree_rectangle.width = (xcenter + PM_SIZE / 2 + 2 -
731                                       clip_rectangle->x);
732             }
733
734           if (!gdk_rectangle_intersect (area, &tree_rectangle, &tc_rectangle))
735             break;
736         }
737
738       offset_x = 1;
739       offset_y = 0;
740       if (ctree->line_style == GTK_CTREE_LINES_DOTTED)
741         {
742           offset_x += abs((clip_rectangle->x + clist->hoffset) % 2);
743           offset_y  = abs((cell_rectangle->y + clist->voffset) % 2);
744         }
745
746       clip_rectangle->y--;
747       clip_rectangle->height++;
748       gdk_gc_set_clip_rectangle (ctree->lines_gc, clip_rectangle);
749       gdk_draw_line (clist->clist_window, ctree->lines_gc,
750                      xcenter,
751                      (ctree->show_stub || clist->row_list->data != ctree_row) ?
752                      cell_rectangle->y + offset_y : ycenter,
753                      xcenter,
754                      (ctree_row->sibling) ? crect->y +crect->height : ycenter);
755
756       gdk_draw_line (clist->clist_window, ctree->lines_gc,
757                      xcenter + (justification_factor * offset_x), ycenter,
758                      xcenter + (justification_factor * (PM_SIZE / 2 + 2)),
759                      ycenter);
760
761       node = ctree_row->parent;
762       while (node)
763         {
764           xcenter -= (justification_factor * ctree->tree_indent);
765
766           if (GTK_CTREE_ROW (node)->sibling)
767             gdk_draw_line (clist->clist_window, ctree->lines_gc, 
768                            xcenter, cell_rectangle->y + offset_y,
769                            xcenter, crect->y + crect->height);
770           node = GTK_CTREE_ROW (node)->parent;
771         }
772       gdk_gc_set_clip_rectangle (ctree->lines_gc, NULL);
773       clip_rectangle->y++;
774       clip_rectangle->height--;
775       break;
776     }
777   return offset;
778 }
779
780 static PangoLayout *
781 sc_gtk_clist_create_cell_layout (GtkCList       *clist,
782                                GtkCListRow    *clist_row,
783                                gint            column)
784 {
785   PangoLayout *layout;
786   GtkStyle *style;
787   GtkCell *cell;
788   gchar *text;
789   
790   gtk_sctree_get_cell_style (clist, clist_row, GTK_STATE_NORMAL, 0, column, &style,
791                   NULL, NULL);
792
793
794   cell = &clist_row->cell[column];
795   switch (cell->type)
796     {
797     case GTK_CELL_TEXT:
798     case GTK_CELL_PIXTEXT:
799       text = ((cell->type == GTK_CELL_PIXTEXT) ?
800               GTK_CELL_PIXTEXT (*cell)->text :
801               GTK_CELL_TEXT (*cell)->text);
802
803       if (!text)
804         return NULL;
805       
806       layout = gtk_widget_create_pango_layout (GTK_WIDGET (clist),
807                                                ((cell->type == GTK_CELL_PIXTEXT) ?
808                                                 GTK_CELL_PIXTEXT (*cell)->text :
809                                                 GTK_CELL_TEXT (*cell)->text));
810       pango_layout_set_font_description (layout, style->font_desc);
811       
812       return layout;
813       
814     default:
815       return NULL;
816     }
817 }
818
819 static void
820 gtk_sctree_draw_row (GtkCList     *clist,
821           GdkRectangle *area,
822           gint          row,
823           GtkCListRow  *clist_row)
824 {
825   GtkWidget *widget;
826   GtkCTree  *ctree;
827   GdkRectangle *rect;
828   GdkRectangle *crect;
829   GdkRectangle row_rectangle;
830   GdkRectangle cell_rectangle; 
831   GdkRectangle clip_rectangle;
832   GdkRectangle intersect_rectangle;
833   gint last_column;
834   gint column_left = 0;
835   gint column_right = 0;
836   gint offset = 0;
837   gint state;
838   gint i;
839   static GdkColor greybg={0, 0, 0, 0};
840   static gboolean color_change = TRUE;
841
842   if (greybg.pixel == 0 &&
843       greybg.red == 0 &&
844       greybg.green == 0 &&
845       greybg.blue == 0) {
846         GdkColor normalbg = {0, 0xffff, 0xffff, 0xffff};
847         if (GTK_WIDGET (clist)->style) {
848                 normalbg = GTK_WIDGET (clist)->style->base[GTK_STATE_NORMAL];
849         }
850         if (normalbg.red > 0x8888 && normalbg.green > 0x8888 && normalbg.blue > 0x8888) {
851                 greybg.pixel = normalbg.pixel;
852                 greybg.red = normalbg.red - prefs_common.stripes_color_offset;
853                 greybg.green = normalbg.green - prefs_common.stripes_color_offset;
854                 greybg.blue = normalbg.blue - prefs_common.stripes_color_offset;
855         } else if (normalbg.red < 0x8888 && normalbg.green < 0x8888 && normalbg.blue < 0x8888) {
856                 greybg.pixel = normalbg.pixel;
857                 greybg.red = normalbg.red + prefs_common.stripes_color_offset;
858                 greybg.green = normalbg.green + prefs_common.stripes_color_offset;
859                 greybg.blue = normalbg.blue + prefs_common.stripes_color_offset;
860         } else {
861                 color_change = FALSE;
862         }
863   }
864
865   g_return_if_fail (clist != NULL);
866
867   /* bail now if we arn't drawable yet */
868   if (!GTK_WIDGET_DRAWABLE (clist) || row < 0 || row >= clist->rows)
869     return;
870
871   widget = GTK_WIDGET (clist);
872   ctree  = GTK_CTREE  (clist);
873
874   /* if the function is passed the pointer to the row instead of null,
875    * it avoids this expensive lookup */
876   if (!clist_row)
877     clist_row = (g_list_nth (clist->row_list, row))->data;
878
879   /* rectangle of the entire row */
880   row_rectangle.x = 0;
881   row_rectangle.y = ROW_TOP_YPIXEL (clist, row);
882   row_rectangle.width = clist->clist_window_width;
883   row_rectangle.height = clist->row_height;
884
885   /* rectangle of the cell spacing above the row */
886   cell_rectangle.x = 0;
887   cell_rectangle.y = row_rectangle.y - CELL_SPACING;
888   cell_rectangle.width = row_rectangle.width;
889   cell_rectangle.height = CELL_SPACING;
890
891   /* rectangle used to clip drawing operations, its y and height
892    * positions only need to be set once, so we set them once here. 
893    * the x and width are set withing the drawing loop below once per
894    * column */
895   clip_rectangle.y = row_rectangle.y;
896   clip_rectangle.height = row_rectangle.height;
897
898   if (prefs_common.use_stripes_everywhere && GTK_SCTREE(ctree)->show_stripes
899       && color_change && row % 2) {
900     clist_row->background = greybg;
901     clist_row->bg_set = TRUE;
902   } else {
903     clist_row->bg_set = FALSE;
904   }
905   if (clist_row->state == GTK_STATE_NORMAL)
906     {
907       if (clist_row->fg_set)
908         gdk_gc_set_foreground (clist->fg_gc, &clist_row->foreground);
909       if (clist_row->bg_set)
910         gdk_gc_set_rgb_fg_color (clist->bg_gc, &clist_row->background);
911     }
912   
913   state = clist_row->state;
914
915   gdk_gc_set_foreground (ctree->lines_gc,
916                          &widget->style->fg[clist_row->state]);
917
918   /* draw the cell borders */
919   if (area)
920     {
921       rect = &intersect_rectangle;
922       crect = &intersect_rectangle;
923
924       if (gdk_rectangle_intersect (area, &cell_rectangle, crect))
925         gdk_draw_rectangle (clist->clist_window,
926                             widget->style->base_gc[GTK_STATE_NORMAL], TRUE,
927                             crect->x, crect->y, crect->width, crect->height);
928     }
929   else
930     {
931       rect = &clip_rectangle;
932       crect = &cell_rectangle;
933
934       gdk_draw_rectangle (clist->clist_window,
935                           widget->style->base_gc[GTK_STATE_NORMAL], TRUE,
936                           crect->x, crect->y, crect->width, crect->height);
937     }
938
939   /* horizontal black lines */
940   if (ctree->line_style == GTK_CTREE_LINES_TABBED)
941     { 
942
943       column_right = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) +
944                       clist->column[ctree->tree_column].area.width +
945                       COLUMN_INSET);
946       column_left = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) -
947                      COLUMN_INSET - (ctree->tree_column != 0) * CELL_SPACING);
948
949       switch (clist->column[ctree->tree_column].justification)
950         {
951         case GTK_JUSTIFY_CENTER:
952         case GTK_JUSTIFY_FILL:
953         case GTK_JUSTIFY_LEFT:
954           offset = (column_left + ctree->tree_indent *
955                     (((GtkCTreeRow *)clist_row)->level - 1));
956
957           gdk_draw_line (clist->clist_window, ctree->lines_gc, 
958                          MIN (offset + TAB_SIZE, column_right),
959                          cell_rectangle.y,
960                          clist->clist_window_width, cell_rectangle.y);
961           break;
962         case GTK_JUSTIFY_RIGHT:
963           offset = (column_right - 1 - ctree->tree_indent *
964                     (((GtkCTreeRow *)clist_row)->level - 1));
965
966           gdk_draw_line (clist->clist_window, ctree->lines_gc,
967                          -1, cell_rectangle.y,
968                          MAX (offset - TAB_SIZE, column_left),
969                          cell_rectangle.y);
970           break;
971         }
972     }
973
974   /* the last row has to clear its bottom cell spacing too */
975   if (clist_row == clist->row_list_end->data)
976     {
977       cell_rectangle.y += clist->row_height + CELL_SPACING;
978
979       if (!area || gdk_rectangle_intersect (area, &cell_rectangle, crect))
980         {
981           gdk_draw_rectangle (clist->clist_window,
982                               widget->style->base_gc[GTK_STATE_NORMAL], TRUE,
983                               crect->x, crect->y, crect->width, crect->height);
984
985           /* horizontal black lines */
986           if (ctree->line_style == GTK_CTREE_LINES_TABBED)
987             { 
988               switch (clist->column[ctree->tree_column].justification)
989                 {
990                 case GTK_JUSTIFY_CENTER:
991                 case GTK_JUSTIFY_FILL:
992                 case GTK_JUSTIFY_LEFT:
993                   gdk_draw_line (clist->clist_window, ctree->lines_gc, 
994                                  MIN (column_left + TAB_SIZE + COLUMN_INSET +
995                                       (((GtkCTreeRow *)clist_row)->level > 1) *
996                                       MIN (ctree->tree_indent / 2, TAB_SIZE),
997                                       column_right),
998                                  cell_rectangle.y,
999                                  clist->clist_window_width, cell_rectangle.y);
1000                   break;
1001                 case GTK_JUSTIFY_RIGHT:
1002                   gdk_draw_line (clist->clist_window, ctree->lines_gc, 
1003                                  -1, cell_rectangle.y,
1004                                  MAX (column_right - TAB_SIZE - 1 -
1005                                       COLUMN_INSET -
1006                                       (((GtkCTreeRow *)clist_row)->level > 1) *
1007                                       MIN (ctree->tree_indent / 2, TAB_SIZE),
1008                                       column_left - 1), cell_rectangle.y);
1009                   break;
1010                 }
1011             }
1012         }
1013     }     
1014
1015   for (last_column = clist->columns - 1;
1016        last_column >= 0 && !clist->column[last_column].visible; last_column--)
1017     ;
1018
1019   /* iterate and draw all the columns (row cells) and draw their contents */
1020   for (i = 0; i < clist->columns; i++)
1021     {
1022       GtkStyle *style;
1023       GdkGC *fg_gc; 
1024       GdkGC *bg_gc;
1025       PangoLayout *layout = NULL;
1026       PangoRectangle logical_rect;
1027
1028       gint width;
1029       gint height;
1030       gint pixmap_width;
1031       gint string_width;
1032       gint old_offset;
1033
1034       if (!clist->column[i].visible)
1035         continue;
1036
1037       gtk_sctree_get_cell_style (clist, clist_row, state, row, i, &style, &fg_gc, &bg_gc);
1038
1039       /* calculate clipping region */
1040       clip_rectangle.x = clist->column[i].area.x + clist->hoffset;
1041       clip_rectangle.width = clist->column[i].area.width;
1042
1043       cell_rectangle.x = clip_rectangle.x - COLUMN_INSET - CELL_SPACING;
1044       cell_rectangle.width = (clip_rectangle.width + 2 * COLUMN_INSET +
1045                               (1 + (i == last_column)) * CELL_SPACING);
1046       cell_rectangle.y = clip_rectangle.y;
1047       cell_rectangle.height = clip_rectangle.height;
1048
1049       string_width = 0;
1050       pixmap_width = 0;
1051
1052       if (area && !gdk_rectangle_intersect (area, &cell_rectangle,
1053                                             &intersect_rectangle))
1054         {
1055           if (i != ctree->tree_column)
1056             continue;
1057         }
1058       else
1059         {
1060           gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
1061                               crect->x, crect->y, crect->width, crect->height);
1062
1063
1064           layout = sc_gtk_clist_create_cell_layout (clist, clist_row, i);
1065           if (layout)
1066             {
1067               pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1068               width = logical_rect.width;
1069             }
1070           else
1071             width = 0;
1072
1073           switch (clist_row->cell[i].type)
1074             {
1075             case GTK_CELL_PIXMAP:
1076               gdk_window_get_size
1077                 (GTK_CELL_PIXMAP (clist_row->cell[i])->pixmap, &pixmap_width,
1078                  &height);
1079               width += pixmap_width;
1080               break;
1081             case GTK_CELL_PIXTEXT:
1082               if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
1083                 {
1084                   gdk_window_get_size 
1085                     (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
1086                      &pixmap_width, &height);
1087                   width += pixmap_width;
1088                 }
1089
1090               if (GTK_CELL_PIXTEXT (clist_row->cell[i])->text &&
1091                   GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
1092                 width +=  GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
1093
1094               if (i == ctree->tree_column)
1095                 width += (ctree->tree_indent *
1096                           ((GtkCTreeRow *)clist_row)->level);
1097               break;
1098             default:
1099               break;
1100             }
1101
1102           switch (clist->column[i].justification)
1103             {
1104             case GTK_JUSTIFY_LEFT:
1105               offset = clip_rectangle.x + clist_row->cell[i].horizontal;
1106               break;
1107             case GTK_JUSTIFY_RIGHT:
1108               offset = (clip_rectangle.x + clist_row->cell[i].horizontal +
1109                         clip_rectangle.width - width);
1110               break;
1111             case GTK_JUSTIFY_CENTER:
1112             case GTK_JUSTIFY_FILL:
1113               offset = (clip_rectangle.x + clist_row->cell[i].horizontal +
1114                         (clip_rectangle.width / 2) - (width / 2));
1115               break;
1116             };
1117
1118           if (i != ctree->tree_column)
1119             {
1120               offset += clist_row->cell[i].horizontal;
1121               switch (clist_row->cell[i].type)
1122                 {
1123                 case GTK_CELL_PIXMAP:
1124                   gtk_sctree_draw_cell_pixmap
1125                     (clist->clist_window, &clip_rectangle, fg_gc,
1126                      GTK_CELL_PIXMAP (clist_row->cell[i])->pixmap,
1127                      GTK_CELL_PIXMAP (clist_row->cell[i])->mask,
1128                      offset,
1129                      clip_rectangle.y + clist_row->cell[i].vertical +
1130                      (clip_rectangle.height - height) / 2,
1131                      pixmap_width, height);
1132                   break;
1133                 case GTK_CELL_PIXTEXT:
1134                   offset = gtk_sctree_draw_cell_pixmap
1135                     (clist->clist_window, &clip_rectangle, fg_gc,
1136                      GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
1137                      GTK_CELL_PIXTEXT (clist_row->cell[i])->mask,
1138                      offset,
1139                      clip_rectangle.y + clist_row->cell[i].vertical +
1140                      (clip_rectangle.height - height) / 2,
1141                      pixmap_width, height);
1142                   offset += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
1143
1144                   /* Fall through */
1145                 case GTK_CELL_TEXT:
1146                   if (layout)
1147                     {
1148                       gint row_center_offset = (clist->row_height - logical_rect.height) / 2;
1149
1150                       gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
1151                       gdk_draw_layout (clist->clist_window, fg_gc,
1152                                        offset,
1153                                        row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
1154                                        layout);
1155                       gdk_gc_set_clip_rectangle (fg_gc, NULL);
1156                       g_object_unref (G_OBJECT (layout));
1157                     }
1158                   break;
1159                 default:
1160                   break;
1161                 }
1162               continue;
1163             }
1164         }
1165
1166       if (bg_gc == clist->bg_gc)
1167         gdk_gc_set_background (ctree->lines_gc, &clist_row->background);
1168
1169       /* draw ctree->tree_column */
1170       cell_rectangle.y -= CELL_SPACING;
1171       cell_rectangle.height += CELL_SPACING;
1172
1173       if (area && !gdk_rectangle_intersect (area, &cell_rectangle,
1174                                             &intersect_rectangle))
1175         {
1176           if (layout)
1177             g_object_unref (G_OBJECT (layout));
1178           continue;
1179         }
1180
1181       /* draw lines */
1182       offset = gtk_sctree_draw_lines (ctree, (GtkCTreeRow *)clist_row, row, i,
1183                                      state, &clip_rectangle, &cell_rectangle,
1184                                      crect, area, style);
1185
1186       /* draw expander */
1187       offset = gtk_sctree_draw_expander (ctree, (GtkCTreeRow *)clist_row,
1188                                         style, &clip_rectangle, offset);
1189
1190       if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
1191         offset -= ctree->tree_spacing;
1192       else
1193         offset += ctree->tree_spacing;
1194
1195       if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
1196         offset -= (pixmap_width + clist_row->cell[i].horizontal);
1197       else
1198         offset += clist_row->cell[i].horizontal;
1199
1200       old_offset = offset;
1201       offset = gtk_sctree_draw_cell_pixmap (clist->clist_window, &clip_rectangle, fg_gc,
1202                                  GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
1203                                  GTK_CELL_PIXTEXT (clist_row->cell[i])->mask,
1204                                  offset, 
1205                                  clip_rectangle.y + clist_row->cell[i].vertical
1206                                  + (clip_rectangle.height - height) / 2,
1207                                  pixmap_width, height);
1208
1209       if (layout)
1210         {
1211           gint row_center_offset = (clist->row_height - logical_rect.height) / 2;
1212           
1213           if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
1214             {
1215               offset = (old_offset - string_width);
1216               if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
1217                 offset -= GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
1218             }
1219           else
1220             {
1221               if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
1222                 offset += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
1223             }
1224           
1225           gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
1226           gdk_draw_layout (clist->clist_window, fg_gc,
1227                            offset,
1228                            row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
1229                            layout);
1230
1231           g_object_unref (G_OBJECT (layout));
1232         }
1233       gdk_gc_set_clip_rectangle (fg_gc, NULL);
1234     }
1235
1236   /* draw focus rectangle */
1237   if (clist->focus_row == row &&
1238       GTK_WIDGET_CAN_FOCUS (widget) && GTK_WIDGET_HAS_FOCUS (widget))
1239     {
1240       if (!area)
1241         gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
1242                             row_rectangle.x, row_rectangle.y,
1243                             row_rectangle.width - 1, row_rectangle.height - 1);
1244       else if (gdk_rectangle_intersect (area, &row_rectangle,
1245                                         &intersect_rectangle))
1246         {
1247           gdk_gc_set_clip_rectangle (clist->xor_gc, &intersect_rectangle);
1248           gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
1249                               row_rectangle.x, row_rectangle.y,
1250                               row_rectangle.width - 1,
1251                               row_rectangle.height - 1);
1252           gdk_gc_set_clip_rectangle (clist->xor_gc, NULL);
1253         }
1254     }
1255 }
1256
1257 static void
1258 gtk_sctree_change_focus_row_expansion (GtkCTree          *ctree,
1259                             GtkCTreeExpansionType action)
1260 {
1261   GtkCList *clist;
1262   GtkCTreeNode *node;
1263
1264   g_return_if_fail (GTK_IS_CTREE (ctree));
1265
1266   clist = GTK_CLIST (ctree);
1267
1268   if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (ctree))) && 
1269       GTK_WIDGET_HAS_GRAB (ctree))
1270     return;
1271   
1272   if (!(node =
1273         GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row))) ||
1274       GTK_CTREE_ROW (node)->is_leaf || !(GTK_CTREE_ROW (node)->children))
1275     return;
1276
1277   switch (action)
1278     {
1279     case GTK_CTREE_EXPANSION_EXPAND:
1280       if (GTK_SCTREE(ctree)->always_expand_recursively)
1281               gtk_ctree_expand_recursive (ctree, node);
1282       else
1283               gtk_ctree_expand (ctree, node);
1284
1285       break;
1286     case GTK_CTREE_EXPANSION_EXPAND_RECURSIVE:
1287       gtk_ctree_expand_recursive (ctree, node);
1288       break;
1289     case GTK_CTREE_EXPANSION_COLLAPSE:
1290       gtk_ctree_collapse (ctree, node);
1291       break;
1292     case GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE:
1293       gtk_ctree_collapse_recursive (ctree, node);
1294       break;
1295     case GTK_CTREE_EXPANSION_TOGGLE:
1296       if (GTK_SCTREE(ctree)->always_expand_recursively)
1297               gtk_ctree_toggle_expansion_recursive (ctree, node);
1298       else
1299               gtk_ctree_toggle_expansion (ctree, node);
1300       break;
1301     case GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE:
1302       gtk_ctree_toggle_expansion_recursive (ctree, node);
1303       break;
1304     }
1305 }
1306
1307 /* Standard class initialization function */
1308 static void
1309 gtk_sctree_class_init (GtkSCTreeClass *klass)
1310 {
1311         GtkObjectClass *object_class;
1312         GtkWidgetClass *widget_class;
1313         GtkCListClass *clist_class;
1314         GtkCTreeClass *ctree_class;
1315
1316         object_class = (GtkObjectClass *) klass;
1317         widget_class = (GtkWidgetClass *) klass;
1318         clist_class = (GtkCListClass *) klass;
1319         ctree_class = (GtkCTreeClass *) klass;
1320
1321         parent_class = gtk_type_class (gtk_ctree_get_type ());
1322
1323         sctree_signals[ROW_POPUP_MENU] =
1324                 g_signal_new ("row_popup_menu",
1325                               G_TYPE_FROM_CLASS (klass),
1326                               G_SIGNAL_RUN_FIRST,
1327                               G_STRUCT_OFFSET (GtkSCTreeClass, row_popup_menu),
1328                               NULL, NULL,
1329                               claws_marshal_VOID__POINTER,
1330                               G_TYPE_NONE, 1,
1331                               GDK_TYPE_EVENT);
1332         sctree_signals[EMPTY_POPUP_MENU] =
1333                 g_signal_new ("empty_popup_menu",
1334                               G_TYPE_FROM_CLASS (klass),
1335                               G_SIGNAL_RUN_FIRST,
1336                               G_STRUCT_OFFSET (GtkSCTreeClass, empty_popup_menu),
1337                               NULL, NULL,
1338                               claws_marshal_VOID__POINTER,
1339                               G_TYPE_NONE, 1,
1340                               GDK_TYPE_EVENT);
1341         sctree_signals[OPEN_ROW] =
1342                 g_signal_new ("open_row",
1343                               G_TYPE_FROM_CLASS (klass),
1344                               G_SIGNAL_RUN_FIRST,
1345                               G_STRUCT_OFFSET (GtkSCTreeClass, open_row),
1346                               NULL, NULL,
1347                               g_cclosure_marshal_VOID__VOID,
1348                               G_TYPE_NONE, 0);
1349         sctree_signals[START_DRAG] =
1350                 g_signal_new ("start_drag",
1351                               G_TYPE_FROM_CLASS (klass),
1352                               G_SIGNAL_RUN_FIRST,
1353                               G_STRUCT_OFFSET (GtkSCTreeClass, start_drag),
1354                               NULL, NULL,
1355                               claws_marshal_VOID__INT_POINTER,
1356                               G_TYPE_NONE, 2,
1357                               G_TYPE_INT,
1358                               GDK_TYPE_EVENT);
1359
1360         /* gtk_object_class_add_signals (object_class, sctree_signals, LAST_SIGNAL); */
1361
1362         clist_class->clear = gtk_sctree_clear;
1363         clist_class->draw_row = gtk_sctree_draw_row;
1364         clist_class->unselect_all = gtk_sctree_real_unselect_all;
1365         ctree_class->tree_collapse = gtk_sctree_collapse;
1366         ctree_class->tree_expand = gtk_sctree_real_tree_expand;
1367         ctree_class->tree_move = sreal_tree_move;
1368         ctree_class->change_focus_row_expansion = gtk_sctree_change_focus_row_expansion;
1369         
1370         widget_class->button_press_event = gtk_sctree_button_press;
1371         widget_class->button_release_event = gtk_sctree_button_release;
1372         widget_class->motion_notify_event = gtk_sctree_motion;
1373         widget_class->drag_begin = gtk_sctree_drag_begin;
1374         widget_class->drag_end = gtk_sctree_drag_end;
1375         widget_class->drag_data_get = gtk_sctree_drag_data_get;
1376         widget_class->drag_leave = gtk_sctree_drag_leave;
1377         widget_class->drag_motion = gtk_sctree_drag_motion;
1378         widget_class->drag_drop = gtk_sctree_drag_drop;
1379         widget_class->drag_data_received = gtk_sctree_drag_data_received;
1380 }
1381
1382 /* Standard object initialization function */
1383 static void
1384 gtk_sctree_init (GtkSCTree *sctree)
1385 {
1386         sctree->anchor_row = NULL;
1387
1388         /* GtkCTree does not specify pointer motion by default */
1389         gtk_widget_add_events (GTK_WIDGET (sctree), GDK_POINTER_MOTION_MASK);
1390         gtk_widget_add_events (GTK_WIDGET (sctree), GDK_POINTER_MOTION_MASK);
1391 }
1392
1393 /* Get information the specified row is selected. */
1394
1395 static gboolean
1396 row_is_selected(GtkSCTree *sctree, gint row)
1397 {
1398         GtkCListRow *clist_row;
1399         clist_row =  g_list_nth (GTK_CLIST(sctree)->row_list, row)->data;
1400         return clist_row ? clist_row->state == GTK_STATE_SELECTED : FALSE;
1401 }
1402
1403 /* Selects the rows between the anchor to the specified row, inclusive.  */
1404 static void
1405 select_range (GtkSCTree *sctree, gint row)
1406 {
1407         gint prev_row;
1408         gint min, max;
1409         gint i;
1410         GList *node;
1411         if (sctree->anchor_row == NULL) {
1412                 prev_row = row;
1413                 sctree->anchor_row = gtk_ctree_node_nth(GTK_CTREE(sctree), row);
1414         } else
1415                 prev_row = g_list_position(GTK_CLIST(sctree)->row_list,
1416                                            (GList *)sctree->anchor_row);
1417
1418         if (row < prev_row) {
1419                 min = row;
1420                 max = prev_row;
1421                 GTK_CLIST(sctree)->focus_row = max;
1422         } else {
1423                 min = prev_row;
1424                 max = row;
1425         }
1426         sctree->selecting_range++;
1427         
1428         if (max < min) {
1429                 int t = min;
1430                 min = max;
1431                 max = t;
1432         }
1433         
1434         if (max - min > 10)
1435                 gtk_clist_freeze(GTK_CLIST(sctree));
1436
1437         node = g_list_nth((GTK_CLIST(sctree))->row_list, min);
1438         for (i = min; i < max; i++) {
1439                 if (node && GTK_CTREE_ROW (node)->row.selectable) {
1440                         g_signal_emit_by_name(G_OBJECT(sctree), "tree_select_row",
1441                                 node, -1);
1442                 }
1443                 node = node->next;
1444         }
1445         if (max - min > 10)
1446                 gtk_clist_thaw(GTK_CLIST(sctree));
1447
1448
1449         sctree->selecting_range--;
1450         gtk_clist_select_row (GTK_CLIST (sctree), max, -1);
1451 }
1452
1453 /* Handles row selection according to the specified modifier state */
1454 /* in certain cases, we arrive here from a function knowing the GtkCTreeNode, and having
1455  * already slowly found row using g_list_position. In which case, _node will be non-NULL
1456  * to avoid this function having to slowly find it with g_list_nth. */
1457 static void
1458 select_row (GtkSCTree *sctree, gint row, gint col, guint state, GtkCTreeNode *_node)
1459 {
1460         gboolean range, additive;
1461         g_return_if_fail (sctree != NULL);
1462         g_return_if_fail (GTK_IS_SCTREE (sctree));
1463     
1464         range = ((state & GDK_SHIFT_MASK) != 0) &&
1465                 (GTK_CLIST(sctree)->selection_mode != GTK_SELECTION_SINGLE) &&
1466                 (GTK_CLIST(sctree)->selection_mode != GTK_SELECTION_BROWSE);
1467         additive = ((state & GDK_CONTROL_MASK) != 0) &&
1468                    (GTK_CLIST(sctree)->selection_mode != GTK_SELECTION_SINGLE) &&
1469                    (GTK_CLIST(sctree)->selection_mode != GTK_SELECTION_BROWSE);
1470
1471         if (!range && !additive && sctree->force_additive_sel)
1472                 additive = TRUE;
1473
1474         GTK_CLIST(sctree)->focus_row = row;
1475
1476         if (!additive) {
1477                 gtk_clist_unselect_all (GTK_CLIST (sctree));
1478         }
1479
1480         if (!range) {
1481                 GtkCTreeNode *node;
1482
1483                 node = _node ? _node : gtk_ctree_node_nth (GTK_CTREE(sctree), row);
1484
1485                 /*No need to manage overlapped list*/
1486                 if (additive) {
1487                         if (row_is_selected(sctree, row))
1488                                 gtk_clist_unselect_row (GTK_CLIST (sctree), row, col);
1489                         else
1490                                 g_signal_emit_by_name
1491                                         (G_OBJECT (sctree),
1492                                          "tree_select_row", node, col);
1493                 } else {
1494                         g_signal_emit_by_name
1495                                 (G_OBJECT (sctree),
1496                                  "tree_select_row", node, col);
1497                 }
1498                 sctree->anchor_row = node;
1499         } else
1500                 select_range (sctree, row);
1501 }
1502
1503 /* Our handler for button_press events.  We override all of GtkCList's broken
1504  * behavior.
1505  */
1506 static gint
1507 gtk_sctree_button_press (GtkWidget *widget, GdkEventButton *event)
1508 {
1509         GtkSCTree *sctree;
1510         GtkCList *clist;
1511         gboolean on_row;
1512         gint row;
1513         gint col;
1514         gint retval;
1515
1516         g_return_val_if_fail (widget != NULL, FALSE);
1517         g_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
1518         g_return_val_if_fail (event != NULL, FALSE);
1519
1520         sctree = GTK_SCTREE (widget);
1521         clist = GTK_CLIST (widget);
1522         retval = FALSE;
1523
1524         if (event->window != clist->clist_window)
1525                 return (* GTK_WIDGET_CLASS (parent_class)->button_press_event) (widget, event);
1526
1527         on_row = gtk_clist_get_selection_info (clist, event->x, event->y, &row, &col);
1528
1529         if (on_row && !GTK_WIDGET_HAS_FOCUS(widget))
1530                 gtk_widget_grab_focus (widget);
1531
1532         if (gtk_ctree_is_hot_spot (GTK_CTREE(sctree), event->x, event->y)) {
1533                 GtkCTreeNode *node = gtk_ctree_node_nth(GTK_CTREE(sctree), row);
1534                 if (GTK_CTREE_ROW (node)->expanded)
1535                         gtk_ctree_collapse(GTK_CTREE(sctree), node);
1536                 else if (GTK_SCTREE(sctree)->always_expand_recursively)
1537                         gtk_ctree_expand_recursive (GTK_CTREE(sctree), node);
1538                 else
1539                         gtk_ctree_expand(GTK_CTREE(sctree), node);
1540                 return TRUE;
1541         }
1542
1543         switch (event->type) {
1544         case GDK_BUTTON_PRESS:
1545                 if (event->button == 1 || event->button == 2) {
1546                         if (event->button == 2)
1547                                 event->state &= ~(GDK_SHIFT_MASK | GDK_CONTROL_MASK);
1548                         if (on_row) {
1549                                 /* Save the mouse info for DnD */
1550                                 sctree->dnd_press_button = event->button;
1551                                 sctree->dnd_press_x = event->x;
1552                                 sctree->dnd_press_y = event->y;
1553
1554                                 /* Handle selection */
1555                                 if ((row_is_selected (sctree, row)
1556                                      && !(event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)))
1557                                     || ((event->state & GDK_CONTROL_MASK)
1558                                         && !(event->state & GDK_SHIFT_MASK))) {
1559                                         sctree->dnd_select_pending = TRUE;
1560                                         sctree->dnd_select_pending_state = event->state;
1561                                         sctree->dnd_select_pending_row = row;
1562                                 } else {
1563                                         select_row (sctree, row, col, event->state, NULL);
1564                                 }
1565                         } else {
1566                                 gtk_clist_unselect_all (clist);
1567                         }
1568
1569                         retval = TRUE;
1570                 } else if (event->button == 3) {
1571                         /* Emit *_popup_menu signal*/
1572                         if (on_row) {
1573                                 if (!row_is_selected(sctree,row))
1574                                         select_row (sctree, row, col, 0, NULL);
1575                                 g_signal_emit (G_OBJECT (sctree),
1576                                                  sctree_signals[ROW_POPUP_MENU],
1577                                                  0, event);
1578                         } else {
1579                                 gtk_clist_unselect_all(clist);
1580                                 g_signal_emit (G_OBJECT (sctree),
1581                                                  sctree_signals[EMPTY_POPUP_MENU],
1582                                                  0, event);
1583                         }
1584                         retval = TRUE;
1585                 }
1586
1587                 break;
1588
1589         case GDK_2BUTTON_PRESS:
1590                 if (event->button != 1)
1591                         break;
1592
1593                 sctree->dnd_select_pending = FALSE;
1594                 sctree->dnd_select_pending_state = 0;
1595
1596                 if (on_row)
1597                         g_signal_emit (G_OBJECT (sctree),
1598                                        sctree_signals[OPEN_ROW], 0);
1599
1600                 retval = TRUE;
1601                 break;
1602
1603         default:
1604                 break;
1605         }
1606
1607         return retval;
1608 }
1609
1610 /* Our handler for button_release events.  We override all of GtkCList's broken
1611  * behavior.
1612  */
1613 static gint
1614 gtk_sctree_button_release (GtkWidget *widget, GdkEventButton *event)
1615 {
1616         GtkSCTree *sctree;
1617         GtkCList *clist;
1618         gint on_row;
1619         gint row, col;
1620         gint retval;
1621
1622         g_return_val_if_fail (widget != NULL, FALSE);
1623         g_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
1624         g_return_val_if_fail (event != NULL, FALSE);
1625
1626         sctree = GTK_SCTREE (widget);
1627         clist = GTK_CLIST (widget);
1628         retval = FALSE;
1629
1630         if (event->window != clist->clist_window)
1631                 return (* GTK_WIDGET_CLASS (parent_class)->button_release_event) (widget, event);
1632
1633         on_row = gtk_clist_get_selection_info (clist, event->x, event->y, &row, &col);
1634
1635         if (!(event->button == 1 || event->button == 2))
1636                 return FALSE;
1637
1638         sctree->dnd_press_button = 0;
1639         sctree->dnd_press_x = 0;
1640         sctree->dnd_press_y = 0;
1641
1642         if (on_row) {
1643                 if (sctree->dnd_select_pending) {
1644                         select_row (sctree, row, col, sctree->dnd_select_pending_state, NULL);
1645                         sctree->dnd_select_pending = FALSE;
1646                         sctree->dnd_select_pending_state = 0;
1647                 }
1648
1649                 retval = TRUE;
1650         }
1651
1652         return retval;
1653 }
1654
1655 /* Our handler for motion_notify events.  We override all of GtkCList's broken
1656  * behavior.
1657  */
1658 static gint
1659 gtk_sctree_motion (GtkWidget *widget, GdkEventMotion *event)
1660 {
1661         GtkSCTree *sctree;
1662         GtkCList *clist;
1663
1664         g_return_val_if_fail (widget != NULL, FALSE);
1665         g_return_val_if_fail (GTK_IS_SCTREE (widget), FALSE);
1666         g_return_val_if_fail (event != NULL, FALSE);
1667
1668         sctree = GTK_SCTREE (widget);
1669         clist = GTK_CLIST (widget);
1670
1671         if (event->window != clist->clist_window)
1672                 return (* GTK_WIDGET_CLASS (parent_class)->motion_notify_event) (widget, event);
1673
1674         if (!((sctree->dnd_press_button == 1 && (event->state & GDK_BUTTON1_MASK))
1675               || (sctree->dnd_press_button == 2 && (event->state & GDK_BUTTON2_MASK))))
1676                 return FALSE;
1677
1678         /* This is the same threshold value that is used in gtkdnd.c */
1679
1680         if (MAX (ABS (sctree->dnd_press_x - event->x),
1681                  ABS (sctree->dnd_press_y - event->y)) <= 3)
1682                 return FALSE;
1683
1684         /* Handle any pending selections */
1685
1686         if (sctree->dnd_select_pending) {
1687                 if (!row_is_selected(sctree,sctree->dnd_select_pending_row))
1688                         select_row (sctree,
1689                                     sctree->dnd_select_pending_row,
1690                                     -1,
1691                                     sctree->dnd_select_pending_state,
1692                                     NULL);
1693
1694                 sctree->dnd_select_pending = FALSE;
1695                 sctree->dnd_select_pending_state = 0;
1696         }
1697
1698         g_signal_emit (G_OBJECT (sctree),
1699                        sctree_signals[START_DRAG],
1700                        0,
1701                        sctree->dnd_press_button,
1702                        event);
1703         return TRUE;
1704 }
1705
1706 /* We override the drag_begin signal to do nothing */
1707 static void
1708 gtk_sctree_drag_begin (GtkWidget *widget, GdkDragContext *context)
1709 {
1710         /* nothing */
1711 }
1712
1713 /* We override the drag_end signal to do nothing */
1714 static void
1715 gtk_sctree_drag_end (GtkWidget *widget, GdkDragContext *context)
1716 {
1717         /* nothing */
1718 }
1719
1720 /* We override the drag_data_get signal to do nothing */
1721 static void
1722 gtk_sctree_drag_data_get (GtkWidget *widget, GdkDragContext *context,
1723                                      GtkSelectionData *data, guint info, guint time)
1724 {
1725         /* nothing */
1726 }
1727
1728 /* We override the drag_leave signal to do nothing */
1729 static void
1730 gtk_sctree_drag_leave (GtkWidget *widget, GdkDragContext *context, guint time)
1731 {
1732         /* nothing */
1733 }
1734
1735 /* We override the drag_motion signal to do nothing */
1736 static gboolean
1737 gtk_sctree_drag_motion (GtkWidget *widget, GdkDragContext *context,
1738                                    gint x, gint y, guint time)
1739 {
1740         return FALSE;
1741 }
1742
1743 /* We override the drag_drop signal to do nothing */
1744 static gboolean
1745 gtk_sctree_drag_drop (GtkWidget *widget, GdkDragContext *context,
1746                                  gint x, gint y, guint time)
1747 {
1748         return FALSE;
1749 }
1750
1751 /* We override the drag_data_received signal to do nothing */
1752 static void
1753 gtk_sctree_drag_data_received (GtkWidget *widget, GdkDragContext *context,
1754                                           gint x, gint y, GtkSelectionData *data,
1755                                           guint info, guint time)
1756 {
1757         /* nothing */
1758 }
1759
1760 /* Our handler for the clear signal of the clist.  We have to reset the anchor
1761  * to null.
1762  */
1763 static void
1764 gtk_sctree_clear (GtkCList *clist)
1765 {
1766         GtkSCTree *sctree;
1767
1768         g_return_if_fail (clist != NULL);
1769         g_return_if_fail (GTK_IS_SCTREE (clist));
1770
1771         sctree = GTK_SCTREE (clist);
1772         sctree->anchor_row = NULL;
1773
1774         if (((GtkCListClass *)parent_class)->clear)
1775                 (* ((GtkCListClass *)parent_class)->clear) (clist);
1776 }
1777
1778 static void
1779 gtk_sctree_real_unselect_all (GtkCList *clist)
1780 {
1781         GtkSCTree *sctree;
1782         gboolean should_freeze = FALSE;
1783
1784         g_return_if_fail (clist != NULL);
1785         g_return_if_fail (GTK_IS_SCTREE (clist));
1786
1787         sctree = GTK_SCTREE (clist);
1788
1789         if (sc_g_list_bigger(GTK_CLIST(sctree)->selection, 10)) {
1790                 should_freeze = TRUE;
1791                 sctree->selecting_range++;
1792                 gtk_clist_freeze (GTK_CLIST (sctree));
1793         }
1794
1795         if (((GtkCListClass *)parent_class)->unselect_all)
1796                 (* ((GtkCListClass *)parent_class)->unselect_all) (clist);
1797
1798         if (should_freeze) {
1799                 gtk_clist_thaw (GTK_CLIST (sctree));
1800                 sctree->selecting_range--;
1801         }
1802 }
1803
1804 /* Our handler for the change_focus_row_expansion signal of the ctree.  
1805  We have to set the anchor to parent visible node.
1806  */
1807 static void 
1808 gtk_sctree_collapse (GtkCTree *ctree, GtkCTreeNode *node)
1809 {
1810         g_return_if_fail (ctree != NULL);
1811         g_return_if_fail (GTK_IS_SCTREE (ctree));
1812
1813         (* parent_class->tree_collapse) (ctree, node);
1814         GTK_SCTREE(ctree)->anchor_row =
1815                 gtk_ctree_node_nth(ctree, GTK_CLIST(ctree)->focus_row);
1816 }
1817
1818 GtkWidget *gtk_sctree_new_with_titles (gint columns, gint tree_column, 
1819                                        gchar *titles[])
1820 {
1821         GtkWidget *widget;
1822                                                                                                             
1823         g_return_val_if_fail (columns > 0, NULL);
1824         g_return_val_if_fail (tree_column >= 0, NULL);
1825                                                                                                             
1826         widget = gtk_widget_new (TYPE_GTK_SCTREE,
1827                                  "n_columns", columns,
1828                                  "tree_column", tree_column,
1829                                  NULL);
1830         if (titles) {
1831                 GtkCList *clist = GTK_CLIST (widget);
1832                 guint i;
1833
1834                 for (i = 0; i < columns; i++)
1835                         gtk_clist_set_column_title (clist, i, titles[i]);
1836                 gtk_clist_column_titles_show (clist);
1837         }
1838
1839         GTK_SCTREE(widget)->show_stripes = TRUE;
1840         GTK_SCTREE(widget)->always_expand_recursively = TRUE;
1841
1842         return widget;
1843 }
1844
1845 void gtk_sctree_select (GtkSCTree *sctree, GtkCTreeNode *node)
1846 {
1847         select_row(sctree, 
1848                    g_list_position(GTK_CLIST(sctree)->row_list, (GList *)node),
1849                    -1, 0, node);
1850 }
1851
1852 void gtk_sctree_select_with_state (GtkSCTree *sctree, GtkCTreeNode *node, int state)
1853 {
1854         select_row(sctree, 
1855                    g_list_position(GTK_CLIST(sctree)->row_list, (GList *)node),
1856                    -1, state, node);
1857 }
1858
1859 void gtk_sctree_unselect_all (GtkSCTree *sctree)
1860 {
1861         gtk_clist_unselect_all(GTK_CLIST(sctree));
1862         sctree->anchor_row = NULL;
1863 }
1864
1865 void gtk_sctree_set_anchor_row (GtkSCTree *sctree, GtkCTreeNode *node)
1866 {
1867         sctree->anchor_row = node;
1868 }
1869
1870 void gtk_sctree_remove_node (GtkSCTree *sctree, GtkCTreeNode *node)
1871 {
1872         if (sctree->anchor_row == node)
1873                 sctree->anchor_row = NULL;
1874         gtk_ctree_remove_node(GTK_CTREE(sctree), node);
1875 }
1876
1877 void gtk_sctree_set_stripes(GtkSCTree  *sctree, gboolean show_stripes)
1878 {
1879         sctree->show_stripes = show_stripes;
1880 }
1881
1882 void gtk_sctree_set_recursive_expand(GtkSCTree  *sctree, gboolean rec_exp)
1883 {
1884         sctree->always_expand_recursively = rec_exp;
1885 }
1886
1887 /***********************************************************
1888  *             Tree sorting functions                      *
1889  ***********************************************************/
1890
1891 static void sink(GtkCList *clist, GPtrArray *numbers, gint root, gint bottom)
1892 {
1893         gint j, k ;
1894         GtkCTreeNode *temp;
1895
1896         j = 2 * root;
1897         k = j + 1;
1898
1899         /* find the maximum element of numbers[root],
1900            numbers[2*root] and numbers[2*root+1] */
1901         if (j <= bottom) {
1902                 if (clist->compare( clist, GTK_CTREE_ROW (g_ptr_array_index(numbers, root)),
1903                                     GTK_CTREE_ROW(g_ptr_array_index( numbers, j))) >= 0)
1904                         j = root;
1905                 if (k <= bottom)
1906                         if (clist->compare( clist, GTK_CTREE_ROW (g_ptr_array_index(numbers, k)),
1907                                             GTK_CTREE_ROW (g_ptr_array_index( numbers, j))) > 0)
1908                                 j = k;
1909                 /* if numbers[root] wasn't the maximum element then
1910                    sink again */
1911                 if (root != j) {
1912                         temp = g_ptr_array_index( numbers,root);
1913                         g_ptr_array_index( numbers, root) = g_ptr_array_index( numbers, j);
1914                         g_ptr_array_index( numbers, j) = temp;
1915                         sink( clist, numbers, j, bottom);
1916                 }
1917         }
1918 }
1919
1920 static void heap_sort(GtkCList *clist, GPtrArray *numbers, gint array_size)
1921 {
1922         gint i;
1923         GtkCTreeNode *temp;
1924         
1925         /* build the Heap */
1926         for (i = (array_size / 2); i >= 1; i--)
1927                 sink( clist, numbers, i, array_size);
1928         /* output the Heap */
1929         for (i = array_size; i >= 2; i--) {
1930                 temp = g_ptr_array_index( numbers, 1);
1931                 g_ptr_array_index( numbers, 1) = g_ptr_array_index( numbers, i);
1932                 g_ptr_array_index( numbers, i) = temp;
1933                 sink( clist, numbers, 1, i-1);
1934         }
1935 }
1936
1937 static void
1938 stree_sort (GtkCTree    *ctree,
1939            GtkCTreeNode *node,
1940            gpointer      data)
1941 {
1942         GtkCTreeNode *list_start, *work, *next;
1943         GPtrArray *row_array, *viewable_array;
1944         GtkCList *clist;
1945         gint i;
1946
1947         clist = GTK_CLIST (ctree);
1948
1949         if (node)
1950                 work = GTK_CTREE_ROW (node)->children;
1951         else
1952                 work = GTK_CTREE_NODE (clist->row_list);
1953
1954         row_array = g_ptr_array_new();
1955         viewable_array = g_ptr_array_new();
1956
1957         if (work) {
1958                 g_ptr_array_add( row_array, NULL);
1959                 while (work) {
1960                         /* add all rows to row_array */
1961                         g_ptr_array_add( row_array, work);
1962                         if (GTK_CTREE_ROW (work)->parent && gtk_ctree_is_viewable( ctree, work))
1963                                 g_ptr_array_add( viewable_array, GTK_CTREE_ROW (work)->parent);
1964                         next = GTK_CTREE_ROW (work)->sibling;
1965                         gtk_sctree_unlink( ctree, work, FALSE);
1966                         work = next;
1967                 }
1968
1969                 heap_sort( clist, row_array, (row_array->len)-1);
1970
1971                 if (node)
1972                         list_start = GTK_CTREE_ROW (node)->children;
1973                 else
1974                         list_start = GTK_CTREE_NODE (clist->row_list);
1975
1976                 if (clist->sort_type == GTK_SORT_ASCENDING) {
1977                         for (i=(row_array->len)-1; i>=1; i--) {
1978                                 work = g_ptr_array_index( row_array, i);
1979                                 gtk_sctree_link( ctree, work, node, list_start, FALSE);
1980                                 list_start = work;
1981                                 /* insert work at the beginning of the list */
1982                         }
1983                 } else {
1984                         for (i=1; i<row_array->len; i++) {
1985                                 work = g_ptr_array_index( row_array, i);
1986                                 gtk_sctree_link( ctree, work, node, list_start, FALSE);
1987                                 list_start = work;
1988                                 /* insert work at the beginning of the list */
1989                         }
1990                 }
1991
1992                 for (i=0; i<viewable_array->len; i++) {
1993                         gtk_ctree_expand( ctree, g_ptr_array_index( viewable_array, i));
1994                 }
1995                 
1996         }
1997         g_ptr_array_free( row_array, TRUE);
1998         g_ptr_array_free( viewable_array, TRUE);
1999 }
2000
2001 void
2002 gtk_sctree_sort_recursive (GtkCTree     *ctree, 
2003                           GtkCTreeNode *node)
2004 {
2005         GtkCList *clist;
2006         GtkCTreeNode *focus_node = NULL;
2007
2008         g_return_if_fail (ctree != NULL);
2009         g_return_if_fail (GTK_IS_CTREE (ctree));
2010
2011         clist = GTK_CLIST (ctree);
2012
2013         gtk_clist_freeze (clist);
2014
2015         if (clist->selection_mode == GTK_SELECTION_EXTENDED) {
2016                 GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
2017       
2018                 g_list_free (clist->undo_selection);
2019                 g_list_free (clist->undo_unselection);
2020                 clist->undo_selection = NULL;
2021                 clist->undo_unselection = NULL;
2022         }
2023
2024         if (!node || (node && gtk_ctree_is_viewable (ctree, node)))
2025                 focus_node = GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
2026       
2027         GTK_SCTREE(ctree)->sorting = TRUE;
2028
2029         gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (stree_sort), NULL);
2030
2031         if (!node)
2032                 stree_sort (ctree, NULL, NULL);
2033
2034         GTK_SCTREE(ctree)->sorting = FALSE;
2035
2036         if (focus_node) {
2037                 clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
2038                 clist->undo_anchor = clist->focus_row;
2039         }
2040
2041         gtk_clist_thaw (clist);
2042 }
2043
2044 void
2045 gtk_sctree_sort_node (GtkCTree     *ctree, 
2046                      GtkCTreeNode *node)
2047 {
2048         GtkCList *clist;
2049         GtkCTreeNode *focus_node = NULL;
2050
2051         g_return_if_fail (ctree != NULL);
2052         g_return_if_fail (GTK_IS_CTREE (ctree));
2053
2054         clist = GTK_CLIST (ctree);
2055
2056         gtk_clist_freeze (clist);
2057
2058         if (clist->selection_mode == GTK_SELECTION_EXTENDED) {
2059                 GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
2060
2061                 g_list_free (clist->undo_selection);
2062                 g_list_free (clist->undo_unselection);
2063                 clist->undo_selection = NULL;
2064                 clist->undo_unselection = NULL;
2065         }
2066
2067         if (!node || (node && gtk_ctree_is_viewable (ctree, node)))
2068                 focus_node = GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
2069
2070         GTK_SCTREE(ctree)->sorting = TRUE;
2071
2072         stree_sort (ctree, node, NULL);
2073
2074         GTK_SCTREE(ctree)->sorting = FALSE;
2075
2076         if (focus_node) {
2077                 clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
2078                 clist->undo_anchor = clist->focus_row;
2079         }
2080
2081         gtk_clist_thaw (clist);
2082 }
2083
2084 /************************************************************************/
2085
2086 static void
2087 gtk_sctree_unlink (GtkCTree     *ctree, 
2088                   GtkCTreeNode *node,
2089                   gboolean      update_focus_row)
2090 {
2091         GtkCList *clist;
2092         gint rows;
2093         gint level;
2094         gint visible;
2095         GtkCTreeNode *work;
2096         GtkCTreeNode *parent;
2097         GList *list;
2098
2099         g_return_if_fail (ctree != NULL);
2100         g_return_if_fail (GTK_IS_CTREE (ctree));
2101         g_return_if_fail (node != NULL);
2102
2103         clist = GTK_CLIST (ctree);
2104   
2105         if (update_focus_row && clist->selection_mode == GTK_SELECTION_EXTENDED) {
2106                 GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
2107
2108                 g_list_free (clist->undo_selection);
2109                 g_list_free (clist->undo_unselection);
2110                 clist->undo_selection = NULL;
2111                 clist->undo_unselection = NULL;
2112         }
2113
2114         visible = gtk_ctree_is_viewable (ctree, node);
2115
2116         /* clist->row_list_end unlinked ? */
2117         if (visible && (GTK_CTREE_NODE_NEXT (node) == NULL ||
2118            (GTK_CTREE_ROW (node)->children && gtk_ctree_is_ancestor (ctree, node,
2119             GTK_CTREE_NODE (clist->row_list_end)))))
2120                 clist->row_list_end = (GList *) (GTK_CTREE_NODE_PREV (node));
2121
2122         /* update list */
2123         rows = 0;
2124         level = GTK_CTREE_ROW (node)->level;
2125         work = GTK_CTREE_NODE_NEXT (node);
2126         while (work && GTK_CTREE_ROW (work)->level > level) {
2127                 work = GTK_CTREE_NODE_NEXT (work);
2128                 rows++;
2129         }
2130
2131         if (visible) {
2132                 clist->rows -= (rows + 1);
2133
2134                 if (update_focus_row) {
2135                         gint pos;
2136                         pos = g_list_position (clist->row_list, (GList *)node);
2137                         if (pos + rows < clist->focus_row)
2138                                 clist->focus_row -= (rows + 1);
2139                         else if (pos <= clist->focus_row) {
2140                                 if (!GTK_CTREE_ROW (node)->sibling)
2141                                         clist->focus_row = MAX (pos - 1, 0);
2142                                 else
2143                                         clist->focus_row = pos;
2144               
2145                                 clist->focus_row = MIN (clist->focus_row, clist->rows - 1);
2146                         }
2147                         clist->undo_anchor = clist->focus_row;
2148                 }
2149         }
2150
2151         if (work) {
2152                 list = (GList *)GTK_CTREE_NODE_PREV (work);
2153                 list->next = NULL;
2154                 list = (GList *)work;
2155                 list->prev = (GList *)GTK_CTREE_NODE_PREV (node);
2156         }
2157
2158         if (GTK_CTREE_NODE_PREV (node) &&
2159             GTK_CTREE_NODE_NEXT (GTK_CTREE_NODE_PREV (node)) == node) {
2160                 list = (GList *)GTK_CTREE_NODE_PREV (node);
2161                 list->next = (GList *)work;
2162         }
2163
2164         /* update tree */
2165         parent = GTK_CTREE_ROW (node)->parent;
2166         if (parent) {
2167                 if (GTK_CTREE_ROW (parent)->children == node) {
2168                         GTK_CTREE_ROW (parent)->children = GTK_CTREE_ROW (node)->sibling;
2169                 }
2170                 else {
2171                         GtkCTreeNode *sibling;
2172
2173                         sibling = GTK_CTREE_ROW (parent)->children;
2174                         while (GTK_CTREE_ROW (sibling)->sibling != node)
2175                                 sibling = GTK_CTREE_ROW (sibling)->sibling;
2176                         GTK_CTREE_ROW (sibling)->sibling = GTK_CTREE_ROW (node)->sibling;
2177                 }
2178         }
2179         else {
2180                 if (clist->row_list == (GList *)node)
2181                         clist->row_list = (GList *) (GTK_CTREE_ROW (node)->sibling);
2182                 else {
2183                         GtkCTreeNode *sibling;
2184
2185                         sibling = GTK_CTREE_NODE (clist->row_list);
2186                         while (GTK_CTREE_ROW (sibling)->sibling != node)
2187                                 sibling = GTK_CTREE_ROW (sibling)->sibling;
2188                         GTK_CTREE_ROW (sibling)->sibling = GTK_CTREE_ROW (node)->sibling;
2189                 }
2190         }
2191 }
2192
2193 static void
2194 gtk_sctree_link (GtkCTree     *ctree,
2195                 GtkCTreeNode *node,
2196                 GtkCTreeNode *parent,
2197                 GtkCTreeNode *sibling,
2198                 gboolean      update_focus_row)
2199 {
2200         GtkCList *clist;
2201         GList *list_end;
2202         GList *list;
2203         GList *work;
2204         gboolean visible = FALSE;
2205         gint rows = 0;
2206   
2207         if (sibling)
2208                 g_return_if_fail (GTK_CTREE_ROW (sibling)->parent == parent);
2209         g_return_if_fail (node != NULL);
2210         g_return_if_fail (node != sibling);
2211         g_return_if_fail (node != parent);
2212
2213         clist = GTK_CLIST (ctree);
2214
2215         if (update_focus_row && clist->selection_mode == GTK_SELECTION_EXTENDED) {
2216                 GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
2217
2218                 g_list_free (clist->undo_selection);
2219                 g_list_free (clist->undo_unselection);
2220                 clist->undo_selection = NULL;
2221                 clist->undo_unselection = NULL;
2222         }
2223
2224         for (rows = 1, list_end = (GList *)node; list_end->next;
2225              list_end = list_end->next)
2226                 rows++;
2227
2228         GTK_CTREE_ROW (node)->parent = parent;
2229         GTK_CTREE_ROW (node)->sibling = sibling;
2230
2231         if (!parent || (parent && (gtk_ctree_is_viewable (ctree, parent) &&
2232             GTK_CTREE_ROW (parent)->expanded))) {
2233                 visible = TRUE;
2234                 clist->rows += rows;
2235         }
2236
2237         if (parent)
2238                 work = (GList *)(GTK_CTREE_ROW (parent)->children);
2239         else
2240                 work = clist->row_list;
2241
2242         if (sibling) {
2243                 if (work != (GList *)sibling) {
2244                         while (GTK_CTREE_ROW (work)->sibling != sibling)
2245                                 work = (GList *)(GTK_CTREE_ROW (work)->sibling);
2246                         GTK_CTREE_ROW (work)->sibling = node;
2247                 }
2248
2249                 if (sibling == GTK_CTREE_NODE (clist->row_list))
2250                 clist->row_list = (GList *) node;
2251                 if (GTK_CTREE_NODE_PREV (sibling) &&
2252                     GTK_CTREE_NODE_NEXT (GTK_CTREE_NODE_PREV (sibling)) == sibling) {
2253                         list = (GList *)GTK_CTREE_NODE_PREV (sibling);
2254                         list->next = (GList *)node;
2255                 }
2256
2257                 list = (GList *)node;
2258                 list->prev = (GList *)GTK_CTREE_NODE_PREV (sibling);
2259                 list_end->next = (GList *)sibling;
2260                 list = (GList *)sibling;
2261                 list->prev = list_end;
2262                 if (parent && GTK_CTREE_ROW (parent)->children == sibling)
2263                         GTK_CTREE_ROW (parent)->children = node;
2264         }
2265         else {
2266                 if (work) {
2267                         /* find sibling */
2268                         while (GTK_CTREE_ROW (work)->sibling)
2269                         work = (GList *)(GTK_CTREE_ROW (work)->sibling);
2270                         GTK_CTREE_ROW (work)->sibling = node;
2271
2272                         /* find last visible child of sibling */
2273                         work = (GList *) gtk_sctree_last_visible (ctree,
2274                                GTK_CTREE_NODE (work));
2275
2276                         list_end->next = work->next;
2277                         if (work->next)
2278                                 list = work->next->prev = list_end;
2279                         work->next = (GList *)node;
2280                         list = (GList *)node;
2281                         list->prev = work;
2282                 }
2283                 else {
2284                         if (parent) {
2285                                 GTK_CTREE_ROW (parent)->children = node;
2286                                 list = (GList *)node;
2287                                 list->prev = (GList *)parent;
2288                                 if (GTK_CTREE_ROW (parent)->expanded) {
2289                                         list_end->next = (GList *)GTK_CTREE_NODE_NEXT (parent);
2290                                         if (GTK_CTREE_NODE_NEXT(parent)) {
2291                                                 list = (GList *)GTK_CTREE_NODE_NEXT (parent);
2292                                                 list->prev = list_end;
2293                                         }
2294                                         list = (GList *)parent;
2295                                         list->next = (GList *)node;
2296                                 }
2297                                 else
2298                                         list_end->next = NULL;
2299                         }
2300                         else {
2301                                 clist->row_list = (GList *)node;
2302                                 list = (GList *)node;
2303                                 list->prev = NULL;
2304                                 list_end->next = NULL;
2305                         }
2306                 }
2307         }
2308
2309         gtk_ctree_pre_recursive (ctree, node, stree_update_level, NULL); 
2310
2311         if (clist->row_list_end == NULL ||
2312             clist->row_list_end->next == (GList *)node)
2313                 clist->row_list_end = list_end;
2314
2315         if (visible && update_focus_row) {
2316                 gint pos;
2317                 pos = g_list_position (clist->row_list, (GList *)node);
2318   
2319                 if (pos <= clist->focus_row) {
2320                         clist->focus_row += rows;
2321                         clist->undo_anchor = clist->focus_row;
2322                 }
2323         }
2324 }
2325
2326 static void
2327 stree_update_level (GtkCTree     *ctree, 
2328                    GtkCTreeNode *node, 
2329                    gpointer      data)
2330 {
2331         if (!node)
2332                 return;
2333
2334         if (GTK_CTREE_ROW (node)->parent)
2335                 GTK_CTREE_ROW (node)->level = 
2336                 GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->level + 1;
2337         else
2338                 GTK_CTREE_ROW (node)->level = 1;
2339 }
2340
2341 static GtkCTreeNode *
2342 gtk_sctree_last_visible (GtkCTree     *ctree,
2343                         GtkCTreeNode *node)
2344 {
2345         GtkCTreeNode *work;
2346   
2347         if (!node)
2348                 return NULL;
2349
2350         work = GTK_CTREE_ROW (node)->children;
2351
2352         if (!work || !GTK_CTREE_ROW (node)->expanded)
2353                 return node;
2354
2355         while (GTK_CTREE_ROW (work)->sibling)
2356                 work = GTK_CTREE_ROW (work)->sibling;
2357
2358         return gtk_sctree_last_visible (ctree, work);
2359 }
2360
2361 /* this wrapper simply replaces NULL pixmaps 
2362  * with a transparent, 1x1 pixmap. This works
2363  * around a memory problem deep inside gtk, 
2364  * revealed by valgrind. 
2365  */
2366 /*GtkCTreeNode* gtk_sctree_insert_node        (GtkCTree *ctree,
2367                                              GtkCTreeNode *parent,
2368                                              GtkCTreeNode *sibling,
2369                                              gchar *text[],
2370                                              guint8 spacing,
2371                                              GdkPixmap *pixmap_closed,
2372                                              GdkBitmap *mask_closed,
2373                                              GdkPixmap *pixmap_opened,
2374                                              GdkBitmap *mask_opened,
2375                                              gboolean is_leaf,
2376                                              gboolean expanded)
2377 {
2378         if (!emptyxpm) {
2379                 stock_pixmap_gdk(GTK_WIDGET(ctree), STOCK_PIXMAP_EMPTY,
2380                          &emptyxpm, &emptyxpmmask);
2381         }
2382         if (!pixmap_closed) {
2383                 pixmap_closed = emptyxpm;
2384                 mask_closed = emptyxpmmask;
2385         }
2386         if (!pixmap_opened) {
2387                 pixmap_opened = emptyxpm;
2388                 mask_opened = emptyxpmmask;
2389         }
2390         return gtk_ctree_insert_node(ctree, parent, sibling, text,spacing,
2391                 pixmap_closed, mask_closed, pixmap_opened, mask_opened,
2392                 is_leaf, expanded);
2393 }*/
2394
2395 static void 
2396 sset_node_info (GtkCTree     *ctree,
2397                GtkCTreeNode *node,
2398                const gchar  *text,
2399                guint8        spacing,
2400                GdkPixmap    *pixmap_closed,
2401                GdkBitmap    *mask_closed,
2402                GdkPixmap    *pixmap_opened,
2403                GdkBitmap    *mask_opened,
2404                gboolean      is_leaf,
2405                gboolean      expanded)
2406 {
2407   if (GTK_CTREE_ROW (node)->pixmap_opened)
2408     {
2409       gdk_pixmap_unref (GTK_CTREE_ROW (node)->pixmap_opened);
2410       if (GTK_CTREE_ROW (node)->mask_opened) 
2411         gdk_bitmap_unref (GTK_CTREE_ROW (node)->mask_opened);
2412     }
2413   if (GTK_CTREE_ROW (node)->pixmap_closed)
2414     {
2415       gdk_pixmap_unref (GTK_CTREE_ROW (node)->pixmap_closed);
2416       if (GTK_CTREE_ROW (node)->mask_closed) 
2417         gdk_bitmap_unref (GTK_CTREE_ROW (node)->mask_closed);
2418     }
2419
2420   GTK_CTREE_ROW (node)->pixmap_opened = NULL;
2421   GTK_CTREE_ROW (node)->mask_opened   = NULL;
2422   GTK_CTREE_ROW (node)->pixmap_closed = NULL;
2423   GTK_CTREE_ROW (node)->mask_closed   = NULL;
2424
2425   if (pixmap_closed)
2426     {
2427       GTK_CTREE_ROW (node)->pixmap_closed = gdk_pixmap_ref (pixmap_closed);
2428       if (mask_closed) 
2429         GTK_CTREE_ROW (node)->mask_closed = gdk_bitmap_ref (mask_closed);
2430     }
2431   if (pixmap_opened)
2432     {
2433       GTK_CTREE_ROW (node)->pixmap_opened = gdk_pixmap_ref (pixmap_opened);
2434       if (mask_opened) 
2435         GTK_CTREE_ROW (node)->mask_opened = gdk_bitmap_ref (mask_opened);
2436     }
2437
2438   GTK_CTREE_ROW (node)->is_leaf  = is_leaf;
2439   GTK_CTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
2440
2441   if (GTK_CTREE_ROW (node)->expanded)
2442     gtk_ctree_node_set_pixtext (ctree, node, ctree->tree_column,
2443                                 text, spacing, pixmap_opened, mask_opened);
2444   else 
2445     gtk_ctree_node_set_pixtext (ctree, node, ctree->tree_column,
2446                                 text, spacing, pixmap_closed, mask_closed);
2447 }
2448
2449 static void
2450 stree_draw_node (GtkCTree     *ctree, 
2451                 GtkCTreeNode *node)
2452 {
2453   GtkCList *clist;
2454   
2455   clist = GTK_CLIST (ctree);
2456
2457   if (CLIST_UNFROZEN (clist) && gtk_ctree_is_viewable (ctree, node))
2458     {
2459       GtkCTreeNode *work;
2460       gint num = 0;
2461       
2462       work = GTK_CTREE_NODE (clist->row_list);
2463       while (work && work != node)
2464         {
2465           work = GTK_CTREE_NODE_NEXT (work);
2466           num++;
2467         }
2468       if (work && gtk_clist_row_is_visible (clist, num) != GTK_VISIBILITY_NONE)
2469         GTK_CLIST_GET_CLASS (clist)->draw_row
2470           (clist, NULL, num, GTK_CLIST_ROW ((GList *) node));
2471     }
2472 }
2473
2474 /* this wrapper simply replaces NULL pixmaps 
2475  * with a transparent, 1x1 pixmap. This works
2476  * around a memory problem deep inside gtk, 
2477  * revealed by valgrind. 
2478  */
2479 void        gtk_sctree_set_node_info        (GtkCTree *ctree,
2480                                              GtkCTreeNode *node,
2481                                              const gchar *text,
2482                                              guint8 spacing,
2483                                              GdkPixmap *pixmap_closed,
2484                                              GdkBitmap *mask_closed,
2485                                              GdkPixmap *pixmap_opened,
2486                                              GdkBitmap *mask_opened,
2487                                              gboolean is_leaf,
2488                                              gboolean expanded)
2489 {
2490   gboolean old_leaf;
2491   gboolean old_expanded;
2492   GtkCTreeNode *work;
2493  
2494   if (!emptyxpm) {
2495           stock_pixmap_gdk(GTK_WIDGET(ctree), STOCK_PIXMAP_EMPTY,
2496                    &emptyxpm, &emptyxpmmask);
2497   }
2498   if (!pixmap_closed) {
2499           pixmap_closed = emptyxpm;
2500           mask_closed = emptyxpmmask;
2501   }
2502   if (!pixmap_opened) {
2503           pixmap_opened = emptyxpm;
2504           mask_opened = emptyxpmmask;
2505   }
2506
2507   if (!GTK_IS_CTREE (ctree) || !node) return;
2508
2509   old_leaf = GTK_CTREE_ROW (node)->is_leaf;
2510   old_expanded = GTK_CTREE_ROW (node)->expanded;
2511
2512   if (is_leaf && (work = GTK_CTREE_ROW (node)->children) != NULL)
2513     {
2514       GtkCTreeNode *ptr;
2515       
2516       while (work)
2517         {
2518           ptr = work;
2519           work = GTK_CTREE_ROW (work)->sibling;
2520           gtk_ctree_remove_node (ctree, ptr);
2521         }
2522     }
2523
2524   sset_node_info (ctree, node, text, spacing, pixmap_closed, mask_closed,
2525                  pixmap_opened, mask_opened, is_leaf, expanded);
2526
2527   if (!is_leaf && !old_leaf)
2528     {
2529       GTK_CTREE_ROW (node)->expanded = old_expanded;
2530       if (expanded && !old_expanded)
2531         gtk_ctree_expand (ctree, node);
2532       else if (!expanded && old_expanded)
2533         gtk_ctree_collapse (ctree, node);
2534     }
2535
2536   GTK_CTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
2537   
2538   stree_draw_node (ctree, node);
2539 }
2540
2541 static GtkCTreeRow *
2542 srow_new (GtkCTree *ctree)
2543 {
2544   GtkCList *clist;
2545   GtkCTreeRow *ctree_row;
2546   int i;
2547
2548   clist = GTK_CLIST (ctree);
2549 #if GTK_CHECK_VERSION(2,9,0)
2550   ctree_row = g_slice_new (GtkCTreeRow);
2551   ctree_row->row.cell = g_slice_alloc (sizeof (GtkCell) * clist->columns);
2552 #else
2553   ctree_row = g_chunk_new (GtkCTreeRow, (GMemChunk *)clist->row_mem_chunk);
2554   ctree_row->row.cell = g_chunk_new (GtkCell, (GMemChunk *)clist->cell_mem_chunk);
2555 #endif
2556   for (i = 0; i < clist->columns; i++)
2557     {
2558       ctree_row->row.cell[i].type = GTK_CELL_EMPTY;
2559       ctree_row->row.cell[i].vertical = 0;
2560       ctree_row->row.cell[i].horizontal = 0;
2561       ctree_row->row.cell[i].style = NULL;
2562     }
2563
2564   GTK_CELL_PIXTEXT (ctree_row->row.cell[ctree->tree_column])->text = NULL;
2565
2566   ctree_row->row.fg_set     = FALSE;
2567   ctree_row->row.bg_set     = FALSE;
2568   ctree_row->row.style      = NULL;
2569   ctree_row->row.selectable = TRUE;
2570   ctree_row->row.state      = GTK_STATE_NORMAL;
2571   ctree_row->row.data       = NULL;
2572   ctree_row->row.destroy    = NULL;
2573
2574   ctree_row->level         = 0;
2575   ctree_row->expanded      = FALSE;
2576   ctree_row->parent        = NULL;
2577   ctree_row->sibling       = NULL;
2578   ctree_row->children      = NULL;
2579   ctree_row->pixmap_closed = NULL;
2580   ctree_row->mask_closed   = NULL;
2581   ctree_row->pixmap_opened = NULL;
2582   ctree_row->mask_opened   = NULL;
2583   
2584   return ctree_row;
2585 }
2586
2587 static void
2588 srow_delete (GtkCTree    *ctree,
2589             GtkCTreeRow *ctree_row)
2590 {
2591   GtkCList *clist;
2592   gint i;
2593
2594   clist = GTK_CLIST (ctree);
2595
2596   for (i = 0; i < clist->columns; i++)
2597     {
2598       GTK_CLIST_GET_CLASS (clist)->set_cell_contents
2599         (clist, &(ctree_row->row), i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
2600       if (ctree_row->row.cell[i].style)
2601         {
2602           if (GTK_WIDGET_REALIZED (ctree))
2603             gtk_style_detach (ctree_row->row.cell[i].style);
2604           g_object_unref (ctree_row->row.cell[i].style);
2605         }
2606     }
2607
2608   if (ctree_row->row.style)
2609     {
2610       if (GTK_WIDGET_REALIZED (ctree))
2611         gtk_style_detach (ctree_row->row.style);
2612       g_object_unref (ctree_row->row.style);
2613     }
2614
2615   if (ctree_row->pixmap_closed)
2616     {
2617       gdk_pixmap_unref (ctree_row->pixmap_closed);
2618       if (ctree_row->mask_closed)
2619         gdk_bitmap_unref (ctree_row->mask_closed);
2620     }
2621
2622   if (ctree_row->pixmap_opened)
2623     {
2624       gdk_pixmap_unref (ctree_row->pixmap_opened);
2625       if (ctree_row->mask_opened)
2626         gdk_bitmap_unref (ctree_row->mask_opened);
2627     }
2628
2629   if (ctree_row->row.destroy)
2630     {
2631       GtkDestroyNotify dnotify = ctree_row->row.destroy;
2632       gpointer ddata = ctree_row->row.data;
2633
2634       ctree_row->row.destroy = NULL;
2635       ctree_row->row.data = NULL;
2636
2637       dnotify (ddata);
2638     }
2639
2640 #if GTK_CHECK_VERSION(2,9,0)  
2641   g_slice_free1 (sizeof (GtkCell) * clist->columns, ctree_row->row.cell);
2642   g_slice_free (GtkCTreeRow, ctree_row);
2643 #else
2644   g_mem_chunk_free ((GMemChunk *)clist->cell_mem_chunk, ctree_row->row.cell);
2645   g_mem_chunk_free ((GMemChunk *)clist->row_mem_chunk, ctree_row);
2646 #endif
2647 }
2648
2649 static void
2650 stree_delete_row (GtkCTree     *ctree, 
2651                  GtkCTreeNode *node, 
2652                  gpointer      data)
2653 {
2654   srow_delete (ctree, GTK_CTREE_ROW (node));
2655   g_list_free_1 ((GList *)node);
2656 }
2657
2658 static void
2659 gtk_sctree_column_auto_resize (GtkCList    *clist,
2660                     GtkCListRow *clist_row,
2661                     gint         column,
2662                     gint         old_width)
2663 {
2664   /* resize column if needed for auto_resize */
2665   GtkRequisition requisition;
2666
2667   if (!clist->column[column].auto_resize ||
2668       GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
2669     return;
2670
2671   if (clist_row)
2672     GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
2673                                                    column, &requisition);
2674   else
2675     requisition.width = 0;
2676
2677   if (requisition.width > clist->column[column].width)
2678     gtk_clist_set_column_width (clist, column, requisition.width);
2679   else if (requisition.width < old_width &&
2680            old_width == clist->column[column].width)
2681     {
2682       GList *list;
2683       gint new_width;
2684
2685       /* run a "gtk_clist_optimal_column_width" but break, if
2686        * the column doesn't shrink */
2687       if (GTK_CLIST_SHOW_TITLES (clist) && clist->column[column].button)
2688         new_width = (clist->column[column].button->requisition.width -
2689                      (CELL_SPACING + (2 * COLUMN_INSET)));
2690       else
2691         new_width = 0;
2692
2693       for (list = clist->row_list; list; list = list->next)
2694         {
2695           GTK_CLIST_GET_CLASS (clist)->cell_size_request
2696             (clist, GTK_CLIST_ROW (list), column, &requisition);
2697           new_width = MAX (new_width, requisition.width);
2698           if (new_width == clist->column[column].width)
2699             break;
2700         }
2701       if (new_width < clist->column[column].width)
2702         gtk_clist_set_column_width (clist, column, new_width);
2703     }
2704 }
2705
2706
2707 static void 
2708 gtk_sctree_real_tree_expand (GtkCTree     *ctree,
2709                   GtkCTreeNode *node)
2710 {
2711   GtkCList *clist;
2712   GtkCTreeNode *work;
2713   GtkRequisition requisition;
2714   gboolean visible;
2715   gint level;
2716
2717   g_return_if_fail (GTK_IS_CTREE (ctree));
2718
2719   if (!node || GTK_CTREE_ROW (node)->expanded || GTK_CTREE_ROW (node)->is_leaf)
2720     return;
2721
2722   clist = GTK_CLIST (ctree);
2723   
2724   GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
2725
2726   GTK_CTREE_ROW (node)->expanded = TRUE;
2727   level = GTK_CTREE_ROW (node)->level;
2728
2729   visible = gtk_ctree_is_viewable (ctree, node);
2730   /* get cell width if tree_column is auto resized */
2731   if (visible && clist->column[ctree->tree_column].auto_resize &&
2732       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
2733     GTK_CLIST_GET_CLASS (clist)->cell_size_request
2734       (clist, &GTK_CTREE_ROW (node)->row, ctree->tree_column, &requisition);
2735
2736   /* unref/unset closed pixmap */
2737   if (GTK_CELL_PIXTEXT 
2738       (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap)
2739     {
2740       gdk_pixmap_unref
2741         (GTK_CELL_PIXTEXT
2742          (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap);
2743       
2744       GTK_CELL_PIXTEXT
2745         (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap = NULL;
2746       
2747       if (GTK_CELL_PIXTEXT 
2748           (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask)
2749         {
2750           gdk_pixmap_unref
2751             (GTK_CELL_PIXTEXT 
2752              (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask);
2753           GTK_CELL_PIXTEXT 
2754             (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = NULL;
2755         }
2756     }
2757
2758   /* set/ref opened pixmap */
2759   if (GTK_CTREE_ROW (node)->pixmap_opened)
2760     {
2761       GTK_CELL_PIXTEXT 
2762         (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap = 
2763         gdk_pixmap_ref (GTK_CTREE_ROW (node)->pixmap_opened);
2764
2765       if (GTK_CTREE_ROW (node)->mask_opened) 
2766         GTK_CELL_PIXTEXT 
2767           (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = 
2768           gdk_pixmap_ref (GTK_CTREE_ROW (node)->mask_opened);
2769     }
2770
2771
2772   work = GTK_CTREE_ROW (node)->children;
2773   if (work)
2774     {
2775       GList *list = (GList *)work;
2776       gint *cell_width = NULL;
2777       gint tmp = 0;
2778       gint row;
2779       gint i;
2780       
2781       if (visible && !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
2782         {
2783           cell_width = g_new0 (gint, clist->columns);
2784           if (clist->column[ctree->tree_column].auto_resize)
2785               cell_width[ctree->tree_column] = requisition.width;
2786
2787           while (work)
2788             {
2789               /* search maximum cell widths of auto_resize columns */
2790               for (i = 0; i < clist->columns; i++)
2791                 if (clist->column[i].auto_resize)
2792                   {
2793                     GTK_CLIST_GET_CLASS (clist)->cell_size_request
2794                       (clist, &GTK_CTREE_ROW (work)->row, i, &requisition);
2795                     cell_width[i] = MAX (requisition.width, cell_width[i]);
2796                   }
2797
2798               list = (GList *)work;
2799               work = GTK_CTREE_NODE_NEXT (work);
2800               tmp++;
2801             }
2802         }
2803       else
2804         while (work)
2805           {
2806             list = (GList *)work;
2807             work = GTK_CTREE_NODE_NEXT (work);
2808             tmp++;
2809           }
2810
2811       list->next = (GList *)GTK_CTREE_NODE_NEXT (node);
2812
2813       if (GTK_CTREE_NODE_NEXT (node))
2814         {
2815           GList *tmp_list;
2816
2817           if (clist->row_list_end == list)
2818               clist->row_list_end = g_list_last(list);
2819
2820           tmp_list = (GList *)GTK_CTREE_NODE_NEXT (node);
2821           tmp_list->prev = list;
2822         }
2823       else
2824         clist->row_list_end = list;
2825
2826       list = (GList *)node;
2827       list->next = (GList *)(GTK_CTREE_ROW (node)->children);
2828
2829       if (visible)
2830         {
2831           /* resize auto_resize columns if needed */
2832           for (i = 0; i < clist->columns; i++)
2833             if (clist->column[i].auto_resize &&
2834                 cell_width[i] > clist->column[i].width)
2835               gtk_clist_set_column_width (clist, i, cell_width[i]);
2836           g_free (cell_width);
2837         
2838           if (!GTK_SCTREE(ctree)->sorting) {
2839                   /* update focus_row position */
2840                   row = g_list_position (clist->row_list, (GList *)node);
2841                   if (row < clist->focus_row)
2842                     clist->focus_row += tmp;
2843           }
2844           clist->rows += tmp;
2845           CLIST_REFRESH (clist);
2846         }
2847     }
2848   else if (visible && clist->column[ctree->tree_column].auto_resize)
2849     /* resize tree_column if needed */
2850     gtk_sctree_column_auto_resize (clist, &GTK_CTREE_ROW (node)->row, ctree->tree_column,
2851                         requisition.width);
2852
2853 }
2854
2855 GtkCTreeNode * 
2856 gtk_sctree_insert_node (GtkCTree     *ctree,
2857                        GtkCTreeNode *parent, 
2858                        GtkCTreeNode *sibling,
2859                        gchar        *text[],
2860                        guint8        spacing,
2861                        GdkPixmap    *pixmap_closed,
2862                        GdkBitmap    *mask_closed,
2863                        GdkPixmap    *pixmap_opened,
2864                        GdkBitmap    *mask_opened,
2865                        gboolean      is_leaf,
2866                        gboolean      expanded)
2867 {
2868   GtkCList *clist;
2869   GtkCTreeRow *new_row;
2870   GtkCTreeNode *node;
2871   GList *list;
2872   gint i;
2873
2874   if (!emptyxpm) {
2875           stock_pixmap_gdk(GTK_WIDGET(ctree), STOCK_PIXMAP_EMPTY,
2876                    &emptyxpm, &emptyxpmmask);
2877   }
2878   if (!pixmap_closed) {
2879           pixmap_closed = emptyxpm;
2880           mask_closed = emptyxpmmask;
2881   }
2882   if (!pixmap_opened) {
2883           pixmap_opened = emptyxpm;
2884           mask_opened = emptyxpmmask;
2885   }
2886   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
2887   if (sibling)
2888     g_return_val_if_fail (GTK_CTREE_ROW (sibling)->parent == parent, NULL);
2889
2890   if (parent && GTK_CTREE_ROW (parent)->is_leaf)
2891     return NULL;
2892
2893   clist = GTK_CLIST (ctree);
2894
2895   /* create the row */
2896   new_row = srow_new (ctree);
2897   list = g_list_alloc ();
2898   list->data = new_row;
2899   node = GTK_CTREE_NODE (list);
2900
2901   if (text)
2902     for (i = 0; i < clist->columns; i++)
2903       if (text[i] && i != ctree->tree_column)
2904         GTK_CLIST_GET_CLASS (clist)->set_cell_contents
2905           (clist, &(new_row->row), i, GTK_CELL_TEXT, text[i], 0, NULL, NULL);
2906
2907   sset_node_info (ctree, node, text ?
2908                  text[ctree->tree_column] : NULL, spacing, pixmap_closed,
2909                  mask_closed, pixmap_opened, mask_opened, is_leaf, expanded);
2910
2911   /* sorted insertion */
2912   if (GTK_CLIST_AUTO_SORT (clist))
2913     {
2914       if (parent)
2915         sibling = GTK_CTREE_ROW (parent)->children;
2916       else
2917         sibling = GTK_CTREE_NODE (clist->row_list);
2918
2919       while (sibling && clist->compare
2920              (clist, GTK_CTREE_ROW (node), GTK_CTREE_ROW (sibling)) > 0)
2921         sibling = GTK_CTREE_ROW (sibling)->sibling;
2922     }
2923
2924   gtk_sctree_link (ctree, node, parent, sibling, FALSE);
2925
2926   if (text && !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist) &&
2927       gtk_ctree_is_viewable (ctree, node))
2928     {
2929       for (i = 0; i < clist->columns; i++)
2930         if (clist->column[i].auto_resize)
2931           gtk_sctree_column_auto_resize (clist, &(new_row->row), i, 0);
2932     }
2933
2934   if (clist->rows == 1)
2935     {
2936       clist->focus_row = 0;
2937       if (clist->selection_mode == GTK_SELECTION_BROWSE)
2938         gtk_sctree_select (GTK_SCTREE(ctree), node);
2939     }
2940
2941
2942   CLIST_REFRESH (clist);
2943
2944   return node;
2945 }
2946
2947 GtkCTreeNode *
2948 gtk_sctree_insert_gnode (GtkCTree          *ctree,
2949                         GtkCTreeNode      *parent,
2950                         GtkCTreeNode      *sibling,
2951                         GNode             *gnode,
2952                         GtkCTreeGNodeFunc  func,
2953                         gpointer           data)
2954 {
2955   GtkCList *clist;
2956   GtkCTreeNode *cnode = NULL;
2957   GtkCTreeNode *child = NULL;
2958   GtkCTreeNode *new_child;
2959   GList *list;
2960   GNode *work;
2961   guint depth = 1;
2962
2963   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
2964   g_return_val_if_fail (gnode != NULL, NULL);
2965   g_return_val_if_fail (func != NULL, NULL);
2966   if (sibling)
2967     g_return_val_if_fail (GTK_CTREE_ROW (sibling)->parent == parent, NULL);
2968   
2969   clist = GTK_CLIST (ctree);
2970
2971   if (parent)
2972     depth = GTK_CTREE_ROW (parent)->level + 1;
2973
2974   list = g_list_alloc ();
2975   list->data = srow_new (ctree);
2976   cnode = GTK_CTREE_NODE (list);
2977
2978   gtk_clist_freeze (clist);
2979
2980   sset_node_info (ctree, cnode, "", 0, NULL, NULL, NULL, NULL, TRUE, FALSE);
2981
2982   if (!func (ctree, depth, gnode, cnode, data))
2983     {
2984       stree_delete_row (ctree, cnode, NULL);
2985       gtk_clist_thaw (clist);
2986       return NULL;
2987     }
2988
2989   if (GTK_CLIST_AUTO_SORT (clist))
2990     {
2991       if (parent)
2992         sibling = GTK_CTREE_ROW (parent)->children;
2993       else
2994         sibling = GTK_CTREE_NODE (clist->row_list);
2995
2996       while (sibling && clist->compare
2997              (clist, GTK_CTREE_ROW (cnode), GTK_CTREE_ROW (sibling)) > 0)
2998         sibling = GTK_CTREE_ROW (sibling)->sibling;
2999     }
3000
3001   gtk_sctree_link (ctree, cnode, parent, sibling, FALSE);
3002
3003   for (work = g_node_last_child (gnode); work; work = work->prev)
3004     {
3005       new_child = gtk_sctree_insert_gnode (ctree, cnode, child,
3006                                           work, func, data);
3007       if (new_child)
3008         child = new_child;
3009     }   
3010   
3011   gtk_clist_thaw (clist);
3012
3013   return cnode;
3014 }
3015
3016 static void
3017 sreal_tree_move (GtkCTree     *ctree,
3018                 GtkCTreeNode *node,
3019                 GtkCTreeNode *new_parent, 
3020                 GtkCTreeNode *new_sibling)
3021 {
3022   GtkCList *clist;
3023   GtkCTreeNode *work;
3024   gboolean visible = FALSE;
3025
3026   g_return_if_fail (ctree != NULL);
3027   g_return_if_fail (node != NULL);
3028   g_return_if_fail (!new_sibling || 
3029                     GTK_CTREE_ROW (new_sibling)->parent == new_parent);
3030
3031   if (new_parent && GTK_CTREE_ROW (new_parent)->is_leaf)
3032     return;
3033
3034   /* new_parent != child of child */
3035   for (work = new_parent; work; work = GTK_CTREE_ROW (work)->parent)
3036     if (work == node)
3037       return;
3038
3039   clist = GTK_CLIST (ctree);
3040
3041   visible = gtk_ctree_is_viewable (ctree, node);
3042
3043   if (clist->selection_mode == GTK_SELECTION_MULTIPLE)
3044     {
3045       GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
3046       
3047       g_list_free (clist->undo_selection);
3048       g_list_free (clist->undo_unselection);
3049       clist->undo_selection = NULL;
3050       clist->undo_unselection = NULL;
3051     }
3052
3053   if (GTK_CLIST_AUTO_SORT (clist))
3054     {
3055       if (new_parent == GTK_CTREE_ROW (node)->parent)
3056         return;
3057       
3058       if (new_parent)
3059         new_sibling = GTK_CTREE_ROW (new_parent)->children;
3060       else
3061         new_sibling = GTK_CTREE_NODE (clist->row_list);
3062
3063       while (new_sibling && clist->compare
3064              (clist, GTK_CTREE_ROW (node), GTK_CTREE_ROW (new_sibling)) > 0)
3065         new_sibling = GTK_CTREE_ROW (new_sibling)->sibling;
3066     }
3067
3068   if (new_parent == GTK_CTREE_ROW (node)->parent && 
3069       new_sibling == GTK_CTREE_ROW (node)->sibling)
3070     return;
3071
3072   gtk_clist_freeze (clist);
3073
3074   work = NULL;
3075
3076   if (!GTK_SCTREE(ctree)->sorting && gtk_ctree_is_viewable (ctree, node))
3077     work = GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
3078       
3079   gtk_sctree_unlink (ctree, node, FALSE);
3080   gtk_sctree_link (ctree, node, new_parent, new_sibling, FALSE);
3081   
3082   if (!GTK_SCTREE(ctree)->sorting && work)
3083     {
3084       while (work &&  !gtk_ctree_is_viewable (ctree, work))
3085         work = GTK_CTREE_ROW (work)->parent;
3086       clist->focus_row = g_list_position (clist->row_list, (GList *)work);
3087       clist->undo_anchor = clist->focus_row;
3088     }
3089
3090   if (clist->column[ctree->tree_column].auto_resize &&
3091       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist) &&
3092       (visible || gtk_ctree_is_viewable (ctree, node)))
3093     gtk_clist_set_column_width
3094       (clist, ctree->tree_column,
3095        gtk_clist_optimal_column_width (clist, ctree->tree_column));
3096
3097   gtk_clist_thaw (clist);
3098 }
3099
3100 void gtk_sctree_set_column_tooltip          (GtkSCTree          *sctree,
3101                                              int                 column,
3102                                              const gchar        *tip)
3103 {
3104         if (!sctree->tips)
3105                 sctree->tips = gtk_tooltips_new();
3106                 
3107         gtk_tooltips_set_tip(GTK_TOOLTIPS(sctree->tips), 
3108                 GTK_CLIST(sctree)->column[column].button,
3109                         tip, NULL);
3110
3111 }
3112