Pileus Git - ~andy/gtk/blob - demos/gtk-demo/toolpalette.c

   1 /* Tool Palette
   2  *
   3  * A tool palette widget shows groups of toolbar items as a grid of icons
   4  * or a list of names.
   5  */
   6
   7 #include <string.h>
   8 #include <gtk/gtk.h>
   9 #include "config.h"
  10 #include "demo-common.h"
  11
  12 static GtkWidget *window = NULL;
  13
  14 static void load_stock_items (GtkToolPalette *palette);
  15 static void load_toggle_items (GtkToolPalette *palette);
  16 static void load_special_items (GtkToolPalette *palette);
  17
  18 typedef struct _CanvasItem CanvasItem;
  19
  20 struct _CanvasItem
  21 {
  22   GdkPixbuf *pixbuf;
  23   gdouble x, y;
  24 };
  25
  26 static CanvasItem *drop_item = NULL;
  27 static GList *canvas_items = NULL;
  28
  29 /********************************/
  30 /* ====== Canvas drawing ====== */
  31 /********************************/
  32
  33 static CanvasItem*
  34 canvas_item_new (GtkWidget     *widget,
  35                  GtkToolButton *button,
  36                  gdouble        x,
  37                  gdouble        y)
  38 {
  39   CanvasItem *item = NULL;
  40   const gchar *stock_id;
  41   GdkPixbuf *pixbuf;
  42
  43   stock_id = gtk_tool_button_get_stock_id (button);
  44   pixbuf = gtk_widget_render_icon (widget, stock_id, GTK_ICON_SIZE_DIALOG, NULL);
  45
  46   if (pixbuf)
  47     {
  48       item = g_slice_new0 (CanvasItem);
  49       item->pixbuf = pixbuf;
  50       item->x = x;
  51       item->y = y;
  52     }
  53
  54   return item;
  55 }
  56
  57 static void
  58 canvas_item_free (CanvasItem *item)
  59 {
  60   g_object_unref (item->pixbuf);
  61   g_slice_free (CanvasItem, item);
  62 }
  63
  64 static void
  65 canvas_item_draw (const CanvasItem *item,
  66                   cairo_t          *cr,
  67                   gboolean          preview)
  68 {
  69   gdouble cx = gdk_pixbuf_get_width (item->pixbuf);
  70   gdouble cy = gdk_pixbuf_get_height (item->pixbuf);
  71
  72   gdk_cairo_set_source_pixbuf (cr,
  73                                item->pixbuf,
  74                                item->x - cx * 0.5,
  75                                item->y - cy * 0.5);
  76
  77   if (preview)
  78     cairo_paint_with_alpha (cr, 0.6);
  79   else
  80     cairo_paint (cr);
  81 }
  82
  83 static gboolean
  84 canvas_expose_event (GtkWidget      *widget,
  85                      GdkEventExpose *event)
  86 {
  87   cairo_t *cr;
  88   GList *iter;
  89
  90   cr = gdk_cairo_create (widget->window);
  91   gdk_cairo_region (cr, event->region);
  92   cairo_clip (cr);
  93
  94   cairo_set_source_rgb (cr, 1, 1, 1);
  95   cairo_rectangle (cr, 0, 0, widget->allocation.width, widget->allocation.height);
  96   cairo_fill (cr);
  97
  98   for (iter = canvas_items; iter; iter = iter->next)
  99     canvas_item_draw (iter->data, cr, FALSE);
 100
 101   if (drop_item)
 102     canvas_item_draw (drop_item, cr, TRUE);
 103
 104   cairo_destroy (cr);
 105
 106   return TRUE;
 107 }
 108
 109 /*****************************/
 110 /* ====== Palette DnD ====== */
 111 /*****************************/
 112
 113 static void
 114 palette_drop_item (GtkToolItem      *drag_item,
 115                    GtkToolItemGroup *drop_group,
 116                    gint              x,
 117                    gint              y)
 118 {
 119   GtkWidget *drag_group = gtk_widget_get_parent (GTK_WIDGET (drag_item));
 120   GtkToolItem *drop_item = gtk_tool_item_group_get_drop_item (drop_group, x, y);
 121   gint drop_position = -1;
 122
 123   if (drop_item)
 124     drop_position = gtk_tool_item_group_get_item_position (GTK_TOOL_ITEM_GROUP (drop_group), drop_item);
 125
 126   if (GTK_TOOL_ITEM_GROUP (drag_group) != drop_group)
 127     {
 128       gboolean homogeneous, expand, fill, new_row;
 129
 130       g_object_ref (drag_item);
 131       gtk_container_child_get (GTK_CONTAINER (drag_group), GTK_WIDGET (drag_item),
 132                                "homogeneous", &homogeneous,
 133                                "expand", &expand,
 134                                "fill", &fill,
 135                                "new-row", &new_row,
 136                                NULL);
 137       gtk_container_remove (GTK_CONTAINER (drag_group), GTK_WIDGET (drag_item));
 138       gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (drop_group),
 139                                   drag_item, drop_position);
 140       gtk_container_child_set (GTK_CONTAINER (drop_group), GTK_WIDGET (drag_item),
 141                                "homogeneous", homogeneous,
 142                                "expand", expand,
 143                                "fill", fill,
 144                                "new-row", new_row,
 145                                NULL);
 146       g_object_unref (drag_item);
 147     }
 148   else
 149     gtk_tool_item_group_set_item_position (GTK_TOOL_ITEM_GROUP (drop_group),
 150                                            drag_item, drop_position);
 151 }
 152
 153 static void
 154 palette_drop_group (GtkToolPalette *palette,
 155                     GtkWidget      *drag_group,
 156                     GtkWidget      *drop_group)
 157 {
 158   gint drop_position = -1;
 159
 160   if (drop_group)
 161     drop_position = gtk_tool_palette_get_group_position (palette, drop_group);
 162
 163   gtk_tool_palette_set_group_position (palette, drag_group, drop_position);
 164 }
 165
 166 static void
 167 palette_drag_data_received (GtkWidget        *widget,
 168                             GdkDragContext   *context,
 169                             gint              x,
 170                             gint              y,
 171                             GtkSelectionData *selection,
 172                             guint             info,
 173                             guint             time,
 174                             gpointer          data)
 175 {
 176   GtkWidget *drag_palette = gtk_drag_get_source_widget (context);
 177   GtkWidget *drag_item = NULL, *drop_group = NULL;
 178
 179   while (drag_palette && !GTK_IS_TOOL_PALETTE (drag_palette))
 180     drag_palette = gtk_widget_get_parent (drag_palette);
 181
 182   if (drag_palette)
 183     {
 184       drag_item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (drag_palette),
 185                                                   selection);
 186       drop_group = gtk_tool_palette_get_drop_group (GTK_TOOL_PALETTE (widget),
 187                                                     x, y);
 188     }
 189
 190   if (GTK_IS_TOOL_ITEM_GROUP (drag_item))
 191     palette_drop_group (GTK_TOOL_PALETTE (drag_palette), drag_item, drop_group);
 192   else if (GTK_IS_TOOL_ITEM (drag_item) && drop_group)
 193     palette_drop_item (GTK_TOOL_ITEM (drag_item),
 194                        GTK_TOOL_ITEM_GROUP (drop_group),
 195                        x - GTK_WIDGET (drop_group)->allocation.x,
 196                        y - GTK_WIDGET (drop_group)->allocation.y);
 197 }
 198
 199 /********************************/
 200 /* ====== Passive Canvas ====== */
 201 /********************************/
 202
 203 static void
 204 passive_canvas_drag_data_received (GtkWidget        *widget,
 205                                    GdkDragContext   *context,
 206                                    gint              x,
 207                                    gint              y,
 208                                    GtkSelectionData *selection,
 209                                    guint             info,
 210                                    guint             time,
 211                                    gpointer          data)
 212 {
 213   /* find the tool button, which is the source of this DnD operation */
 214
 215   GtkWidget *palette = gtk_drag_get_source_widget (context);
 216   CanvasItem *canvas_item = NULL;
 217   GtkWidget *tool_item = NULL;
 218
 219   while (palette && !GTK_IS_TOOL_PALETTE (palette))
 220     palette = gtk_widget_get_parent (palette);
 221
 222   if (palette)
 223     tool_item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (palette),
 224                                                 selection);
 225
 226   g_assert (NULL == drop_item);
 227
 228   /* append a new canvas item when a tool button was found */
 229
 230   if (GTK_IS_TOOL_ITEM (tool_item))
 231     canvas_item = canvas_item_new (widget, GTK_TOOL_BUTTON (tool_item), x, y);
 232
 233   if (canvas_item)
 234     {
 235       canvas_items = g_list_append (canvas_items, canvas_item);
 236       gtk_widget_queue_draw (widget);
 237     }
 238 }
 239
 240 /************************************/
 241 /* ====== Interactive Canvas ====== */
 242 /************************************/
 243
 244 static gboolean
 245 interactive_canvas_drag_motion (GtkWidget      *widget,
 246                                 GdkDragContext *context,
 247                                 gint            x,
 248                                 gint            y,
 249                                 guint           time,
 250                                 gpointer        data)
 251 {
 252   if (drop_item)
 253     {
 254       /* already have a drop indicator - just update position */
 255
 256       drop_item->x = x;
 257       drop_item->y = y;
 258
 259       gtk_widget_queue_draw (widget);
 260       gdk_drag_status (context, GDK_ACTION_COPY, time);
 261     }
 262   else
 263     {
 264       /* request DnD data for creating a drop indicator */
 265
 266       GdkAtom target = gtk_drag_dest_find_target (widget, context, NULL);
 267
 268       if (!target)
 269         return FALSE;
 270
 271       gtk_drag_get_data (widget, context, target, time);
 272     }
 273
 274   return TRUE;
 275 }
 276
 277 static void
 278 interactive_canvas_drag_data_received (GtkWidget        *widget,
 279                                        GdkDragContext   *context,
 280                                        gint              x,
 281                                        gint              y,
 282                                        GtkSelectionData *selection,
 283                                        guint             info,
 284                                        guint             time,
 285                                        gpointer          data)
 286
 287 {
 288   /* find the tool button which is the source of this DnD operation */
 289
 290   GtkWidget *palette = gtk_drag_get_source_widget (context);
 291   GtkWidget *tool_item = NULL;
 292
 293   while (palette && !GTK_IS_TOOL_PALETTE (palette))
 294     palette = gtk_widget_get_parent (palette);
 295
 296   if (palette)
 297     tool_item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (palette),
 298                                                 selection);
 299
 300   /* create a drop indicator when a tool button was found */
 301
 302   g_assert (NULL == drop_item);
 303
 304   if (GTK_IS_TOOL_ITEM (tool_item))
 305     {
 306       drop_item = canvas_item_new (widget, GTK_TOOL_BUTTON (tool_item), x, y);
 307       gdk_drag_status (context, GDK_ACTION_COPY, time);
 308       gtk_widget_queue_draw (widget);
 309     }
 310 }
 311
 312 static gboolean
 313 interactive_canvas_drag_drop (GtkWidget      *widget,
 314                               GdkDragContext *context,
 315                               gint            x,
 316                               gint            y,
 317                               guint           time,
 318                               gpointer        data)
 319 {
 320   if (drop_item)
 321     {
 322       /* turn the drop indicator into a real canvas item */
 323
 324       drop_item->x = x;
 325       drop_item->y = y;
 326
 327       canvas_items = g_list_append (canvas_items, drop_item);
 328       drop_item = NULL;
 329
 330       /* signal the item was accepted and redraw */
 331
 332       gtk_drag_finish (context, TRUE, FALSE, time);
 333       gtk_widget_queue_draw (widget);
 334
 335       return TRUE;
 336     }
 337
 338   return FALSE;
 339 }
 340
 341 static gboolean
 342 interactive_canvas_real_drag_leave (gpointer data)
 343 {
 344   if (drop_item)
 345     {
 346       GtkWidget *widget = GTK_WIDGET (data);
 347
 348       canvas_item_free (drop_item);
 349       drop_item = NULL;
 350
 351       gtk_widget_queue_draw (widget);
 352     }
 353
 354   return FALSE;
 355 }
 356
 357 static void
 358 interactive_canvas_drag_leave (GtkWidget      *widget,
 359                                GdkDragContext *context,
 360                                guint           time,
 361                                gpointer        data)
 362 {
 363   /* defer cleanup until a potential "drag-drop" signal was received */
 364   g_idle_add (interactive_canvas_real_drag_leave, widget);
 365 }
 366
 367 static void
 368 on_combo_orientation_changed (GtkComboBox *combo_box,
 369                               gpointer     user_data)
 370 {
 371   GtkToolPalette *palette = GTK_TOOL_PALETTE (user_data);
 372   GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW (GTK_WIDGET (palette)->parent);
 373   GtkTreeModel *model = gtk_combo_box_get_model (combo_box);
 374   GtkTreeIter iter;
 375   gint val = 0;
 376
 377   if (!gtk_combo_box_get_active_iter (combo_box, &iter))
 378     return;
 379
 380   gtk_tree_model_get (model, &iter, 1, &val, -1);
 381
 382   gtk_orientable_set_orientation (GTK_ORIENTABLE (palette), val);
 383
 384   if (val == GTK_ORIENTATION_HORIZONTAL)
 385     gtk_scrolled_window_set_policy (sw, GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
 386   else
 387     gtk_scrolled_window_set_policy (sw, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 388 }
 389
 390 static void
 391 on_combo_style_changed (GtkComboBox *combo_box,
 392                         gpointer     user_data)
 393 {
 394   GtkToolPalette *palette = GTK_TOOL_PALETTE (user_data);
 395   GtkTreeModel *model = gtk_combo_box_get_model (combo_box);
 396   GtkTreeIter iter;
 397   gint val = 0;
 398
 399   if (!gtk_combo_box_get_active_iter (combo_box, &iter))
 400     return;
 401
 402   gtk_tree_model_get (model, &iter, 1, &val, -1);
 403
 404   if (val == -1)
 405     gtk_tool_palette_unset_style (palette);
 406   else
 407     gtk_tool_palette_set_style (palette, val);
 408 }
 409
 410 GtkWidget *
 411 do_toolpalette (GtkWidget *do_widget)
 412 {
 413   GtkWidget *box = NULL;
 414   GtkWidget *hbox = NULL;
 415   GtkWidget *combo_orientation = NULL;
 416   GtkListStore *orientation_model = NULL;
 417   GtkWidget *combo_style = NULL;
 418   GtkListStore *style_model = NULL;
 419   GtkCellRenderer *cell_renderer = NULL;
 420   GtkTreeIter iter;
 421   GtkWidget *palette = NULL;
 422   GtkWidget *palette_scroller = NULL;
 423   GtkWidget *notebook = NULL;
 424   GtkWidget *contents = NULL;
 425   GtkWidget *contents_scroller = NULL;
 426
 427   if (!window)
 428     {
 429       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 430       gtk_window_set_screen (GTK_WINDOW (window),
 431                              gtk_widget_get_screen (do_widget));
 432       gtk_window_set_title (GTK_WINDOW (window), "Tool Palette");
 433       gtk_window_set_default_size (GTK_WINDOW (window), 200, 600);
 434
 435       g_signal_connect (window, "destroy",
 436                         G_CALLBACK (gtk_widget_destroyed), &window);
 437       gtk_container_set_border_width (GTK_CONTAINER (window), 8);
 438
 439       /* Add widgets to control the ToolPalette appearance: */
 440       box = gtk_vbox_new (FALSE, 6);
 441       gtk_container_add (GTK_CONTAINER (window), box);
 442
 443       /* Orientation combo box: */
 444       orientation_model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 445       gtk_list_store_append (orientation_model, &iter);
 446       gtk_list_store_set (orientation_model, &iter,
 447                           0, "Horizontal",
 448                           1, GTK_ORIENTATION_HORIZONTAL,
 449                           -1);
 450       gtk_list_store_append (orientation_model, &iter);
 451       gtk_list_store_set (orientation_model, &iter,
 452                           0, "Vertical",
 453                           1, GTK_ORIENTATION_VERTICAL,
 454                           -1);
 455
 456       combo_orientation =
 457         gtk_combo_box_new_with_model (GTK_TREE_MODEL (orientation_model));
 458       cell_renderer = gtk_cell_renderer_text_new ();
 459       gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_orientation),
 460                                   cell_renderer,
 461                                   TRUE);
 462       gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_orientation),
 463                                       cell_renderer,
 464                                       "text", 0,
 465                                       NULL);
 466       gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_orientation), &iter);
 467       gtk_box_pack_start (GTK_BOX (box), combo_orientation, FALSE, FALSE, 0);
 468
 469       /* Style combo box: */
 470       style_model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 471       gtk_list_store_append (style_model, &iter);
 472       gtk_list_store_set (style_model, &iter,
 473                           0, "Text",
 474                           1, GTK_TOOLBAR_TEXT,
 475                           -1);
 476       gtk_list_store_append (style_model, &iter);
 477       gtk_list_store_set (style_model, &iter,
 478                           0, "Both",
 479                           1, GTK_TOOLBAR_BOTH,
 480                           -1);
 481       gtk_list_store_append (style_model, &iter);
 482       gtk_list_store_set (style_model, &iter,
 483                           0, "Both: Horizontal",
 484                           1, GTK_TOOLBAR_BOTH_HORIZ,
 485                           -1);
 486       gtk_list_store_append (style_model, &iter);
 487       gtk_list_store_set (style_model, &iter,
 488                           0, "Icons",
 489                           1, GTK_TOOLBAR_ICONS,
 490                           -1);
 491       gtk_list_store_append (style_model, &iter);
 492       gtk_list_store_set (style_model, &iter,
 493                           0, "Default",
 494                           1, -1,  /* A custom meaning for this demo. */
 495                           -1);
 496       combo_style = gtk_combo_box_new_with_model (GTK_TREE_MODEL (style_model));
 497       cell_renderer = gtk_cell_renderer_text_new ();
 498       gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_style),
 499                                   cell_renderer,
 500                                   TRUE);
 501       gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_style),
 502                                       cell_renderer,
 503                                       "text", 0,
 504                                       NULL);
 505       gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_style), &iter);
 506       gtk_box_pack_start (GTK_BOX (box), combo_style, FALSE, FALSE, 0);
 507
 508       /* Add hbox */
 509       hbox = gtk_hbox_new (FALSE, 5);
 510       gtk_box_pack_start (GTK_BOX (box), hbox, TRUE, TRUE, 0);
 511
 512       /* Add and fill the ToolPalette: */
 513       palette = gtk_tool_palette_new ();
 514
 515       load_stock_items (GTK_TOOL_PALETTE (palette));
 516       load_toggle_items (GTK_TOOL_PALETTE (palette));
 517       load_special_items (GTK_TOOL_PALETTE (palette));
 518
 519       palette_scroller = gtk_scrolled_window_new (NULL, NULL);
 520       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (palette_scroller),
 521                                       GTK_POLICY_NEVER,
 522                                       GTK_POLICY_AUTOMATIC);
 523       gtk_container_set_border_width (GTK_CONTAINER (palette_scroller), 6);
 524
 525       gtk_container_add (GTK_CONTAINER (palette_scroller), palette);
 526       gtk_container_add (GTK_CONTAINER (hbox), palette_scroller);
 527
 528       gtk_widget_show_all (box);
 529
 530       /* Connect signals: */
 531       g_signal_connect (combo_orientation, "changed",
 532                         G_CALLBACK (on_combo_orientation_changed), palette);
 533       g_signal_connect (combo_style, "changed",
 534                         G_CALLBACK (on_combo_style_changed), palette);
 535
 536       /* Keep the widgets in sync: */
 537       on_combo_orientation_changed (GTK_COMBO_BOX (combo_orientation), palette);
 538
 539       /* ===== notebook ===== */
 540
 541       notebook = gtk_notebook_new ();
 542       gtk_container_set_border_width (GTK_CONTAINER (notebook), 6);
 543       gtk_box_pack_end (GTK_BOX(hbox), notebook, FALSE, FALSE, 0);
 544
 545       /* ===== DnD for tool items ===== */
 546
 547       g_signal_connect (palette, "drag-data-received",
 548                         G_CALLBACK (palette_drag_data_received), NULL);
 549
 550       gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette),
 551                                       palette,
 552                                       GTK_DEST_DEFAULT_ALL,
 553                                       GTK_TOOL_PALETTE_DRAG_ITEMS |
 554                                       GTK_TOOL_PALETTE_DRAG_GROUPS,
 555                                       GDK_ACTION_MOVE);
 556
 557       /* ===== passive DnD dest ===== */
 558
 559       contents = gtk_drawing_area_new ();
 560       gtk_widget_set_app_paintable (contents, TRUE);
 561
 562       g_object_connect (contents,
 563                         "signal::expose-event", canvas_expose_event, NULL,
 564                         "signal::drag-data-received", passive_canvas_drag_data_received, NULL,
 565                         NULL);
 566
 567       gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette),
 568                                       contents,
 569                                       GTK_DEST_DEFAULT_ALL,
 570                                       GTK_TOOL_PALETTE_DRAG_ITEMS,
 571                                       GDK_ACTION_COPY);
 572
 573       contents_scroller = gtk_scrolled_window_new (NULL, NULL);
 574       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (contents_scroller),
 575                                       GTK_POLICY_AUTOMATIC,
 576                                       GTK_POLICY_ALWAYS);
 577       gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (contents_scroller),
 578                                              contents);
 579       gtk_container_set_border_width (GTK_CONTAINER (contents_scroller), 6);
 580
 581       gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
 582                                 contents_scroller,
 583                                 gtk_label_new ("Passive DnD Mode"));
 584
 585       /* ===== interactive DnD dest ===== */
 586
 587       contents = gtk_drawing_area_new ();
 588       gtk_widget_set_app_paintable (contents, TRUE);
 589
 590       g_object_connect (contents,
 591                         "signal::expose-event", canvas_expose_event, NULL,
 592                         "signal::drag-motion", interactive_canvas_drag_motion, NULL,
 593                         "signal::drag-data-received", interactive_canvas_drag_data_received, NULL,
 594                         "signal::drag-leave", interactive_canvas_drag_leave, NULL,
 595                         "signal::drag-drop", interactive_canvas_drag_drop, NULL,
 596                         NULL);
 597
 598       gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette),
 599                                       contents,
 600                                       GTK_DEST_DEFAULT_HIGHLIGHT,
 601                                       GTK_TOOL_PALETTE_DRAG_ITEMS,
 602                                       GDK_ACTION_COPY);
 603
 604       contents_scroller = gtk_scrolled_window_new (NULL, NULL);
 605       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (contents_scroller),
 606                                       GTK_POLICY_AUTOMATIC,
 607                                       GTK_POLICY_ALWAYS);
 608       gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (contents_scroller),
 609                                              contents);
 610       gtk_container_set_border_width (GTK_CONTAINER (contents_scroller), 6);
 611
 612       gtk_notebook_append_page (GTK_NOTEBOOK (notebook), contents_scroller,
 613                                 gtk_label_new ("Interactive DnD Mode"));
 614     }
 615
 616   if (!GTK_WIDGET_VISIBLE (window))
 617     {
 618       gtk_widget_show_all (window);
 619     }
 620   else
 621     {
 622       gtk_widget_destroy (window);
 623       window = NULL;
 624     }
 625
 626   return window;
 627 }
 628
 629
 630 static void
 631 load_stock_items (GtkToolPalette *palette)
 632 {
 633   GtkWidget *group_af = gtk_tool_item_group_new ("Stock Icons (A-F)");
 634   GtkWidget *group_gn = gtk_tool_item_group_new ("Stock Icons (G-N)");
 635   GtkWidget *group_or = gtk_tool_item_group_new ("Stock Icons (O-R)");
 636   GtkWidget *group_sz = gtk_tool_item_group_new ("Stock Icons (S-Z)");
 637   GtkWidget *group = NULL;
 638
 639   GtkToolItem *item;
 640   GSList *stock_ids;
 641   GSList *iter;
 642
 643   stock_ids = gtk_stock_list_ids ();
 644   stock_ids = g_slist_sort (stock_ids, (GCompareFunc) strcmp);
 645
 646   gtk_container_add (GTK_CONTAINER (palette), group_af);
 647   gtk_container_add (GTK_CONTAINER (palette), group_gn);
 648   gtk_container_add (GTK_CONTAINER (palette), group_or);
 649   gtk_container_add (GTK_CONTAINER (palette), group_sz);
 650
 651   for (iter = stock_ids; iter; iter = g_slist_next (iter))
 652     {
 653       GtkStockItem stock_item;
 654       gchar *id = iter->data;
 655
 656       switch (id[4])
 657         {
 658           case 'a':
 659             group = group_af;
 660             break;
 661
 662           case 'g':
 663             group = group_gn;
 664             break;
 665
 666           case 'o':
 667             group = group_or;
 668             break;
 669
 670           case 's':
 671             group = group_sz;
 672             break;
 673         }
 674
 675       item = gtk_tool_button_new_from_stock (id);
 676       gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (item), id);
 677       gtk_tool_item_set_is_important (GTK_TOOL_ITEM (item), TRUE);
 678       gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 679
 680       if (!gtk_stock_lookup (id, &stock_item) || !stock_item.label)
 681         gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), id);
 682
 683       g_free (id);
 684     }
 685
 686   g_slist_free (stock_ids);
 687 }
 688
 689 static void
 690 load_toggle_items (GtkToolPalette *palette)
 691 {
 692   GSList *toggle_group = NULL;
 693   GtkToolItem *item;
 694   GtkWidget *group;
 695   char *label;
 696   int i;
 697
 698   group = gtk_tool_item_group_new ("Radio Item");
 699   gtk_container_add (GTK_CONTAINER (palette), group);
 700
 701   for (i = 1; i <= 10; ++i)
 702     {
 703       label = g_strdup_printf ("#%d", i);
 704       item = gtk_radio_tool_button_new (toggle_group);
 705       gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), label);
 706       g_free (label);
 707
 708       gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 709       toggle_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
 710     }
 711 }
 712
 713 static GtkToolItem *
 714 create_entry_item (const char *text)
 715 {
 716   GtkToolItem *item;
 717   GtkWidget *entry;
 718
 719   entry = gtk_entry_new ();
 720   gtk_entry_set_text (GTK_ENTRY (entry), text);
 721   gtk_entry_set_width_chars (GTK_ENTRY (entry), 5);
 722
 723   item = gtk_tool_item_new ();
 724   gtk_container_add (GTK_CONTAINER (item), entry);
 725
 726   return item;
 727 }
 728
 729 static void
 730 load_special_items (GtkToolPalette *palette)
 731 {
 732   GtkToolItem *item;
 733   GtkWidget *group;
 734   GtkWidget *label_button;
 735
 736   group = gtk_tool_item_group_new (NULL);
 737   label_button = gtk_button_new_with_label ("Advanced Features");
 738   gtk_widget_show (label_button);
 739   gtk_tool_item_group_set_label_widget (GTK_TOOL_ITEM_GROUP (group),
 740                                         label_button);
 741   gtk_container_add (GTK_CONTAINER (palette), group);
 742
 743   item = create_entry_item ("homogeneous=FALSE");
 744   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 745   gtk_container_child_set (GTK_CONTAINER (group), GTK_WIDGET (item),
 746                            "homogeneous", FALSE, NULL);
 747
 748   item = create_entry_item ("homogeneous=FALSE, expand=TRUE");
 749   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 750   gtk_container_child_set (GTK_CONTAINER (group), GTK_WIDGET (item),
 751                            "homogeneous", FALSE, "expand", TRUE,
 752                            NULL);
 753
 754   item = create_entry_item ("homogeneous=FALSE, expand=TRUE, fill=FALSE");
 755   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 756   gtk_container_child_set (GTK_CONTAINER (group), GTK_WIDGET (item),
 757                            "homogeneous", FALSE, "expand", TRUE,
 758                            "fill", FALSE, NULL);
 759
 760   item = create_entry_item ("homogeneous=FALSE, expand=TRUE, new-row=TRUE");
 761   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 762   gtk_container_child_set (GTK_CONTAINER (group), GTK_WIDGET (item),
 763                            "homogeneous", FALSE, "expand", TRUE,
 764                            "new-row", TRUE, NULL);
 765
 766   item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_UP);
 767   gtk_tool_item_set_tooltip_text (item, "Show on vertical palettes only");
 768   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 769   gtk_tool_item_set_visible_horizontal (item, FALSE);
 770
 771   item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD);
 772   gtk_tool_item_set_tooltip_text (item, "Show on horizontal palettes only");
 773   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 774   gtk_tool_item_set_visible_vertical (item, FALSE);
 775
 776   item = gtk_tool_button_new_from_stock (GTK_STOCK_DELETE);
 777   gtk_tool_item_set_tooltip_text (item, "Do not show at all");
 778   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 779   gtk_widget_set_no_show_all (GTK_WIDGET (item), TRUE);
 780
 781   item = gtk_tool_button_new_from_stock (GTK_STOCK_FULLSCREEN);
 782   gtk_tool_item_set_tooltip_text (item, "Expanded this item");
 783   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 784   gtk_container_child_set (GTK_CONTAINER (group), GTK_WIDGET (item),
 785                            "homogeneous", FALSE,
 786                            "expand", TRUE,
 787                            NULL);
 788
 789   item = gtk_tool_button_new_from_stock (GTK_STOCK_HELP);
 790   gtk_tool_item_set_tooltip_text (item, "A regular item");
 791   gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
 792 }