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   gtk_box_pack_start (box, widget, FALSE, FALSE, 0);
 227   gtk_widget_show (widget);
 228 }
 229
 230 static void
 231 toggle_merge (GtkWidget    *button,
 232               GtkUIManager *merge)
 233 {
 234   gint mergenum;
 235
 236   mergenum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "mergenum"));
 237
 238   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
 239     {
 240       GError *err = NULL;
 241
 242       g_message ("merging %s", merge_ids[mergenum].filename);
 243       merge_ids[mergenum].merge_id =
 244         gtk_ui_manager_add_ui_from_file (merge, merge_ids[mergenum].filename, &err);
 245       if (err != NULL)
 246         {
 247           GtkWidget *dialog;
 248
 249           dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (button)),
 250                                            0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
 251                                            "could not merge %s: %s", merge_ids[mergenum].filename,
 252                                            err->message);
 253
 254           g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
 255           gtk_widget_show (dialog);
 256
 257           g_clear_error (&err);
 258         }
 259     }
 260   else
 261     {
 262       g_message ("unmerging %s (merge_id=%u)", merge_ids[mergenum].filename,
 263                  merge_ids[mergenum].merge_id);
 264       gtk_ui_manager_remove_ui (merge, merge_ids[mergenum].merge_id);
 265     }
 266 }
 267
 268 static void
 269 set_name_func (GtkTreeViewColumn *tree_column,
 270                GtkCellRenderer   *cell,
 271                GtkTreeModel      *tree_model,
 272                GtkTreeIter       *iter,
 273                gpointer           data)
 274 {
 275   GtkAction *action;
 276   char *name;
 277
 278   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 279   g_object_get (action, "name", &name, NULL);
 280   g_object_set (cell, "text", name, NULL);
 281   g_free (name);
 282   g_object_unref (action);
 283 }
 284
 285 static void
 286 set_sensitive_func (GtkTreeViewColumn *tree_column,
 287                     GtkCellRenderer   *cell,
 288                     GtkTreeModel      *tree_model,
 289                     GtkTreeIter       *iter,
 290                     gpointer           data)
 291 {
 292   GtkAction *action;
 293   gboolean sensitive;
 294
 295   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 296   g_object_get (action, "sensitive", &sensitive, NULL);
 297   g_object_set (cell, "active", sensitive, NULL);
 298   g_object_unref (action);
 299 }
 300
 301
 302 static void
 303 set_visible_func (GtkTreeViewColumn *tree_column,
 304                   GtkCellRenderer   *cell,
 305                   GtkTreeModel      *tree_model,
 306                   GtkTreeIter       *iter,
 307                   gpointer           data)
 308 {
 309   GtkAction *action;
 310   gboolean visible;
 311
 312   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 313   g_object_get (action, "visible", &visible, NULL);
 314   g_object_set (cell, "active", visible, NULL);
 315   g_object_unref (action);
 316 }
 317
 318 static void
 319 sensitivity_toggled (GtkCellRendererToggle *cell,
 320                      const gchar           *path_str,
 321                      GtkTreeModel          *model)
 322 {
 323   GtkTreePath *path;
 324   GtkTreeIter iter;
 325   GtkAction *action;
 326   gboolean sensitive;
 327
 328   path = gtk_tree_path_new_from_string (path_str);
 329   gtk_tree_model_get_iter (model, &iter, path);
 330
 331   gtk_tree_model_get (model, &iter, 0, &action, -1);
 332   g_object_get (action, "sensitive", &sensitive, NULL);
 333   g_object_set (action, "sensitive", !sensitive, NULL);
 334   gtk_tree_model_row_changed (model, path, &iter);
 335   gtk_tree_path_free (path);
 336 }
 337
 338 static void
 339 visibility_toggled (GtkCellRendererToggle *cell,
 340                     const gchar           *path_str,
 341                     GtkTreeModel          *model)
 342 {
 343   GtkTreePath *path;
 344   GtkTreeIter iter;
 345   GtkAction *action;
 346   gboolean visible;
 347
 348   path = gtk_tree_path_new_from_string (path_str);
 349   gtk_tree_model_get_iter (model, &iter, path);
 350
 351   gtk_tree_model_get (model, &iter, 0, &action, -1);
 352   g_object_get (action, "visible", &visible, NULL);
 353   g_object_set (action, "visible", !visible, NULL);
 354   gtk_tree_model_row_changed (model, path, &iter);
 355   gtk_tree_path_free (path);
 356 }
 357
 358 static gint
 359 iter_compare_func (GtkTreeModel *model,
 360                    GtkTreeIter  *a,
 361                    GtkTreeIter  *b,
 362                    gpointer      user_data)
 363 {
 364   GValue a_value = { 0, }, b_value = { 0, };
 365   GtkAction *a_action, *b_action;
 366   const gchar *a_name, *b_name;
 367   gint retval = 0;
 368
 369   gtk_tree_model_get_value (model, a, 0, &a_value);
 370   gtk_tree_model_get_value (model, b, 0, &b_value);
 371   a_action = GTK_ACTION (g_value_get_object (&a_value));
 372   b_action = GTK_ACTION (g_value_get_object (&b_value));
 373
 374   a_name = gtk_action_get_name (a_action);
 375   b_name = gtk_action_get_name (b_action);
 376   if (a_name == NULL && b_name == NULL)
 377     retval = 0;
 378   else if (a_name == NULL)
 379     retval = -1;
 380   else if (b_name == NULL)
 381     retval = 1;
 382   else
 383     retval = strcmp (a_name, b_name);
 384
 385   g_value_unset (&b_value);
 386   g_value_unset (&a_value);
 387
 388   return retval;
 389 }
 390
 391 static GtkWidget *
 392 create_tree_view (GtkUIManager *merge)
 393 {
 394   GtkWidget *tree_view, *sw;
 395   GtkListStore *store;
 396   GList *p;
 397   GtkCellRenderer *cell;
 398
 399   store = gtk_list_store_new (1, GTK_TYPE_ACTION);
 400   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), 0,
 401                                    iter_compare_func, NULL, NULL);
 402   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 0,
 403                                         GTK_SORT_ASCENDING);
 404
 405   for (p = gtk_ui_manager_get_action_groups (merge); p; p = p->next)
 406     {
 407       GList *actions, *l;
 408
 409       actions = gtk_action_group_list_actions (p->data);
 410
 411       for (l = actions; l; l = l->next)
 412         {
 413           GtkTreeIter iter;
 414
 415           gtk_list_store_append (store, &iter);
 416           gtk_list_store_set (store, &iter, 0, l->data, -1);
 417         }
 418
 419       g_list_free (actions);
 420     }
 421
 422   tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 423   g_object_unref (store);
 424
 425   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 426                                               -1, "Action",
 427                                               gtk_cell_renderer_text_new (),
 428                                               set_name_func, NULL, NULL);
 429
 430   gtk_tree_view_column_set_sort_column_id (gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), 0), 0);
 431
 432   cell = gtk_cell_renderer_toggle_new ();
 433   g_signal_connect (cell, "toggled", G_CALLBACK (sensitivity_toggled), store);
 434   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 435                                               -1, "Sensitive",
 436                                               cell,
 437                                               set_sensitive_func, NULL, NULL);
 438
 439   cell = gtk_cell_renderer_toggle_new ();
 440   g_signal_connect (cell, "toggled", G_CALLBACK (visibility_toggled), store);
 441   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 442                                               -1, "Visible",
 443                                               cell,
 444                                               set_visible_func, NULL, NULL);
 445
 446   sw = gtk_scrolled_window_new (NULL, NULL);
 447   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 448                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 449   gtk_container_add (GTK_CONTAINER (sw), tree_view);
 450
 451   return sw;
 452 }
 453
 454 static gboolean
 455 area_press (GtkWidget      *drawing_area,
 456             GdkEventButton *event,
 457             GtkUIManager   *merge)
 458 {
 459   gtk_widget_grab_focus (drawing_area);
 460
 461   if (event->button == 3 &&
 462       event->type == GDK_BUTTON_PRESS)
 463     {
 464       GtkWidget *menu = gtk_ui_manager_get_widget (merge, "/FileMenu");
 465
 466       if (GTK_IS_MENU (menu))
 467         {
 468           gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
 469                           NULL, drawing_area,
 470                           3, event->time);
 471           return TRUE;
 472         }
 473     }
 474
 475   return FALSE;
 476
 477 }
 478
 479 static void
 480 activate_path (GtkWidget      *button,
 481                GtkUIManager   *merge)
 482 {
 483   GtkAction *action = gtk_ui_manager_get_action (merge,
 484                                                  "/menubar/HelpMenu/About");
 485   if (action)
 486     gtk_action_activate (action);
 487   else
 488     g_message ("no action found");
 489 }
 490
 491 typedef struct _ActionStatus ActionStatus;
 492
 493 struct _ActionStatus {
 494   GtkAction *action;
 495   GtkWidget *statusbar;
 496 };
 497
 498 static void
 499 action_status_destroy (gpointer data)
 500 {
 501   ActionStatus *action_status = data;
 502
 503   g_object_unref (action_status->action);
 504   g_object_unref (action_status->statusbar);
 505
 506   g_free (action_status);
 507 }
 508
 509 static void
 510 set_tip (GtkWidget *widget)
 511 {
 512   ActionStatus *data;
 513   gchar *tooltip;
 514
 515   data = g_object_get_data (G_OBJECT (widget), "action-status");
 516
 517   if (data)
 518     {
 519       g_object_get (data->action, "tooltip", &tooltip, NULL);
 520
 521       gtk_statusbar_push (GTK_STATUSBAR (data->statusbar), 0,
 522                           tooltip ? tooltip : "");
 523
 524       g_free (tooltip);
 525     }
 526 }
 527
 528 static void
 529 unset_tip (GtkWidget *widget)
 530 {
 531   ActionStatus *data;
 532
 533   data = g_object_get_data (G_OBJECT (widget), "action-status");
 534
 535   if (data)
 536     gtk_statusbar_pop (GTK_STATUSBAR (data->statusbar), 0);
 537 }
 538
 539 static void
 540 connect_proxy (GtkUIManager *merge,
 541                GtkAction    *action,
 542                GtkWidget    *proxy,
 543                GtkWidget    *statusbar)
 544 {
 545   if (GTK_IS_MENU_ITEM (proxy))
 546     {
 547       ActionStatus *data;
 548
 549       data = g_object_get_data (G_OBJECT (proxy), "action-status");
 550       if (data)
 551         {
 552           g_object_unref (data->action);
 553           g_object_unref (data->statusbar);
 554
 555           data->action = g_object_ref (action);
 556           data->statusbar = g_object_ref (statusbar);
 557         }
 558       else
 559         {
 560           data = g_new0 (ActionStatus, 1);
 561
 562           data->action = g_object_ref (action);
 563           data->statusbar = g_object_ref (statusbar);
 564
 565           g_object_set_data_full (G_OBJECT (proxy), "action-status",
 566                                   data, action_status_destroy);
 567
 568           g_signal_connect (proxy, "select",  G_CALLBACK (set_tip), NULL);
 569           g_signal_connect (proxy, "deselect", G_CALLBACK (unset_tip), NULL);
 570         }
 571     }
 572 }
 573
 574 int
 575 main (int argc, char **argv)
 576 {
 577   GtkActionGroup *action_group;
 578   GtkAction *action;
 579   GtkUIManager *merge;
 580   GtkWidget *window, *grid, *frame, *menu_box, *vbox, *view;
 581   GtkWidget *button, *area, *statusbar;
 582   GtkWidget *box;
 583   gint i;
 584
 585   gtk_init (&argc, &argv);
 586
 587   action_group = gtk_action_group_new ("TestActions");
 588   gtk_action_group_add_actions (action_group,
 589                                 entries, n_entries,
 590                                 NULL);
 591   action = gtk_action_group_get_action (action_group, "EmptyMenu1Action");
 592   g_object_set (action, "hide_if_empty", FALSE, NULL);
 593   action = gtk_action_group_get_action (action_group, "EmptyMenu2Action");
 594   g_object_set (action, "hide_if_empty", TRUE, NULL);
 595   gtk_action_group_add_toggle_actions (action_group,
 596                                        toggle_entries, n_toggle_entries,
 597                                        NULL);
 598   gtk_action_group_add_radio_actions (action_group,
 599                                       radio_entries, n_radio_entries,
 600                                       JUSTIFY_RIGHT,
 601                                       G_CALLBACK (radio_action_changed), NULL);
 602
 603   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 604   gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
 605   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 606
 607   grid = gtk_grid_new ();
 608   gtk_grid_set_row_spacing (GTK_GRID (grid), 2);
 609   gtk_grid_set_column_spacing (GTK_GRID (grid), 2);
 610   gtk_container_set_border_width (GTK_CONTAINER (grid), 2);
 611   gtk_container_add (GTK_CONTAINER (window), grid);
 612
 613   frame = gtk_frame_new ("Menus and Toolbars");
 614   gtk_grid_attach (GTK_GRID (grid), frame, 0, 1, 2, 1);
 615
 616   menu_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 617   gtk_container_set_border_width (GTK_CONTAINER (menu_box), 2);
 618   gtk_container_add (GTK_CONTAINER (frame), menu_box);
 619
 620   statusbar = gtk_statusbar_new ();
 621   gtk_box_pack_end (GTK_BOX (menu_box), statusbar, FALSE, FALSE, 0);
 622
 623   area = gtk_drawing_area_new ();
 624   gtk_widget_set_events (area, GDK_BUTTON_PRESS_MASK);
 625   gtk_widget_set_size_request (area, -1, 40);
 626   gtk_box_pack_end (GTK_BOX (menu_box), area, FALSE, FALSE, 0);
 627   gtk_widget_show (area);
 628
 629   button = gtk_button_new ();
 630   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 631   gtk_activatable_set_related_action (GTK_ACTIVATABLE (button),
 632                             gtk_action_group_get_action (action_group, "AboutAction"));
 633
 634   gtk_widget_show (button);
 635
 636   button = gtk_check_button_new ();
 637   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 638   gtk_activatable_set_related_action (GTK_ACTIVATABLE (button),
 639                             gtk_action_group_get_action (action_group, "BoldAction"));
 640   gtk_widget_show (button);
 641
 642   box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
 643   gtk_box_pack_end (GTK_BOX (menu_box), box, FALSE, FALSE, 0);
 644   gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Bold:"));
 645   button = gtk_switch_new ();
 646   gtk_container_add (GTK_CONTAINER (box), button);
 647   gtk_activatable_set_related_action (GTK_ACTIVATABLE (button),
 648                             gtk_action_group_get_action (action_group, "BoldAction"));
 649   gtk_widget_show_all (box);
 650
 651   merge = gtk_ui_manager_new ();
 652
 653   g_signal_connect (merge, "connect-proxy", G_CALLBACK (connect_proxy), statusbar);
 654   g_signal_connect (area, "button_press_event", G_CALLBACK (area_press), merge);
 655
 656   gtk_ui_manager_insert_action_group (merge, action_group, 0);
 657   g_signal_connect (merge, "add_widget", G_CALLBACK (add_widget), menu_box);
 658
 659   gtk_window_add_accel_group (GTK_WINDOW (window),
 660                               gtk_ui_manager_get_accel_group (merge));
 661
 662   frame = gtk_frame_new ("UI Files");
 663   gtk_widget_set_vexpand (frame, TRUE);
 664   gtk_grid_attach (GTK_GRID (grid), frame, 0, 0, 1, 1);
 665
 666   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
 667   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
 668   gtk_container_add (GTK_CONTAINER (frame), vbox);
 669
 670   for (i = 0; i < G_N_ELEMENTS (merge_ids); i++)
 671     {
 672       button = gtk_check_button_new_with_label (merge_ids[i].filename);
 673       g_object_set_data (G_OBJECT (button), "mergenum", GINT_TO_POINTER (i));
 674       g_signal_connect (button, "toggled", G_CALLBACK (toggle_merge), merge);
 675       gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 676       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 677     }
 678
 679   button = gtk_check_button_new_with_label ("Tearoffs");
 680   g_signal_connect (button, "clicked", G_CALLBACK (toggle_tearoffs), merge);
 681   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 682
 683   button = gtk_check_button_new_with_label ("Dynamic");
 684   g_signal_connect (button, "clicked", G_CALLBACK (toggle_dynamic), merge);
 685   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 686
 687   button = gtk_button_new_with_label ("Activate path");
 688   g_signal_connect (button, "clicked", G_CALLBACK (activate_path), merge);
 689   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 690
 691   button = gtk_button_new_with_label ("Dump Tree");
 692   g_signal_connect (button, "clicked", G_CALLBACK (dump_tree), merge);
 693   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 694
 695   button = gtk_button_new_with_label ("Dump Toplevels");
 696   g_signal_connect (button, "clicked", G_CALLBACK (dump_toplevels), merge);
 697   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 698
 699   button = gtk_button_new_with_label ("Dump Accels");
 700   g_signal_connect (button, "clicked", G_CALLBACK (dump_accels), NULL);
 701   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 702
 703   view = create_tree_view (merge);
 704   gtk_widget_set_hexpand (view, TRUE);
 705   gtk_widget_set_vexpand (view, TRUE);
 706   gtk_grid_attach (GTK_GRID (grid), view, 1, 0, 1, 1);
 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 }