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   { "Test", NULL, "Test" },
 127
 128   { "QuitAction",  GTK_STOCK_QUIT,  NULL,     "<control>q", NULL, G_CALLBACK (gtk_main_quit) },
 129   { "NewAction",   GTK_STOCK_NEW,   NULL,     "<control>n", NULL, G_CALLBACK (activate_action) },
 130   { "New2Action",  GTK_STOCK_NEW,   NULL,     "<control>m", NULL, G_CALLBACK (activate_action) },
 131   { "OpenAction",  GTK_STOCK_OPEN,  NULL,     "<control>o", NULL, G_CALLBACK (activate_action) },
 132   { "CutAction",   GTK_STOCK_CUT,   NULL,     "<control>x", NULL, G_CALLBACK (activate_action) },
 133   { "CopyAction",  GTK_STOCK_COPY,  NULL,     "<control>c", NULL, G_CALLBACK (activate_action) },
 134   { "PasteAction", GTK_STOCK_PASTE, NULL,     "<control>v", NULL, G_CALLBACK (activate_action) },
 135   { "AboutAction", NULL,            "_About", NULL,         NULL, G_CALLBACK (activate_action) },
 136 };
 137 static guint n_entries = G_N_ELEMENTS (entries);
 138
 139 static GtkToggleActionEntry toggle_entries[] = {
 140   { "BoldAction",  GTK_STOCK_BOLD,  "_Bold",  "<control>b", NULL, G_CALLBACK (toggle_action),
 141     TRUE },
 142 };
 143 static guint n_toggle_entries = G_N_ELEMENTS (toggle_entries);
 144
 145 enum {
 146   JUSTIFY_LEFT,
 147   JUSTIFY_CENTER,
 148   JUSTIFY_RIGHT,
 149   JUSTIFY_FILL
 150 };
 151
 152 static GtkRadioActionEntry radio_entries[] = {
 153   { "justify-left", GTK_STOCK_JUSTIFY_LEFT, NULL, "<control>L",
 154     "Left justify the text", JUSTIFY_LEFT },
 155   { "justify-center", GTK_STOCK_JUSTIFY_CENTER, NULL, "<control>E",
 156     "Center justify the text", JUSTIFY_CENTER },
 157   { "justify-right", GTK_STOCK_JUSTIFY_RIGHT, NULL, "<control>R",
 158     "Right justify the text", JUSTIFY_RIGHT },
 159   { "justify-fill", GTK_STOCK_JUSTIFY_FILL, NULL, "<control>J",
 160     "Fill justify the text", JUSTIFY_FILL },
 161 };
 162 static guint n_radio_entries = G_N_ELEMENTS (radio_entries);
 163
 164 static void
 165 add_widget (GtkUIManager *merge,
 166             GtkWidget    *widget,
 167             GtkBox       *box)
 168 {
 169   GtkWidget *handle_box;
 170
 171   if (GTK_IS_TOOLBAR (widget))
 172     {
 173       handle_box = gtk_handle_box_new ();
 174       gtk_widget_show (handle_box);
 175       gtk_container_add (GTK_CONTAINER (handle_box), widget);
 176       gtk_box_pack_start (box, handle_box, FALSE, FALSE, 0);
 177       g_signal_connect_swapped (widget, "destroy",
 178                                 G_CALLBACK (gtk_widget_destroy), handle_box);
 179     }
 180   else
 181     gtk_box_pack_start (box, widget, FALSE, FALSE, 0);
 182
 183   gtk_widget_show (widget);
 184 }
 185
 186 static void
 187 toggle_merge (GtkWidget    *button,
 188               GtkUIManager *merge)
 189 {
 190   gint mergenum;
 191
 192   mergenum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "mergenum"));
 193
 194   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
 195     {
 196       GError *err = NULL;
 197
 198       g_message ("merging %s", merge_ids[mergenum].filename);
 199       merge_ids[mergenum].merge_id =
 200         gtk_ui_manager_add_ui_from_file (merge, merge_ids[mergenum].filename, &err);
 201       if (err != NULL)
 202         {
 203           GtkWidget *dialog;
 204
 205           dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (button)),
 206                                            0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
 207                                            "could not merge %s: %s", merge_ids[mergenum].filename,
 208                                            err->message);
 209
 210           g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_object_destroy), NULL);
 211           gtk_widget_show (dialog);
 212
 213           g_clear_error (&err);
 214         }
 215     }
 216   else
 217     {
 218       g_message ("unmerging %s (merge_id=%u)", merge_ids[mergenum].filename,
 219                  merge_ids[mergenum].merge_id);
 220       gtk_ui_manager_remove_ui (merge, merge_ids[mergenum].merge_id);
 221     }
 222 }
 223
 224 static void
 225 set_name_func (GtkTreeViewColumn *tree_column,
 226                GtkCellRenderer   *cell,
 227                GtkTreeModel      *tree_model,
 228                GtkTreeIter       *iter,
 229                gpointer           data)
 230 {
 231   GtkAction *action;
 232   char *name;
 233
 234   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 235   g_object_get (G_OBJECT (action), "name", &name, NULL);
 236   g_object_set (G_OBJECT (cell), "text", name, NULL);
 237   g_free (name);
 238   g_object_unref (action);
 239 }
 240
 241 static void
 242 set_sensitive_func (GtkTreeViewColumn *tree_column,
 243                     GtkCellRenderer   *cell,
 244                     GtkTreeModel      *tree_model,
 245                     GtkTreeIter       *iter,
 246                     gpointer           data)
 247 {
 248   GtkAction *action;
 249   gboolean sensitive;
 250
 251   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 252   g_object_get (G_OBJECT (action), "sensitive", &sensitive, NULL);
 253   g_object_set (G_OBJECT (cell), "active", sensitive, NULL);
 254   g_object_unref (action);
 255 }
 256
 257
 258 static void
 259 set_visible_func (GtkTreeViewColumn *tree_column,
 260                   GtkCellRenderer   *cell,
 261                   GtkTreeModel      *tree_model,
 262                   GtkTreeIter       *iter,
 263                   gpointer           data)
 264 {
 265   GtkAction *action;
 266   gboolean visible;
 267
 268   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 269   g_object_get (G_OBJECT (action), "visible", &visible, NULL);
 270   g_object_set (G_OBJECT (cell), "active", visible, NULL);
 271   g_object_unref (action);
 272 }
 273
 274 static void
 275 sensitivity_toggled (GtkCellRendererToggle *cell,
 276                      const gchar           *path_str,
 277                      GtkTreeModel          *model)
 278 {
 279   GtkTreePath *path;
 280   GtkTreeIter iter;
 281   GtkAction *action;
 282   gboolean sensitive;
 283
 284   path = gtk_tree_path_new_from_string (path_str);
 285   gtk_tree_model_get_iter (model, &iter, path);
 286
 287   gtk_tree_model_get (model, &iter, 0, &action, -1);
 288   g_object_get (G_OBJECT (action), "sensitive", &sensitive, NULL);
 289   g_object_set (G_OBJECT (action), "sensitive", !sensitive, NULL);
 290   gtk_tree_model_row_changed (model, path, &iter);
 291   gtk_tree_path_free (path);
 292 }
 293
 294 static void
 295 visibility_toggled (GtkCellRendererToggle *cell,
 296                     const gchar           *path_str,
 297                     GtkTreeModel          *model)
 298 {
 299   GtkTreePath *path;
 300   GtkTreeIter iter;
 301   GtkAction *action;
 302   gboolean visible;
 303
 304   path = gtk_tree_path_new_from_string (path_str);
 305   gtk_tree_model_get_iter (model, &iter, path);
 306
 307   gtk_tree_model_get (model, &iter, 0, &action, -1);
 308   g_object_get (G_OBJECT (action), "visible", &visible, NULL);
 309   g_object_set (G_OBJECT (action), "visible", !visible, NULL);
 310   gtk_tree_model_row_changed (model, path, &iter);
 311   gtk_tree_path_free (path);
 312 }
 313
 314 static gint
 315 iter_compare_func (GtkTreeModel *model,
 316                    GtkTreeIter  *a,
 317                    GtkTreeIter  *b,
 318                    gpointer      user_data)
 319 {
 320   GValue a_value = { 0, }, b_value = { 0, };
 321   GtkAction *a_action, *b_action;
 322   const gchar *a_name, *b_name;
 323   gint retval = 0;
 324
 325   gtk_tree_model_get_value (model, a, 0, &a_value);
 326   gtk_tree_model_get_value (model, b, 0, &b_value);
 327   a_action = GTK_ACTION (g_value_get_object (&a_value));
 328   b_action = GTK_ACTION (g_value_get_object (&b_value));
 329
 330   a_name = gtk_action_get_name (a_action);
 331   b_name = gtk_action_get_name (b_action);
 332   if (a_name == NULL && b_name == NULL)
 333     retval = 0;
 334   else if (a_name == NULL)
 335     retval = -1;
 336   else if (b_name == NULL)
 337     retval = 1;
 338   else
 339     retval = strcmp (a_name, b_name);
 340
 341   g_value_unset (&b_value);
 342   g_value_unset (&a_value);
 343
 344   return retval;
 345 }
 346
 347 static GtkWidget *
 348 create_tree_view (GtkUIManager *merge)
 349 {
 350   GtkWidget *tree_view, *sw;
 351   GtkListStore *store;
 352   GList *p;
 353   GtkCellRenderer *cell;
 354
 355   store = gtk_list_store_new (1, GTK_TYPE_ACTION);
 356   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), 0,
 357                                    iter_compare_func, NULL, NULL);
 358   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 0,
 359                                         GTK_SORT_ASCENDING);
 360
 361   for (p = gtk_ui_manager_get_action_groups (merge); p; p = p->next)
 362     {
 363       GList *actions, *l;
 364
 365       actions = gtk_action_group_list_actions (p->data);
 366
 367       for (l = actions; l; l = l->next)
 368         {
 369           GtkTreeIter iter;
 370
 371           gtk_list_store_append (store, &iter);
 372           gtk_list_store_set (store, &iter, 0, l->data, -1);
 373         }
 374     }
 375
 376   tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 377   g_object_unref (store);
 378
 379   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 380                                               -1, "Action",
 381                                               gtk_cell_renderer_text_new (),
 382                                               set_name_func, NULL, NULL);
 383
 384   gtk_tree_view_column_set_sort_column_id (gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), 0), 0);
 385
 386   cell = gtk_cell_renderer_toggle_new ();
 387   g_signal_connect (cell, "toggled", G_CALLBACK (sensitivity_toggled), store);
 388   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 389                                               -1, "Sensitive",
 390                                               cell,
 391                                               set_sensitive_func, NULL, NULL);
 392
 393   cell = gtk_cell_renderer_toggle_new ();
 394   g_signal_connect (cell, "toggled", G_CALLBACK (visibility_toggled), store);
 395   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 396                                               -1, "Visible",
 397                                               cell,
 398                                               set_visible_func, NULL, NULL);
 399
 400   sw = gtk_scrolled_window_new (NULL, NULL);
 401   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 402                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 403   gtk_container_add (GTK_CONTAINER (sw), tree_view);
 404
 405   return sw;
 406 }
 407
 408 static gboolean
 409 area_press (GtkWidget      *drawing_area,
 410             GdkEventButton *event,
 411             GtkUIManager   *merge)
 412 {
 413   gtk_widget_grab_focus (drawing_area);
 414
 415   if (event->button == 3 &&
 416       event->type == GDK_BUTTON_PRESS)
 417     {
 418       GtkWidget *menu = gtk_ui_manager_get_widget (merge, "/FileMenu");
 419
 420       if (GTK_IS_MENU (menu))
 421         {
 422           gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
 423                           NULL, drawing_area,
 424                           3, event->time);
 425           return TRUE;
 426         }
 427     }
 428
 429   return FALSE;
 430
 431 }
 432
 433 static void
 434 activate_path (GtkWidget      *button,
 435                GtkUIManager   *merge)
 436 {
 437   GtkAction *action = gtk_ui_manager_get_action (merge,
 438                                                  "/menubar/HelpMenu/About");
 439   if (action)
 440     gtk_action_activate (action);
 441   else
 442     g_message ("no action found");
 443 }
 444
 445 int
 446 main (int argc, char **argv)
 447 {
 448   GtkActionGroup *action_group;
 449   GtkUIManager *merge;
 450   GtkWidget *window, *table, *frame, *menu_box, *vbox, *view;
 451   GtkWidget *button, *area;
 452   gint i;
 453
 454   gtk_init (&argc, &argv);
 455
 456   action_group = gtk_action_group_new ("TestActions");
 457   gtk_action_group_add_actions (action_group,
 458                                 entries, n_entries,
 459                                 NULL);
 460   gtk_action_group_add_toggle_actions (action_group,
 461                                        toggle_entries, n_toggle_entries,
 462                                        NULL);
 463   gtk_action_group_add_radio_actions (action_group,
 464                                       radio_entries, n_radio_entries,
 465                                       JUSTIFY_RIGHT,
 466                                       G_CALLBACK (radio_action_changed), NULL);
 467
 468   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 469   gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
 470   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 471
 472   table = gtk_table_new (2, 2, FALSE);
 473   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
 474   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
 475   gtk_container_set_border_width (GTK_CONTAINER (table), 2);
 476   gtk_container_add (GTK_CONTAINER (window), table);
 477
 478   frame = gtk_frame_new ("Menus and Toolbars");
 479   gtk_table_attach (GTK_TABLE (table), frame, 0,2, 1,2,
 480                     GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 481
 482   menu_box = gtk_vbox_new (FALSE, 0);
 483   gtk_container_set_border_width (GTK_CONTAINER (menu_box), 2);
 484   gtk_container_add (GTK_CONTAINER (frame), menu_box);
 485
 486   area = gtk_drawing_area_new ();
 487   gtk_widget_set_events (area, GDK_BUTTON_PRESS_MASK);
 488   gtk_widget_set_size_request (area, -1, 40);
 489   gtk_box_pack_end (GTK_BOX (menu_box), area, FALSE, FALSE, 0);
 490   gtk_widget_show (area);
 491
 492   button = gtk_button_new ();
 493   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 494   gtk_action_connect_proxy (gtk_action_group_get_action (action_group, "AboutAction"),
 495                             button);
 496   gtk_widget_show (button);
 497   merge = gtk_ui_manager_new ();
 498
 499   button = gtk_check_button_new ();
 500   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 501   gtk_action_connect_proxy (gtk_action_group_get_action (action_group, "BoldAction"),
 502                             button);
 503   gtk_widget_show (button);
 504   merge = gtk_ui_manager_new ();
 505
 506   g_signal_connect (area, "button_press_event",
 507                     G_CALLBACK (area_press), merge);
 508
 509   gtk_ui_manager_insert_action_group (merge, action_group, 0);
 510   g_signal_connect (merge, "add_widget", G_CALLBACK (add_widget), menu_box);
 511
 512   gtk_window_add_accel_group (GTK_WINDOW (window),
 513                               gtk_ui_manager_get_accel_group (merge));
 514
 515   frame = gtk_frame_new ("UI Files");
 516   gtk_table_attach (GTK_TABLE (table), frame, 0,1, 0,1,
 517                     GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 518
 519   vbox = gtk_vbox_new (FALSE, 2);
 520   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
 521   gtk_container_add (GTK_CONTAINER (frame), vbox);
 522
 523   for (i = 0; i < G_N_ELEMENTS (merge_ids); i++)
 524     {
 525       button = gtk_check_button_new_with_label (merge_ids[i].filename);
 526       g_object_set_data (G_OBJECT (button), "mergenum", GINT_TO_POINTER (i));
 527       g_signal_connect (button, "toggled", G_CALLBACK (toggle_merge), merge);
 528       gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 529       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 530     }
 531
 532   button = gtk_check_button_new_with_label ("Tearoffs");
 533   g_signal_connect (button, "clicked", G_CALLBACK (toggle_tearoffs), merge);
 534   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 535
 536   button = gtk_check_button_new_with_label ("Dynamic");
 537   g_signal_connect (button, "clicked", G_CALLBACK (toggle_dynamic), merge);
 538   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 539
 540   button = gtk_button_new_with_label ("Activate path");
 541   g_signal_connect (button, "clicked", G_CALLBACK (activate_path), merge);
 542   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 543
 544   button = gtk_button_new_with_label ("Dump Tree");
 545   g_signal_connect (button, "clicked", G_CALLBACK (dump_tree), merge);
 546   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 547
 548   button = gtk_button_new_with_label ("Dump Accels");
 549   g_signal_connect (button, "clicked", G_CALLBACK (dump_accels), NULL);
 550   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 551
 552   view = create_tree_view (merge);
 553   gtk_table_attach (GTK_TABLE (table), view, 1,2, 0,1,
 554                     GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 555
 556   gtk_widget_show_all (window);
 557   gtk_main ();
 558
 559   g_object_unref (action_group);
 560   g_object_unref (merge);
 561
 562   return 0;
 563 }