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

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