Pileus Git - ~andy/gtk/blob - gtk/gtktree.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "gtkmain.h"
  28 #include "gtksignal.h"
  29 #include "gtklist.h"
  30
  31 #define GTK_ENABLE_BROKEN
  32 #include "gtktree.h"
  33 #include "gtktreeitem.h"
  34
  35 enum {
  36   SELECTION_CHANGED,
  37   SELECT_CHILD,
  38   UNSELECT_CHILD,
  39   LAST_SIGNAL
  40 };
  41
  42 static void gtk_tree_class_init      (GtkTreeClass   *klass);
  43 static void gtk_tree_init            (GtkTree        *tree);
  44 static void gtk_tree_destroy         (GtkObject      *object);
  45 static void gtk_tree_map             (GtkWidget      *widget);
  46 static void gtk_tree_parent_set      (GtkWidget      *widget,
  47                                       GtkWidget      *previous_parent);
  48 static void gtk_tree_unmap           (GtkWidget      *widget);
  49 static void gtk_tree_realize         (GtkWidget      *widget);
  50 static gint gtk_tree_motion_notify   (GtkWidget      *widget,
  51                                       GdkEventMotion *event);
  52 static gint gtk_tree_button_press    (GtkWidget      *widget,
  53                                       GdkEventButton *event);
  54 static gint gtk_tree_button_release  (GtkWidget      *widget,
  55                                       GdkEventButton *event);
  56 static void gtk_tree_size_request    (GtkWidget      *widget,
  57                                       GtkRequisition *requisition);
  58 static void gtk_tree_size_allocate   (GtkWidget      *widget,
  59                                       GtkAllocation  *allocation);
  60 static void gtk_tree_add             (GtkContainer   *container,
  61                                       GtkWidget      *widget);
  62 static void gtk_tree_forall          (GtkContainer   *container,
  63                                       gboolean        include_internals,
  64                                       GtkCallback     callback,
  65                                       gpointer        callback_data);
  66
  67 static void gtk_real_tree_select_child   (GtkTree       *tree,
  68                                           GtkWidget     *child);
  69 static void gtk_real_tree_unselect_child (GtkTree       *tree,
  70                                           GtkWidget     *child);
  71
  72 static GtkType gtk_tree_child_type  (GtkContainer   *container);
  73
  74 static GtkContainerClass *parent_class = NULL;
  75 static guint tree_signals[LAST_SIGNAL] = { 0 };
  76
  77 GtkType
  78 gtk_tree_get_type (void)
  79 {
  80   static GtkType tree_type = 0;
  81
  82   if (!tree_type)
  83     {
  84       static const GtkTypeInfo tree_info =
  85       {
  86         "GtkTree",
  87         sizeof (GtkTree),
  88         sizeof (GtkTreeClass),
  89         (GtkClassInitFunc) gtk_tree_class_init,
  90         (GtkObjectInitFunc) gtk_tree_init,
  91         /* reserved_1 */ NULL,
  92         /* reserved_2 */ NULL,
  93         (GtkClassInitFunc) NULL,
  94       };
  95
  96       tree_type = gtk_type_unique (gtk_container_get_type (), &tree_info);
  97     }
  98
  99   return tree_type;
 100 }
 101
 102 static void
 103 gtk_tree_class_init (GtkTreeClass *class)
 104 {
 105   GtkObjectClass *object_class;
 106   GtkWidgetClass *widget_class;
 107   GtkContainerClass *container_class;
 108
 109   object_class = (GtkObjectClass*) class;
 110   widget_class = (GtkWidgetClass*) class;
 111   container_class = (GtkContainerClass*) class;
 112
 113   parent_class = gtk_type_class (gtk_container_get_type ());
 114
 115
 116   object_class->destroy = gtk_tree_destroy;
 117
 118   widget_class->map = gtk_tree_map;
 119   widget_class->unmap = gtk_tree_unmap;
 120   widget_class->parent_set = gtk_tree_parent_set;
 121   widget_class->realize = gtk_tree_realize;
 122   widget_class->motion_notify_event = gtk_tree_motion_notify;
 123   widget_class->button_press_event = gtk_tree_button_press;
 124   widget_class->button_release_event = gtk_tree_button_release;
 125   widget_class->size_request = gtk_tree_size_request;
 126   widget_class->size_allocate = gtk_tree_size_allocate;
 127
 128   container_class->add = gtk_tree_add;
 129   container_class->remove =
 130     (void (*)(GtkContainer *, GtkWidget *)) gtk_tree_remove_item;
 131   container_class->forall = gtk_tree_forall;
 132   container_class->child_type = gtk_tree_child_type;
 133
 134   class->selection_changed = NULL;
 135   class->select_child = gtk_real_tree_select_child;
 136   class->unselect_child = gtk_real_tree_unselect_child;
 137
 138   tree_signals[SELECTION_CHANGED] =
 139     gtk_signal_new ("selection_changed",
 140                     GTK_RUN_FIRST,
 141                     GTK_CLASS_TYPE (object_class),
 142                     GTK_SIGNAL_OFFSET (GtkTreeClass, selection_changed),
 143                     gtk_marshal_VOID__VOID,
 144                     GTK_TYPE_NONE, 0);
 145   tree_signals[SELECT_CHILD] =
 146     gtk_signal_new ("select_child",
 147                     GTK_RUN_FIRST,
 148                     GTK_CLASS_TYPE (object_class),
 149                     GTK_SIGNAL_OFFSET (GtkTreeClass, select_child),
 150                     gtk_marshal_VOID__OBJECT,
 151                     GTK_TYPE_NONE, 1,
 152                     GTK_TYPE_WIDGET);
 153   tree_signals[UNSELECT_CHILD] =
 154     gtk_signal_new ("unselect_child",
 155                     GTK_RUN_FIRST,
 156                     GTK_CLASS_TYPE (object_class),
 157                     GTK_SIGNAL_OFFSET (GtkTreeClass, unselect_child),
 158                     gtk_marshal_VOID__OBJECT,
 159                     GTK_TYPE_NONE, 1,
 160                     GTK_TYPE_WIDGET);
 161 }
 162
 163 static GtkType
 164 gtk_tree_child_type (GtkContainer     *container)
 165 {
 166   return GTK_TYPE_TREE_ITEM;
 167 }
 168
 169 static void
 170 gtk_tree_init (GtkTree *tree)
 171 {
 172   tree->children = NULL;
 173   tree->root_tree = tree;
 174   tree->selection = NULL;
 175   tree->tree_owner = NULL;
 176   tree->selection_mode = GTK_SELECTION_SINGLE;
 177   tree->indent_value = 9;
 178   tree->current_indent = 0;
 179   tree->level = 0;
 180   tree->view_mode = GTK_TREE_VIEW_LINE;
 181   tree->view_line = TRUE;
 182 }
 183
 184 GtkWidget*
 185 gtk_tree_new (void)
 186 {
 187   return GTK_WIDGET (gtk_type_new (gtk_tree_get_type ()));
 188 }
 189
 190 void
 191 gtk_tree_append (GtkTree   *tree,
 192                  GtkWidget *tree_item)
 193 {
 194   g_return_if_fail (GTK_IS_TREE (tree));
 195   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 196
 197   gtk_tree_insert (tree, tree_item, -1);
 198 }
 199
 200 void
 201 gtk_tree_prepend (GtkTree   *tree,
 202                   GtkWidget *tree_item)
 203 {
 204   g_return_if_fail (GTK_IS_TREE (tree));
 205   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 206
 207   gtk_tree_insert (tree, tree_item, 0);
 208 }
 209
 210 void
 211 gtk_tree_insert (GtkTree   *tree,
 212                  GtkWidget *tree_item,
 213                  gint       position)
 214 {
 215   gint nchildren;
 216
 217   g_return_if_fail (GTK_IS_TREE (tree));
 218   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 219
 220   nchildren = g_list_length (tree->children);
 221
 222   if ((position < 0) || (position > nchildren))
 223     position = nchildren;
 224
 225   if (position == nchildren)
 226     tree->children = g_list_append (tree->children, tree_item);
 227   else
 228     tree->children = g_list_insert (tree->children, tree_item, position);
 229
 230   gtk_widget_set_parent (tree_item, GTK_WIDGET (tree));
 231
 232   if (GTK_WIDGET_REALIZED (tree_item->parent))
 233     gtk_widget_realize (tree_item);
 234
 235   if (GTK_WIDGET_VISIBLE (tree_item->parent) && GTK_WIDGET_VISIBLE (tree_item))
 236     {
 237       if (GTK_WIDGET_MAPPED (tree_item->parent))
 238         gtk_widget_map (tree_item);
 239
 240       gtk_widget_queue_resize (tree_item);
 241     }
 242 }
 243
 244 static void
 245 gtk_tree_add (GtkContainer *container,
 246               GtkWidget    *child)
 247 {
 248   GtkTree *tree;
 249
 250   g_return_if_fail (GTK_IS_TREE (container));
 251   g_return_if_fail (GTK_IS_TREE_ITEM (child));
 252
 253   tree = GTK_TREE (container);
 254
 255   tree->children = g_list_append (tree->children, child);
 256
 257   gtk_widget_set_parent (child, GTK_WIDGET (container));
 258
 259   if (GTK_WIDGET_REALIZED (child->parent))
 260     gtk_widget_realize (child);
 261
 262   if (GTK_WIDGET_VISIBLE (child->parent) && GTK_WIDGET_VISIBLE (child))
 263     {
 264       if (GTK_WIDGET_MAPPED (child->parent))
 265         gtk_widget_map (child);
 266
 267       gtk_widget_queue_resize (child);
 268     }
 269
 270   if (!tree->selection && (tree->selection_mode == GTK_SELECTION_BROWSE))
 271     gtk_tree_select_child (tree, child);
 272 }
 273
 274 static gint
 275 gtk_tree_button_press (GtkWidget      *widget,
 276                        GdkEventButton *event)
 277 {
 278   GtkTree *tree;
 279   GtkWidget *item;
 280
 281   g_return_val_if_fail (GTK_IS_TREE (widget), FALSE);
 282   g_return_val_if_fail (event != NULL, FALSE);
 283
 284   tree = GTK_TREE (widget);
 285   item = gtk_get_event_widget ((GdkEvent*) event);
 286
 287   while (item && !GTK_IS_TREE_ITEM (item))
 288     item = item->parent;
 289
 290   if (!item || (item->parent != widget))
 291     return FALSE;
 292
 293   switch(event->button)
 294     {
 295     case 1:
 296       gtk_tree_select_child (tree, item);
 297       break;
 298     case 2:
 299       if(GTK_TREE_ITEM(item)->subtree) gtk_tree_item_expand(GTK_TREE_ITEM(item));
 300       break;
 301     case 3:
 302       if(GTK_TREE_ITEM(item)->subtree) gtk_tree_item_collapse(GTK_TREE_ITEM(item));
 303       break;
 304     }
 305
 306   return TRUE;
 307 }
 308
 309 static gint
 310 gtk_tree_button_release (GtkWidget      *widget,
 311                          GdkEventButton *event)
 312 {
 313   GtkTree *tree;
 314   GtkWidget *item;
 315
 316   g_return_val_if_fail (GTK_IS_TREE (widget), FALSE);
 317   g_return_val_if_fail (event != NULL, FALSE);
 318
 319   tree = GTK_TREE (widget);
 320   item = gtk_get_event_widget ((GdkEvent*) event);
 321
 322   return TRUE;
 323 }
 324
 325 gint
 326 gtk_tree_child_position (GtkTree   *tree,
 327                          GtkWidget *child)
 328 {
 329   GList *children;
 330   gint pos;
 331
 332
 333   g_return_val_if_fail (GTK_IS_TREE (tree), -1);
 334   g_return_val_if_fail (child != NULL, -1);
 335
 336   pos = 0;
 337   children = tree->children;
 338
 339   while (children)
 340     {
 341       if (child == GTK_WIDGET (children->data))
 342         return pos;
 343
 344       pos += 1;
 345       children = children->next;
 346     }
 347
 348
 349   return -1;
 350 }
 351
 352 void
 353 gtk_tree_clear_items (GtkTree *tree,
 354                       gint     start,
 355                       gint     end)
 356 {
 357   GtkWidget *widget;
 358   GList *clear_list;
 359   GList *tmp_list;
 360   guint nchildren;
 361   guint index;
 362
 363   g_return_if_fail (GTK_IS_TREE (tree));
 364
 365   nchildren = g_list_length (tree->children);
 366
 367   if (nchildren > 0)
 368     {
 369       if ((end < 0) || (end > nchildren))
 370         end = nchildren;
 371
 372       if (start >= end)
 373         return;
 374
 375       tmp_list = g_list_nth (tree->children, start);
 376       clear_list = NULL;
 377       index = start;
 378       while (tmp_list && index <= end)
 379         {
 380           widget = tmp_list->data;
 381           tmp_list = tmp_list->next;
 382           index++;
 383
 384           clear_list = g_list_prepend (clear_list, widget);
 385         }
 386
 387       gtk_tree_remove_items (tree, clear_list);
 388     }
 389 }
 390
 391 static void
 392 gtk_tree_destroy (GtkObject *object)
 393 {
 394   GtkTree *tree;
 395   GtkWidget *child;
 396   GList *children;
 397
 398   g_return_if_fail (GTK_IS_TREE (object));
 399
 400   tree = GTK_TREE (object);
 401
 402   children = tree->children;
 403   while (children)
 404     {
 405       child = children->data;
 406       children = children->next;
 407
 408       gtk_widget_ref (child);
 409       gtk_widget_unparent (child);
 410       gtk_widget_destroy (child);
 411       gtk_widget_unref (child);
 412     }
 413
 414   g_list_free (tree->children);
 415   tree->children = NULL;
 416
 417   if (tree->root_tree == tree)
 418     {
 419       GList *node;
 420       for (node = tree->selection; node; node = node->next)
 421         gtk_widget_unref ((GtkWidget *)node->data);
 422       g_list_free (tree->selection);
 423       tree->selection = NULL;
 424     }
 425
 426   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 427     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 428 }
 429
 430 static void
 431 gtk_tree_forall (GtkContainer *container,
 432                  gboolean      include_internals,
 433                  GtkCallback   callback,
 434                  gpointer      callback_data)
 435 {
 436   GtkTree *tree;
 437   GtkWidget *child;
 438   GList *children;
 439
 440
 441   g_return_if_fail (GTK_IS_TREE (container));
 442   g_return_if_fail (callback != NULL);
 443
 444   tree = GTK_TREE (container);
 445   children = tree->children;
 446
 447   while (children)
 448     {
 449       child = children->data;
 450       children = children->next;
 451
 452       (* callback) (child, callback_data);
 453     }
 454 }
 455
 456 static void
 457 gtk_tree_unselect_all (GtkTree *tree)
 458 {
 459   GList *tmp_list, *selection;
 460   GtkWidget *tmp_item;
 461
 462   selection = tree->selection;
 463   tree->selection = NULL;
 464
 465   tmp_list = selection;
 466   while (tmp_list)
 467     {
 468       tmp_item = selection->data;
 469
 470       if (tmp_item->parent &&
 471           GTK_IS_TREE (tmp_item->parent) &&
 472           GTK_TREE (tmp_item->parent)->root_tree == tree)
 473         gtk_tree_item_deselect (GTK_TREE_ITEM (tmp_item));
 474
 475       gtk_widget_unref (tmp_item);
 476
 477       tmp_list = tmp_list->next;
 478     }
 479
 480   g_list_free (selection);
 481 }
 482
 483 static void
 484 gtk_tree_parent_set (GtkWidget *widget,
 485                      GtkWidget *previous_parent)
 486 {
 487   GtkTree *tree = GTK_TREE (widget);
 488   GtkWidget *child;
 489   GList *children;
 490
 491   if (widget->parent && GTK_IS_TREE (widget->parent))
 492     {
 493       gtk_tree_unselect_all (tree);
 494
 495       /* set root tree for this tree */
 496       tree->root_tree = GTK_TREE(widget->parent)->root_tree;
 497
 498       tree->level = GTK_TREE(GTK_WIDGET(tree)->parent)->level+1;
 499       tree->indent_value = GTK_TREE(GTK_WIDGET(tree)->parent)->indent_value;
 500       tree->current_indent = GTK_TREE(GTK_WIDGET(tree)->parent)->current_indent +
 501         tree->indent_value;
 502       tree->view_mode = GTK_TREE(GTK_WIDGET(tree)->parent)->view_mode;
 503       tree->view_line = GTK_TREE(GTK_WIDGET(tree)->parent)->view_line;
 504     }
 505   else
 506     {
 507       tree->root_tree = tree;
 508
 509       tree->level = 0;
 510       tree->current_indent = 0;
 511     }
 512
 513   children = tree->children;
 514   while (children)
 515     {
 516       child = children->data;
 517       children = children->next;
 518
 519       if (GTK_TREE_ITEM (child)->subtree)
 520         gtk_tree_parent_set (GTK_TREE_ITEM (child)->subtree, child);
 521     }
 522 }
 523
 524 static void
 525 gtk_tree_map (GtkWidget *widget)
 526 {
 527   GtkTree *tree = GTK_TREE (widget);
 528   GtkWidget *child;
 529   GList *children;
 530
 531   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 532
 533   children = tree->children;
 534   while (children)
 535     {
 536       child = children->data;
 537       children = children->next;
 538
 539       if (GTK_WIDGET_VISIBLE (child) &&
 540           !GTK_WIDGET_MAPPED (child))
 541         gtk_widget_map (child);
 542
 543       if (GTK_TREE_ITEM (child)->subtree)
 544         {
 545           child = GTK_WIDGET (GTK_TREE_ITEM (child)->subtree);
 546
 547           if (GTK_WIDGET_VISIBLE (child) && !GTK_WIDGET_MAPPED (child))
 548             gtk_widget_map (child);
 549         }
 550     }
 551
 552   gdk_window_show (widget->window);
 553 }
 554
 555 static gint
 556 gtk_tree_motion_notify (GtkWidget      *widget,
 557                         GdkEventMotion *event)
 558 {
 559   g_return_val_if_fail (GTK_IS_TREE (widget), FALSE);
 560   g_return_val_if_fail (event != NULL, FALSE);
 561
 562 #ifdef TREE_DEBUG
 563   g_message("gtk_tree_motion_notify\n");
 564 #endif /* TREE_DEBUG */
 565
 566   return FALSE;
 567 }
 568
 569 static void
 570 gtk_tree_realize (GtkWidget *widget)
 571 {
 572   GdkWindowAttr attributes;
 573   gint attributes_mask;
 574
 575
 576   g_return_if_fail (GTK_IS_TREE (widget));
 577
 578   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 579
 580   attributes.window_type = GDK_WINDOW_CHILD;
 581   attributes.x = widget->allocation.x;
 582   attributes.y = widget->allocation.y;
 583   attributes.width = widget->allocation.width;
 584   attributes.height = widget->allocation.height;
 585   attributes.wclass = GDK_INPUT_OUTPUT;
 586   attributes.visual = gtk_widget_get_visual (widget);
 587   attributes.colormap = gtk_widget_get_colormap (widget);
 588   attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
 589
 590   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 591
 592   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 593   gdk_window_set_user_data (widget->window, widget);
 594
 595   widget->style = gtk_style_attach (widget->style, widget->window);
 596   gdk_window_set_background (widget->window,
 597                              &widget->style->base[GTK_STATE_NORMAL]);
 598 }
 599
 600 void
 601 gtk_tree_remove_item (GtkTree      *container,
 602                       GtkWidget    *widget)
 603 {
 604   GList *item_list;
 605
 606   g_return_if_fail (GTK_IS_TREE (container));
 607   g_return_if_fail (widget != NULL);
 608   g_return_if_fail (container == GTK_TREE (widget->parent));
 609
 610   item_list = g_list_append (NULL, widget);
 611
 612   gtk_tree_remove_items (GTK_TREE (container), item_list);
 613
 614   g_list_free (item_list);
 615 }
 616
 617 /* used by gtk_tree_remove_items to make the function independant of
 618    order in list of items to remove.
 619    Sort item bu depth in tree */
 620 static gint
 621 gtk_tree_sort_item_by_depth(GtkWidget* a, GtkWidget* b)
 622 {
 623   if((GTK_TREE(a->parent)->level) < (GTK_TREE(b->parent)->level))
 624     return 1;
 625   if((GTK_TREE(a->parent)->level) > (GTK_TREE(b->parent)->level))
 626     return -1;
 627
 628   return 0;
 629 }
 630
 631 void
 632 gtk_tree_remove_items (GtkTree *tree,
 633                        GList   *items)
 634 {
 635   GtkWidget *widget;
 636   GList *selected_widgets;
 637   GList *tmp_list;
 638   GList *sorted_list;
 639   GtkTree *real_tree;
 640   GtkTree *root_tree;
 641
 642   g_return_if_fail (GTK_IS_TREE (tree));
 643
 644 #ifdef TREE_DEBUG
 645   g_message("+ gtk_tree_remove_items [ tree %#x items list %#x ]\n", (int)tree, (int)items);
 646 #endif /* TREE_DEBUG */
 647
 648   /* We may not yet be mapped, so we actively have to find our
 649    * root tree
 650    */
 651   if (tree->root_tree)
 652     root_tree = tree->root_tree;
 653   else
 654     {
 655       GtkWidget *tmp = GTK_WIDGET (tree);
 656       while (tmp->parent && GTK_IS_TREE (tmp->parent))
 657         tmp = tmp->parent;
 658
 659       root_tree = GTK_TREE (tmp);
 660     }
 661
 662   tmp_list = items;
 663   selected_widgets = NULL;
 664   sorted_list = NULL;
 665   widget = NULL;
 666
 667 #ifdef TREE_DEBUG
 668   g_message("* sort list by depth\n");
 669 #endif /* TREE_DEBUG */
 670
 671   while (tmp_list)
 672     {
 673
 674 #ifdef TREE_DEBUG
 675       g_message ("* item [%#x] depth [%d]\n",
 676                  (int)tmp_list->data,
 677                  (int)GTK_TREE(GTK_WIDGET(tmp_list->data)->parent)->level);
 678 #endif /* TREE_DEBUG */
 679
 680       sorted_list = g_list_insert_sorted(sorted_list,
 681                                          tmp_list->data,
 682                                          (GCompareFunc)gtk_tree_sort_item_by_depth);
 683       tmp_list = g_list_next(tmp_list);
 684     }
 685
 686 #ifdef TREE_DEBUG
 687   /* print sorted list */
 688   g_message("* sorted list result\n");
 689   tmp_list = sorted_list;
 690   while(tmp_list)
 691     {
 692       g_message("* item [%#x] depth [%d]\n",
 693                 (int)tmp_list->data,
 694                 (int)GTK_TREE(GTK_WIDGET(tmp_list->data)->parent)->level);
 695       tmp_list = g_list_next(tmp_list);
 696     }
 697 #endif /* TREE_DEBUG */
 698
 699 #ifdef TREE_DEBUG
 700   g_message("* scan sorted list\n");
 701 #endif /* TREE_DEBUG */
 702
 703   tmp_list = sorted_list;
 704   while (tmp_list)
 705     {
 706       widget = tmp_list->data;
 707       tmp_list = tmp_list->next;
 708
 709 #ifdef TREE_DEBUG
 710       g_message("* item [%#x] subtree [%#x]\n",
 711                 (int)widget, (int)GTK_TREE_ITEM_SUBTREE(widget));
 712 #endif /* TREE_DEBUG */
 713
 714       /* get real owner of this widget */
 715       real_tree = GTK_TREE(widget->parent);
 716 #ifdef TREE_DEBUG
 717       g_message("* subtree having this widget [%#x]\n", (int)real_tree);
 718 #endif /* TREE_DEBUG */
 719
 720
 721       if (widget->state == GTK_STATE_SELECTED)
 722         {
 723           selected_widgets = g_list_prepend (selected_widgets, widget);
 724 #ifdef TREE_DEBUG
 725           g_message("* selected widget - adding it in selected list [%#x]\n",
 726                     (int)selected_widgets);
 727 #endif /* TREE_DEBUG */
 728         }
 729
 730       /* remove this item from its real parent */
 731 #ifdef TREE_DEBUG
 732       g_message("* remove widget from its owner tree\n");
 733 #endif /* TREE_DEBUG */
 734       real_tree->children = g_list_remove (real_tree->children, widget);
 735
 736       /* remove subtree associate at this item if it exist */
 737       if(GTK_TREE_ITEM(widget)->subtree)
 738         {
 739 #ifdef TREE_DEBUG
 740           g_message("* remove subtree associate at this item [%#x]\n",
 741                     (int) GTK_TREE_ITEM(widget)->subtree);
 742 #endif /* TREE_DEBUG */
 743           if (GTK_WIDGET_MAPPED (GTK_TREE_ITEM(widget)->subtree))
 744             gtk_widget_unmap (GTK_TREE_ITEM(widget)->subtree);
 745
 746           gtk_widget_unparent (GTK_TREE_ITEM(widget)->subtree);
 747           GTK_TREE_ITEM(widget)->subtree = NULL;
 748         }
 749
 750       /* really remove widget for this item */
 751 #ifdef TREE_DEBUG
 752       g_message("* unmap and unparent widget [%#x]\n", (int)widget);
 753 #endif /* TREE_DEBUG */
 754       if (GTK_WIDGET_MAPPED (widget))
 755         gtk_widget_unmap (widget);
 756
 757       gtk_widget_unparent (widget);
 758
 759       /* delete subtree if there is no children in it */
 760       if(real_tree->children == NULL &&
 761          real_tree != root_tree)
 762         {
 763 #ifdef TREE_DEBUG
 764           g_message("* owner tree don't have children ... destroy it\n");
 765 #endif /* TREE_DEBUG */
 766           gtk_tree_item_remove_subtree(GTK_TREE_ITEM(real_tree->tree_owner));
 767         }
 768
 769 #ifdef TREE_DEBUG
 770       g_message("* next item in list\n");
 771 #endif /* TREE_DEBUG */
 772     }
 773
 774   if (selected_widgets)
 775     {
 776 #ifdef TREE_DEBUG
 777       g_message("* scan selected item list\n");
 778 #endif /* TREE_DEBUG */
 779       tmp_list = selected_widgets;
 780       while (tmp_list)
 781         {
 782           widget = tmp_list->data;
 783           tmp_list = tmp_list->next;
 784
 785 #ifdef TREE_DEBUG
 786           g_message("* widget [%#x] subtree [%#x]\n",
 787                     (int)widget, (int)GTK_TREE_ITEM_SUBTREE(widget));
 788 #endif /* TREE_DEBUG */
 789
 790           /* remove widget of selection */
 791           root_tree->selection = g_list_remove (root_tree->selection, widget);
 792
 793           /* unref it to authorize is destruction */
 794           gtk_widget_unref (widget);
 795         }
 796
 797       /* emit only one selection_changed signal */
 798       gtk_signal_emit (GTK_OBJECT (root_tree),
 799                        tree_signals[SELECTION_CHANGED]);
 800     }
 801
 802 #ifdef TREE_DEBUG
 803   g_message("* free selected_widgets list\n");
 804 #endif /* TREE_DEBUG */
 805   g_list_free (selected_widgets);
 806   g_list_free (sorted_list);
 807
 808   if (root_tree->children && !root_tree->selection &&
 809       (root_tree->selection_mode == GTK_SELECTION_BROWSE))
 810     {
 811 #ifdef TREE_DEBUG
 812       g_message("* BROWSE mode, select another item\n");
 813 #endif /* TREE_DEBUG */
 814       widget = root_tree->children->data;
 815       gtk_tree_select_child (root_tree, widget);
 816     }
 817
 818   if (GTK_WIDGET_VISIBLE (root_tree))
 819     {
 820 #ifdef TREE_DEBUG
 821       g_message("* query queue resizing for root_tree\n");
 822 #endif /* TREE_DEBUG */
 823       gtk_widget_queue_resize (GTK_WIDGET (root_tree));
 824     }
 825 }
 826
 827 void
 828 gtk_tree_select_child (GtkTree   *tree,
 829                        GtkWidget *tree_item)
 830 {
 831   g_return_if_fail (GTK_IS_TREE (tree));
 832   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 833
 834   gtk_signal_emit (GTK_OBJECT (tree), tree_signals[SELECT_CHILD], tree_item);
 835 }
 836
 837 void
 838 gtk_tree_select_item (GtkTree   *tree,
 839                       gint       item)
 840 {
 841   GList *tmp_list;
 842
 843   g_return_if_fail (GTK_IS_TREE (tree));
 844
 845   tmp_list = g_list_nth (tree->children, item);
 846   if (tmp_list)
 847     gtk_tree_select_child (tree, GTK_WIDGET (tmp_list->data));
 848
 849 }
 850
 851 static void
 852 gtk_tree_size_allocate (GtkWidget     *widget,
 853                         GtkAllocation *allocation)
 854 {
 855   GtkTree *tree;
 856   GtkWidget *child, *subtree;
 857   GtkAllocation child_allocation;
 858   GList *children;
 859
 860
 861   g_return_if_fail (GTK_IS_TREE (widget));
 862   g_return_if_fail (allocation != NULL);
 863
 864   tree = GTK_TREE (widget);
 865
 866   widget->allocation = *allocation;
 867   if (GTK_WIDGET_REALIZED (widget))
 868     gdk_window_move_resize (widget->window,
 869                             allocation->x, allocation->y,
 870                             allocation->width, allocation->height);
 871
 872   if (tree->children)
 873     {
 874       child_allocation.x = GTK_CONTAINER (tree)->border_width;
 875       child_allocation.y = GTK_CONTAINER (tree)->border_width;
 876       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
 877
 878       children = tree->children;
 879
 880       while (children)
 881         {
 882           child = children->data;
 883           children = children->next;
 884
 885           if (GTK_WIDGET_VISIBLE (child))
 886             {
 887               GtkRequisition child_requisition;
 888               gtk_widget_get_child_requisition (child, &child_requisition);
 889
 890               child_allocation.height = child_requisition.height;
 891
 892               gtk_widget_size_allocate (child, &child_allocation);
 893
 894               child_allocation.y += child_allocation.height;
 895
 896               if((subtree = GTK_TREE_ITEM(child)->subtree))
 897                 if(GTK_WIDGET_VISIBLE (subtree))
 898                   {
 899                     child_allocation.height = subtree->requisition.height;
 900                     gtk_widget_size_allocate (subtree, &child_allocation);
 901                     child_allocation.y += child_allocation.height;
 902                   }
 903             }
 904         }
 905     }
 906
 907 }
 908
 909 static void
 910 gtk_tree_size_request (GtkWidget      *widget,
 911                        GtkRequisition *requisition)
 912 {
 913   GtkTree *tree;
 914   GtkWidget *child, *subtree;
 915   GList *children;
 916   GtkRequisition child_requisition;
 917
 918
 919   g_return_if_fail (GTK_IS_TREE (widget));
 920   g_return_if_fail (requisition != NULL);
 921
 922   tree = GTK_TREE (widget);
 923   requisition->width = 0;
 924   requisition->height = 0;
 925
 926   children = tree->children;
 927   while (children)
 928     {
 929       child = children->data;
 930       children = children->next;
 931
 932       if (GTK_WIDGET_VISIBLE (child))
 933         {
 934           gtk_widget_size_request (child, &child_requisition);
 935
 936           requisition->width = MAX (requisition->width, child_requisition.width);
 937           requisition->height += child_requisition.height;
 938
 939           if((subtree = GTK_TREE_ITEM(child)->subtree) &&
 940              GTK_WIDGET_VISIBLE (subtree))
 941             {
 942               gtk_widget_size_request (subtree, &child_requisition);
 943
 944               requisition->width = MAX (requisition->width,
 945                                         child_requisition.width);
 946
 947               requisition->height += child_requisition.height;
 948             }
 949         }
 950     }
 951
 952   requisition->width += GTK_CONTAINER (tree)->border_width * 2;
 953   requisition->height += GTK_CONTAINER (tree)->border_width * 2;
 954
 955   requisition->width = MAX (requisition->width, 1);
 956   requisition->height = MAX (requisition->height, 1);
 957
 958 }
 959
 960 static void
 961 gtk_tree_unmap (GtkWidget *widget)
 962 {
 963
 964   g_return_if_fail (GTK_IS_TREE (widget));
 965
 966   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
 967   gdk_window_hide (widget->window);
 968
 969 }
 970
 971 void
 972 gtk_tree_unselect_child (GtkTree   *tree,
 973                          GtkWidget *tree_item)
 974 {
 975   g_return_if_fail (GTK_IS_TREE (tree));
 976   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 977
 978   gtk_signal_emit (GTK_OBJECT (tree), tree_signals[UNSELECT_CHILD], tree_item);
 979 }
 980
 981 void
 982 gtk_tree_unselect_item (GtkTree *tree,
 983                         gint     item)
 984 {
 985   GList *tmp_list;
 986
 987   g_return_if_fail (GTK_IS_TREE (tree));
 988
 989   tmp_list = g_list_nth (tree->children, item);
 990   if (tmp_list)
 991     gtk_tree_unselect_child (tree, GTK_WIDGET (tmp_list->data));
 992
 993 }
 994
 995 static void
 996 gtk_real_tree_select_child (GtkTree   *tree,
 997                             GtkWidget *child)
 998 {
 999   GList *selection, *root_selection;
1000   GList *tmp_list;
1001   GtkWidget *tmp_item;
1002
1003   g_return_if_fail (GTK_IS_TREE (tree));
1004   g_return_if_fail (GTK_IS_TREE_ITEM (child));
1005
1006   root_selection = tree->root_tree->selection;
1007
1008   switch (tree->root_tree->selection_mode)
1009     {
1010     case GTK_SELECTION_SINGLE:
1011
1012       selection = root_selection;
1013
1014       /* remove old selection list */
1015       while (selection)
1016         {
1017           tmp_item = selection->data;
1018
1019           if (tmp_item != child)
1020             {
1021               gtk_tree_item_deselect (GTK_TREE_ITEM (tmp_item));
1022
1023               tmp_list = selection;
1024               selection = selection->next;
1025
1026               root_selection = g_list_remove_link (root_selection, tmp_list);
1027               gtk_widget_unref (tmp_item);
1028
1029               g_list_free (tmp_list);
1030             }
1031           else
1032             selection = selection->next;
1033         }
1034
1035       if (child->state == GTK_STATE_NORMAL)
1036         {
1037           gtk_tree_item_select (GTK_TREE_ITEM (child));
1038           root_selection = g_list_prepend (root_selection, child);
1039           gtk_widget_ref (child);
1040         }
1041       else if (child->state == GTK_STATE_SELECTED)
1042         {
1043           gtk_tree_item_deselect (GTK_TREE_ITEM (child));
1044           root_selection = g_list_remove (root_selection, child);
1045           gtk_widget_unref (child);
1046         }
1047
1048       tree->root_tree->selection = root_selection;
1049
1050       gtk_signal_emit (GTK_OBJECT (tree->root_tree),
1051                        tree_signals[SELECTION_CHANGED]);
1052       break;
1053
1054
1055     case GTK_SELECTION_BROWSE:
1056       selection = root_selection;
1057
1058       while (selection)
1059         {
1060           tmp_item = selection->data;
1061
1062           if (tmp_item != child)
1063             {
1064               gtk_tree_item_deselect (GTK_TREE_ITEM (tmp_item));
1065
1066               tmp_list = selection;
1067               selection = selection->next;
1068
1069               root_selection = g_list_remove_link (root_selection, tmp_list);
1070               gtk_widget_unref (tmp_item);
1071
1072               g_list_free (tmp_list);
1073             }
1074           else
1075             selection = selection->next;
1076         }
1077
1078       tree->root_tree->selection = root_selection;
1079
1080       if (child->state == GTK_STATE_NORMAL)
1081         {
1082           gtk_tree_item_select (GTK_TREE_ITEM (child));
1083           root_selection = g_list_prepend (root_selection, child);
1084           gtk_widget_ref (child);
1085           tree->root_tree->selection = root_selection;
1086           gtk_signal_emit (GTK_OBJECT (tree->root_tree),
1087                            tree_signals[SELECTION_CHANGED]);
1088         }
1089       break;
1090
1091     case GTK_SELECTION_MULTIPLE:
1092       if (child->state == GTK_STATE_NORMAL)
1093         {
1094           gtk_tree_item_select (GTK_TREE_ITEM (child));
1095           root_selection = g_list_prepend (root_selection, child);
1096           gtk_widget_ref (child);
1097           tree->root_tree->selection = root_selection;
1098           gtk_signal_emit (GTK_OBJECT (tree->root_tree),
1099                            tree_signals[SELECTION_CHANGED]);
1100         }
1101       else if (child->state == GTK_STATE_SELECTED)
1102         {
1103           gtk_tree_item_deselect (GTK_TREE_ITEM (child));
1104           root_selection = g_list_remove (root_selection, child);
1105           gtk_widget_unref (child);
1106           tree->root_tree->selection = root_selection;
1107           gtk_signal_emit (GTK_OBJECT (tree->root_tree),
1108                            tree_signals[SELECTION_CHANGED]);
1109         }
1110       break;
1111
1112     case GTK_SELECTION_EXTENDED:
1113       break;
1114     }
1115 }
1116
1117 static void
1118 gtk_real_tree_unselect_child (GtkTree   *tree,
1119                               GtkWidget *child)
1120 {
1121   g_return_if_fail (GTK_IS_TREE (tree));
1122   g_return_if_fail (GTK_IS_TREE_ITEM (child));
1123
1124   switch (tree->selection_mode)
1125     {
1126     case GTK_SELECTION_SINGLE:
1127     case GTK_SELECTION_MULTIPLE:
1128     case GTK_SELECTION_BROWSE:
1129       if (child->state == GTK_STATE_SELECTED)
1130         {
1131           GtkTree* root_tree = GTK_TREE_ROOT_TREE(tree);
1132           gtk_tree_item_deselect (GTK_TREE_ITEM (child));
1133           root_tree->selection = g_list_remove (root_tree->selection, child);
1134           gtk_widget_unref (child);
1135           gtk_signal_emit (GTK_OBJECT (tree->root_tree),
1136                            tree_signals[SELECTION_CHANGED]);
1137         }
1138       break;
1139
1140     case GTK_SELECTION_EXTENDED:
1141       break;
1142     }
1143 }
1144
1145 void
1146 gtk_tree_set_selection_mode (GtkTree       *tree,
1147                              GtkSelectionMode mode)
1148 {
1149   g_return_if_fail (GTK_IS_TREE (tree));
1150
1151   tree->selection_mode = mode;
1152 }
1153
1154 void
1155 gtk_tree_set_view_mode (GtkTree       *tree,
1156                         GtkTreeViewMode mode)
1157 {
1158   g_return_if_fail (GTK_IS_TREE (tree));
1159
1160   tree->view_mode = mode;
1161 }
1162
1163 void
1164 gtk_tree_set_view_lines (GtkTree       *tree,
1165                          gboolean       flag)
1166 {
1167   g_return_if_fail (GTK_IS_TREE (tree));
1168
1169   tree->view_line = flag;
1170 }