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

   1 /* testmerge.c
   2  * Copyright (C) 2003 James Henstridge
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library 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 #include "config.h"
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27 #include <gtk/gtk.h>
  28
  29 #ifndef STDOUT_FILENO
  30 #define STDOUT_FILENO 1
  31 #endif
  32
  33 struct { const gchar *filename; guint merge_id; } merge_ids[] = {
  34   { "merge-1.ui", 0 },
  35   { "merge-2.ui", 0 },
  36   { "merge-3.ui", 0 }
  37 };
  38
  39 static void
  40 dump_tree (GtkWidget    *button,
  41            GtkUIManager *merge)
  42 {
  43   gchar *dump;
  44
  45   dump = gtk_ui_manager_get_ui (merge);
  46   g_message ("%s", dump);
  47   g_free (dump);
  48 }
  49
  50 static void
  51 dump_accels (void)
  52 {
  53   gtk_accel_map_save_fd (STDOUT_FILENO);
  54 }
  55
  56 static void
  57 print_toplevel (GtkWidget *widget, gpointer user_data)
  58 {
  59   g_print ("%s\n", G_OBJECT_TYPE_NAME (widget));
  60 }
  61
  62 static void
  63 dump_toplevels (GtkWidget    *button,
  64                 GtkUIManager *merge)
  65 {
  66   GSList *toplevels;
  67
  68   toplevels = gtk_ui_manager_get_toplevels (merge,
  69                                             GTK_UI_MANAGER_MENUBAR |
  70                                             GTK_UI_MANAGER_TOOLBAR |
  71                                             GTK_UI_MANAGER_POPUP);
  72
  73   g_slist_foreach (toplevels, (GFunc) print_toplevel, NULL);
  74   g_slist_free (toplevels);
  75 }
  76
  77 static void
  78 toggle_tearoffs (GtkWidget    *button,
  79                  GtkUIManager *merge)
  80 {
  81   gboolean add_tearoffs;
  82
  83   add_tearoffs = gtk_ui_manager_get_add_tearoffs (merge);
  84
  85   gtk_ui_manager_set_add_tearoffs (merge, !add_tearoffs);
  86 }
  87
  88 static gint
  89 delayed_toggle_dynamic (GtkUIManager *merge)
  90 {
  91   GtkAction *dyn;
  92   static GtkActionGroup *dynamic = NULL;
  93   static guint merge_id = 0;
  94
  95   if (!dynamic)
  96     {
  97       dynamic = gtk_action_group_new ("dynamic");
  98       gtk_ui_manager_insert_action_group (merge, dynamic, 0);
  99       dyn = g_object_new (GTK_TYPE_ACTION,
 100                           "name", "dyn1",
 101                           "label", "Dynamic action 1",
 102                           "stock_id", GTK_STOCK_COPY,
 103                           NULL);
 104       gtk_action_group_add_action (dynamic, dyn);
 105       dyn = g_object_new (GTK_TYPE_ACTION,
 106                           "name", "dyn2",
 107                           "label", "Dynamic action 2",
 108                           "stock_id", GTK_STOCK_EXECUTE,
 109                           NULL);
 110       gtk_action_group_add_action (dynamic, dyn);
 111     }
 112
 113   if (merge_id == 0)
 114     {
 115       merge_id = gtk_ui_manager_new_merge_id (merge);
 116       gtk_ui_manager_add_ui (merge, merge_id, "/toolbar1/ToolbarPlaceholder",
 117                              "dyn1", "dyn1", 0, 0);
 118       gtk_ui_manager_add_ui (merge, merge_id, "/toolbar1/ToolbarPlaceholder",
 119                              "dynsep", NULL, GTK_UI_MANAGER_SEPARATOR, 0);
 120       gtk_ui_manager_add_ui (merge, merge_id, "/toolbar1/ToolbarPlaceholder",
 121                              "dyn2", "dyn2", 0, 0);
 122
 123       gtk_ui_manager_add_ui (merge, merge_id, "/menubar/EditMenu",
 124                              "dyn1menu", "dyn1", GTK_UI_MANAGER_MENU, 0);
 125       gtk_ui_manager_add_ui (merge, merge_id, "/menubar/EditMenu/dyn1menu",
 126                              "dyn1", "dyn1", GTK_UI_MANAGER_MENUITEM, 0);
 127       gtk_ui_manager_add_ui (merge, merge_id, "/menubar/EditMenu/dyn1menu/dyn1",
 128                              "dyn2", "dyn2", GTK_UI_MANAGER_AUTO, FALSE);
 129     }
 130   else
 131     {
 132       gtk_ui_manager_remove_ui (merge, merge_id);
 133       merge_id = 0;
 134     }
 135
 136   return FALSE;
 137 }
 138
 139 static void
 140 toggle_dynamic (GtkWidget    *button,
 141                 GtkUIManager *merge)
 142 {
 143   gdk_threads_add_timeout (2000, (GSourceFunc)delayed_toggle_dynamic, merge);
 144 }
 145
 146 static void
 147 activate_action (GtkAction *action)
 148 {
 149   const gchar *name = gtk_action_get_name (action);
 150   const gchar *typename = G_OBJECT_TYPE_NAME (action);
 151
 152   g_message ("Action %s (type=%s) activated", name, typename);
 153 }
 154
 155 static void
 156 toggle_action (GtkAction *action)
 157 {
 158   const gchar *name = gtk_action_get_name (action);
 159   const gchar *typename = G_OBJECT_TYPE_NAME (action);
 160
 161   g_message ("ToggleAction %s (type=%s) toggled (active=%d)", name, typename,
 162              gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
 163 }
 164
 165
 166 static void
 167 radio_action_changed (GtkAction *action, GtkRadioAction *current)
 168 {
 169   g_message ("RadioAction %s (type=%s) activated (active=%d) (value %d)",
 170              gtk_action_get_name (GTK_ACTION (current)),
 171              G_OBJECT_TYPE_NAME (GTK_ACTION (current)),
 172              gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (current)),
 173              gtk_radio_action_get_current_value (current));
 174 }
 175
 176 static GtkActionEntry entries[] = {
 177   { "FileMenuAction", NULL, "_File" },
 178   { "EditMenuAction", NULL, "_Edit" },
 179   { "HelpMenuAction", NULL, "_Help" },
 180   { "JustifyMenuAction", NULL, "_Justify" },
 181   { "EmptyMenu1Action", NULL, "Empty 1" },
 182   { "EmptyMenu2Action", NULL, "Empty 2" },
 183   { "Test", NULL, "Test" },
 184
 185   { "QuitAction",  GTK_STOCK_QUIT,  NULL,     "<control>q", "Quit", G_CALLBACK (gtk_main_quit) },
 186   { "NewAction",   GTK_STOCK_NEW,   NULL,     "<control>n", "Create something", G_CALLBACK (activate_action) },
 187   { "New2Action",  GTK_STOCK_NEW,   NULL,     "<control>m", "Create something else", G_CALLBACK (activate_action) },
 188   { "OpenAction",  GTK_STOCK_OPEN,  NULL,     NULL,         "Open it", G_CALLBACK (activate_action) },
 189   { "CutAction",   GTK_STOCK_CUT,   NULL,     "<control>x", "Knive", G_CALLBACK (activate_action) },
 190   { "CopyAction",  GTK_STOCK_COPY,  NULL,     "<control>c", "Copy", G_CALLBACK (activate_action) },
 191   { "PasteAction", GTK_STOCK_PASTE, NULL,     "<control>v", "Paste", G_CALLBACK (activate_action) },
 192   { "AboutAction", NULL,            "_About", NULL,         "About", G_CALLBACK (activate_action) },
 193 };
 194 static guint n_entries = G_N_ELEMENTS (entries);
 195
 196 static GtkToggleActionEntry toggle_entries[] = {
 197   { "BoldAction",  GTK_STOCK_BOLD,  "_Bold",  "<control>b", "Make it bold", G_CALLBACK (toggle_action),
 198     TRUE },
 199 };
 200 static guint n_toggle_entries = G_N_ELEMENTS (toggle_entries);
 201
 202 enum {
 203   JUSTIFY_LEFT,
 204   JUSTIFY_CENTER,
 205   JUSTIFY_RIGHT,
 206   JUSTIFY_FILL
 207 };
 208
 209 static GtkRadioActionEntry radio_entries[] = {
 210   { "justify-left", GTK_STOCK_JUSTIFY_LEFT, NULL, "<control>L",
 211     "Left justify the text", JUSTIFY_LEFT },
 212   { "justify-center", GTK_STOCK_JUSTIFY_CENTER, NULL, "<control>E",
 213     "Center justify the text", JUSTIFY_CENTER },
 214   { "justify-right", GTK_STOCK_JUSTIFY_RIGHT, NULL, "<control>R",
 215     "Right justify the text", JUSTIFY_RIGHT },
 216   { "justify-fill", GTK_STOCK_JUSTIFY_FILL, NULL, "<control>J",
 217     "Fill justify the text", JUSTIFY_FILL },
 218 };
 219 static guint n_radio_entries = G_N_ELEMENTS (radio_entries);
 220
 221 static void
 222 add_widget (GtkUIManager *merge,
 223             GtkWidget    *widget,
 224             GtkBox       *box)
 225 {
 226   GtkWidget *handle_box;
 227
 228   if (GTK_IS_TOOLBAR (widget))
 229     {
 230       handle_box = gtk_handle_box_new ();
 231       gtk_widget_show (handle_box);
 232       gtk_container_add (GTK_CONTAINER (handle_box), widget);
 233       gtk_box_pack_start (box, handle_box, FALSE, FALSE, 0);
 234       g_signal_connect_swapped (widget, "destroy",
 235                                 G_CALLBACK (gtk_widget_destroy), handle_box);
 236     }
 237   else
 238     gtk_box_pack_start (box, widget, FALSE, FALSE, 0);
 239
 240   gtk_widget_show (widget);
 241 }
 242
 243 static void
 244 toggle_merge (GtkWidget    *button,
 245               GtkUIManager *merge)
 246 {
 247   gint mergenum;
 248
 249   mergenum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "mergenum"));
 250
 251   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
 252     {
 253       GError *err = NULL;
 254
 255       g_message ("merging %s", merge_ids[mergenum].filename);
 256       merge_ids[mergenum].merge_id =
 257         gtk_ui_manager_add_ui_from_file (merge, merge_ids[mergenum].filename, &err);
 258       if (err != NULL)
 259         {
 260           GtkWidget *dialog;
 261
 262           dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (button)),
 263                                            0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
 264                                            "could not merge %s: %s", merge_ids[mergenum].filename,
 265                                            err->message);
 266
 267           g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
 268           gtk_widget_show (dialog);
 269
 270           g_clear_error (&err);
 271         }
 272     }
 273   else
 274     {
 275       g_message ("unmerging %s (merge_id=%u)", merge_ids[mergenum].filename,
 276                  merge_ids[mergenum].merge_id);
 277       gtk_ui_manager_remove_ui (merge, merge_ids[mergenum].merge_id);
 278     }
 279 }
 280
 281 static void
 282 set_name_func (GtkTreeViewColumn *tree_column,
 283                GtkCellRenderer   *cell,
 284                GtkTreeModel      *tree_model,
 285                GtkTreeIter       *iter,
 286                gpointer           data)
 287 {
 288   GtkAction *action;
 289   char *name;
 290
 291   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 292   g_object_get (action, "name", &name, NULL);
 293   g_object_set (cell, "text", name, NULL);
 294   g_free (name);
 295   g_object_unref (action);
 296 }
 297
 298 static void
 299 set_sensitive_func (GtkTreeViewColumn *tree_column,
 300                     GtkCellRenderer   *cell,
 301                     GtkTreeModel      *tree_model,
 302                     GtkTreeIter       *iter,
 303                     gpointer           data)
 304 {
 305   GtkAction *action;
 306   gboolean sensitive;
 307
 308   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 309   g_object_get (action, "sensitive", &sensitive, NULL);
 310   g_object_set (cell, "active", sensitive, NULL);
 311   g_object_unref (action);
 312 }
 313
 314
 315 static void
 316 set_visible_func (GtkTreeViewColumn *tree_column,
 317                   GtkCellRenderer   *cell,
 318                   GtkTreeModel      *tree_model,
 319                   GtkTreeIter       *iter,
 320                   gpointer           data)
 321 {
 322   GtkAction *action;
 323   gboolean visible;
 324
 325   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 326   g_object_get (action, "visible", &visible, NULL);
 327   g_object_set (cell, "active", visible, NULL);
 328   g_object_unref (action);
 329 }
 330
 331 static void
 332 sensitivity_toggled (GtkCellRendererToggle *cell,
 333                      const gchar           *path_str,
 334                      GtkTreeModel          *model)
 335 {
 336   GtkTreePath *path;
 337   GtkTreeIter iter;
 338   GtkAction *action;
 339   gboolean sensitive;
 340
 341   path = gtk_tree_path_new_from_string (path_str);
 342   gtk_tree_model_get_iter (model, &iter, path);
 343
 344   gtk_tree_model_get (model, &iter, 0, &action, -1);
 345   g_object_get (action, "sensitive", &sensitive, NULL);
 346   g_object_set (action, "sensitive", !sensitive, NULL);
 347   gtk_tree_model_row_changed (model, path, &iter);
 348   gtk_tree_path_free (path);
 349 }
 350
 351 static void
 352 visibility_toggled (GtkCellRendererToggle *cell,
 353                     const gchar           *path_str,
 354                     GtkTreeModel          *model)
 355 {
 356   GtkTreePath *path;
 357   GtkTreeIter iter;
 358   GtkAction *action;
 359   gboolean visible;
 360
 361   path = gtk_tree_path_new_from_string (path_str);
 362   gtk_tree_model_get_iter (model, &iter, path);
 363
 364   gtk_tree_model_get (model, &iter, 0, &action, -1);
 365   g_object_get (action, "visible", &visible, NULL);
 366   g_object_set (action, "visible", !visible, NULL);
 367   gtk_tree_model_row_changed (model, path, &iter);
 368   gtk_tree_path_free (path);
 369 }
 370
 371 static gint
 372 iter_compare_func (GtkTreeModel *model,
 373                    GtkTreeIter  *a,
 374                    GtkTreeIter  *b,
 375                    gpointer      user_data)
 376 {
 377   GValue a_value = { 0, }, b_value = { 0, };
 378   GtkAction *a_action, *b_action;
 379   const gchar *a_name, *b_name;
 380   gint retval = 0;
 381
 382   gtk_tree_model_get_value (model, a, 0, &a_value);
 383   gtk_tree_model_get_value (model, b, 0, &b_value);
 384   a_action = GTK_ACTION (g_value_get_object (&a_value));
 385   b_action = GTK_ACTION (g_value_get_object (&b_value));
 386
 387   a_name = gtk_action_get_name (a_action);
 388   b_name = gtk_action_get_name (b_action);
 389   if (a_name == NULL && b_name == NULL)
 390     retval = 0;
 391   else if (a_name == NULL)
 392     retval = -1;
 393   else if (b_name == NULL)
 394     retval = 1;
 395   else
 396     retval = strcmp (a_name, b_name);
 397
 398   g_value_unset (&b_value);
 399   g_value_unset (&a_value);
 400
 401   return retval;
 402 }
 403
 404 static GtkWidget *
 405 create_tree_view (GtkUIManager *merge)
 406 {
 407   GtkWidget *tree_view, *sw;
 408   GtkListStore *store;
 409   GList *p;
 410   GtkCellRenderer *cell;
 411
 412   store = gtk_list_store_new (1, GTK_TYPE_ACTION);
 413   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), 0,
 414                                    iter_compare_func, NULL, NULL);
 415   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 0,
 416                                         GTK_SORT_ASCENDING);
 417
 418   for (p = gtk_ui_manager_get_action_groups (merge); p; p = p->next)
 419     {
 420       GList *actions, *l;
 421
 422       actions = gtk_action_group_list_actions (p->data);
 423
 424       for (l = actions; l; l = l->next)
 425         {
 426           GtkTreeIter iter;
 427
 428           gtk_list_store_append (store, &iter);
 429           gtk_list_store_set (store, &iter, 0, l->data, -1);
 430         }
 431
 432       g_list_free (actions);
 433     }
 434
 435   tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 436   g_object_unref (store);
 437
 438   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 439                                               -1, "Action",
 440                                               gtk_cell_renderer_text_new (),
 441                                               set_name_func, NULL, NULL);
 442
 443   gtk_tree_view_column_set_sort_column_id (gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), 0), 0);
 444
 445   cell = gtk_cell_renderer_toggle_new ();
 446   g_signal_connect (cell, "toggled", G_CALLBACK (sensitivity_toggled), store);
 447   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 448                                               -1, "Sensitive",
 449                                               cell,
 450                                               set_sensitive_func, NULL, NULL);
 451
 452   cell = gtk_cell_renderer_toggle_new ();
 453   g_signal_connect (cell, "toggled", G_CALLBACK (visibility_toggled), store);
 454   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 455                                               -1, "Visible",
 456                                               cell,
 457                                               set_visible_func, NULL, NULL);
 458
 459   sw = gtk_scrolled_window_new (NULL, NULL);
 460   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 461                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 462   gtk_container_add (GTK_CONTAINER (sw), tree_view);
 463
 464   return sw;
 465 }
 466
 467 static gboolean
 468 area_press (GtkWidget      *drawing_area,
 469             GdkEventButton *event,
 470             GtkUIManager   *merge)
 471 {
 472   gtk_widget_grab_focus (drawing_area);
 473
 474   if (event->button == 3 &&
 475       event->type == GDK_BUTTON_PRESS)
 476     {
 477       GtkWidget *menu = gtk_ui_manager_get_widget (merge, "/FileMenu");
 478
 479       if (GTK_IS_MENU (menu))
 480         {
 481           gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
 482                           NULL, drawing_area,
 483                           3, event->time);
 484           return TRUE;
 485         }
 486     }
 487
 488   return FALSE;
 489
 490 }
 491
 492 static void
 493 activate_path (GtkWidget      *button,
 494                GtkUIManager   *merge)
 495 {
 496   GtkAction *action = gtk_ui_manager_get_action (merge,
 497                                                  "/menubar/HelpMenu/About");
 498   if (action)
 499     gtk_action_activate (action);
 500   else
 501     g_message ("no action found");
 502 }
 503
 504 typedef struct _ActionStatus ActionStatus;
 505
 506 struct _ActionStatus {
 507   GtkAction *action;
 508   GtkWidget *statusbar;
 509 };
 510
 511 static void
 512 action_status_destroy (gpointer data)
 513 {
 514   ActionStatus *action_status = data;
 515
 516   g_object_unref (action_status->action);
 517   g_object_unref (action_status->statusbar);
 518
 519   g_free (action_status);
 520 }
 521
 522 static void
 523 set_tip (GtkWidget *widget)
 524 {
 525   ActionStatus *data;
 526   gchar *tooltip;
 527
 528   data = g_object_get_data (G_OBJECT (widget), "action-status");
 529
 530   if (data)
 531     {
 532       g_object_get (data->action, "tooltip", &tooltip, NULL);
 533
 534       gtk_statusbar_push (GTK_STATUSBAR (data->statusbar), 0,
 535                           tooltip ? tooltip : "");
 536
 537       g_free (tooltip);
 538     }
 539 }
 540
 541 static void
 542 unset_tip (GtkWidget *widget)
 543 {
 544   ActionStatus *data;
 545
 546   data = g_object_get_data (G_OBJECT (widget), "action-status");
 547
 548   if (data)
 549     gtk_statusbar_pop (GTK_STATUSBAR (data->statusbar), 0);
 550 }
 551
 552 static void
 553 connect_proxy (GtkUIManager *merge,
 554                GtkAction    *action,
 555                GtkWidget    *proxy,
 556                GtkWidget    *statusbar)
 557 {
 558   if (GTK_IS_MENU_ITEM (proxy))
 559     {
 560       ActionStatus *data;
 561
 562       data = g_object_get_data (G_OBJECT (proxy), "action-status");
 563       if (data)
 564         {
 565           g_object_unref (data->action);
 566           g_object_unref (data->statusbar);
 567
 568           data->action = g_object_ref (action);
 569           data->statusbar = g_object_ref (statusbar);
 570         }
 571       else
 572         {
 573           data = g_new0 (ActionStatus, 1);
 574
 575           data->action = g_object_ref (action);
 576           data->statusbar = g_object_ref (statusbar);
 577
 578           g_object_set_data_full (G_OBJECT (proxy), "action-status",
 579                                   data, action_status_destroy);
 580
 581           g_signal_connect (proxy, "select",  G_CALLBACK (set_tip), NULL);
 582           g_signal_connect (proxy, "deselect", G_CALLBACK (unset_tip), NULL);
 583         }
 584     }
 585 }
 586
 587 int
 588 main (int argc, char **argv)
 589 {
 590   GtkActionGroup *action_group;
 591   GtkAction *action;
 592   GtkUIManager *merge;
 593   GtkWidget *window, *table, *frame, *menu_box, *vbox, *view;
 594   GtkWidget *button, *area, *statusbar;
 595   gint i;
 596
 597   gtk_init (&argc, &argv);
 598
 599   action_group = gtk_action_group_new ("TestActions");
 600   gtk_action_group_add_actions (action_group,
 601                                 entries, n_entries,
 602                                 NULL);
 603   action = gtk_action_group_get_action (action_group, "EmptyMenu1Action");
 604   g_object_set (action, "hide_if_empty", FALSE, NULL);
 605   action = gtk_action_group_get_action (action_group, "EmptyMenu2Action");
 606   g_object_set (action, "hide_if_empty", TRUE, NULL);
 607   gtk_action_group_add_toggle_actions (action_group,
 608                                        toggle_entries, n_toggle_entries,
 609                                        NULL);
 610   gtk_action_group_add_radio_actions (action_group,
 611                                       radio_entries, n_radio_entries,
 612                                       JUSTIFY_RIGHT,
 613                                       G_CALLBACK (radio_action_changed), NULL);
 614
 615   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 616   gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
 617   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 618
 619   table = gtk_table_new (2, 2, FALSE);
 620   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
 621   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
 622   gtk_container_set_border_width (GTK_CONTAINER (table), 2);
 623   gtk_container_add (GTK_CONTAINER (window), table);
 624
 625   frame = gtk_frame_new ("Menus and Toolbars");
 626   gtk_table_attach (GTK_TABLE (table), frame, 0,2, 1,2,
 627                     GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 628
 629   menu_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
 630   gtk_container_set_border_width (GTK_CONTAINER (menu_box), 2);
 631   gtk_container_add (GTK_CONTAINER (frame), menu_box);
 632
 633   statusbar = gtk_statusbar_new ();
 634   gtk_box_pack_end (GTK_BOX (menu_box), statusbar, FALSE, FALSE, 0);
 635
 636   area = gtk_drawing_area_new ();
 637   gtk_widget_set_events (area, GDK_BUTTON_PRESS_MASK);
 638   gtk_widget_set_size_request (area, -1, 40);
 639   gtk_box_pack_end (GTK_BOX (menu_box), area, FALSE, FALSE, 0);
 640   gtk_widget_show (area);
 641
 642   button = gtk_button_new ();
 643   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 644   gtk_activatable_set_related_action (GTK_ACTIVATABLE (button),
 645                             gtk_action_group_get_action (action_group, "AboutAction"));
 646
 647   gtk_widget_show (button);
 648
 649   button = gtk_check_button_new ();
 650   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 651   gtk_activatable_set_related_action (GTK_ACTIVATABLE (button),
 652                             gtk_action_group_get_action (action_group, "BoldAction"));
 653   gtk_widget_show (button);
 654
 655   merge = gtk_ui_manager_new ();
 656
 657   g_signal_connect (merge, "connect-proxy", G_CALLBACK (connect_proxy), statusbar);
 658   g_signal_connect (area, "button_press_event", G_CALLBACK (area_press), merge);
 659
 660   gtk_ui_manager_insert_action_group (merge, action_group, 0);
 661   g_signal_connect (merge, "add_widget", G_CALLBACK (add_widget), menu_box);
 662
 663   gtk_window_add_accel_group (GTK_WINDOW (window),
 664                               gtk_ui_manager_get_accel_group (merge));
 665
 666   frame = gtk_frame_new ("UI Files");
 667   gtk_table_attach (GTK_TABLE (table), frame, 0,1, 0,1,
 668                     GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 669
 670   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 2);
 671   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
 672   gtk_container_add (GTK_CONTAINER (frame), vbox);
 673
 674   for (i = 0; i < G_N_ELEMENTS (merge_ids); i++)
 675     {
 676       button = gtk_check_button_new_with_label (merge_ids[i].filename);
 677       g_object_set_data (G_OBJECT (button), "mergenum", GINT_TO_POINTER (i));
 678       g_signal_connect (button, "toggled", G_CALLBACK (toggle_merge), merge);
 679       gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 680       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 681     }
 682
 683   button = gtk_check_button_new_with_label ("Tearoffs");
 684   g_signal_connect (button, "clicked", G_CALLBACK (toggle_tearoffs), merge);
 685   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 686
 687   button = gtk_check_button_new_with_label ("Dynamic");
 688   g_signal_connect (button, "clicked", G_CALLBACK (toggle_dynamic), merge);
 689   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 690
 691   button = gtk_button_new_with_label ("Activate path");
 692   g_signal_connect (button, "clicked", G_CALLBACK (activate_path), merge);
 693   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 694
 695   button = gtk_button_new_with_label ("Dump Tree");
 696   g_signal_connect (button, "clicked", G_CALLBACK (dump_tree), merge);
 697   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 698
 699   button = gtk_button_new_with_label ("Dump Toplevels");
 700   g_signal_connect (button, "clicked", G_CALLBACK (dump_toplevels), merge);
 701   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 702
 703   button = gtk_button_new_with_label ("Dump Accels");
 704   g_signal_connect (button, "clicked", G_CALLBACK (dump_accels), NULL);
 705   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 706
 707   view = create_tree_view (merge);
 708   gtk_table_attach (GTK_TABLE (table), view, 1,2, 0,1,
 709                     GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 710
 711   gtk_widget_show_all (window);
 712   gtk_main ();
 713
 714 #ifdef DEBUG_UI_MANAGER
 715   {
 716     GList *action;
 717
 718     g_print ("\n> before unreffing the ui manager <\n");
 719     for (action = gtk_action_group_list_actions (action_group);
 720          action;
 721          action = action->next)
 722       {
 723         GtkAction *a = action->data;
 724         g_print ("  action %s ref count %d\n",
 725                  gtk_action_get_name (a), G_OBJECT (a)->ref_count);
 726       }
 727   }
 728 #endif
 729
 730   g_object_unref (merge);
 731
 732 #ifdef DEBUG_UI_MANAGER
 733   {
 734     GList *action;
 735
 736     g_print ("\n> after unreffing the ui manager <\n");
 737     for (action = gtk_action_group_list_actions (action_group);
 738          action;
 739          action = action->next)
 740       {
 741         GtkAction *a = action->data;
 742         g_print ("  action %s ref count %d\n",
 743                  gtk_action_get_name (a), G_OBJECT (a)->ref_count);
 744       }
 745   }
 746 #endif
 747
 748   g_object_unref (action_group);
 749
 750   return 0;
 751 }