Pileus Git - ~andy/gtk/blob - gtk/gtktreeitem.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 "gtklabel.h"
  28 #include "gtkeventbox.h"
  29 #include "gtkpixmap.h"
  30 #include "gtkmain.h"
  31 #include "gtksignal.h"
  32 #define GTK_ENABLE_BROKEN
  33 #include "gtktree.h"
  34 #include "gtktreeitem.h"
  35
  36 #include "tree_plus.xpm"
  37 #include "tree_minus.xpm"
  38
  39 #define DEFAULT_DELTA 9
  40
  41 enum {
  42   COLLAPSE_TREE,
  43   EXPAND_TREE,
  44   LAST_SIGNAL
  45 };
  46
  47 typedef struct _GtkTreePixmaps GtkTreePixmaps;
  48
  49 struct _GtkTreePixmaps {
  50   gint refcount;
  51   GdkColormap *colormap;
  52
  53   GdkPixmap *pixmap_plus;
  54   GdkPixmap *pixmap_minus;
  55   GdkBitmap *mask_plus;
  56   GdkBitmap *mask_minus;
  57 };
  58
  59 static GList *pixmaps = NULL;
  60
  61 static void gtk_tree_item_class_init (GtkTreeItemClass *klass);
  62 static void gtk_tree_item_init       (GtkTreeItem      *tree_item);
  63 static void gtk_tree_item_realize       (GtkWidget        *widget);
  64 static void gtk_tree_item_size_request  (GtkWidget        *widget,
  65                                          GtkRequisition   *requisition);
  66 static void gtk_tree_item_size_allocate (GtkWidget        *widget,
  67                                          GtkAllocation    *allocation);
  68 static void gtk_tree_item_draw_focus    (GtkWidget        *widget);
  69 static void gtk_tree_item_paint         (GtkWidget        *widget,
  70                                          GdkRectangle     *area);
  71 static gint gtk_tree_item_button_press  (GtkWidget        *widget,
  72                                          GdkEventButton   *event);
  73 static gint gtk_tree_item_expose        (GtkWidget        *widget,
  74                                          GdkEventExpose   *event);
  75 static gint gtk_tree_item_focus_in      (GtkWidget        *widget,
  76                                          GdkEventFocus    *event);
  77 static gint gtk_tree_item_focus_out     (GtkWidget        *widget,
  78                                          GdkEventFocus    *event);
  79 static void gtk_tree_item_forall        (GtkContainer    *container,
  80                                          gboolean         include_internals,
  81                                          GtkCallback      callback,
  82                                          gpointer         callback_data);
  83
  84 static void gtk_real_tree_item_select   (GtkItem          *item);
  85 static void gtk_real_tree_item_deselect (GtkItem          *item);
  86 static void gtk_real_tree_item_toggle   (GtkItem          *item);
  87 static void gtk_real_tree_item_expand   (GtkTreeItem      *item);
  88 static void gtk_real_tree_item_collapse (GtkTreeItem      *item);
  89 static void gtk_real_tree_item_expand   (GtkTreeItem      *item);
  90 static void gtk_real_tree_item_collapse (GtkTreeItem      *item);
  91 static void gtk_tree_item_destroy        (GtkObject *object);
  92 static void gtk_tree_item_subtree_button_click (GtkWidget *widget);
  93 static void gtk_tree_item_subtree_button_changed_state (GtkWidget *widget);
  94
  95 static void gtk_tree_item_map(GtkWidget*);
  96 static void gtk_tree_item_unmap(GtkWidget*);
  97
  98 static void gtk_tree_item_add_pixmaps    (GtkTreeItem       *tree_item);
  99 static void gtk_tree_item_remove_pixmaps (GtkTreeItem       *tree_item);
 100
 101 static GtkItemClass *parent_class = NULL;
 102 static guint tree_item_signals[LAST_SIGNAL] = { 0 };
 103
 104 GtkType
 105 gtk_tree_item_get_type (void)
 106 {
 107   static GtkType tree_item_type = 0;
 108
 109   if (!tree_item_type)
 110     {
 111       static const GtkTypeInfo tree_item_info =
 112       {
 113         "GtkTreeItem",
 114         sizeof (GtkTreeItem),
 115         sizeof (GtkTreeItemClass),
 116         (GtkClassInitFunc) gtk_tree_item_class_init,
 117         (GtkObjectInitFunc) gtk_tree_item_init,
 118         /* reserved_1 */ NULL,
 119         /* reserved_2 */ NULL,
 120         (GtkClassInitFunc) NULL,
 121       };
 122
 123       tree_item_type = gtk_type_unique (gtk_item_get_type (), &tree_item_info);
 124     }
 125
 126   return tree_item_type;
 127 }
 128
 129 static void
 130 gtk_tree_item_class_init (GtkTreeItemClass *class)
 131 {
 132   GtkObjectClass *object_class;
 133   GtkWidgetClass *widget_class;
 134   GtkContainerClass *container_class;
 135   GtkItemClass *item_class;
 136
 137   parent_class = gtk_type_class (GTK_TYPE_ITEM);
 138
 139   object_class = (GtkObjectClass*) class;
 140   widget_class = (GtkWidgetClass*) class;
 141   item_class = (GtkItemClass*) class;
 142   container_class = (GtkContainerClass*) class;
 143
 144   object_class->destroy = gtk_tree_item_destroy;
 145
 146   widget_class->realize = gtk_tree_item_realize;
 147   widget_class->size_request = gtk_tree_item_size_request;
 148   widget_class->size_allocate = gtk_tree_item_size_allocate;
 149   widget_class->draw_focus = gtk_tree_item_draw_focus;
 150   widget_class->button_press_event = gtk_tree_item_button_press;
 151   widget_class->expose_event = gtk_tree_item_expose;
 152   widget_class->focus_in_event = gtk_tree_item_focus_in;
 153   widget_class->focus_out_event = gtk_tree_item_focus_out;
 154   widget_class->map = gtk_tree_item_map;
 155   widget_class->unmap = gtk_tree_item_unmap;
 156
 157   container_class->forall = gtk_tree_item_forall;
 158
 159   item_class->select = gtk_real_tree_item_select;
 160   item_class->deselect = gtk_real_tree_item_deselect;
 161   item_class->toggle = gtk_real_tree_item_toggle;
 162
 163   class->expand = gtk_real_tree_item_expand;
 164   class->collapse = gtk_real_tree_item_collapse;
 165
 166   tree_item_signals[EXPAND_TREE] =
 167     gtk_signal_new ("expand",
 168                     GTK_RUN_FIRST,
 169                     GTK_CLASS_TYPE (object_class),
 170                     GTK_SIGNAL_OFFSET (GtkTreeItemClass, expand),
 171                     gtk_marshal_VOID__VOID,
 172                     GTK_TYPE_NONE, 0);
 173   tree_item_signals[COLLAPSE_TREE] =
 174     gtk_signal_new ("collapse",
 175                     GTK_RUN_FIRST,
 176                     GTK_CLASS_TYPE (object_class),
 177                     GTK_SIGNAL_OFFSET (GtkTreeItemClass, collapse),
 178                     gtk_marshal_VOID__VOID,
 179                     GTK_TYPE_NONE, 0);
 180 }
 181
 182 /* callback for event box mouse event */
 183 static void
 184 gtk_tree_item_subtree_button_click (GtkWidget *widget)
 185 {
 186   GtkTreeItem* item;
 187
 188   g_return_if_fail (widget != NULL);
 189   g_return_if_fail (GTK_IS_EVENT_BOX (widget));
 190
 191   item = (GtkTreeItem*) gtk_object_get_user_data (GTK_OBJECT (widget));
 192   if (!GTK_WIDGET_IS_SENSITIVE (item))
 193     return;
 194
 195   if (item->expanded)
 196     gtk_tree_item_collapse (item);
 197   else
 198     gtk_tree_item_expand (item);
 199 }
 200
 201 /* callback for event box state changed */
 202 static void
 203 gtk_tree_item_subtree_button_changed_state (GtkWidget *widget)
 204 {
 205   g_return_if_fail (widget != NULL);
 206   g_return_if_fail (GTK_IS_EVENT_BOX (widget));
 207
 208   if (GTK_WIDGET_VISIBLE (widget))
 209     {
 210
 211       if (widget->state == GTK_STATE_NORMAL)
 212         gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
 213       else
 214         gdk_window_set_background (widget->window, &widget->style->bg[widget->state]);
 215
 216       if (GTK_WIDGET_DRAWABLE (widget))
 217         gdk_window_clear_area (widget->window, 0, 0,
 218                                widget->allocation.width, widget->allocation.height);
 219     }
 220 }
 221
 222 static void
 223 gtk_tree_item_init (GtkTreeItem *tree_item)
 224 {
 225   GtkWidget *eventbox, *pixmapwid;
 226
 227   g_return_if_fail (tree_item != NULL);
 228   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 229
 230   tree_item->expanded = FALSE;
 231   tree_item->subtree = NULL;
 232   GTK_WIDGET_SET_FLAGS (tree_item, GTK_CAN_FOCUS);
 233
 234   /* create an event box containing one pixmaps */
 235   eventbox = gtk_event_box_new();
 236   gtk_widget_set_events (eventbox, GDK_BUTTON_PRESS_MASK);
 237   gtk_signal_connect(GTK_OBJECT(eventbox), "state_changed",
 238                      (GtkSignalFunc)gtk_tree_item_subtree_button_changed_state,
 239                      (gpointer)NULL);
 240   gtk_signal_connect(GTK_OBJECT(eventbox), "realize",
 241                      (GtkSignalFunc)gtk_tree_item_subtree_button_changed_state,
 242                      (gpointer)NULL);
 243   gtk_signal_connect(GTK_OBJECT(eventbox), "button_press_event",
 244                      (GtkSignalFunc)gtk_tree_item_subtree_button_click,
 245                      (gpointer)NULL);
 246   gtk_object_set_user_data(GTK_OBJECT(eventbox), tree_item);
 247   tree_item->pixmaps_box = eventbox;
 248
 249   /* create pixmap for button '+' */
 250   pixmapwid = gtk_type_new (gtk_pixmap_get_type ());
 251   if (!tree_item->expanded)
 252     gtk_container_add (GTK_CONTAINER (eventbox), pixmapwid);
 253   gtk_widget_show (pixmapwid);
 254   tree_item->plus_pix_widget = pixmapwid;
 255   gtk_widget_ref (tree_item->plus_pix_widget);
 256   gtk_object_sink (GTK_OBJECT (tree_item->plus_pix_widget));
 257
 258   /* create pixmap for button '-' */
 259   pixmapwid = gtk_type_new (gtk_pixmap_get_type ());
 260   if (tree_item->expanded)
 261     gtk_container_add (GTK_CONTAINER (eventbox), pixmapwid);
 262   gtk_widget_show (pixmapwid);
 263   tree_item->minus_pix_widget = pixmapwid;
 264   gtk_widget_ref (tree_item->minus_pix_widget);
 265   gtk_object_sink (GTK_OBJECT (tree_item->minus_pix_widget));
 266
 267   gtk_widget_set_parent (eventbox, GTK_WIDGET (tree_item));
 268 }
 269
 270
 271 GtkWidget*
 272 gtk_tree_item_new (void)
 273 {
 274   GtkWidget *tree_item;
 275
 276   tree_item = GTK_WIDGET (gtk_type_new (gtk_tree_item_get_type ()));
 277
 278   return tree_item;
 279 }
 280
 281 GtkWidget*
 282 gtk_tree_item_new_with_label (const gchar *label)
 283 {
 284   GtkWidget *tree_item;
 285   GtkWidget *label_widget;
 286
 287   tree_item = gtk_tree_item_new ();
 288   label_widget = gtk_label_new (label);
 289   gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
 290
 291   gtk_container_add (GTK_CONTAINER (tree_item), label_widget);
 292   gtk_widget_show (label_widget);
 293
 294
 295   return tree_item;
 296 }
 297
 298 void
 299 gtk_tree_item_set_subtree (GtkTreeItem *tree_item,
 300                            GtkWidget   *subtree)
 301 {
 302   g_return_if_fail (tree_item != NULL);
 303   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 304   g_return_if_fail (subtree != NULL);
 305   g_return_if_fail (GTK_IS_TREE (subtree));
 306
 307   if (tree_item->subtree)
 308     {
 309       g_warning("there is already a subtree for this tree item\n");
 310       return;
 311     }
 312
 313   tree_item->subtree = subtree;
 314   GTK_TREE (subtree)->tree_owner = GTK_WIDGET (tree_item);
 315
 316   /* show subtree button */
 317   if (tree_item->pixmaps_box)
 318     gtk_widget_show (tree_item->pixmaps_box);
 319
 320   if (tree_item->expanded)
 321     gtk_widget_show (subtree);
 322   else
 323     gtk_widget_hide (subtree);
 324
 325   gtk_widget_set_parent (subtree, GTK_WIDGET (tree_item)->parent);
 326
 327   if (GTK_WIDGET_REALIZED (subtree->parent))
 328     gtk_widget_realize (subtree);
 329
 330   if (GTK_WIDGET_VISIBLE (subtree->parent) && GTK_WIDGET_VISIBLE (subtree))
 331     {
 332       if (GTK_WIDGET_MAPPED (subtree->parent))
 333         gtk_widget_map (subtree);
 334
 335       gtk_widget_queue_resize (subtree);
 336     }
 337 }
 338
 339 void
 340 gtk_tree_item_select (GtkTreeItem *tree_item)
 341 {
 342   g_return_if_fail (tree_item != NULL);
 343   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 344
 345   gtk_item_select (GTK_ITEM (tree_item));
 346 }
 347
 348 void
 349 gtk_tree_item_deselect (GtkTreeItem *tree_item)
 350 {
 351   g_return_if_fail (tree_item != NULL);
 352   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 353
 354   gtk_item_deselect (GTK_ITEM (tree_item));
 355 }
 356
 357 void
 358 gtk_tree_item_expand (GtkTreeItem *tree_item)
 359 {
 360   g_return_if_fail (tree_item != NULL);
 361   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 362
 363   gtk_signal_emit (GTK_OBJECT (tree_item), tree_item_signals[EXPAND_TREE], NULL);
 364 }
 365
 366 void
 367 gtk_tree_item_collapse (GtkTreeItem *tree_item)
 368 {
 369   g_return_if_fail (tree_item != NULL);
 370   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 371
 372   gtk_signal_emit (GTK_OBJECT (tree_item), tree_item_signals[COLLAPSE_TREE], NULL);
 373 }
 374
 375 static void
 376 gtk_tree_item_add_pixmaps (GtkTreeItem *tree_item)
 377 {
 378   GList *tmp_list;
 379   GdkColormap *colormap;
 380   GtkTreePixmaps *pixmap_node = NULL;
 381
 382   g_return_if_fail (tree_item != NULL);
 383   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 384
 385   if (tree_item->pixmaps)
 386     return;
 387
 388   colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_item));
 389
 390   tmp_list = pixmaps;
 391   while (tmp_list)
 392     {
 393       pixmap_node = (GtkTreePixmaps *)tmp_list->data;
 394
 395       if (pixmap_node->colormap == colormap)
 396         break;
 397
 398       tmp_list = tmp_list->next;
 399     }
 400
 401   if (tmp_list)
 402     {
 403       pixmap_node->refcount++;
 404       tree_item->pixmaps = tmp_list;
 405     }
 406   else
 407     {
 408       pixmap_node = g_new (GtkTreePixmaps, 1);
 409
 410       pixmap_node->colormap = colormap;
 411       gdk_colormap_ref (colormap);
 412
 413       pixmap_node->refcount = 1;
 414
 415       /* create pixmaps for plus icon */
 416       pixmap_node->pixmap_plus =
 417         gdk_pixmap_create_from_xpm_d (GTK_WIDGET (tree_item)->window,
 418                                       &pixmap_node->mask_plus,
 419                                       NULL,
 420                                       tree_plus);
 421
 422       /* create pixmaps for minus icon */
 423       pixmap_node->pixmap_minus =
 424         gdk_pixmap_create_from_xpm_d (GTK_WIDGET (tree_item)->window,
 425                                       &pixmap_node->mask_minus,
 426                                       NULL,
 427                                       tree_minus);
 428
 429       tree_item->pixmaps = pixmaps = g_list_prepend (pixmaps, pixmap_node);
 430     }
 431
 432   gtk_pixmap_set (GTK_PIXMAP (tree_item->plus_pix_widget),
 433                   pixmap_node->pixmap_plus, pixmap_node->mask_plus);
 434   gtk_pixmap_set (GTK_PIXMAP (tree_item->minus_pix_widget),
 435                   pixmap_node->pixmap_minus, pixmap_node->mask_minus);
 436 }
 437
 438 static void
 439 gtk_tree_item_remove_pixmaps (GtkTreeItem *tree_item)
 440 {
 441   g_return_if_fail (tree_item != NULL);
 442   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 443
 444   if (tree_item->pixmaps)
 445     {
 446       GtkTreePixmaps *pixmap_node = (GtkTreePixmaps *)tree_item->pixmaps->data;
 447
 448       g_assert (pixmap_node->refcount > 0);
 449
 450       if (--pixmap_node->refcount == 0)
 451         {
 452           gdk_colormap_unref (pixmap_node->colormap);
 453           gdk_pixmap_unref (pixmap_node->pixmap_plus);
 454           gdk_bitmap_unref (pixmap_node->mask_plus);
 455           gdk_pixmap_unref (pixmap_node->pixmap_minus);
 456           gdk_bitmap_unref (pixmap_node->mask_minus);
 457
 458           pixmaps = g_list_remove_link (pixmaps, tree_item->pixmaps);
 459           g_list_free_1 (tree_item->pixmaps);
 460           g_free (pixmap_node);
 461         }
 462
 463       tree_item->pixmaps = NULL;
 464     }
 465 }
 466
 467 static void
 468 gtk_tree_item_realize (GtkWidget *widget)
 469 {
 470   g_return_if_fail (widget != NULL);
 471   g_return_if_fail (GTK_IS_TREE_ITEM (widget));
 472
 473   if (GTK_WIDGET_CLASS (parent_class)->realize)
 474     (* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
 475
 476   gdk_window_set_background (widget->window,
 477                              &widget->style->base[GTK_STATE_NORMAL]);
 478
 479   gtk_tree_item_add_pixmaps (GTK_TREE_ITEM (widget));
 480 }
 481
 482 static void
 483 gtk_tree_item_size_request (GtkWidget      *widget,
 484                             GtkRequisition *requisition)
 485 {
 486   GtkBin *bin;
 487   GtkTreeItem* item;
 488   GtkRequisition child_requisition;
 489
 490   g_return_if_fail (widget != NULL);
 491   g_return_if_fail (GTK_IS_TREE_ITEM (widget));
 492   g_return_if_fail (requisition != NULL);
 493
 494   bin = GTK_BIN (widget);
 495   item = GTK_TREE_ITEM(widget);
 496
 497   requisition->width = (GTK_CONTAINER (widget)->border_width +
 498                         widget->style->xthickness) * 2;
 499   requisition->height = GTK_CONTAINER (widget)->border_width * 2;
 500
 501   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 502     {
 503       GtkRequisition pix_requisition;
 504
 505       gtk_widget_size_request (bin->child, &child_requisition);
 506
 507       requisition->width += child_requisition.width;
 508
 509       gtk_widget_size_request (item->pixmaps_box,
 510                                &pix_requisition);
 511       requisition->width += pix_requisition.width + DEFAULT_DELTA +
 512         GTK_TREE (widget->parent)->current_indent;
 513
 514       requisition->height += MAX (child_requisition.height,
 515                                   pix_requisition.height);
 516     }
 517 }
 518
 519 static void
 520 gtk_tree_item_size_allocate (GtkWidget     *widget,
 521                              GtkAllocation *allocation)
 522 {
 523   GtkBin *bin;
 524   GtkTreeItem* item;
 525   GtkAllocation child_allocation;
 526   gint border_width;
 527   int temp;
 528
 529   g_return_if_fail (widget != NULL);
 530   g_return_if_fail (GTK_IS_TREE_ITEM (widget));
 531   g_return_if_fail (allocation != NULL);
 532
 533   widget->allocation = *allocation;
 534   if (GTK_WIDGET_REALIZED (widget))
 535     gdk_window_move_resize (widget->window,
 536                             allocation->x, allocation->y,
 537                             allocation->width, allocation->height);
 538
 539   bin = GTK_BIN (widget);
 540   item = GTK_TREE_ITEM(widget);
 541
 542   if (bin->child)
 543     {
 544       border_width = (GTK_CONTAINER (widget)->border_width +
 545                       widget->style->xthickness);
 546
 547       child_allocation.x = border_width + GTK_TREE(widget->parent)->current_indent;
 548       child_allocation.y = GTK_CONTAINER (widget)->border_width;
 549
 550       child_allocation.width = item->pixmaps_box->requisition.width;
 551       child_allocation.height = item->pixmaps_box->requisition.height;
 552
 553       temp = allocation->height - child_allocation.height;
 554       child_allocation.y += ( temp / 2 ) + ( temp % 2 );
 555
 556       gtk_widget_size_allocate (item->pixmaps_box, &child_allocation);
 557
 558       child_allocation.y = GTK_CONTAINER (widget)->border_width;
 559       child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
 560       child_allocation.x += item->pixmaps_box->requisition.width+DEFAULT_DELTA;
 561
 562       child_allocation.width =
 563         MAX (1, (gint)allocation->width - ((gint)child_allocation.x + border_width));
 564
 565       gtk_widget_size_allocate (bin->child, &child_allocation);
 566     }
 567 }
 568
 569 static void
 570 gtk_tree_item_draw_lines (GtkWidget *widget)
 571 {
 572   GtkTreeItem* item;
 573   GtkTree* tree;
 574   guint lx1, ly1, lx2, ly2;
 575
 576   g_return_if_fail (widget != NULL);
 577   g_return_if_fail (GTK_IS_TREE_ITEM (widget));
 578
 579   item = GTK_TREE_ITEM(widget);
 580   tree = GTK_TREE(widget->parent);
 581
 582   if (!tree->view_line)
 583     return;
 584
 585   /* draw vertical line */
 586   lx1 = item->pixmaps_box->allocation.width;
 587   lx1 = lx2 = ((lx1 / 2) + (lx1 % 2) +
 588                GTK_CONTAINER (widget)->border_width + 1 + tree->current_indent);
 589   ly1 = 0;
 590   ly2 = widget->allocation.height;
 591
 592   if (g_list_last (tree->children)->data == widget)
 593     ly2 = (ly2 / 2) + (ly2 % 2);
 594
 595   if (tree != tree->root_tree)
 596     gdk_draw_line (widget->window, widget->style->black_gc, lx1, ly1, lx2, ly2);
 597
 598   /* draw vertical line for subtree connecting */
 599   if(g_list_last(tree->children)->data != (gpointer)widget)
 600     ly2 = (ly2 / 2) + (ly2 % 2);
 601
 602   lx2 += DEFAULT_DELTA;
 603
 604   if (item->subtree && item->expanded)
 605     gdk_draw_line (widget->window, widget->style->black_gc,
 606                    lx2, ly2, lx2, widget->allocation.height);
 607
 608   /* draw horizontal line */
 609   ly1 = ly2;
 610   lx2 += 2;
 611
 612   gdk_draw_line (widget->window, widget->style->black_gc,
 613                  lx1, ly1, lx2, ly2);
 614
 615   lx2 -= DEFAULT_DELTA+2;
 616   ly1 = 0;
 617   ly2 = widget->allocation.height;
 618
 619   if (tree != tree->root_tree)
 620     {
 621       item = GTK_TREE_ITEM (tree->tree_owner);
 622       tree = GTK_TREE (GTK_WIDGET (tree)->parent);
 623       while (tree != tree->root_tree)
 624         {
 625           lx1 = lx2 -= tree->indent_value;
 626
 627           if (g_list_last (tree->children)->data != item)
 628             gdk_draw_line (widget->window, widget->style->black_gc, lx1, ly1, lx2, ly2);
 629           item = GTK_TREE_ITEM (tree->tree_owner);
 630           tree = GTK_TREE (GTK_WIDGET (tree)->parent);
 631         }
 632     }
 633 }
 634
 635 static void
 636 gtk_tree_item_paint (GtkWidget    *widget,
 637                      GdkRectangle *area)
 638 {
 639   GtkBin *bin;
 640   GdkRectangle child_area, item_area;
 641   GtkTreeItem* tree_item;
 642
 643   g_return_if_fail (widget != NULL);
 644   g_return_if_fail (GTK_IS_TREE_ITEM (widget));
 645   g_return_if_fail (area != NULL);
 646
 647   /* FIXME: We should honor tree->view_mode, here - I think
 648    * the desired effect is that when the mode is VIEW_ITEM,
 649    * only the subitem is drawn as selected, not the entire
 650    * line. (Like the way that the tree in Windows Explorer
 651    * works).
 652    */
 653   if (GTK_WIDGET_DRAWABLE (widget))
 654     {
 655       bin = GTK_BIN (widget);
 656       tree_item = GTK_TREE_ITEM(widget);
 657
 658       if (widget->state == GTK_STATE_NORMAL)
 659         {
 660           gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
 661           gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
 662         }
 663       else
 664         {
 665           if (!GTK_WIDGET_IS_SENSITIVE (widget))
 666             gtk_paint_flat_box(widget->style, widget->window,
 667                                widget->state, GTK_STATE_INSENSITIVE,
 668                                area, widget, "treeitem",
 669                                0, 0, -1, -1);
 670           else
 671             gtk_paint_flat_box(widget->style, widget->window,
 672                                widget->state, GTK_SHADOW_ETCHED_OUT,
 673                                area, widget, "treeitem",
 674                                0, 0, -1, -1);
 675         }
 676
 677       /* draw left size of tree item */
 678       item_area.x = 0;
 679       item_area.y = 0;
 680       item_area.width = (tree_item->pixmaps_box->allocation.width + DEFAULT_DELTA +
 681                          GTK_TREE (widget->parent)->current_indent + 2);
 682       item_area.height = widget->allocation.height;
 683
 684
 685       if (gdk_rectangle_intersect(&item_area, area, &child_area))
 686         {
 687
 688           gtk_tree_item_draw_lines(widget);
 689
 690           if (tree_item->pixmaps_box &&
 691               GTK_WIDGET_VISIBLE(tree_item->pixmaps_box) &&
 692               gtk_widget_intersect (tree_item->pixmaps_box, area, &child_area))
 693             gtk_widget_draw (tree_item->pixmaps_box, &child_area);
 694         }
 695
 696       if (GTK_WIDGET_HAS_FOCUS (widget))
 697         gtk_paint_focus (widget->style, widget->window,
 698                          NULL, widget, "treeitem",
 699                          0, 0,
 700                          widget->allocation.width - 1,
 701                          widget->allocation.height - 1);
 702
 703     }
 704 }
 705
 706 static void
 707 gtk_tree_item_draw_focus (GtkWidget *widget)
 708 {
 709   g_return_if_fail (widget != NULL);
 710   g_return_if_fail (GTK_IS_TREE_ITEM (widget));
 711
 712   gtk_widget_draw(widget, NULL);
 713 }
 714
 715 static gint
 716 gtk_tree_item_button_press (GtkWidget      *widget,
 717                             GdkEventButton *event)
 718 {
 719
 720   g_return_val_if_fail (widget != NULL, FALSE);
 721   g_return_val_if_fail (GTK_IS_TREE_ITEM (widget), FALSE);
 722   g_return_val_if_fail (event != NULL, FALSE);
 723
 724   if (event->type == GDK_BUTTON_PRESS
 725         && GTK_WIDGET_IS_SENSITIVE(widget)
 726         && !GTK_WIDGET_HAS_FOCUS (widget))
 727       gtk_widget_grab_focus (widget);
 728
 729   return FALSE;
 730 }
 731
 732 static gint
 733 gtk_tree_item_expose (GtkWidget      *widget,
 734                       GdkEventExpose *event)
 735 {
 736   GdkEventExpose child_event;
 737   GtkBin *bin;
 738
 739   g_return_val_if_fail (widget != NULL, FALSE);
 740   g_return_val_if_fail (GTK_IS_TREE_ITEM (widget), FALSE);
 741   g_return_val_if_fail (event != NULL, FALSE);
 742
 743   if (GTK_WIDGET_DRAWABLE (widget))
 744     {
 745       bin = GTK_BIN (widget);
 746
 747       gtk_tree_item_paint (widget, &event->area);
 748
 749       child_event = *event;
 750       if (bin->child && GTK_WIDGET_NO_WINDOW (bin->child) &&
 751           gtk_widget_intersect (bin->child, &event->area, &child_event.area))
 752         gtk_widget_event (bin->child, (GdkEvent*) &child_event);
 753    }
 754
 755   return FALSE;
 756 }
 757
 758 static gint
 759 gtk_tree_item_focus_in (GtkWidget     *widget,
 760                         GdkEventFocus *event)
 761 {
 762   g_return_val_if_fail (widget != NULL, FALSE);
 763   g_return_val_if_fail (GTK_IS_TREE_ITEM (widget), FALSE);
 764   g_return_val_if_fail (event != NULL, FALSE);
 765
 766   GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
 767   gtk_widget_draw_focus (widget);
 768
 769
 770   return FALSE;
 771 }
 772
 773 static gint
 774 gtk_tree_item_focus_out (GtkWidget     *widget,
 775                          GdkEventFocus *event)
 776 {
 777   g_return_val_if_fail (widget != NULL, FALSE);
 778   g_return_val_if_fail (GTK_IS_TREE_ITEM (widget), FALSE);
 779   g_return_val_if_fail (event != NULL, FALSE);
 780
 781   GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
 782   gtk_widget_draw_focus (widget);
 783
 784
 785   return FALSE;
 786 }
 787
 788 static void
 789 gtk_real_tree_item_select (GtkItem *item)
 790 {
 791   GtkTreeItem *tree_item;
 792   GtkWidget *widget;
 793
 794   g_return_if_fail (item != NULL);
 795   g_return_if_fail (GTK_IS_TREE_ITEM (item));
 796
 797   tree_item = GTK_TREE_ITEM (item);
 798   widget = GTK_WIDGET (item);
 799
 800   gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_SELECTED);
 801
 802   if (!widget->parent || GTK_TREE (widget->parent)->view_mode == GTK_TREE_VIEW_LINE)
 803     gtk_widget_set_state (GTK_TREE_ITEM (item)->pixmaps_box, GTK_STATE_SELECTED);
 804 }
 805
 806 static void
 807 gtk_real_tree_item_deselect (GtkItem *item)
 808 {
 809   GtkTreeItem *tree_item;
 810   GtkWidget *widget;
 811
 812   g_return_if_fail (item != NULL);
 813   g_return_if_fail (GTK_IS_TREE_ITEM (item));
 814
 815   tree_item = GTK_TREE_ITEM (item);
 816   widget = GTK_WIDGET (item);
 817
 818   gtk_widget_set_state (widget, GTK_STATE_NORMAL);
 819
 820   if (!widget->parent || GTK_TREE (widget->parent)->view_mode == GTK_TREE_VIEW_LINE)
 821     gtk_widget_set_state (tree_item->pixmaps_box, GTK_STATE_NORMAL);
 822 }
 823
 824 static void
 825 gtk_real_tree_item_toggle (GtkItem *item)
 826 {
 827   g_return_if_fail (item != NULL);
 828   g_return_if_fail (GTK_IS_TREE_ITEM (item));
 829
 830   if(!GTK_WIDGET_IS_SENSITIVE(item))
 831     return;
 832
 833   if (GTK_WIDGET (item)->parent && GTK_IS_TREE (GTK_WIDGET (item)->parent))
 834     gtk_tree_select_child (GTK_TREE (GTK_WIDGET (item)->parent),
 835                            GTK_WIDGET (item));
 836   else
 837     {
 838       /* Should we really bother with this bit? A listitem not in a list?
 839        * -Johannes Keukelaar
 840        * yes, always be on the safe side!
 841        * -timj
 842        */
 843       if (GTK_WIDGET (item)->state == GTK_STATE_SELECTED)
 844         gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_NORMAL);
 845       else
 846         gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_SELECTED);
 847     }
 848 }
 849
 850 static void
 851 gtk_real_tree_item_expand (GtkTreeItem *tree_item)
 852 {
 853   GtkTree* tree;
 854
 855   g_return_if_fail (tree_item != NULL);
 856   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 857
 858   if (tree_item->subtree && !tree_item->expanded)
 859     {
 860       tree = GTK_TREE (GTK_WIDGET (tree_item)->parent);
 861
 862       /* hide subtree widget */
 863       gtk_widget_show (tree_item->subtree);
 864
 865       /* hide button '+' and show button '-' */
 866       if (tree_item->pixmaps_box)
 867         {
 868           gtk_container_remove (GTK_CONTAINER (tree_item->pixmaps_box),
 869                                 tree_item->plus_pix_widget);
 870           gtk_container_add (GTK_CONTAINER (tree_item->pixmaps_box),
 871                              tree_item->minus_pix_widget);
 872         }
 873       if (tree->root_tree)
 874         gtk_widget_queue_resize (GTK_WIDGET (tree->root_tree));
 875       tree_item->expanded = TRUE;
 876     }
 877 }
 878
 879 static void
 880 gtk_real_tree_item_collapse (GtkTreeItem *tree_item)
 881 {
 882   GtkTree* tree;
 883
 884   g_return_if_fail (tree_item != NULL);
 885   g_return_if_fail (GTK_IS_TREE_ITEM (tree_item));
 886
 887   if (tree_item->subtree && tree_item->expanded)
 888     {
 889       tree = GTK_TREE (GTK_WIDGET (tree_item)->parent);
 890
 891       /* hide subtree widget */
 892       gtk_widget_hide (tree_item->subtree);
 893
 894       /* hide button '-' and show button '+' */
 895       if (tree_item->pixmaps_box)
 896         {
 897           gtk_container_remove (GTK_CONTAINER (tree_item->pixmaps_box),
 898                                 tree_item->minus_pix_widget);
 899           gtk_container_add (GTK_CONTAINER (tree_item->pixmaps_box),
 900                              tree_item->plus_pix_widget);
 901         }
 902       if (tree->root_tree)
 903         gtk_widget_queue_resize (GTK_WIDGET (tree->root_tree));
 904       tree_item->expanded = FALSE;
 905     }
 906 }
 907
 908 static void
 909 gtk_tree_item_destroy (GtkObject *object)
 910 {
 911   GtkTreeItem* item;
 912   GtkWidget* child;
 913
 914   g_return_if_fail (object != NULL);
 915   g_return_if_fail (GTK_IS_TREE_ITEM (object));
 916
 917 #ifdef TREE_DEBUG
 918   g_message("+ gtk_tree_item_destroy [object %#x]\n", (int)object);
 919 #endif /* TREE_DEBUG */
 920
 921   item = GTK_TREE_ITEM(object);
 922
 923   /* free sub tree if it exist */
 924   child = item->subtree;
 925   if (child)
 926     {
 927       gtk_widget_ref (child);
 928       gtk_widget_unparent (child);
 929       gtk_widget_destroy (child);
 930       gtk_widget_unref (child);
 931       item->subtree = NULL;
 932     }
 933
 934   /* free pixmaps box */
 935   child = item->pixmaps_box;
 936   if (child)
 937     {
 938       gtk_widget_ref (child);
 939       gtk_widget_unparent (child);
 940       gtk_widget_destroy (child);
 941       gtk_widget_unref (child);
 942       item->pixmaps_box = NULL;
 943     }
 944
 945
 946   /* destroy plus pixmap */
 947   if (item->plus_pix_widget)
 948     {
 949       gtk_widget_destroy (item->plus_pix_widget);
 950       gtk_widget_unref (item->plus_pix_widget);
 951       item->plus_pix_widget = NULL;
 952     }
 953
 954   /* destroy minus pixmap */
 955   if (item->minus_pix_widget)
 956     {
 957       gtk_widget_destroy (item->minus_pix_widget);
 958       gtk_widget_unref (item->minus_pix_widget);
 959       item->minus_pix_widget = NULL;
 960     }
 961
 962   /* By removing the pixmaps here, and not in unrealize, we depend on
 963    * the fact that a widget can never change colormap or visual.
 964    */
 965   gtk_tree_item_remove_pixmaps (item);
 966
 967   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 968
 969 #ifdef TREE_DEBUG
 970   g_message("- gtk_tree_item_destroy\n");
 971 #endif /* TREE_DEBUG */
 972 }
 973
 974 void
 975 gtk_tree_item_remove_subtree (GtkTreeItem* item)
 976 {
 977   g_return_if_fail (item != NULL);
 978   g_return_if_fail (GTK_IS_TREE_ITEM(item));
 979   g_return_if_fail (item->subtree != NULL);
 980
 981   if (GTK_TREE (item->subtree)->children)
 982     {
 983       /* The following call will remove the children and call
 984        * gtk_tree_item_remove_subtree() again. So we are done.
 985        */
 986       gtk_tree_remove_items (GTK_TREE (item->subtree),
 987                              GTK_TREE (item->subtree)->children);
 988       return;
 989     }
 990
 991   if (GTK_WIDGET_MAPPED (item->subtree))
 992     gtk_widget_unmap (item->subtree);
 993
 994   gtk_widget_unparent (item->subtree);
 995
 996   if (item->pixmaps_box)
 997     gtk_widget_hide (item->pixmaps_box);
 998
 999   item->subtree = NULL;
1000
1001   if (item->expanded)
1002     {
1003       item->expanded = FALSE;
1004       if (item->pixmaps_box)
1005         {
1006           gtk_container_remove (GTK_CONTAINER (item->pixmaps_box),
1007                                 item->minus_pix_widget);
1008           gtk_container_add (GTK_CONTAINER (item->pixmaps_box),
1009                              item->plus_pix_widget);
1010         }
1011     }
1012 }
1013
1014 static void
1015 gtk_tree_item_map (GtkWidget *widget)
1016 {
1017   GtkBin *bin;
1018   GtkTreeItem* item;
1019
1020   g_return_if_fail (widget != NULL);
1021   g_return_if_fail (GTK_IS_TREE_ITEM (widget));
1022
1023   bin = GTK_BIN (widget);
1024   item = GTK_TREE_ITEM(widget);
1025
1026   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
1027
1028   if(item->pixmaps_box &&
1029      GTK_WIDGET_VISIBLE (item->pixmaps_box) &&
1030      !GTK_WIDGET_MAPPED (item->pixmaps_box))
1031     gtk_widget_map (item->pixmaps_box);
1032
1033   if (bin->child &&
1034       GTK_WIDGET_VISIBLE (bin->child) &&
1035       !GTK_WIDGET_MAPPED (bin->child))
1036     gtk_widget_map (bin->child);
1037
1038   gdk_window_show (widget->window);
1039 }
1040
1041 static void
1042 gtk_tree_item_unmap (GtkWidget *widget)
1043 {
1044   GtkBin *bin;
1045   GtkTreeItem* item;
1046
1047   g_return_if_fail (widget != NULL);
1048   g_return_if_fail (GTK_IS_TREE_ITEM (widget));
1049
1050   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
1051   bin = GTK_BIN (widget);
1052   item = GTK_TREE_ITEM(widget);
1053
1054   gdk_window_hide (widget->window);
1055
1056   if(item->pixmaps_box &&
1057      GTK_WIDGET_VISIBLE (item->pixmaps_box) &&
1058      GTK_WIDGET_MAPPED (item->pixmaps_box))
1059     gtk_widget_unmap (bin->child);
1060
1061   if (bin->child &&
1062       GTK_WIDGET_VISIBLE (bin->child) &&
1063       GTK_WIDGET_MAPPED (bin->child))
1064     gtk_widget_unmap (bin->child);
1065 }
1066
1067 static void
1068 gtk_tree_item_forall (GtkContainer *container,
1069                       gboolean      include_internals,
1070                       GtkCallback   callback,
1071                       gpointer      callback_data)
1072 {
1073   GtkBin *bin;
1074   GtkTreeItem *tree_item;
1075
1076   g_return_if_fail (container != NULL);
1077   g_return_if_fail (GTK_IS_TREE_ITEM (container));
1078   g_return_if_fail (callback != NULL);
1079
1080   bin = GTK_BIN (container);
1081   tree_item = GTK_TREE_ITEM (container);
1082
1083   if (bin->child)
1084     (* callback) (bin->child, callback_data);
1085   if (include_internals && tree_item->subtree)
1086     (* callback) (tree_item->subtree, callback_data);
1087 }