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

   1 /* testgmenu.c
   2  * Copyright (C) 2011  Red Hat, Inc.
   3  * Written by Matthias Clasen
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <gio/gio.h>
  24 #include <gtk/gtk.h>
  25
  26 /* GtkMenu construction {{{1 */
  27
  28 static void
  29 enabled_changed (GActionGroup *group,
  30                  const gchar  *action_name,
  31                  gboolean      enabled,
  32                  GtkWidget    *widget)
  33 {
  34   gtk_widget_set_sensitive (widget, enabled);
  35 }
  36
  37 typedef struct {
  38   GActionGroup *group;
  39   const gchar  *name;
  40   const gchar  *target;
  41 } Activation;
  42
  43 static void
  44 activate_item (GtkWidget *w, gpointer data)
  45 {
  46   Activation *a;
  47
  48   a = g_object_get_data (G_OBJECT (w), "activation");
  49
  50   g_action_group_activate_action (a->group, a->name, NULL);
  51 }
  52
  53 static void
  54 toggle_item_toggled (GtkCheckMenuItem *w, gpointer data)
  55 {
  56   Activation *a;
  57   gboolean b;
  58
  59   a = g_object_get_data (G_OBJECT (w), "activation");
  60   b = gtk_check_menu_item_get_active (w);
  61   g_action_group_change_action_state (a->group, a->name,
  62                                       g_variant_new_boolean (b));
  63 }
  64
  65 static void
  66 toggle_state_changed (GActionGroup     *group,
  67                       const gchar      *name,
  68                       GVariant         *state,
  69                       GtkCheckMenuItem *w)
  70 {
  71   gtk_check_menu_item_set_active (w, g_variant_get_boolean (state));
  72 }
  73
  74 static void
  75 radio_item_toggled (GtkCheckMenuItem *w, gpointer data)
  76 {
  77   Activation *a;
  78   GVariant *v;
  79
  80   a = g_object_get_data (G_OBJECT (w), "activation");
  81   /*g_print ("Radio item %s toggled\n", a->name);*/
  82   if (gtk_check_menu_item_get_active (w))
  83     g_action_group_change_action_state (a->group, a->name,
  84                                         g_variant_new_string (a->target));
  85   else
  86     {
  87       v = g_action_group_get_action_state (a->group, a->name);
  88       if (g_strcmp0 (g_variant_get_string (v, NULL), a->target) == 0)
  89         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
  90       g_variant_unref (v);
  91     }
  92 }
  93
  94 static void
  95 radio_state_changed (GActionGroup     *group,
  96                      const gchar      *name,
  97                      GVariant         *state,
  98                      GtkCheckMenuItem *w)
  99 {
 100   Activation *a;
 101   gboolean b;
 102
 103   /*g_print ("Radio state changed %s\n", name);*/
 104   a = g_object_get_data (G_OBJECT (w), "activation");
 105   b = g_strcmp0 (a->target, g_variant_get_string (state, NULL)) == 0;
 106
 107   gtk_check_menu_item_set_active (w, b);
 108 }
 109
 110 static GtkWidget *
 111 create_menuitem_from_model (GMenuModelItem *item,
 112                             GActionGroup   *group)
 113 {
 114   GtkWidget *w;
 115   gchar *label;
 116   gchar *action;
 117   gchar *target;
 118   gchar *s;
 119   Activation *a;
 120   const GVariantType *type;
 121   GVariant *v;
 122
 123   g_menu_model_item_get_attribute (item, G_MENU_ATTRIBUTE_LABEL, "s", &label);
 124
 125   action = NULL;
 126   g_menu_model_item_get_attribute (item, G_MENU_ATTRIBUTE_ACTION, "s", &action);
 127
 128   if (action != NULL)
 129     type = g_action_group_get_action_state_type (group, action);
 130   else
 131     type = NULL;
 132
 133   if (type == NULL)
 134     w = gtk_menu_item_new_with_mnemonic (label);
 135   else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
 136     w = gtk_check_menu_item_new_with_label (label);
 137   else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
 138     {
 139       w = gtk_check_menu_item_new_with_label (label);
 140       gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (w), TRUE);
 141     }
 142   else
 143     g_assert_not_reached ();
 144
 145   if (action != NULL)
 146     {
 147       if (!g_action_group_get_action_enabled (group, action))
 148         gtk_widget_set_sensitive (w, FALSE);
 149
 150       s = g_strconcat ("action-enabled-changed::", action, NULL);
 151       g_signal_connect (group, s, G_CALLBACK (enabled_changed), w);
 152       g_free (s);
 153
 154       a = g_new0 (Activation, 1);
 155       a->group = group;
 156       a->name = action;
 157       g_object_set_data_full (G_OBJECT (w), "activation", a, g_free);
 158
 159       if (type == NULL)
 160         g_signal_connect (w, "activate", G_CALLBACK (activate_item), NULL);
 161       else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
 162         {
 163           g_signal_connect (w, "toggled", G_CALLBACK (toggle_item_toggled), NULL);
 164           s = g_strconcat ("action-state-changed::", action, NULL);
 165           g_signal_connect (group, s, G_CALLBACK (toggle_state_changed), w);
 166           g_free (s);
 167           v = g_action_group_get_action_state (group, action);
 168           gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
 169                                           g_variant_get_boolean (v));
 170           g_variant_unref (v);
 171         }
 172       else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
 173         {
 174           g_signal_connect (w, "toggled", G_CALLBACK (radio_item_toggled), NULL);
 175           s = g_strconcat ("action-state-changed::", action, NULL);
 176           g_signal_connect (group, s, G_CALLBACK (radio_state_changed), w);
 177           g_free (s);
 178           g_menu_model_item_get_attribute (item, G_MENU_ATTRIBUTE_TARGET, "s", &target);
 179           a->target = target;
 180           v = g_action_group_get_action_state (group, action);
 181           gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
 182                                           g_strcmp0 (g_variant_get_string (v, NULL), target) == 0);
 183           g_variant_unref (v);
 184         }
 185     }
 186
 187   g_free (label);
 188
 189   return w;
 190 }
 191
 192 static GtkWidget *create_menu_from_model (GMenuModel   *model,
 193                                           GActionGroup *group);
 194
 195 static void
 196 append_items_from_model (GtkWidget    *menu,
 197                          GMenuModel   *model,
 198                          GActionGroup *group,
 199                          gboolean     *need_separator)
 200 {
 201   gint n;
 202   gint i;
 203   GtkWidget *w;
 204   GtkWidget *menuitem;
 205   GMenuModelItem item;
 206   GMenuModel *m;
 207
 208   n = g_menu_model_get_n_items (model);
 209
 210   if (*need_separator && n > 0)
 211     {
 212       /* TODO section heading */
 213       w = gtk_separator_menu_item_new ();
 214       gtk_widget_show (w);
 215       gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
 216
 217       *need_separator = FALSE;
 218     }
 219
 220   for (i = 0; i < n; i++)
 221     {
 222       g_menu_model_get_item (model, i, &item);
 223       if ((m = g_menu_model_item_get_link (&item, G_MENU_LINK_SECTION)))
 224         {
 225           append_items_from_model (menu, m, group, need_separator);
 226           continue;
 227         }
 228
 229       menuitem = create_menuitem_from_model (&item, group);
 230
 231       if ((m = g_menu_model_item_get_link (&item, G_MENU_LINK_SUBMENU)))
 232         gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu_from_model (m, group));
 233
 234       gtk_widget_show (menuitem);
 235       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
 236
 237       *need_separator = TRUE;
 238     }
 239 }
 240
 241 static GtkWidget *
 242 create_menu_from_model (GMenuModel   *model,
 243                         GActionGroup *group)
 244 {
 245   GtkWidget *w;
 246   gboolean need_separator;
 247
 248   w = gtk_menu_new ();
 249   need_separator = FALSE;
 250   append_items_from_model (w, model, group, &need_separator);
 251
 252   return w;
 253 }
 254
 255 /* The example menu {{{1 */
 256
 257 static const gchar menu_markup[] =
 258   "<menu id='edit-menu'>\n"
 259   "  <section>\n"
 260   "    <item label='Undo' action='undo'/>\n"
 261   "    <item label='Redo' action='redo'/>\n"
 262   "  </section>\n"
 263   "  <section></section>\n"
 264   "  <section label='Copy &amp; Paste'>\n"
 265   "    <item label='Cut' action='cut'/>\n"
 266   "    <item label='Copy' action='copy'/>\n"
 267   "    <item label='Paste' action='paste'/>\n"
 268   "  </section>\n"
 269   "  <section>\n"
 270   "    <item label='Bold' action='bold'/>\n"
 271   "    <submenu label='Language'>\n"
 272   "      <item label='Latin' action='lang' target='latin'/>\n"
 273   "      <item label='Greek' action='lang' target='greek'/>\n"
 274   "      <item label='Urdu'  action='lang' target='urdu'/>\n"
 275   "    </submenu>\n"
 276   "  </section>\n"
 277   "</menu>\n";
 278
 279 static void
 280 start_element (GMarkupParseContext *context,
 281                const gchar         *element_name,
 282                const gchar        **attribute_names,
 283                const gchar        **attribute_values,
 284                gpointer             user_data,
 285                GError             **error)
 286 {
 287   if (strcmp (element_name, "menu") == 0)
 288     g_menu_markup_parser_start_menu (context, NULL);
 289 }
 290
 291 static void
 292 end_element (GMarkupParseContext *context,
 293              const gchar         *element_name,
 294              gpointer             user_data,
 295              GError             **error)
 296 {
 297   GMenu **menu = user_data;
 298
 299   if (strcmp (element_name, "menu") == 0)
 300     *menu = g_menu_markup_parser_end_menu (context);
 301 }
 302
 303 static const GMarkupParser parser = {
 304    start_element, end_element, NULL, NULL, NULL
 305 };
 306
 307 static GMenuModel *
 308 get_model (void)
 309 {
 310   GMarkupParseContext *context;
 311   GMenu *menu = NULL;
 312   GError *error = NULL;
 313
 314   context = g_markup_parse_context_new (&parser, 0, &menu, NULL);
 315   if (!g_markup_parse_context_parse (context, menu_markup, -1, &error))
 316     {
 317        g_warning ("menu parsing failed: %s\n", error->message);
 318        exit (1);
 319     }
 320   g_markup_parse_context_free (context);
 321   g_assert (menu);
 322
 323    return G_MENU_MODEL (menu);
 324 }
 325
 326 /* The example actions {{{1 */
 327
 328 static void
 329 activate_action (GSimpleAction *action, GVariant *parameter, gpointer user_data)
 330 {
 331   g_print ("Action %s activated\n", g_action_get_name (G_ACTION (action)));
 332 }
 333
 334 static void
 335 toggle_changed (GSimpleAction *action, GVariant *value, gpointer user_data)
 336 {
 337   g_print ("Toggle action %s state changed to %d\n",
 338            g_action_get_name (G_ACTION (action)),
 339            g_variant_get_boolean (value));
 340
 341   g_simple_action_set_state (action, value);
 342 }
 343
 344 static void
 345 radio_changed (GSimpleAction *action, GVariant *value, gpointer user_data)
 346 {
 347   g_print ("Radio action %s state changed to %s\n",
 348            g_action_get_name (G_ACTION (action)),
 349            g_variant_get_string (value, NULL));
 350
 351   g_simple_action_set_state (action, value);
 352 }
 353
 354 static GActionEntry actions[] = {
 355   { "undo",  activate_action, NULL, NULL,      NULL },
 356   { "redo",  activate_action, NULL, NULL,      NULL },
 357   { "cut",   activate_action, NULL, NULL,      NULL },
 358   { "copy",  activate_action, NULL, NULL,      NULL },
 359   { "paste", activate_action, NULL, NULL,      NULL },
 360   { "bold",  NULL,            NULL, "true",    toggle_changed },
 361   { "lang",  NULL,            NULL, "'latin'", radio_changed },
 362 };
 363
 364 static GActionGroup *
 365 get_group (void)
 366 {
 367   GSimpleActionGroup *group;
 368
 369   group = g_simple_action_group_new ();
 370
 371   g_simple_action_group_add_entries (group, actions, G_N_ELEMENTS (actions), NULL);
 372
 373   return G_ACTION_GROUP (group);
 374 }
 375
 376 /* The action treeview {{{1 */
 377
 378 static void
 379 enabled_cell_func (GtkTreeViewColumn *column,
 380                    GtkCellRenderer   *cell,
 381                    GtkTreeModel      *model,
 382                    GtkTreeIter       *iter,
 383                    gpointer           data)
 384 {
 385   GActionGroup *group = data;
 386   gchar *name;
 387   gboolean enabled;
 388
 389   gtk_tree_model_get (model, iter, 0, &name, -1);
 390   enabled = g_action_group_get_action_enabled (group, name);
 391   g_free (name);
 392
 393   gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell), enabled);
 394 }
 395
 396 static void
 397 state_cell_func (GtkTreeViewColumn *column,
 398                  GtkCellRenderer   *cell,
 399                  GtkTreeModel      *model,
 400                  GtkTreeIter       *iter,
 401                  gpointer           data)
 402 {
 403   GActionGroup *group = data;
 404   gchar *name;
 405   GVariant *state;
 406
 407   gtk_tree_model_get (model, iter, 0, &name, -1);
 408   state = g_action_group_get_action_state (group, name);
 409   g_free (name);
 410
 411   gtk_cell_renderer_set_visible (cell, FALSE);
 412   g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
 413
 414   if (state &&
 415       g_variant_is_of_type (state, G_VARIANT_TYPE_BOOLEAN) &&
 416       GTK_IS_CELL_RENDERER_TOGGLE (cell))
 417     {
 418       gtk_cell_renderer_set_visible (cell, TRUE);
 419       g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
 420       gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell),
 421                                            g_variant_get_boolean (state));
 422     }
 423   else if (state &&
 424            g_variant_is_of_type (state, G_VARIANT_TYPE_STRING) &&
 425            GTK_IS_CELL_RENDERER_COMBO (cell))
 426     {
 427       gtk_cell_renderer_set_visible (cell, TRUE);
 428       g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
 429       g_object_set (cell, "text", g_variant_get_string (state, NULL), NULL);
 430     }
 431
 432   if (state)
 433     g_variant_unref (state);
 434 }
 435
 436 static void
 437 enabled_cell_toggled (GtkCellRendererToggle *cell,
 438                       const gchar           *path_str,
 439                       GtkTreeModel          *model)
 440 {
 441   GActionGroup *group;
 442   GAction *action;
 443   gchar *name;
 444   GtkTreePath *path;
 445   GtkTreeIter iter;
 446   gboolean enabled;
 447
 448   group = g_object_get_data (G_OBJECT (model), "group");
 449   path = gtk_tree_path_new_from_string (path_str);
 450   gtk_tree_model_get_iter (model, &iter, path);
 451   gtk_tree_model_get (model, &iter, 0, &name, -1);
 452
 453   enabled = g_action_group_get_action_enabled (group, name);
 454   action = g_simple_action_group_lookup (G_SIMPLE_ACTION_GROUP (group), name);
 455   g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !enabled);
 456
 457   gtk_tree_model_row_changed (model, path, &iter);
 458
 459   g_free (name);
 460   gtk_tree_path_free (path);
 461 }
 462
 463 static void
 464 state_cell_toggled (GtkCellRendererToggle *cell,
 465                     const gchar           *path_str,
 466                     GtkTreeModel          *model)
 467 {
 468   GActionGroup *group;
 469   GAction *action;
 470   gchar *name;
 471   GtkTreePath *path;
 472   GtkTreeIter iter;
 473   GVariant *state;
 474
 475   group = g_object_get_data (G_OBJECT (model), "group");
 476   path = gtk_tree_path_new_from_string (path_str);
 477   gtk_tree_model_get_iter (model, &iter, path);
 478   gtk_tree_model_get (model, &iter, 0, &name, -1);
 479
 480   state = g_action_group_get_action_state (group, name);
 481   action = g_simple_action_group_lookup (G_SIMPLE_ACTION_GROUP (group), name);
 482   if (state && g_variant_is_of_type (state, G_VARIANT_TYPE_BOOLEAN))
 483     {
 484       gboolean b;
 485
 486       b = g_variant_get_boolean (state);
 487       g_simple_action_set_state (G_SIMPLE_ACTION (action), g_variant_new_boolean (!b));
 488     }
 489   else
 490     {
 491       /* nothing to do */
 492     }
 493
 494   gtk_tree_model_row_changed (model, path, &iter);
 495
 496   g_free (name);
 497   gtk_tree_path_free (path);
 498   if (state)
 499     g_variant_unref (state);
 500 }
 501
 502 static void
 503 state_cell_edited (GtkCellRendererCombo  *cell,
 504                    const gchar           *path_str,
 505                    const gchar           *new_text,
 506                    GtkTreeModel          *model)
 507 {
 508   GActionGroup *group;
 509   GAction *action;
 510   gchar *name;
 511   GtkTreePath *path;
 512   GtkTreeIter iter;
 513
 514   group = g_object_get_data (G_OBJECT (model), "group");
 515   path = gtk_tree_path_new_from_string (path_str);
 516   gtk_tree_model_get_iter (model, &iter, path);
 517   gtk_tree_model_get (model, &iter, 0, &name, -1);
 518   action = g_simple_action_group_lookup (G_SIMPLE_ACTION_GROUP (group), name);
 519   g_simple_action_set_state (G_SIMPLE_ACTION (action), g_variant_new_string (new_text));
 520
 521   gtk_tree_model_row_changed (model, path, &iter);
 522
 523   g_free (name);
 524   gtk_tree_path_free (path);
 525 }
 526
 527 static GtkWidget *
 528 create_action_treeview (GActionGroup *group)
 529 {
 530   GtkWidget *tv;
 531   GtkListStore *store;
 532   GtkListStore *values;
 533   GtkTreeIter iter;
 534   GtkTreeViewColumn *column;
 535   GtkCellRenderer *cell;
 536   gchar **actions;
 537   gint i;
 538
 539   store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
 540   actions = g_action_group_list_actions (group);
 541   for (i = 0; actions[i]; i++)
 542     {
 543       gtk_list_store_append (store, &iter);
 544       gtk_list_store_set (store, &iter, 0, actions[i], -1);
 545     }
 546   g_strfreev (actions);
 547   g_object_set_data (G_OBJECT (store), "group", group);
 548
 549   tv = gtk_tree_view_new ();
 550
 551   g_signal_connect_swapped (group, "action-enabled-changed",
 552                             G_CALLBACK (gtk_widget_queue_draw), tv);
 553   g_signal_connect_swapped (group, "action-state-changed",
 554                             G_CALLBACK (gtk_widget_queue_draw), tv);
 555
 556   gtk_tree_view_set_model (GTK_TREE_VIEW (tv), GTK_TREE_MODEL (store));
 557
 558   cell = gtk_cell_renderer_text_new ();
 559   column = gtk_tree_view_column_new_with_attributes ("Action", cell,
 560                                                      "text", 0,
 561                                                      NULL);
 562   gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 563
 564   column = gtk_tree_view_column_new ();
 565   gtk_tree_view_column_set_title (column, "Enabled");
 566   cell = gtk_cell_renderer_toggle_new ();
 567   gtk_tree_view_column_pack_start (column, cell, FALSE);
 568   gtk_tree_view_column_set_cell_data_func (column, cell, enabled_cell_func, group, NULL);
 569   g_signal_connect (cell, "toggled", G_CALLBACK (enabled_cell_toggled), store);
 570   gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 571
 572   column = gtk_tree_view_column_new ();
 573   gtk_tree_view_column_set_title (column, "State");
 574   cell = gtk_cell_renderer_toggle_new ();
 575   gtk_tree_view_column_pack_start (column, cell, FALSE);
 576   gtk_tree_view_column_set_cell_data_func (column, cell, state_cell_func, group, NULL);
 577   g_signal_connect (cell, "toggled", G_CALLBACK (state_cell_toggled), store);
 578   cell = gtk_cell_renderer_combo_new ();
 579   values = gtk_list_store_new (1, G_TYPE_STRING);
 580   gtk_list_store_append (values, &iter);
 581   gtk_list_store_set (values, &iter, 0, "latin", -1);
 582   gtk_list_store_append (values, &iter);
 583   gtk_list_store_set (values, &iter, 0, "greek", -1);
 584   gtk_list_store_append (values, &iter);
 585   gtk_list_store_set (values, &iter, 0, "urdu", -1);
 586   g_object_set (cell,
 587                 "has-entry", FALSE,
 588                 "model", values,
 589                 "text-column", 0,
 590                 "editable", TRUE,
 591                 NULL);
 592   gtk_tree_view_column_pack_start (column, cell, FALSE);
 593   gtk_tree_view_column_set_cell_data_func (column, cell, state_cell_func, group, NULL);
 594   g_signal_connect (cell, "edited", G_CALLBACK (state_cell_edited), store);
 595   gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 596
 597   return tv;
 598 }
 599
 600 /* The menu button {{{1 */
 601
 602 static void
 603 button_clicked (GtkButton *button, gpointer data)
 604 {
 605   GMenuModel *model;
 606   GActionGroup *group;
 607   GtkWidget *menu;
 608
 609   menu = g_object_get_data (G_OBJECT (button), "menu");
 610   if (!menu)
 611     {
 612       model = g_object_get_data (G_OBJECT (button), "model");
 613       group = g_object_get_data (G_OBJECT (button), "group");
 614       menu = create_menu_from_model (model, group);
 615       g_object_set_data_full (G_OBJECT (button), "menu", menu, (GDestroyNotify)gtk_widget_destroy);
 616     }
 617
 618   gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, 0);
 619 }
 620
 621 static void
 622 items_changed (GMenuModel *model,
 623                gint        position,
 624                gint        removed,
 625                gint        added,
 626                GtkButton  *button)
 627 {
 628   g_object_set_data (G_OBJECT (button), "menu", NULL);
 629 }
 630
 631 static GtkWidget *
 632 create_menu_button (GMenuModel *model, GActionGroup *group)
 633 {
 634   GtkWidget *button;
 635
 636   button = gtk_button_new_with_label ("Click here");
 637   g_object_set_data (G_OBJECT (button), "model", model);
 638   g_object_set_data (G_OBJECT (button), "group", group);
 639
 640   g_signal_connect (button, "clicked", G_CALLBACK (button_clicked), NULL);
 641   g_signal_connect (model, "items-changed", G_CALLBACK (items_changed), button);
 642
 643   return button;
 644 }
 645
 646 /* main {{{1 */
 647
 648 int
 649 main (int argc, char *argv[])
 650 {
 651   GtkWidget *window;
 652   GtkWidget *box;
 653   GtkWidget *button;
 654   GtkWidget *tv;
 655   GMenuModel *model;
 656   GActionGroup *group;
 657   GDBusConnection *bus;
 658   GError *error = NULL;
 659   gboolean do_export = FALSE;
 660   gboolean do_import = FALSE;
 661   GOptionEntry entries[] = {
 662     { "export", 0, 0, G_OPTION_ARG_NONE, &do_export, "Export actions and menus over D-Bus", NULL },
 663     { "import", 0, 0, G_OPTION_ARG_NONE, &do_import, "Use exported actions and menus", NULL },
 664     { NULL, }
 665   };
 666
 667   gtk_init_with_args (&argc, &argv, NULL, entries, NULL, NULL);
 668
 669   if (do_export && do_import)
 670     {
 671        g_error ("can't have it both ways\n");
 672        exit (1);
 673     }
 674
 675   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 676   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
 677   gtk_container_add (GTK_CONTAINER (window), box);
 678
 679   bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
 680
 681   if (do_import)
 682     {
 683       g_print ("Getting menus from the bus...\n");
 684       model = (GMenuModel*)g_menu_proxy_get (bus, "org.gtk.TestMenus", "/path");
 685       g_print ("Getting actions from the bus...\n");
 686       group = (GActionGroup*)g_dbus_action_group_new_sync (bus, "org.gtk.TestMenus", "/path", 0, NULL, NULL);
 687     }
 688   else
 689     {
 690       group = get_group ();
 691       model = get_model ();
 692
 693       tv = create_action_treeview (group);
 694       gtk_container_add (GTK_CONTAINER (box), tv);
 695     }
 696
 697   if (do_export)
 698     {
 699       g_print ("Exporting menus on the bus...\n");
 700       if (!g_menu_exporter_export (bus, "/path", model, &error))
 701         {
 702           g_warning ("Menu export failed: %s", error->message);
 703           exit (1);
 704         }
 705       g_print ("Exporting actions on the bus...\n");
 706       if (!g_action_group_exporter_export (bus, "/path", group, &error))
 707         {
 708           g_warning ("Action export failed: %s", error->message);
 709           exit (1);
 710         }
 711       g_bus_own_name_on_connection (bus, "org.gtk.TestMenus",
 712                                     0, NULL, NULL, NULL, NULL);
 713     }
 714   else
 715     {
 716       button = create_menu_button (model, group);
 717       gtk_container_add (GTK_CONTAINER (box), button);
 718     }
 719
 720   gtk_widget_show_all (window);
 721
 722   gtk_main ();
 723
 724   return 0;
 725 }
 726
 727 /* Epilogue {{{1 */
 728 /* vim:set foldmethod=marker: */