Pileus Git - ~andy/gtk/blob - tests/testtoolbar.c

   1 /* testtoolbar.c
   2  *
   3  * Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
   4  * Copyright (C) 2002 James Henstridge <james@daa.com.au>
   5  * Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22 #include "config.h"
  23 #include <gtk/gtk.h>
  24 #include "prop-editor.h"
  25
  26 static void
  27 reload_clicked (GtkWidget *widget)
  28 {
  29   static GdkAtom atom_rcfiles = GDK_NONE;
  30
  31   GdkEventClient sev;
  32   int i;
  33
  34   if (!atom_rcfiles)
  35     atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
  36
  37   for(i = 0; i < 5; i++)
  38     sev.data.l[i] = 0;
  39   sev.data_format = 32;
  40   sev.message_type = atom_rcfiles;
  41   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
  42 }
  43
  44 static void
  45 change_orientation (GtkWidget *button, GtkWidget *toolbar)
  46 {
  47   GtkWidget *table;
  48   GtkOrientation orientation;
  49
  50   table = gtk_widget_get_parent (toolbar);
  51   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
  52     orientation = GTK_ORIENTATION_VERTICAL;
  53   else
  54     orientation = GTK_ORIENTATION_HORIZONTAL;
  55
  56   g_object_ref (toolbar);
  57   gtk_container_remove (GTK_CONTAINER (table), toolbar);
  58   gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), orientation);
  59   if (orientation == GTK_ORIENTATION_HORIZONTAL)
  60     {
  61       gtk_table_attach (GTK_TABLE (table), toolbar,
  62                         0,2, 0,1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
  63     }
  64   else
  65     {
  66       gtk_table_attach (GTK_TABLE (table), toolbar,
  67                         0,1, 0,4, GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
  68     }
  69   g_object_unref (toolbar);
  70 }
  71
  72 static void
  73 change_show_arrow (GtkWidget *button, GtkWidget *toolbar)
  74 {
  75   gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar),
  76                 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
  77 }
  78
  79 static void
  80 set_toolbar_style_toggled (GtkCheckButton *button, GtkToolbar *toolbar)
  81 {
  82   GtkWidget *option_menu;
  83   int style;
  84
  85   option_menu = g_object_get_data (G_OBJECT (button), "option-menu");
  86
  87   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
  88     {
  89       style = gtk_combo_box_get_active (GTK_COMBO_BOX (option_menu));
  90
  91       gtk_toolbar_set_style (toolbar, style);
  92       gtk_widget_set_sensitive (option_menu, TRUE);
  93     }
  94   else
  95     {
  96       gtk_toolbar_unset_style (toolbar);
  97       gtk_widget_set_sensitive (option_menu, FALSE);
  98     }
  99 }
 100
 101 static void
 102 change_toolbar_style (GtkWidget *option_menu, GtkWidget *toolbar)
 103 {
 104   GtkToolbarStyle style;
 105
 106   style = gtk_combo_box_get_active (GTK_COMBO_BOX (option_menu));
 107   gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), style);
 108 }
 109
 110 static void
 111 set_visible_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
 112                  GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 113 {
 114   GtkToolItem *tool_item;
 115   gboolean visible;
 116
 117   gtk_tree_model_get (model, iter, 0, &tool_item, -1);
 118
 119   g_object_get (tool_item, "visible", &visible, NULL);
 120   g_object_set (cell, "active", visible, NULL);
 121   g_object_unref (tool_item);
 122 }
 123
 124 static void
 125 visibile_toggled(GtkCellRendererToggle *cell, const gchar *path_str,
 126                  GtkTreeModel *model)
 127 {
 128   GtkTreePath *path;
 129   GtkTreeIter iter;
 130   GtkToolItem *tool_item;
 131   gboolean visible;
 132
 133   path = gtk_tree_path_new_from_string (path_str);
 134   gtk_tree_model_get_iter (model, &iter, path);
 135
 136   gtk_tree_model_get (model, &iter, 0, &tool_item, -1);
 137   g_object_get (tool_item, "visible", &visible, NULL);
 138   g_object_set (tool_item, "visible", !visible, NULL);
 139   g_object_unref (tool_item);
 140
 141   gtk_tree_model_row_changed (model, path, &iter);
 142   gtk_tree_path_free (path);
 143 }
 144
 145 static void
 146 set_expand_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
 147                 GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 148 {
 149   GtkToolItem *tool_item;
 150
 151   gtk_tree_model_get (model, iter, 0, &tool_item, -1);
 152
 153   g_object_set (cell, "active", gtk_tool_item_get_expand (tool_item), NULL);
 154   g_object_unref (tool_item);
 155 }
 156
 157 static void
 158 expand_toggled(GtkCellRendererToggle *cell, const gchar *path_str,
 159                GtkTreeModel *model)
 160 {
 161   GtkTreePath *path;
 162   GtkTreeIter iter;
 163   GtkToolItem *tool_item;
 164
 165   path = gtk_tree_path_new_from_string (path_str);
 166   gtk_tree_model_get_iter (model, &iter, path);
 167
 168   gtk_tree_model_get (model, &iter, 0, &tool_item, -1);
 169   gtk_tool_item_set_expand (tool_item, !gtk_tool_item_get_expand (tool_item));
 170   g_object_unref (tool_item);
 171
 172   gtk_tree_model_row_changed (model, path, &iter);
 173   gtk_tree_path_free (path);
 174 }
 175
 176 static void
 177 set_homogeneous_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
 178                      GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 179 {
 180   GtkToolItem *tool_item;
 181
 182   gtk_tree_model_get (model, iter, 0, &tool_item, -1);
 183
 184   g_object_set (cell, "active", gtk_tool_item_get_homogeneous (tool_item), NULL);
 185   g_object_unref (tool_item);
 186 }
 187
 188 static void
 189 homogeneous_toggled(GtkCellRendererToggle *cell, const gchar *path_str,
 190                     GtkTreeModel *model)
 191 {
 192   GtkTreePath *path;
 193   GtkTreeIter iter;
 194   GtkToolItem *tool_item;
 195
 196   path = gtk_tree_path_new_from_string (path_str);
 197   gtk_tree_model_get_iter (model, &iter, path);
 198
 199   gtk_tree_model_get (model, &iter, 0, &tool_item, -1);
 200   gtk_tool_item_set_homogeneous (tool_item, !gtk_tool_item_get_homogeneous (tool_item));
 201   g_object_unref (tool_item);
 202
 203   gtk_tree_model_row_changed (model, path, &iter);
 204   gtk_tree_path_free (path);
 205 }
 206
 207
 208 static void
 209 set_important_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
 210                    GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 211 {
 212   GtkToolItem *tool_item;
 213
 214   gtk_tree_model_get (model, iter, 0, &tool_item, -1);
 215
 216   g_object_set (cell, "active", gtk_tool_item_get_is_important (tool_item), NULL);
 217   g_object_unref (tool_item);
 218 }
 219
 220 static void
 221 important_toggled(GtkCellRendererToggle *cell, const gchar *path_str,
 222                   GtkTreeModel *model)
 223 {
 224   GtkTreePath *path;
 225   GtkTreeIter iter;
 226   GtkToolItem *tool_item;
 227
 228   path = gtk_tree_path_new_from_string (path_str);
 229   gtk_tree_model_get_iter (model, &iter, path);
 230
 231   gtk_tree_model_get (model, &iter, 0, &tool_item, -1);
 232   gtk_tool_item_set_is_important (tool_item, !gtk_tool_item_get_is_important (tool_item));
 233   g_object_unref (tool_item);
 234
 235   gtk_tree_model_row_changed (model, path, &iter);
 236   gtk_tree_path_free (path);
 237 }
 238
 239 static GtkListStore *
 240 create_items_list (GtkWidget **tree_view_p)
 241 {
 242   GtkWidget *tree_view;
 243   GtkListStore *list_store;
 244   GtkCellRenderer *cell;
 245
 246   list_store = gtk_list_store_new (2, GTK_TYPE_TOOL_ITEM, G_TYPE_STRING);
 247
 248   tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
 249
 250   gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
 251                                                -1, "Tool Item",
 252                                                gtk_cell_renderer_text_new (),
 253                                                "text", 1, NULL);
 254
 255   cell = gtk_cell_renderer_toggle_new ();
 256   g_signal_connect (cell, "toggled", G_CALLBACK (visibile_toggled),
 257                     list_store);
 258   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 259                                               -1, "Visible",
 260                                               cell,
 261                                               set_visible_func, NULL, NULL);
 262
 263   cell = gtk_cell_renderer_toggle_new ();
 264   g_signal_connect (cell, "toggled", G_CALLBACK (expand_toggled),
 265                     list_store);
 266   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 267                                               -1, "Expand",
 268                                               cell,
 269                                               set_expand_func, NULL, NULL);
 270
 271   cell = gtk_cell_renderer_toggle_new ();
 272   g_signal_connect (cell, "toggled", G_CALLBACK (homogeneous_toggled),
 273                     list_store);
 274   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 275                                               -1, "Homogeneous",
 276                                               cell,
 277                                               set_homogeneous_func, NULL,NULL);
 278
 279   cell = gtk_cell_renderer_toggle_new ();
 280   g_signal_connect (cell, "toggled", G_CALLBACK (important_toggled),
 281                     list_store);
 282   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 283                                               -1, "Important",
 284                                               cell,
 285                                               set_important_func, NULL,NULL);
 286
 287   g_object_unref (list_store);
 288
 289   *tree_view_p = tree_view;
 290
 291   return list_store;
 292 }
 293
 294 static void
 295 add_item_to_list (GtkListStore *store, GtkToolItem *item, const gchar *text)
 296 {
 297   GtkTreeIter iter;
 298
 299   gtk_list_store_append (store, &iter);
 300   gtk_list_store_set (store, &iter,
 301                       0, item,
 302                       1, text,
 303                       -1);
 304
 305 }
 306
 307 static void
 308 bold_toggled (GtkToggleToolButton *button)
 309 {
 310   g_message ("Bold toggled (active=%d)",
 311              gtk_toggle_tool_button_get_active (button));
 312 }
 313
 314 static void
 315 set_icon_size_toggled (GtkCheckButton *button, GtkToolbar *toolbar)
 316 {
 317   GtkWidget *option_menu;
 318   int icon_size;
 319
 320   option_menu = g_object_get_data (G_OBJECT (button), "option-menu");
 321
 322   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
 323     {
 324       if (gtk_combo_box_get_active (GTK_COMBO_BOX (option_menu)) == 0)
 325         icon_size = GTK_ICON_SIZE_SMALL_TOOLBAR;
 326       else
 327         icon_size = GTK_ICON_SIZE_LARGE_TOOLBAR;
 328
 329       gtk_toolbar_set_icon_size (toolbar, icon_size);
 330       gtk_widget_set_sensitive (option_menu, TRUE);
 331     }
 332   else
 333     {
 334       gtk_toolbar_unset_icon_size (toolbar);
 335       gtk_widget_set_sensitive (option_menu, FALSE);
 336     }
 337 }
 338
 339 static void
 340 icon_size_history_changed (GtkComboBox *menu, GtkToolbar *toolbar)
 341 {
 342   int icon_size;
 343
 344   if (gtk_combo_box_get_active (menu) == 0)
 345     icon_size = GTK_ICON_SIZE_SMALL_TOOLBAR;
 346   else
 347     icon_size = GTK_ICON_SIZE_LARGE_TOOLBAR;
 348
 349   gtk_toolbar_set_icon_size (toolbar, icon_size);
 350 }
 351
 352 static gboolean
 353 toolbar_drag_drop (GtkWidget *widget, GdkDragContext *context,
 354                    gint x, gint y, guint time, GtkWidget *label)
 355 {
 356   gchar buf[32];
 357
 358   g_snprintf(buf, sizeof(buf), "%d",
 359              gtk_toolbar_get_drop_index (GTK_TOOLBAR (widget), x, y));
 360   gtk_label_set_label (GTK_LABEL (label), buf);
 361
 362   return TRUE;
 363 }
 364
 365 static GtkTargetEntry target_table[] = {
 366   { "application/x-toolbar-item", 0, 0 }
 367 };
 368
 369 static GtkWidget *
 370 make_prop_editor (GObject *object)
 371 {
 372   GtkWidget *prop_editor = create_prop_editor (object, 0);
 373   gtk_widget_show (prop_editor);
 374   return prop_editor;
 375 }
 376
 377 static void
 378 rtl_toggled (GtkCheckButton *check)
 379 {
 380   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check)))
 381     gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
 382   else
 383     gtk_widget_set_default_direction (GTK_TEXT_DIR_LTR);
 384 }
 385
 386 typedef struct
 387 {
 388   int x;
 389   int y;
 390 } MenuPositionData;
 391
 392 static void
 393 position_function (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data)
 394 {
 395   /* Do not do this in your own code */
 396
 397   MenuPositionData *position_data = user_data;
 398
 399   if (x)
 400     *x = position_data->x;
 401
 402   if (y)
 403     *y = position_data->y;
 404
 405   if (push_in)
 406     *push_in = FALSE;
 407 }
 408
 409 static gboolean
 410 popup_context_menu (GtkToolbar *toolbar, gint x, gint y, gint button_number)
 411 {
 412   MenuPositionData position_data;
 413
 414   GtkMenu *menu = GTK_MENU (gtk_menu_new ());
 415   int i;
 416
 417   for (i = 0; i < 5; i++)
 418     {
 419       GtkWidget *item;
 420       gchar *label = g_strdup_printf ("Item _%d", i);
 421       item = gtk_menu_item_new_with_mnemonic (label);
 422       gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 423     }
 424   gtk_widget_show_all (GTK_WIDGET (menu));
 425
 426   if (button_number != -1)
 427     {
 428       position_data.x = x;
 429       position_data.y = y;
 430
 431       gtk_menu_popup (menu, NULL, NULL, position_function,
 432                       &position_data, button_number, gtk_get_current_event_time());
 433     }
 434   else
 435     gtk_menu_popup (menu, NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time());
 436
 437   return TRUE;
 438 }
 439
 440 static GtkToolItem *drag_item = NULL;
 441
 442 static gboolean
 443 toolbar_drag_motion (GtkToolbar     *toolbar,
 444                      GdkDragContext *context,
 445                      gint            x,
 446                      gint            y,
 447                      guint           time,
 448                      gpointer        null)
 449 {
 450   gint index;
 451
 452   if (!drag_item)
 453     {
 454       drag_item = gtk_tool_button_new (NULL, "A quite long button");
 455       g_object_ref_sink (g_object_ref (drag_item));
 456     }
 457
 458   gdk_drag_status (context, GDK_ACTION_MOVE, time);
 459
 460   index = gtk_toolbar_get_drop_index (toolbar, x, y);
 461
 462   gtk_toolbar_set_drop_highlight_item (toolbar, drag_item, index);
 463
 464   return TRUE;
 465 }
 466
 467 static void
 468 toolbar_drag_leave (GtkToolbar     *toolbar,
 469                     GdkDragContext *context,
 470                     guint           time,
 471                     gpointer        null)
 472 {
 473   if (drag_item)
 474     {
 475       g_object_unref (drag_item);
 476       drag_item = NULL;
 477     }
 478
 479   gtk_toolbar_set_drop_highlight_item (toolbar, NULL, 0);
 480 }
 481
 482 static gboolean
 483 timeout_cb (GtkWidget *widget)
 484 {
 485   static gboolean sensitive = TRUE;
 486
 487   sensitive = !sensitive;
 488
 489   gtk_widget_set_sensitive (widget, sensitive);
 490
 491   return TRUE;
 492 }
 493
 494 static gboolean
 495 timeout_cb1 (GtkWidget *widget)
 496 {
 497         static gboolean sensitive = TRUE;
 498         sensitive = !sensitive;
 499         gtk_widget_set_sensitive (widget, sensitive);
 500         return TRUE;
 501 }
 502
 503 gint
 504 main (gint argc, gchar **argv)
 505 {
 506   GtkWidget *window, *toolbar, *table, *treeview, *scrolled_window;
 507   GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
 508   gint i;
 509   static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
 510                                            "both (horizontal)" };
 511   GtkToolItem *item;
 512   GtkListStore *store;
 513   GtkWidget *image;
 514   GtkWidget *menuitem;
 515   GtkWidget *button;
 516   GtkWidget *label;
 517   GIcon *gicon;
 518   GSList *group;
 519
 520   gtk_init (&argc, &argv);
 521
 522   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 523
 524   g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
 525
 526   table = gtk_table_new (4, 2, FALSE);
 527   gtk_container_add (GTK_CONTAINER (window), table);
 528
 529   toolbar = gtk_toolbar_new ();
 530   gtk_table_attach (GTK_TABLE (table), toolbar,
 531                     0,2, 0,1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 532
 533   hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
 534   gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
 535   gtk_table_attach (GTK_TABLE (table), hbox1,
 536                     1,2, 1,2, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 537
 538   hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
 539   gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
 540   gtk_table_attach (GTK_TABLE (table), hbox2,
 541                     1,2, 2,3, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 542
 543   checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
 544   gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
 545   g_signal_connect (checkbox, "toggled",
 546                     G_CALLBACK (change_orientation), toolbar);
 547
 548   checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
 549   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
 550   gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
 551   g_signal_connect (checkbox, "toggled",
 552                     G_CALLBACK (change_show_arrow), toolbar);
 553
 554   checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
 555   g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
 556   gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
 557
 558   option_menu = gtk_combo_box_text_new ();
 559   gtk_widget_set_sensitive (option_menu, FALSE);
 560   g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
 561
 562   for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
 563     gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]);
 564   gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu),
 565                             gtk_toolbar_get_style (GTK_TOOLBAR (toolbar)));
 566   gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
 567   g_signal_connect (option_menu, "changed",
 568                     G_CALLBACK (change_toolbar_style), toolbar);
 569
 570   checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:");
 571   g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
 572   gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
 573
 574   option_menu = gtk_combo_box_text_new ();
 575   g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
 576   gtk_widget_set_sensitive (option_menu, FALSE);
 577   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar");
 578   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar");
 579
 580   gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
 581   g_signal_connect (option_menu, "changed",
 582                     G_CALLBACK (icon_size_history_changed), toolbar);
 583
 584   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 585   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 586                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 587   gtk_table_attach (GTK_TABLE (table), scrolled_window,
 588                     1,2, 3,4, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 589
 590   store = create_items_list (&treeview);
 591   gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
 592
 593   item = gtk_tool_button_new_from_stock (GTK_STOCK_NEW);
 594   gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
 595   gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), NULL);
 596   add_item_to_list (store, item, "New");
 597   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 598   gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
 599   gtk_tool_item_set_expand (item, TRUE);
 600
 601   menu = gtk_menu_new ();
 602   for (i = 0; i < 20; i++)
 603     {
 604       char *text;
 605       text = g_strdup_printf ("Menuitem %d", i);
 606       menuitem = gtk_menu_item_new_with_label (text);
 607       g_free (text);
 608       gtk_widget_show (menuitem);
 609       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
 610     }
 611
 612   item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_OPEN);
 613   gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
 614   add_item_to_list (store, item, "Open");
 615   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 616   gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
 617
 618   menu = gtk_menu_new ();
 619   for (i = 0; i < 20; i++)
 620     {
 621       char *text;
 622       text = g_strdup_printf ("A%d", i);
 623       menuitem = gtk_menu_item_new_with_label (text);
 624       g_free (text);
 625       gtk_widget_show (menuitem);
 626       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
 627     }
 628
 629   item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_GO_BACK);
 630   gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
 631   add_item_to_list (store, item, "BackWithHistory");
 632   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 633
 634   item = gtk_separator_tool_item_new ();
 635   add_item_to_list (store, item, "-----");
 636   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 637
 638   item = gtk_tool_button_new_from_stock (GTK_STOCK_REFRESH);
 639   add_item_to_list (store, item, "Refresh");
 640   g_signal_connect (item, "clicked", G_CALLBACK (reload_clicked), NULL);
 641   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 642
 643   image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
 644   item = gtk_tool_item_new ();
 645   gtk_widget_show (image);
 646   gtk_container_add (GTK_CONTAINER (item), image);
 647   add_item_to_list (store, item, "(Custom Item)");
 648   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 649
 650   item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_BACK);
 651   add_item_to_list (store, item, "Back");
 652   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 653
 654   item = gtk_separator_tool_item_new ();
 655   add_item_to_list (store, item, "-----");
 656   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 657
 658   item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD);
 659   add_item_to_list (store, item, "Forward");
 660   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 661
 662   item = gtk_toggle_tool_button_new_from_stock (GTK_STOCK_BOLD);
 663   g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
 664   add_item_to_list (store, item, "Bold");
 665   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 666   gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
 667
 668   item = gtk_separator_tool_item_new ();
 669   add_item_to_list (store, item, "-----");
 670   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 671   gtk_tool_item_set_expand (item, TRUE);
 672   gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
 673   g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
 674
 675   item = gtk_radio_tool_button_new_from_stock (NULL, GTK_STOCK_JUSTIFY_LEFT);
 676   group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
 677   add_item_to_list (store, item, "Left");
 678   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 679
 680
 681   item = gtk_radio_tool_button_new_from_stock (group, GTK_STOCK_JUSTIFY_CENTER);
 682   make_prop_editor (G_OBJECT (item));
 683
 684   group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
 685   add_item_to_list (store, item, "Center");
 686   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 687
 688   item = gtk_radio_tool_button_new_from_stock (group, GTK_STOCK_JUSTIFY_RIGHT);
 689   add_item_to_list (store, item, "Right");
 690   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 691
 692   item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
 693   add_item_to_list (store, item, "Apple");
 694   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 695   gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
 696
 697   gicon = g_content_type_get_icon ("video/ogg");
 698   image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
 699   g_object_unref (gicon);
 700   item = gtk_tool_button_new (image, "Video");
 701   add_item_to_list (store, item, "Video");
 702   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 703
 704   image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
 705   item = gtk_tool_button_new (image, "Terminal");
 706   add_item_to_list (store, item, "Terminal");
 707   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
 708
 709   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
 710   gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
 711   gtk_table_attach (GTK_TABLE (table), hbox,
 712                     1,2, 4,5, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 713
 714   button = gtk_button_new_with_label ("Drag me to the toolbar");
 715   gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 716
 717   label = gtk_label_new ("Drop index:");
 718   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 719
 720   label = gtk_label_new ("");
 721   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 722
 723   checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
 724   if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
 725     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
 726   else
 727     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
 728   g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);
 729
 730   gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
 731
 732   gtk_drag_source_set (button, GDK_BUTTON1_MASK,
 733                        target_table, G_N_ELEMENTS (target_table),
 734                        GDK_ACTION_MOVE);
 735   gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
 736                      target_table, G_N_ELEMENTS (target_table),
 737                      GDK_ACTION_MOVE);
 738   g_signal_connect (toolbar, "drag_motion",
 739                     G_CALLBACK (toolbar_drag_motion), NULL);
 740   g_signal_connect (toolbar, "drag_leave",
 741                     G_CALLBACK (toolbar_drag_leave), NULL);
 742   g_signal_connect (toolbar, "drag_drop",
 743                     G_CALLBACK (toolbar_drag_drop), label);
 744
 745   gtk_widget_show_all (window);
 746
 747   make_prop_editor (G_OBJECT (toolbar));
 748
 749   g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
 750
 751   g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
 752
 753   gtk_main ();
 754
 755   return 0;
 756 }