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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  * GtkToolbar copyright (C) Federico Mena
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the Free
  17  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #include "gtkbutton.h"
  21 #include "gtklabel.h"
  22 #include "gtkvbox.h"
  23 #include "gtktoolbar.h"
  24
  25
  26 #define DEFAULT_SPACE_SIZE 5
  27
  28
  29 enum {
  30   ORIENTATION_CHANGED,
  31   STYLE_CHANGED,
  32   LAST_SIGNAL
  33 };
  34
  35 typedef void (*GtkToolbarSignal1) (GtkObject *object,
  36                                    gint       arg1,
  37                                    gpointer   data);
  38
  39 static void gtk_toolbar_marshal_signal_1 (GtkObject     *object,
  40                                           GtkSignalFunc  func,
  41                                           gpointer       func_data,
  42                                           GtkArg        *args);
  43
  44
  45 static void gtk_toolbar_class_init               (GtkToolbarClass *class);
  46 static void gtk_toolbar_init                     (GtkToolbar      *toolbar);
  47 static void gtk_toolbar_destroy                  (GtkObject       *object);
  48 static void gtk_toolbar_map                      (GtkWidget       *widget);
  49 static void gtk_toolbar_unmap                    (GtkWidget       *widget);
  50 static void gtk_toolbar_draw                     (GtkWidget       *widget,
  51                                                   GdkRectangle    *area);
  52 static gint gtk_toolbar_expose                   (GtkWidget       *widget,
  53                                                   GdkEventExpose  *event);
  54 static void gtk_toolbar_size_request             (GtkWidget       *widget,
  55                                                   GtkRequisition  *requisition);
  56 static void gtk_toolbar_size_allocate            (GtkWidget       *widget,
  57                                                   GtkAllocation   *allocation);
  58 static void gtk_toolbar_add                      (GtkContainer    *container,
  59                                                   GtkWidget       *widget);
  60 static void gtk_toolbar_remove                   (GtkContainer    *container,
  61                                                   GtkWidget       *widget);
  62 static void gtk_toolbar_foreach                  (GtkContainer    *container,
  63                                                   GtkCallback      callback,
  64                                                   gpointer         callback_data);
  65 static void gtk_real_toolbar_orientation_changed (GtkToolbar      *toolbar,
  66                                                   GtkOrientation   orientation);
  67 static void gtk_real_toolbar_style_changed       (GtkToolbar      *toolbar,
  68                                                   GtkToolbarStyle  style);
  69
  70
  71 static GtkContainerClass *parent_class;
  72
  73 static gint toolbar_signals[LAST_SIGNAL] = { 0 };
  74
  75
  76 guint
  77 gtk_toolbar_get_type (void)
  78 {
  79   static guint toolbar_type = 0;
  80
  81   if (!toolbar_type)
  82     {
  83       GtkTypeInfo toolbar_info =
  84       {
  85         "GtkToolbar",
  86         sizeof (GtkToolbar),
  87         sizeof (GtkToolbarClass),
  88         (GtkClassInitFunc) gtk_toolbar_class_init,
  89         (GtkObjectInitFunc) gtk_toolbar_init,
  90         (GtkArgSetFunc) NULL,
  91         (GtkArgGetFunc) NULL,
  92       };
  93
  94       toolbar_type = gtk_type_unique (gtk_container_get_type (), &toolbar_info);
  95     }
  96
  97   return toolbar_type;
  98 }
  99
 100 static void
 101 gtk_toolbar_class_init (GtkToolbarClass *class)
 102 {
 103   GtkObjectClass *object_class;
 104   GtkWidgetClass *widget_class;
 105   GtkContainerClass *container_class;
 106
 107   object_class = (GtkObjectClass *) class;
 108   widget_class = (GtkWidgetClass *) class;
 109   container_class = (GtkContainerClass *) class;
 110
 111   parent_class = gtk_type_class (gtk_container_get_type ());
 112
 113   toolbar_signals[ORIENTATION_CHANGED] =
 114     gtk_signal_new ("orientation_changed",
 115                     GTK_RUN_FIRST,
 116                     object_class->type,
 117                     GTK_SIGNAL_OFFSET (GtkToolbarClass, orientation_changed),
 118                     gtk_toolbar_marshal_signal_1,
 119                     GTK_TYPE_NONE, 1,
 120                     GTK_TYPE_INT);
 121   toolbar_signals[STYLE_CHANGED] =
 122     gtk_signal_new ("style_changed",
 123                     GTK_RUN_FIRST,
 124                     object_class->type,
 125                     GTK_SIGNAL_OFFSET (GtkToolbarClass, style_changed),
 126                     gtk_toolbar_marshal_signal_1,
 127                     GTK_TYPE_NONE, 1,
 128                     GTK_TYPE_INT);
 129
 130   gtk_object_class_add_signals (object_class, toolbar_signals, LAST_SIGNAL);
 131
 132   object_class->destroy = gtk_toolbar_destroy;
 133
 134   widget_class->map = gtk_toolbar_map;
 135   widget_class->unmap = gtk_toolbar_unmap;
 136   widget_class->draw = gtk_toolbar_draw;
 137   widget_class->expose_event = gtk_toolbar_expose;
 138   widget_class->size_request = gtk_toolbar_size_request;
 139   widget_class->size_allocate = gtk_toolbar_size_allocate;
 140
 141   container_class->add = gtk_toolbar_add;
 142   container_class->remove = gtk_toolbar_remove;
 143   container_class->foreach = gtk_toolbar_foreach;
 144   container_class->focus = NULL;
 145
 146   class->orientation_changed = gtk_real_toolbar_orientation_changed;
 147   class->style_changed = gtk_real_toolbar_style_changed;
 148 }
 149
 150 static void
 151 gtk_toolbar_init (GtkToolbar *toolbar)
 152 {
 153   GTK_WIDGET_SET_FLAGS (toolbar, GTK_NO_WINDOW);
 154   GTK_WIDGET_UNSET_FLAGS (toolbar, GTK_CAN_FOCUS);
 155
 156   toolbar->num_children = 0;
 157   toolbar->children     = NULL;
 158   toolbar->orientation  = GTK_ORIENTATION_HORIZONTAL;
 159   toolbar->style        = GTK_TOOLBAR_ICONS;
 160   toolbar->space_size   = DEFAULT_SPACE_SIZE;
 161   toolbar->tooltips     = gtk_tooltips_new ();
 162   toolbar->button_maxw  = 0;
 163   toolbar->button_maxh  = 0;
 164 }
 165
 166 GtkWidget *
 167 gtk_toolbar_new (GtkOrientation  orientation,
 168                  GtkToolbarStyle style)
 169 {
 170   GtkToolbar *toolbar;
 171
 172   toolbar = gtk_type_new (gtk_toolbar_get_type ());
 173
 174   toolbar->orientation = orientation;
 175   toolbar->style = style;
 176
 177   return GTK_WIDGET (toolbar);
 178 }
 179
 180 static void
 181 gtk_toolbar_destroy (GtkObject *object)
 182 {
 183   GtkToolbar *toolbar;
 184   GList      *children;
 185   GtkToolbarChild      *child;
 186
 187   g_return_if_fail (object != NULL);
 188   g_return_if_fail (GTK_IS_TOOLBAR (object));
 189
 190   toolbar = GTK_TOOLBAR (object);
 191
 192   gtk_object_unref (GTK_OBJECT (toolbar->tooltips));
 193
 194   for (children = toolbar->children; children; children = children->next)
 195     {
 196       child = children->data;
 197
 198       if (child->type != GTK_TOOLBAR_CHILD_SPACE)
 199         {
 200           child->widget->parent = NULL;
 201           gtk_object_unref (GTK_OBJECT (child->widget));
 202           gtk_widget_destroy (child->widget);
 203         }
 204
 205       g_free (child);
 206     }
 207
 208   g_list_free (toolbar->children);
 209
 210   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 211     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 212 }
 213
 214 static void
 215 gtk_toolbar_map (GtkWidget *widget)
 216 {
 217   GtkToolbar *toolbar;
 218   GList      *children;
 219   GtkToolbarChild      *child;
 220
 221   g_return_if_fail (widget != NULL);
 222   g_return_if_fail (GTK_IS_TOOLBAR (widget));
 223
 224   toolbar = GTK_TOOLBAR (widget);
 225   GTK_WIDGET_SET_FLAGS (toolbar, GTK_MAPPED);
 226
 227   for (children = toolbar->children; children; children = children->next)
 228     {
 229       child = children->data;
 230
 231       if ((child->type != GTK_TOOLBAR_CHILD_SPACE)
 232           && GTK_WIDGET_VISIBLE (child->widget) && !GTK_WIDGET_MAPPED (child->widget))
 233         gtk_widget_map (child->widget);
 234     }
 235 }
 236
 237 static void
 238 gtk_toolbar_unmap (GtkWidget *widget)
 239 {
 240   GtkToolbar *toolbar;
 241   GList      *children;
 242   GtkToolbarChild      *child;
 243
 244   g_return_if_fail (widget != NULL);
 245   g_return_if_fail (GTK_IS_TOOLBAR (widget));
 246
 247   toolbar = GTK_TOOLBAR (widget);
 248   GTK_WIDGET_UNSET_FLAGS (toolbar, GTK_MAPPED);
 249
 250   for (children = toolbar->children; children; children = children->next)
 251     {
 252       child = children->data;
 253
 254       if ((child->type != GTK_TOOLBAR_CHILD_SPACE)
 255           && GTK_WIDGET_VISIBLE (child->widget) && GTK_WIDGET_MAPPED (child->widget))
 256         gtk_widget_unmap (child->widget);
 257     }
 258 }
 259
 260 static void
 261 gtk_toolbar_draw (GtkWidget    *widget,
 262                   GdkRectangle *area)
 263 {
 264   GtkToolbar   *toolbar;
 265   GList        *children;
 266   GtkToolbarChild        *child;
 267   GdkRectangle  child_area;
 268
 269   g_return_if_fail (widget != NULL);
 270   g_return_if_fail (GTK_IS_TOOLBAR (widget));
 271
 272   if (GTK_WIDGET_DRAWABLE (widget))
 273     {
 274       toolbar = GTK_TOOLBAR (widget);
 275
 276       for (children = toolbar->children; children; children = children->next)
 277         {
 278           child = children->data;
 279
 280           if ((child->type != GTK_TOOLBAR_CHILD_SPACE)
 281               && gtk_widget_intersect (child->widget, area, &child_area))
 282             gtk_widget_draw (child->widget, &child_area);
 283         }
 284     }
 285 }
 286
 287 static gint
 288 gtk_toolbar_expose (GtkWidget      *widget,
 289                     GdkEventExpose *event)
 290 {
 291   GtkToolbar     *toolbar;
 292   GList          *children;
 293   GtkToolbarChild          *child;
 294   GdkEventExpose  child_event;
 295
 296   g_return_val_if_fail (widget != NULL, FALSE);
 297   g_return_val_if_fail (GTK_IS_TOOLBAR (widget), FALSE);
 298   g_return_val_if_fail (event != NULL, FALSE);
 299
 300   if (GTK_WIDGET_DRAWABLE (widget))
 301     {
 302       toolbar = GTK_TOOLBAR (widget);
 303
 304       child_event = *event;
 305
 306       for (children = toolbar->children; children; children = children->next)
 307         {
 308           child = children->data;
 309
 310           if ((child->type != GTK_TOOLBAR_CHILD_SPACE)
 311               && GTK_WIDGET_NO_WINDOW (child->widget)
 312               && gtk_widget_intersect (child->widget, &event->area, &child_event.area))
 313             gtk_widget_event (child->widget, (GdkEvent *) &child_event);
 314         }
 315     }
 316
 317   return FALSE;
 318 }
 319
 320 static void
 321 gtk_toolbar_size_request (GtkWidget      *widget,
 322                           GtkRequisition *requisition)
 323 {
 324   GtkToolbar *toolbar;
 325   GList      *children;
 326   GtkToolbarChild      *child;
 327   gint        nbuttons;
 328   gint        button_maxw, button_maxh;
 329   gint        widget_maxw, widget_maxh;
 330
 331   g_return_if_fail (widget != NULL);
 332   g_return_if_fail (GTK_IS_TOOLBAR (widget));
 333   g_return_if_fail (requisition != NULL);
 334
 335   toolbar = GTK_TOOLBAR (widget);
 336
 337   requisition->width = GTK_CONTAINER (toolbar)->border_width * 2;
 338   requisition->height = GTK_CONTAINER (toolbar)->border_width * 2;
 339   nbuttons = 0;
 340   button_maxw = 0;
 341   button_maxh = 0;
 342   widget_maxw = 0;
 343   widget_maxh = 0;
 344
 345   for (children = toolbar->children; children; children = children->next)
 346     {
 347       child = children->data;
 348
 349       switch (child->type)
 350         {
 351         case GTK_TOOLBAR_CHILD_SPACE:
 352           if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 353             requisition->width += toolbar->space_size;
 354           else
 355             requisition->height += toolbar->space_size;
 356
 357           break;
 358
 359         case GTK_TOOLBAR_CHILD_BUTTON:
 360           if (GTK_WIDGET_VISIBLE (child->widget))
 361             {
 362               gtk_widget_size_request (child->widget, &child->widget->requisition);
 363
 364               nbuttons++;
 365               button_maxw = MAX (button_maxw, child->widget->requisition.width);
 366               button_maxh = MAX (button_maxh, child->widget->requisition.height);
 367             }
 368
 369           break;
 370
 371         case GTK_TOOLBAR_CHILD_WIDGET:
 372           if (GTK_WIDGET_VISIBLE (child->widget))
 373             {
 374               gtk_widget_size_request (child->widget, &child->widget->requisition);
 375
 376               widget_maxw = MAX (widget_maxw, child->widget->requisition.width);
 377               widget_maxh = MAX (widget_maxh, child->widget->requisition.height);
 378
 379               if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 380                 requisition->width += child->widget->requisition.width;
 381               else
 382                 requisition->height += child->widget->requisition.height;
 383             }
 384
 385           break;
 386
 387         default:
 388           g_assert_not_reached ();
 389         }
 390     }
 391
 392   if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 393     {
 394       requisition->width += nbuttons * button_maxw;
 395       requisition->height += MAX (button_maxh, widget_maxh);
 396     }
 397   else
 398     {
 399       requisition->width += MAX (button_maxw, widget_maxw);
 400       requisition->height += nbuttons * button_maxh;
 401     }
 402
 403   toolbar->button_maxw = button_maxw;
 404   toolbar->button_maxh = button_maxh;
 405 }
 406
 407 static void
 408 gtk_toolbar_size_allocate (GtkWidget     *widget,
 409                            GtkAllocation *allocation)
 410 {
 411   GtkToolbar     *toolbar;
 412   GList          *children;
 413   GtkToolbarChild          *child;
 414   GtkAllocation   alloc;
 415   gint            border_width;
 416
 417   g_return_if_fail (widget != NULL);
 418   g_return_if_fail (GTK_IS_TOOLBAR (widget));
 419   g_return_if_fail (allocation != NULL);
 420
 421   toolbar = GTK_TOOLBAR (widget);
 422   widget->allocation = *allocation;
 423
 424   border_width = GTK_CONTAINER (toolbar)->border_width;
 425
 426   if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 427     alloc.x = allocation->x + border_width;
 428   else
 429     alloc.y = allocation->y + border_width;
 430
 431   for (children = toolbar->children; children; children = children->next)
 432     {
 433       child = children->data;
 434
 435       switch (child->type)
 436         {
 437         case GTK_TOOLBAR_CHILD_SPACE:
 438           if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 439             alloc.x += toolbar->space_size;
 440           else
 441             alloc.y += toolbar->space_size;
 442
 443           break;
 444
 445         case GTK_TOOLBAR_CHILD_BUTTON:
 446           alloc.width = toolbar->button_maxw;
 447           alloc.height = toolbar->button_maxh;
 448
 449           if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 450             alloc.y = allocation->y + (allocation->height - toolbar->button_maxh) / 2;
 451           else
 452             alloc.x = allocation->x + (allocation->width - toolbar->button_maxw) / 2;
 453
 454           gtk_widget_size_allocate (child->widget, &alloc);
 455
 456           if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 457             alloc.x += toolbar->button_maxw;
 458           else
 459             alloc.y += toolbar->button_maxh;
 460
 461           break;
 462
 463         case GTK_TOOLBAR_CHILD_WIDGET:
 464           alloc.width = child->widget->requisition.width;
 465           alloc.height = child->widget->requisition.height;
 466
 467           if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 468             alloc.y = allocation->y + (allocation->height - child->widget->requisition.height) / 2;
 469           else
 470             alloc.x = allocation->x + (allocation->width - child->widget->requisition.width) / 2;
 471
 472           gtk_widget_size_allocate (child->widget, &alloc);
 473
 474           if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
 475             alloc.x += child->widget->requisition.width;
 476           else
 477             alloc.y += child->widget->requisition.height;
 478
 479           break;
 480
 481         default:
 482           g_assert_not_reached ();
 483         }
 484     }
 485 }
 486
 487 static void
 488 gtk_toolbar_add (GtkContainer *container,
 489                  GtkWidget    *widget)
 490 {
 491   g_return_if_fail (container != NULL);
 492   g_return_if_fail (GTK_IS_TOOLBAR (container));
 493   g_return_if_fail (widget != NULL);
 494
 495   gtk_toolbar_append_widget (GTK_TOOLBAR (container), widget, NULL);
 496 }
 497
 498 static void
 499 gtk_toolbar_remove (GtkContainer *container,
 500                     GtkWidget    *widget)
 501 {
 502   GtkToolbar *toolbar;
 503   GList      *children;
 504   GtkToolbarChild      *child;
 505
 506   g_return_if_fail (container != NULL);
 507   g_return_if_fail (GTK_IS_TOOLBAR (container));
 508   g_return_if_fail (widget != NULL);
 509
 510   toolbar = GTK_TOOLBAR (container);
 511
 512   for (children = toolbar->children; children; children = children->next)
 513     {
 514       child = children->data;
 515
 516       if ((child->type != GTK_TOOLBAR_CHILD_SPACE) && (child->widget == widget))
 517         {
 518           gtk_widget_unparent (widget);
 519
 520           toolbar->children = g_list_remove_link (toolbar->children, children);
 521           g_free (child);
 522           g_list_free (children);
 523           toolbar->num_children--;
 524
 525           if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (container))
 526             gtk_widget_queue_resize (GTK_WIDGET (container));
 527
 528           break;
 529         }
 530     }
 531 }
 532
 533 static void
 534 gtk_toolbar_foreach (GtkContainer *container,
 535                      GtkCallback   callback,
 536                      gpointer      callback_data)
 537 {
 538   GtkToolbar *toolbar;
 539   GList      *children;
 540   GtkToolbarChild      *child;
 541
 542   g_return_if_fail (container != NULL);
 543   g_return_if_fail (GTK_IS_TOOLBAR (container));
 544   g_return_if_fail (callback != NULL);
 545
 546   toolbar = GTK_TOOLBAR (container);
 547
 548   for (children = toolbar->children; children; children = children->next)
 549     {
 550       child = children->data;
 551
 552       if (child->type != GTK_TOOLBAR_CHILD_SPACE)
 553         (*callback) (child->widget, callback_data);
 554     }
 555 }
 556
 557 GtkWidget *
 558 gtk_toolbar_append_item (GtkToolbar    *toolbar,
 559                          const char    *text,
 560                          const char    *tooltip_text,
 561                          GtkWidget     *icon,
 562                          GtkSignalFunc  callback,
 563                          gpointer       user_data)
 564 {
 565   return gtk_toolbar_insert_item (toolbar, text, tooltip_text, icon,
 566                                   callback, user_data, toolbar->num_children);
 567 }
 568
 569 GtkWidget *
 570 gtk_toolbar_prepend_item (GtkToolbar    *toolbar,
 571                           const char    *text,
 572                           const char    *tooltip_text,
 573                           GtkWidget     *icon,
 574                           GtkSignalFunc  callback,
 575                           gpointer       user_data)
 576 {
 577   return gtk_toolbar_insert_item (toolbar, text, tooltip_text, icon,
 578                                   callback, user_data, 0);
 579 }
 580
 581 GtkWidget *
 582 gtk_toolbar_insert_item (GtkToolbar    *toolbar,
 583                          const char    *text,
 584                          const char    *tooltip_text,
 585                          GtkWidget     *icon,
 586                          GtkSignalFunc  callback,
 587                          gpointer       user_data,
 588                          gint           position)
 589 {
 590   GtkToolbarChild     *child;
 591   GtkWidget *vbox;
 592
 593   g_return_val_if_fail (toolbar != NULL, NULL);
 594   g_return_val_if_fail (GTK_IS_TOOLBAR (toolbar), NULL);
 595
 596   child = g_new (GtkToolbarChild, 1);
 597
 598   child->type = GTK_TOOLBAR_CHILD_BUTTON;
 599   child->widget = gtk_button_new ();
 600
 601   if (callback)
 602     gtk_signal_connect (GTK_OBJECT (child->widget), "clicked",
 603                         callback, user_data);
 604
 605   if (tooltip_text)
 606     gtk_tooltips_set_tips (toolbar->tooltips, child->widget, tooltip_text);
 607
 608   if (text)
 609     child->label = gtk_label_new (text);
 610   else
 611     child->label = NULL;
 612
 613   if (icon)
 614     child->icon = GTK_WIDGET (icon);
 615   else
 616     child->icon = NULL;
 617
 618   vbox = gtk_vbox_new (FALSE, 0);
 619   gtk_container_add (GTK_CONTAINER (child->widget), vbox);
 620   gtk_widget_show (vbox);
 621
 622   if (child->icon)
 623     gtk_box_pack_start (GTK_BOX (vbox), child->icon, FALSE, FALSE, 0);
 624
 625   if (child->label)
 626     gtk_box_pack_start (GTK_BOX (vbox), child->label, FALSE, FALSE, 0);
 627
 628   switch (toolbar->style)
 629     {
 630     case GTK_TOOLBAR_ICONS:
 631       if (child->icon)
 632         gtk_widget_show (child->icon);
 633       break;
 634
 635     case GTK_TOOLBAR_TEXT:
 636       if (child->label)
 637         gtk_widget_show (child->label);
 638       break;
 639
 640     case GTK_TOOLBAR_BOTH:
 641       if (child->icon)
 642         gtk_widget_show (child->icon);
 643
 644       if (child->label)
 645         gtk_widget_show (child->label);
 646
 647       break;
 648
 649     default:
 650       g_assert_not_reached ();
 651     }
 652
 653   gtk_widget_show (child->widget);
 654
 655   toolbar->children = g_list_insert (toolbar->children, child, position);
 656   toolbar->num_children++;
 657
 658   gtk_widget_set_parent (child->widget, GTK_WIDGET (toolbar));
 659
 660   if (GTK_WIDGET_VISIBLE (toolbar))
 661     {
 662       if (GTK_WIDGET_REALIZED (toolbar)
 663           && !GTK_WIDGET_REALIZED (child->widget))
 664         gtk_widget_realize (child->widget);
 665
 666       if (GTK_WIDGET_MAPPED (toolbar)
 667           && !GTK_WIDGET_MAPPED (child->widget))
 668         gtk_widget_map (child->widget);
 669     }
 670
 671   if (GTK_WIDGET_VISIBLE (child->widget) && GTK_WIDGET_VISIBLE (toolbar))
 672     gtk_widget_queue_resize (child->widget);
 673
 674   return child->widget;
 675 }
 676
 677 void
 678 gtk_toolbar_append_space (GtkToolbar *toolbar)
 679 {
 680   gtk_toolbar_insert_space (toolbar, toolbar->num_children);
 681 }
 682
 683 void
 684 gtk_toolbar_prepend_space (GtkToolbar *toolbar)
 685 {
 686   gtk_toolbar_insert_space (toolbar, 0);
 687 }
 688
 689 void
 690 gtk_toolbar_insert_space (GtkToolbar *toolbar,
 691                           gint        position)
 692 {
 693   GtkToolbarChild *child;
 694
 695   g_return_if_fail (toolbar != NULL);
 696   g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
 697
 698   child = g_new (GtkToolbarChild, 1);
 699   child->type   = GTK_TOOLBAR_CHILD_SPACE;
 700   child->widget = NULL;
 701   child->icon   = NULL;
 702   child->label  = NULL;
 703
 704   toolbar->children = g_list_insert (toolbar->children, child, position);
 705   toolbar->num_children++;
 706
 707   if (GTK_WIDGET_VISIBLE (toolbar))
 708     gtk_widget_queue_resize (GTK_WIDGET (toolbar));
 709 }
 710
 711 void
 712 gtk_toolbar_append_widget (GtkToolbar *toolbar,
 713                            GtkWidget  *widget,
 714                            const char *tooltip_text)
 715 {
 716   gtk_toolbar_insert_widget (toolbar, widget, tooltip_text, toolbar->num_children);
 717 }
 718
 719 void
 720 gtk_toolbar_prepend_widget (GtkToolbar *toolbar,
 721                             GtkWidget  *widget,
 722                             const char *tooltip_text)
 723 {
 724   gtk_toolbar_insert_widget (toolbar, widget, tooltip_text, 0);
 725 }
 726
 727 void
 728 gtk_toolbar_insert_widget (GtkToolbar *toolbar,
 729                            GtkWidget  *widget,
 730                            const char *tooltip_text,
 731                            gint        position)
 732 {
 733   GtkToolbarChild *child;
 734
 735   g_return_if_fail (toolbar != NULL);
 736   g_return_if_fail (widget != NULL);
 737
 738   child = g_new (GtkToolbarChild, 1);
 739   child->type   = GTK_TOOLBAR_CHILD_WIDGET;
 740   child->widget = widget;
 741   child->icon   = NULL;
 742   child->label  = NULL;
 743
 744   if (tooltip_text)
 745     gtk_tooltips_set_tips (toolbar->tooltips, child->widget, tooltip_text);
 746
 747   toolbar->children = g_list_insert (toolbar->children, child, position);
 748   toolbar->num_children++;
 749
 750   gtk_widget_set_parent (child->widget, GTK_WIDGET (toolbar));
 751
 752   if (GTK_WIDGET_VISIBLE (toolbar))
 753     {
 754       if (GTK_WIDGET_REALIZED (toolbar)
 755           && !GTK_WIDGET_REALIZED (child->widget))
 756         gtk_widget_realize (child->widget);
 757
 758       if (GTK_WIDGET_MAPPED (toolbar)
 759           && !GTK_WIDGET_MAPPED (child->widget))
 760         gtk_widget_map (child->widget);
 761     }
 762
 763   if (GTK_WIDGET_VISIBLE (child->widget) && GTK_WIDGET_VISIBLE (toolbar))
 764     gtk_widget_queue_resize (child->widget);
 765 }
 766
 767 void
 768 gtk_toolbar_set_orientation (GtkToolbar     *toolbar,
 769                              GtkOrientation  orientation)
 770 {
 771   gtk_signal_emit (GTK_OBJECT (toolbar), toolbar_signals[ORIENTATION_CHANGED], orientation);
 772 }
 773
 774 void
 775 gtk_toolbar_set_style (GtkToolbar      *toolbar,
 776                        GtkToolbarStyle  style)
 777 {
 778   gtk_signal_emit (GTK_OBJECT (toolbar), toolbar_signals[STYLE_CHANGED], style);
 779 }
 780
 781 void
 782 gtk_toolbar_set_space_size (GtkToolbar *toolbar,
 783                             gint        space_size)
 784 {
 785   g_return_if_fail (toolbar != NULL);
 786   g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
 787
 788   if (toolbar->space_size != space_size)
 789     {
 790       toolbar->space_size = space_size;
 791       gtk_widget_queue_resize (GTK_WIDGET (toolbar));
 792     }
 793 }
 794
 795 void
 796 gtk_toolbar_set_tooltips (GtkToolbar *toolbar,
 797                           gint        enable)
 798 {
 799   g_return_if_fail (toolbar != NULL);
 800   g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
 801
 802   if (enable)
 803     gtk_tooltips_enable (toolbar->tooltips);
 804   else
 805     gtk_tooltips_disable (toolbar->tooltips);
 806 }
 807
 808 static void
 809 gtk_toolbar_marshal_signal_1 (GtkObject     *object,
 810                               GtkSignalFunc  func,
 811                               gpointer       func_data,
 812                               GtkArg        *args)
 813 {
 814   GtkToolbarSignal1 rfunc;
 815
 816   rfunc = (GtkToolbarSignal1) func;
 817
 818   (*rfunc) (object, GTK_VALUE_ENUM (args[0]), func_data);
 819 }
 820
 821 static void
 822 gtk_real_toolbar_orientation_changed (GtkToolbar     *toolbar,
 823                                       GtkOrientation  orientation)
 824 {
 825   g_return_if_fail (toolbar != NULL);
 826   g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
 827
 828   if (toolbar->orientation != orientation)
 829     {
 830       toolbar->orientation = orientation;
 831       gtk_widget_queue_resize (GTK_WIDGET (toolbar));
 832     }
 833 }
 834
 835 static void
 836 gtk_real_toolbar_style_changed (GtkToolbar      *toolbar,
 837                                 GtkToolbarStyle  style)
 838 {
 839   GList *children;
 840   GtkToolbarChild *child;
 841
 842   g_return_if_fail (toolbar != NULL);
 843   g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
 844
 845   if (toolbar->style != style)
 846     {
 847       toolbar->style = style;
 848
 849       for (children = toolbar->children; children; children = children->next)
 850         {
 851           child = children->data;
 852
 853           if (child->type == GTK_TOOLBAR_CHILD_BUTTON)
 854             switch (style)
 855               {
 856               case GTK_TOOLBAR_ICONS:
 857                 if (child->icon && !GTK_WIDGET_VISIBLE (child->icon))
 858                   gtk_widget_show (child->icon);
 859
 860                 if (child->label && GTK_WIDGET_VISIBLE (child->label))
 861                   gtk_widget_hide (child->label);
 862
 863                 break;
 864
 865               case GTK_TOOLBAR_TEXT:
 866                 if (child->icon && GTK_WIDGET_VISIBLE (child->icon))
 867                   gtk_widget_hide (child->icon);
 868
 869                 if (child->label && !GTK_WIDGET_VISIBLE (child->label))
 870                   gtk_widget_show (child->label);
 871
 872                 break;
 873
 874               case GTK_TOOLBAR_BOTH:
 875                 if (child->icon && !GTK_WIDGET_VISIBLE (child->icon))
 876                   gtk_widget_show (child->icon);
 877
 878                 if (child->label && !GTK_WIDGET_VISIBLE (child->label))
 879                   gtk_widget_show (child->label);
 880
 881                 break;
 882
 883               default:
 884                 g_assert_not_reached ();
 885               }
 886         }
 887
 888       gtk_widget_queue_resize (GTK_WIDGET (toolbar));
 889     }
 890 }