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 (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_object_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
 433   tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 434   g_object_unref (store);
 435
 436   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 437                                               -1, "Action",
 438                                               gtk_cell_renderer_text_new (),
 439                                               set_name_func, NULL, NULL);
 440
 441   gtk_tree_view_column_set_sort_column_id (gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), 0), 0);
 442
 443   cell = gtk_cell_renderer_toggle_new ();
 444   g_signal_connect (cell, "toggled", G_CALLBACK (sensitivity_toggled), store);
 445   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 446                                               -1, "Sensitive",
 447                                               cell,
 448                                               set_sensitive_func, NULL, NULL);
 449
 450   cell = gtk_cell_renderer_toggle_new ();
 451   g_signal_connect (cell, "toggled", G_CALLBACK (visibility_toggled), store);
 452   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 453                                               -1, "Visible",
 454                                               cell,
 455                                               set_visible_func, NULL, NULL);
 456
 457   sw = gtk_scrolled_window_new (NULL, NULL);
 458   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 459                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 460   gtk_container_add (GTK_CONTAINER (sw), tree_view);
 461
 462   return sw;
 463 }
 464
 465 static gboolean
 466 area_press (GtkWidget      *drawing_area,
 467             GdkEventButton *event,
 468             GtkUIManager   *merge)
 469 {
 470   gtk_widget_grab_focus (drawing_area);
 471
 472   if (event->button == 3 &&
 473       event->type == GDK_BUTTON_PRESS)
 474     {
 475       GtkWidget *menu = gtk_ui_manager_get_widget (merge, "/FileMenu");
 476
 477       if (GTK_IS_MENU (menu))
 478         {
 479           gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
 480                           NULL, drawing_area,
 481                           3, event->time);
 482           return TRUE;
 483         }
 484     }
 485
 486   return FALSE;
 487
 488 }
 489
 490 static void
 491 activate_path (GtkWidget      *button,
 492                GtkUIManager   *merge)
 493 {
 494   GtkAction *action = gtk_ui_manager_get_action (merge,
 495                                                  "/menubar/HelpMenu/About");
 496   if (action)
 497     gtk_action_activate (action);
 498   else
 499     g_message ("no action found");
 500 }
 501
 502 typedef struct _ActionStatus ActionStatus;
 503
 504 struct _ActionStatus {
 505   GtkAction *action;
 506   GtkWidget *statusbar;
 507 };
 508
 509 static void
 510 action_status_destroy (gpointer data)
 511 {
 512   ActionStatus *action_status = data;
 513
 514   g_object_unref (action_status->action);
 515   g_object_unref (action_status->statusbar);
 516
 517   g_free (action_status);
 518 }
 519
 520 static void
 521 set_tip (GtkWidget *widget)
 522 {
 523   ActionStatus *data;
 524   gchar *tooltip;
 525
 526   data = g_object_get_data (G_OBJECT (widget), "action-status");
 527
 528   if (data)
 529     {
 530       g_object_get (data->action, "tooltip", &tooltip, NULL);
 531
 532       gtk_statusbar_push (GTK_STATUSBAR (data->statusbar), 0,
 533                           tooltip ? tooltip : "");
 534
 535       g_free (tooltip);
 536     }
 537 }
 538
 539 static void
 540 unset_tip (GtkWidget *widget)
 541 {
 542   ActionStatus *data;
 543
 544   data = g_object_get_data (G_OBJECT (widget), "action-status");
 545
 546   if (data)
 547     gtk_statusbar_pop (GTK_STATUSBAR (data->statusbar), 0);
 548 }
 549
 550 static void
 551 connect_proxy (GtkUIManager *merge,
 552                GtkAction    *action,
 553                GtkWidget    *proxy,
 554                GtkWidget    *statusbar)
 555 {
 556   if (GTK_IS_MENU_ITEM (proxy))
 557     {
 558       ActionStatus *data;
 559
 560       data = g_object_get_data (G_OBJECT (proxy), "action-status");
 561       if (data)
 562         {
 563           g_object_unref (data->action);
 564           g_object_unref (data->statusbar);
 565
 566           data->action = g_object_ref (action);
 567           data->statusbar = g_object_ref (statusbar);
 568         }
 569       else
 570         {
 571           data = g_new0 (ActionStatus, 1);
 572
 573           data->action = g_object_ref (action);
 574           data->statusbar = g_object_ref (statusbar);
 575
 576           g_object_set_data_full (G_OBJECT (proxy), "action-status",
 577                                   data, action_status_destroy);
 578
 579           g_signal_connect (proxy, "select",  G_CALLBACK (set_tip), NULL);
 580           g_signal_connect (proxy, "deselect", G_CALLBACK (unset_tip), NULL);
 581         }
 582     }
 583 }
 584
 585 int
 586 main (int argc, char **argv)
 587 {
 588   GtkActionGroup *action_group;
 589   GtkAction *action;
 590   GtkUIManager *merge;
 591   GtkWidget *window, *table, *frame, *menu_box, *vbox, *view;
 592   GtkWidget *button, *area, *statusbar;
 593   gint i;
 594
 595   gtk_init (&argc, &argv);
 596
 597   action_group = gtk_action_group_new ("TestActions");
 598   gtk_action_group_add_actions (action_group,
 599                                 entries, n_entries,
 600                                 NULL);
 601   action = gtk_action_group_get_action (action_group, "EmptyMenu1Action");
 602   g_object_set (action, "hide_if_empty", FALSE, NULL);
 603   action = gtk_action_group_get_action (action_group, "EmptyMenu2Action");
 604   g_object_set (action, "hide_if_empty", TRUE, NULL);
 605   gtk_action_group_add_toggle_actions (action_group,
 606                                        toggle_entries, n_toggle_entries,
 607                                        NULL);
 608   gtk_action_group_add_radio_actions (action_group,
 609                                       radio_entries, n_radio_entries,
 610                                       JUSTIFY_RIGHT,
 611                                       G_CALLBACK (radio_action_changed), NULL);
 612
 613   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 614   gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
 615   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 616
 617   table = gtk_table_new (2, 2, FALSE);
 618   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
 619   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
 620   gtk_container_set_border_width (GTK_CONTAINER (table), 2);
 621   gtk_container_add (GTK_CONTAINER (window), table);
 622
 623   frame = gtk_frame_new ("Menus and Toolbars");
 624   gtk_table_attach (GTK_TABLE (table), frame, 0,2, 1,2,
 625                     GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 626
 627   menu_box = gtk_vbox_new (FALSE, 0);
 628   gtk_container_set_border_width (GTK_CONTAINER (menu_box), 2);
 629   gtk_container_add (GTK_CONTAINER (frame), menu_box);
 630
 631   statusbar = gtk_statusbar_new ();
 632   gtk_box_pack_end (GTK_BOX (menu_box), statusbar, FALSE, FALSE, 0);
 633
 634   area = gtk_drawing_area_new ();
 635   gtk_widget_set_events (area, GDK_BUTTON_PRESS_MASK);
 636   gtk_widget_set_size_request (area, -1, 40);
 637   gtk_box_pack_end (GTK_BOX (menu_box), area, FALSE, FALSE, 0);
 638   gtk_widget_show (area);
 639
 640   button = gtk_button_new ();
 641   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 642   gtk_action_connect_proxy (gtk_action_group_get_action (action_group, "AboutAction"),
 643                             button);
 644   gtk_widget_show (button);
 645
 646   button = gtk_check_button_new ();
 647   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 648   gtk_action_connect_proxy (gtk_action_group_get_action (action_group, "BoldAction"),
 649                             button);
 650   gtk_widget_show (button);
 651
 652   merge = gtk_ui_manager_new ();
 653
 654   g_signal_connect (merge, "connect-proxy", G_CALLBACK (connect_proxy), statusbar);
 655   g_signal_connect (area, "button_press_event", G_CALLBACK (area_press), merge);
 656
 657   gtk_ui_manager_insert_action_group (merge, action_group, 0);
 658   g_signal_connect (merge, "add_widget", G_CALLBACK (add_widget), menu_box);
 659
 660   gtk_window_add_accel_group (GTK_WINDOW (window),
 661                               gtk_ui_manager_get_accel_group (merge));
 662
 663   frame = gtk_frame_new ("UI Files");
 664   gtk_table_attach (GTK_TABLE (table), frame, 0,1, 0,1,
 665                     GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 666
 667   vbox = gtk_vbox_new (FALSE, 2);
 668   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
 669   gtk_container_add (GTK_CONTAINER (frame), vbox);
 670
 671   for (i = 0; i < G_N_ELEMENTS (merge_ids); i++)
 672     {
 673       button = gtk_check_button_new_with_label (merge_ids[i].filename);
 674       g_object_set_data (G_OBJECT (button), "mergenum", GINT_TO_POINTER (i));
 675       g_signal_connect (button, "toggled", G_CALLBACK (toggle_merge), merge);
 676       gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 677       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 678     }
 679
 680   button = gtk_check_button_new_with_label ("Tearoffs");
 681   g_signal_connect (button, "clicked", G_CALLBACK (toggle_tearoffs), merge);
 682   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 683
 684   button = gtk_check_button_new_with_label ("Dynamic");
 685   g_signal_connect (button, "clicked", G_CALLBACK (toggle_dynamic), merge);
 686   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 687
 688   button = gtk_button_new_with_label ("Activate path");
 689   g_signal_connect (button, "clicked", G_CALLBACK (activate_path), merge);
 690   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 691
 692   button = gtk_button_new_with_label ("Dump Tree");
 693   g_signal_connect (button, "clicked", G_CALLBACK (dump_tree), merge);
 694   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 695
 696   button = gtk_button_new_with_label ("Dump Toplevels");
 697   g_signal_connect (button, "clicked", G_CALLBACK (dump_toplevels), merge);
 698   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 699
 700   button = gtk_button_new_with_label ("Dump Accels");
 701   g_signal_connect (button, "clicked", G_CALLBACK (dump_accels), NULL);
 702   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 703
 704   view = create_tree_view (merge);
 705   gtk_table_attach (GTK_TABLE (table), view, 1,2, 0,1,
 706                     GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 707
 708   gtk_widget_show_all (window);
 709   gtk_main ();
 710
 711 #ifdef DEBUG_UI_MANAGER
 712   {
 713     GList *action;
 714
 715     g_print ("\n> before unreffing the ui manager <\n");
 716     for (action = gtk_action_group_list_actions (action_group);
 717          action;
 718          action = action->next)
 719       {
 720         GtkAction *a = action->data;
 721         g_print ("  action %s ref count %d\n",
 722                  gtk_action_get_name (a), G_OBJECT (a)->ref_count);
 723       }
 724   }
 725 #endif
 726
 727   g_object_unref (merge);
 728
 729 #ifdef DEBUG_UI_MANAGER
 730   {
 731     GList *action;
 732
 733     g_print ("\n> after unreffing the ui manager <\n");
 734     for (action = gtk_action_group_list_actions (action_group);
 735          action;
 736          action = action->next)
 737       {
 738         GtkAction *a = action->data;
 739         g_print ("  action %s ref count %d\n",
 740                  gtk_action_get_name (a), G_OBJECT (a)->ref_count);
 741       }
 742   }
 743 #endif
 744
 745   g_object_unref (action_group);
 746
 747   return 0;
 748 }