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 /* TODO
  27  *
  28  * - Labeled sections
  29  *
  30  * - Focus changes. Verify that stopping subscriptions works.
  31  *
  32  * - Other attributes. What about icons ?
  33  */
  34
  35 /* MenuHolder {{{1 */
  36
  37 typedef struct {
  38   GMenuModel   *model;
  39   GActionGroup *group;
  40   GtkWidget    *menu;
  41   gboolean      items_changed;
  42 } MenuHolder;
  43
  44 /* Menumodel callbacks {{{2 */
  45
  46 static void
  47 connect_to_items_changed (GMenuModel *model,
  48                           GCallback   callback,
  49                           gpointer    data)
  50 {
  51   gint i;
  52   GMenuModel *m;
  53   GMenuLinkIter *iter;
  54
  55   if (!g_object_get_data (G_OBJECT (model), "handler-connected"))
  56     {
  57       g_signal_connect (model, "items-changed", callback, data);
  58       g_object_set_data (G_OBJECT (model), "handler-connected", GINT_TO_POINTER (1));
  59     }
  60   for (i = 0; i < g_menu_model_get_n_items (model); i++)
  61     {
  62       iter = g_menu_model_iterate_item_links (model, i);
  63       while (g_menu_link_iter_next (iter))
  64         {
  65           m = g_menu_link_iter_get_value (iter);
  66           connect_to_items_changed (m, callback, data);
  67           g_object_unref (m);
  68         }
  69       g_object_unref (iter);
  70     }
  71 }
  72
  73 static void
  74 items_changed (GMenuModel *model,
  75                gint        position,
  76                gint        removed,
  77                gint        added,
  78                MenuHolder *holder)
  79 {
  80   g_print ("Received GMenuModel::items-changed\n");
  81   holder->items_changed = TRUE;
  82   connect_to_items_changed (model, G_CALLBACK (items_changed), holder);
  83 }
  84
  85  /* Actiongroup callbacks {{{2 */
  86
  87 typedef struct {
  88   GActionGroup *group;
  89   gchar        *name;
  90   gchar        *target;
  91   gulong        enabled_changed_id;
  92   gulong        state_changed_id;
  93   gulong        activate_handler;
  94 } ActionData;
  95
  96 static void
  97 action_data_free (gpointer data)
  98 {
  99   ActionData *a = data;
 100
 101   if (a->enabled_changed_id)
 102     g_signal_handler_disconnect (a->group, a->enabled_changed_id);
 103
 104   if (a->state_changed_id)
 105     g_signal_handler_disconnect (a->group, a->state_changed_id);
 106
 107   g_object_unref (a->group);
 108   g_free (a->name);
 109   g_free (a->target);
 110
 111   g_free (a);
 112 }
 113
 114 static void
 115 enabled_changed (GActionGroup *group,
 116                  const gchar  *action_name,
 117                  gboolean      enabled,
 118                  GtkWidget    *widget)
 119 {
 120   gtk_widget_set_sensitive (widget, enabled);
 121 }
 122
 123 static void
 124 toggle_state_changed (GActionGroup     *group,
 125                       const gchar      *name,
 126                       GVariant         *state,
 127                       GtkCheckMenuItem *w)
 128 {
 129   ActionData *a;
 130
 131   a = g_object_get_data (G_OBJECT (w), "action");
 132   g_signal_handler_block (w, a->activate_handler);
 133   gtk_check_menu_item_set_active (w, g_variant_get_boolean (state));
 134   g_signal_handler_unblock (w, a->activate_handler);
 135 }
 136
 137 static void
 138 radio_state_changed (GActionGroup     *group,
 139                      const gchar      *name,
 140                      GVariant         *state,
 141                      GtkCheckMenuItem *w)
 142 {
 143   ActionData *a;
 144   gboolean b;
 145
 146   a = g_object_get_data (G_OBJECT (w), "action");
 147   g_signal_handler_block (w, a->activate_handler);
 148   b = g_strcmp0 (a->target, g_variant_get_string (state, NULL)) == 0;
 149   gtk_check_menu_item_set_active (w, b);
 150   g_signal_handler_unblock (w, a->activate_handler);
 151 }
 152
 153 /* Menuitem callbacks {{{2 */
 154
 155 static void
 156 item_activated (GtkWidget *w,
 157                 gpointer   data)
 158 {
 159   ActionData *a;
 160   GVariant *parameter;
 161
 162   a = g_object_get_data (G_OBJECT (w), "action");
 163   if (a->target)
 164     parameter = g_variant_new_string (a->target);
 165   else
 166     parameter = NULL;
 167   g_action_group_activate_action (a->group, a->name, parameter);
 168   if (parameter)
 169     g_variant_unref (parameter);
 170 }
 171
 172 /* GtkMenu construction {{{2 */
 173
 174 static GtkWidget *
 175 create_menuitem_from_model (GMenuModel   *model,
 176                             gint          item,
 177                             GActionGroup *group)
 178 {
 179   GtkWidget *w;
 180   gchar *label;
 181   gchar *action;
 182   gchar *target;
 183   gchar *s;
 184   ActionData *a;
 185   const GVariantType *type;
 186   GVariant *v;
 187
 188   label = NULL;
 189   g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_LABEL, "s", &label);
 190
 191   action = NULL;
 192   g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_ACTION, "s", &action);
 193
 194   if (action != NULL)
 195     type = g_action_group_get_action_state_type (group, action);
 196   else
 197     type = NULL;
 198
 199   if (type == NULL)
 200     w = gtk_menu_item_new_with_mnemonic (label);
 201   else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
 202     w = gtk_check_menu_item_new_with_label (label);
 203   else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
 204     {
 205       w = gtk_check_menu_item_new_with_label (label);
 206       gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (w), TRUE);
 207     }
 208   else
 209     g_assert_not_reached ();
 210
 211   if (action != NULL)
 212     {
 213       a = g_new0 (ActionData, 1);
 214       a->group = g_object_ref (group);
 215       a->name = g_strdup (action);
 216       g_object_set_data_full (G_OBJECT (w), "action", a, action_data_free);
 217
 218       if (!g_action_group_get_action_enabled (group, action))
 219         gtk_widget_set_sensitive (w, FALSE);
 220
 221       s = g_strconcat ("action-enabled-changed::", action, NULL);
 222       a->enabled_changed_id = g_signal_connect (group, s,
 223                                                 G_CALLBACK (enabled_changed), w);
 224       g_free (s);
 225
 226       a->activate_handler = g_signal_connect (w, "activate", G_CALLBACK (item_activated), NULL);
 227
 228       if (type == NULL)
 229         {
 230           /* all set */
 231         }
 232       else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
 233         {
 234           s = g_strconcat ("action-state-changed::", action, NULL);
 235           a->state_changed_id = g_signal_connect (group, s,
 236                                                   G_CALLBACK (toggle_state_changed), w);
 237           g_free (s);
 238           v = g_action_group_get_action_state (group, action);
 239           gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
 240                                           g_variant_get_boolean (v));
 241           g_variant_unref (v);
 242         }
 243       else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
 244         {
 245           s = g_strconcat ("action-state-changed::", action, NULL);
 246           a->state_changed_id = g_signal_connect (group, s,
 247                                                   G_CALLBACK (radio_state_changed), w);
 248           g_free (s);
 249           g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_TARGET, "s", &target);
 250           a->target = g_strdup (target);
 251           v = g_action_group_get_action_state (group, action);
 252           gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
 253                                           g_strcmp0 (g_variant_get_string (v, NULL), target) == 0);
 254           g_variant_unref (v);
 255           g_free (target);
 256         }
 257       else
 258         g_assert_not_reached ();
 259     }
 260
 261   g_free (label);
 262   g_free (action);
 263
 264   return w;
 265 }
 266
 267 static GtkWidget *create_menu_from_model (GMenuModel   *model,
 268                                           GActionGroup *group);
 269
 270 static void
 271 append_items_from_model (GtkWidget    *menu,
 272                          GMenuModel   *model,
 273                          GActionGroup *group,
 274                          gboolean     *need_separator,
 275                          const gchar  *heading)
 276 {
 277   gint n;
 278   gint i;
 279   GtkWidget *w;
 280   GtkWidget *menuitem;
 281   GtkWidget *submenu;
 282   GMenuModel *m;
 283   gchar *label;
 284
 285   n = g_menu_model_get_n_items (model);
 286
 287   if (*need_separator && n > 0)
 288     {
 289       w = gtk_separator_menu_item_new ();
 290       gtk_widget_show (w);
 291       gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
 292       *need_separator = FALSE;
 293     }
 294
 295   if (heading != NULL)
 296     {
 297       w = gtk_menu_item_new_with_label (heading);
 298       gtk_widget_show (w);
 299       gtk_widget_set_sensitive (w, FALSE);
 300       gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
 301 #if 0
 302       /* FIXME: this interferes with toggle spacing */
 303       w = gtk_bin_get_child (GTK_BIN (w));
 304       gtk_misc_set_alignment (GTK_MISC (w), 0.5, 0.5);
 305 #endif
 306     }
 307
 308   for (i = 0; i < n; i++)
 309     {
 310       if ((m = g_menu_model_get_item_link (model, i, G_MENU_LINK_SECTION)))
 311         {
 312           label = NULL;
 313           g_menu_model_get_item_attribute (model, i, G_MENU_ATTRIBUTE_LABEL, "s", &label);
 314           append_items_from_model (menu, m, group, need_separator, label);
 315           g_object_unref (m);
 316           g_free (label);
 317           continue;
 318         }
 319
 320       if (*need_separator)
 321         {
 322           w = gtk_separator_menu_item_new ();
 323           gtk_widget_show (w);
 324           gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
 325           *need_separator = FALSE;
 326         }
 327
 328       menuitem = create_menuitem_from_model (model, i, group);
 329
 330       if ((m = g_menu_model_get_item_link (model, i, G_MENU_LINK_SUBMENU)))
 331         {
 332           submenu = create_menu_from_model (m, group);
 333           gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
 334           g_object_unref (m);
 335         }
 336
 337       gtk_widget_show (menuitem);
 338       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
 339
 340       *need_separator = TRUE;
 341     }
 342 }
 343
 344 static GtkWidget *
 345 create_menu_from_model (GMenuModel   *model,
 346                         GActionGroup *group)
 347 {
 348   GtkWidget *w;
 349   gboolean need_separator;
 350
 351   w = gtk_menu_new ();
 352   need_separator = FALSE;
 353   append_items_from_model (w, model, group, &need_separator, NULL);
 354
 355   return w;
 356 }
 357
 358 /* }}}2 */
 359
 360 MenuHolder *
 361 menu_holder_new (GMenuModel   *model,
 362                  GActionGroup *group)
 363 {
 364   MenuHolder *holder;
 365
 366   holder = g_new (MenuHolder, 1);
 367   holder->model = g_object_ref (model);
 368   holder->group = g_object_ref (group);
 369   holder->menu = create_menu_from_model (model, group);
 370   holder->items_changed = FALSE;
 371
 372   connect_to_items_changed (model, G_CALLBACK (items_changed), holder);
 373
 374   return holder;
 375 }
 376
 377 GtkWidget *
 378 menu_holder_get_menu (MenuHolder *holder)
 379 {
 380   if (holder->items_changed)
 381     {
 382       holder->items_changed = FALSE;
 383       gtk_widget_destroy (holder->menu);
 384       holder->menu = create_menu_from_model (holder->model, holder->group);
 385     }
 386
 387   return holder->menu;
 388 }
 389
 390 /* The example menu {{{1 */
 391
 392 static const gchar menu_markup[] =
 393   "<menu id='edit-menu'>\n"
 394   "  <section>\n"
 395   "    <item action='undo'>\n"
 396   "      <attribute name='label' translatable='yes' context='Stock label'>'_Undo'</attribute>\n"
 397   "    </item>\n"
 398   "    <item label='Redo' action='redo'/>\n"
 399   "  </section>\n"
 400   "  <section></section>\n"
 401   "  <section label='Copy &amp; Paste'>\n"
 402   "    <item label='Cut' action='cut'/>\n"
 403   "    <item label='Copy' action='copy'/>\n"
 404   "    <item label='Paste' action='paste'/>\n"
 405   "  </section>\n"
 406   "  <section>\n"
 407   "    <item label='Bold' action='bold'/>\n"
 408   "    <submenu label='Language'>\n"
 409   "      <item label='Latin' action='lang' target='latin'/>\n"
 410   "      <item label='Greek' action='lang' target='greek'/>\n"
 411   "      <item label='Urdu'  action='lang' target='urdu'/>\n"
 412   "    </submenu>\n"
 413   "  </section>\n"
 414   "</menu>\n";
 415
 416 static void
 417 start_element (GMarkupParseContext *context,
 418                const gchar         *element_name,
 419                const gchar        **attribute_names,
 420                const gchar        **attribute_values,
 421                gpointer             user_data,
 422                GError             **error)
 423 {
 424   if (strcmp (element_name, "menu") == 0)
 425     g_menu_markup_parser_start_menu (context, "gtk30", NULL);
 426 }
 427
 428 static void
 429 end_element (GMarkupParseContext *context,
 430              const gchar         *element_name,
 431              gpointer             user_data,
 432              GError             **error)
 433 {
 434   GMenu **menu = user_data;
 435
 436   if (strcmp (element_name, "menu") == 0)
 437     *menu = g_menu_markup_parser_end_menu (context);
 438 }
 439
 440 static const GMarkupParser parser = {
 441    start_element, end_element, NULL, NULL, NULL
 442 };
 443
 444 static GMenuModel *
 445 get_model (void)
 446 {
 447   GMarkupParseContext *context;
 448   GMenu *menu = NULL;
 449   GError *error = NULL;
 450
 451   context = g_markup_parse_context_new (&parser, 0, &menu, NULL);
 452   if (!g_markup_parse_context_parse (context, menu_markup, -1, &error))
 453     {
 454        g_warning ("menu parsing failed: %s\n", error->message);
 455        exit (1);
 456     }
 457   g_markup_parse_context_free (context);
 458   g_assert (menu);
 459
 460    return G_MENU_MODEL (menu);
 461 }
 462
 463  /* The example actions {{{1 */
 464
 465 static void
 466 activate_action (GSimpleAction *action, GVariant *parameter, gpointer user_data)
 467 {
 468   g_print ("Action %s activated\n", g_action_get_name (G_ACTION (action)));
 469 }
 470
 471 static void
 472 activate_toggle (GSimpleAction *action, GVariant *parameter, gpointer user_data)
 473 {
 474   GVariant *old_state, *new_state;
 475
 476   old_state = g_action_get_state (G_ACTION (action));
 477   new_state = g_variant_new_boolean (!g_variant_get_boolean (old_state));
 478
 479   g_print ("Toggle action %s activated, state changes from %d to %d\n",
 480            g_action_get_name (G_ACTION (action)),
 481            g_variant_get_boolean (old_state),
 482            g_variant_get_boolean (new_state));
 483
 484   g_simple_action_set_state (action, new_state);
 485   g_variant_unref (old_state);
 486 }
 487
 488 static void
 489 activate_radio (GSimpleAction *action, GVariant *parameter, gpointer user_data)
 490 {
 491   GVariant *old_state, *new_state;
 492
 493   old_state = g_action_get_state (G_ACTION (action));
 494   new_state = g_variant_new_string (g_variant_get_string (parameter, NULL));
 495
 496   g_print ("Radio action %s activated, state changes from %s to %s\n",
 497            g_action_get_name (G_ACTION (action)),
 498            g_variant_get_string (old_state, NULL),
 499            g_variant_get_string (new_state, NULL));
 500
 501   g_simple_action_set_state (action, new_state);
 502   g_variant_unref (old_state);
 503 }
 504
 505 static GActionEntry actions[] = {
 506   { "undo",  activate_action, NULL, NULL,      NULL },
 507   { "redo",  activate_action, NULL, NULL,      NULL },
 508   { "cut",   activate_action, NULL, NULL,      NULL },
 509   { "copy",  activate_action, NULL, NULL,      NULL },
 510   { "paste", activate_action, NULL, NULL,      NULL },
 511   { "bold",  activate_toggle, NULL, "true",    NULL },
 512   { "lang",  activate_radio,  "s",  "'latin'", NULL },
 513 };
 514
 515 static GActionGroup *
 516 get_group (void)
 517 {
 518   GSimpleActionGroup *group;
 519
 520   group = g_simple_action_group_new ();
 521
 522   g_simple_action_group_add_entries (group, actions, G_N_ELEMENTS (actions), NULL);
 523
 524   return G_ACTION_GROUP (group);
 525 }
 526
 527 /* The action treeview {{{1 */
 528
 529 static void
 530 enabled_cell_func (GtkTreeViewColumn *column,
 531                    GtkCellRenderer   *cell,
 532                    GtkTreeModel      *model,
 533                    GtkTreeIter       *iter,
 534                    gpointer           data)
 535 {
 536   GActionGroup *group = data;
 537   gchar *name;
 538   gboolean enabled;
 539
 540   gtk_tree_model_get (model, iter, 0, &name, -1);
 541   enabled = g_action_group_get_action_enabled (group, name);
 542   g_free (name);
 543
 544   gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell), enabled);
 545 }
 546
 547 static void
 548 state_cell_func (GtkTreeViewColumn *column,
 549                  GtkCellRenderer   *cell,
 550                  GtkTreeModel      *model,
 551                  GtkTreeIter       *iter,
 552                  gpointer           data)
 553 {
 554   GActionGroup *group = data;
 555   gchar *name;
 556   GVariant *state;
 557
 558   gtk_tree_model_get (model, iter, 0, &name, -1);
 559   state = g_action_group_get_action_state (group, name);
 560   g_free (name);
 561
 562   gtk_cell_renderer_set_visible (cell, FALSE);
 563   g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
 564
 565   if (state == NULL)
 566     return;
 567
 568   if (g_variant_is_of_type (state, G_VARIANT_TYPE_BOOLEAN) &&
 569       GTK_IS_CELL_RENDERER_TOGGLE (cell))
 570     {
 571       gtk_cell_renderer_set_visible (cell, TRUE);
 572       g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
 573       gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell),
 574                                            g_variant_get_boolean (state));
 575     }
 576   else if (g_variant_is_of_type (state, G_VARIANT_TYPE_STRING) &&
 577            GTK_IS_CELL_RENDERER_COMBO (cell))
 578     {
 579       gtk_cell_renderer_set_visible (cell, TRUE);
 580       g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
 581       g_object_set (cell, "text", g_variant_get_string (state, NULL), NULL);
 582     }
 583
 584   g_variant_unref (state);
 585 }
 586
 587 static void
 588 enabled_cell_toggled (GtkCellRendererToggle *cell,
 589                       const gchar           *path_str,
 590                       GtkTreeModel          *model)
 591 {
 592   GActionGroup *group;
 593   GAction *action;
 594   gchar *name;
 595   GtkTreePath *path;
 596   GtkTreeIter iter;
 597   gboolean enabled;
 598
 599   group = g_object_get_data (G_OBJECT (model), "group");
 600   path = gtk_tree_path_new_from_string (path_str);
 601   gtk_tree_model_get_iter (model, &iter, path);
 602   gtk_tree_model_get (model, &iter, 0, &name, -1);
 603
 604   enabled = g_action_group_get_action_enabled (group, name);
 605   action = g_simple_action_group_lookup (G_SIMPLE_ACTION_GROUP (group), name);
 606   g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !enabled);
 607
 608   gtk_tree_model_row_changed (model, path, &iter);
 609
 610   g_free (name);
 611   gtk_tree_path_free (path);
 612 }
 613
 614 static void
 615 state_cell_toggled (GtkCellRendererToggle *cell,
 616                     const gchar           *path_str,
 617                     GtkTreeModel          *model)
 618 {
 619   GActionGroup *group;
 620   GAction *action;
 621   gchar *name;
 622   GtkTreePath *path;
 623   GtkTreeIter iter;
 624   GVariant *state;
 625
 626   group = g_object_get_data (G_OBJECT (model), "group");
 627   path = gtk_tree_path_new_from_string (path_str);
 628   gtk_tree_model_get_iter (model, &iter, path);
 629   gtk_tree_model_get (model, &iter, 0, &name, -1);
 630
 631   state = g_action_group_get_action_state (group, name);
 632   action = g_simple_action_group_lookup (G_SIMPLE_ACTION_GROUP (group), name);
 633   if (state && g_variant_is_of_type (state, G_VARIANT_TYPE_BOOLEAN))
 634     {
 635       gboolean b;
 636
 637       b = g_variant_get_boolean (state);
 638       g_simple_action_set_state (G_SIMPLE_ACTION (action), g_variant_new_boolean (!b));
 639     }
 640   else
 641     {
 642       /* nothing to do */
 643     }
 644
 645   gtk_tree_model_row_changed (model, path, &iter);
 646
 647   g_free (name);
 648   gtk_tree_path_free (path);
 649   if (state)
 650     g_variant_unref (state);
 651 }
 652
 653 static void
 654 state_cell_edited (GtkCellRendererCombo  *cell,
 655                    const gchar           *path_str,
 656                    const gchar           *new_text,
 657                    GtkTreeModel          *model)
 658 {
 659   GActionGroup *group;
 660   GAction *action;
 661   gchar *name;
 662   GtkTreePath *path;
 663   GtkTreeIter iter;
 664
 665   group = g_object_get_data (G_OBJECT (model), "group");
 666   path = gtk_tree_path_new_from_string (path_str);
 667   gtk_tree_model_get_iter (model, &iter, path);
 668   gtk_tree_model_get (model, &iter, 0, &name, -1);
 669   action = g_simple_action_group_lookup (G_SIMPLE_ACTION_GROUP (group), name);
 670   g_simple_action_set_state (G_SIMPLE_ACTION (action), g_variant_new_string (new_text));
 671
 672   gtk_tree_model_row_changed (model, path, &iter);
 673
 674   g_free (name);
 675   gtk_tree_path_free (path);
 676 }
 677
 678 static GtkWidget *
 679 create_action_treeview (GActionGroup *group)
 680 {
 681   GtkWidget *tv;
 682   GtkListStore *store;
 683   GtkListStore *values;
 684   GtkTreeIter iter;
 685   GtkTreeViewColumn *column;
 686   GtkCellRenderer *cell;
 687   gchar **actions;
 688   gint i;
 689
 690   store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
 691   actions = g_action_group_list_actions (group);
 692   for (i = 0; actions[i]; i++)
 693     {
 694       gtk_list_store_append (store, &iter);
 695       gtk_list_store_set (store, &iter, 0, actions[i], -1);
 696     }
 697   g_strfreev (actions);
 698   g_object_set_data (G_OBJECT (store), "group", group);
 699
 700   tv = gtk_tree_view_new ();
 701
 702   g_signal_connect_swapped (group, "action-enabled-changed",
 703                             G_CALLBACK (gtk_widget_queue_draw), tv);
 704   g_signal_connect_swapped (group, "action-state-changed",
 705                             G_CALLBACK (gtk_widget_queue_draw), tv);
 706
 707   gtk_tree_view_set_model (GTK_TREE_VIEW (tv), GTK_TREE_MODEL (store));
 708
 709   cell = gtk_cell_renderer_text_new ();
 710   column = gtk_tree_view_column_new_with_attributes ("Action", cell,
 711                                                      "text", 0,
 712                                                      NULL);
 713   gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 714
 715   column = gtk_tree_view_column_new ();
 716   gtk_tree_view_column_set_title (column, "Enabled");
 717   cell = gtk_cell_renderer_toggle_new ();
 718   gtk_tree_view_column_pack_start (column, cell, FALSE);
 719   gtk_tree_view_column_set_cell_data_func (column, cell, enabled_cell_func, group, NULL);
 720   g_signal_connect (cell, "toggled", G_CALLBACK (enabled_cell_toggled), store);
 721   gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 722
 723   column = gtk_tree_view_column_new ();
 724   gtk_tree_view_column_set_title (column, "State");
 725   cell = gtk_cell_renderer_toggle_new ();
 726   gtk_tree_view_column_pack_start (column, cell, FALSE);
 727   gtk_tree_view_column_set_cell_data_func (column, cell, state_cell_func, group, NULL);
 728   g_signal_connect (cell, "toggled", G_CALLBACK (state_cell_toggled), store);
 729   cell = gtk_cell_renderer_combo_new ();
 730   values = gtk_list_store_new (1, G_TYPE_STRING);
 731   gtk_list_store_append (values, &iter);
 732   gtk_list_store_set (values, &iter, 0, "latin", -1);
 733   gtk_list_store_append (values, &iter);
 734   gtk_list_store_set (values, &iter, 0, "greek", -1);
 735   gtk_list_store_append (values, &iter);
 736   gtk_list_store_set (values, &iter, 0, "urdu", -1);
 737   gtk_list_store_append (values, &iter);
 738   gtk_list_store_set (values, &iter, 0, "sumerian", -1);
 739   g_object_set (cell,
 740                 "has-entry", FALSE,
 741                 "model", values,
 742                 "text-column", 0,
 743                 "editable", TRUE,
 744                 NULL);
 745   gtk_tree_view_column_pack_start (column, cell, FALSE);
 746   gtk_tree_view_column_set_cell_data_func (column, cell, state_cell_func, group, NULL);
 747   g_signal_connect (cell, "edited", G_CALLBACK (state_cell_edited), store);
 748   gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
 749
 750   return tv;
 751 }
 752
 753 /* Dynamic menu changes {{{1 */
 754
 755 static void
 756 toggle_sumerian (GtkToggleButton *button, gpointer data)
 757 {
 758   GMenuModel *model;
 759   gboolean adding;
 760   GMenuModel *m;
 761
 762   model = g_object_get_data (G_OBJECT (button), "model");
 763
 764   adding = gtk_toggle_button_get_active (button);
 765
 766   m = g_menu_model_get_item_link (model, g_menu_model_get_n_items (model) - 1, G_MENU_LINK_SECTION);
 767   m = g_menu_model_get_item_link (m, g_menu_model_get_n_items (m) - 1, G_MENU_LINK_SUBMENU);
 768   if (adding)
 769     g_menu_append (G_MENU (m), "Sumerian", "lang::sumerian");
 770   else
 771     g_menu_remove (G_MENU (m), g_menu_model_get_n_items (m) - 1);
 772 }
 773
 774 static void
 775 action_list_add (GtkTreeModel *store,
 776                  const gchar  *action)
 777 {
 778   GtkTreeIter iter;
 779
 780   gtk_list_store_append (GTK_LIST_STORE (store), &iter);
 781   gtk_list_store_set (GTK_LIST_STORE (store), &iter, 0, action, -1);
 782 }
 783
 784 static void
 785 action_list_remove (GtkTreeModel *store,
 786                     const gchar  *action)
 787 {
 788   GtkTreeIter iter;
 789   gchar *text;
 790
 791   gtk_tree_model_get_iter_first (store, &iter);
 792   do {
 793     gtk_tree_model_get (store, &iter, 0, &text, -1);
 794     if (g_strcmp0 (action, text) == 0)
 795       {
 796         g_free (text);
 797         gtk_list_store_remove (GTK_LIST_STORE (store), &iter);
 798         break;
 799       }
 800     g_free (text);
 801   } while (gtk_tree_model_iter_next (store, &iter));
 802 }
 803
 804 static void
 805 toggle_italic (GtkToggleButton *button, gpointer data)
 806 {
 807   GMenuModel *model;
 808   GActionGroup *group;
 809   GSimpleAction *action;
 810   gboolean adding;
 811   GMenuModel *m;
 812   GtkTreeView *tv = data;
 813   GtkTreeModel *store;
 814
 815   model = g_object_get_data (G_OBJECT (button), "model");
 816   group = g_object_get_data (G_OBJECT (button), "group");
 817
 818   store = gtk_tree_view_get_model (tv);
 819
 820   adding = gtk_toggle_button_get_active (button);
 821
 822   m = g_menu_model_get_item_link (model, g_menu_model_get_n_items (model) - 1, G_MENU_LINK_SECTION);
 823   if (adding)
 824     {
 825       action = g_simple_action_new_stateful ("italic", NULL, g_variant_new_boolean (FALSE));
 826       g_simple_action_group_insert (G_SIMPLE_ACTION_GROUP (group), G_ACTION (action));
 827       g_signal_connect (action, "activate", G_CALLBACK (activate_toggle), NULL);
 828       g_object_unref (action);
 829       action_list_add (store, "italic");
 830       g_menu_insert (G_MENU (m), 1, "Italic", "italic");
 831     }
 832   else
 833     {
 834       g_simple_action_group_remove (G_SIMPLE_ACTION_GROUP (group), "italic");
 835       action_list_remove (store, "italic");
 836       g_menu_remove (G_MENU (m), 1);
 837     }
 838 }
 839
 840 static void
 841 toggle_speed (GtkToggleButton *button, gpointer data)
 842 {
 843   GMenuModel *model;
 844   GActionGroup *group;
 845   GSimpleAction *action;
 846   gboolean adding;
 847   GMenuModel *m;
 848   GMenu *submenu;
 849   GtkTreeView *tv = data;
 850   GtkTreeModel *store;
 851
 852   model = g_object_get_data (G_OBJECT (button), "model");
 853   group = g_object_get_data (G_OBJECT (button), "group");
 854
 855   store = gtk_tree_view_get_model (tv);
 856
 857   adding = gtk_toggle_button_get_active (button);
 858
 859   m = g_menu_model_get_item_link (model, 1, G_MENU_LINK_SECTION);
 860   if (adding)
 861     {
 862       action = g_simple_action_new ("faster", NULL);
 863       g_simple_action_group_insert (G_SIMPLE_ACTION_GROUP (group), G_ACTION (action));
 864       g_signal_connect (action, "activate", G_CALLBACK (activate_action), NULL);
 865       g_object_unref (action);
 866
 867       action = g_simple_action_new ("slower", NULL);
 868       g_simple_action_group_insert (G_SIMPLE_ACTION_GROUP (group), G_ACTION (action));
 869       g_signal_connect (action, "activate", G_CALLBACK (activate_action), NULL);
 870       g_object_unref (action);
 871
 872       action_list_add (store, "faster");
 873       action_list_add (store, "slower");
 874
 875       submenu = g_menu_new ();
 876       g_menu_append (submenu, "Faster", "faster");
 877       g_menu_append (submenu, "Slower", "slower");
 878       g_menu_append_submenu (G_MENU (m), "Speed", G_MENU_MODEL (submenu));
 879     }
 880   else
 881     {
 882       g_simple_action_group_remove (G_SIMPLE_ACTION_GROUP (group), "faster");
 883       g_simple_action_group_remove (G_SIMPLE_ACTION_GROUP (group), "slower");
 884
 885       action_list_remove (store, "faster");
 886       action_list_remove (store, "slower");
 887
 888       g_menu_remove (G_MENU (m), g_menu_model_get_n_items (m) - 1);
 889     }
 890 }
 891 static GtkWidget *
 892 create_add_remove_buttons (GActionGroup *group,
 893                            GMenuModel   *model,
 894                            GtkWidget    *treeview)
 895 {
 896   GtkWidget *box;
 897   GtkWidget *button;
 898
 899   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
 900
 901   button = gtk_check_button_new_with_label ("Add Italic");
 902   gtk_container_add (GTK_CONTAINER (box), button);
 903
 904   g_object_set_data  (G_OBJECT (button), "group", group);
 905   g_object_set_data  (G_OBJECT (button), "model", model);
 906
 907   g_signal_connect (button, "toggled",
 908                     G_CALLBACK (toggle_italic), treeview);
 909
 910   button = gtk_check_button_new_with_label ("Add Sumerian");
 911   gtk_container_add (GTK_CONTAINER (box), button);
 912
 913   g_object_set_data  (G_OBJECT (button), "group", group);
 914   g_object_set_data  (G_OBJECT (button), "model", model);
 915
 916   g_signal_connect (button, "toggled",
 917                     G_CALLBACK (toggle_sumerian), NULL);
 918
 919   button = gtk_check_button_new_with_label ("Add Speed");
 920   gtk_container_add (GTK_CONTAINER (box), button);
 921
 922   g_object_set_data  (G_OBJECT (button), "group", group);
 923   g_object_set_data  (G_OBJECT (button), "model", model);
 924
 925   g_signal_connect (button, "toggled",
 926                     G_CALLBACK (toggle_speed), treeview);
 927   return box;
 928 }
 929
 930 /* main {{{1 */
 931
 932 static void
 933 button_clicked (GtkButton  *button,
 934                 MenuHolder *holder)
 935 {
 936   GtkWidget *menu;
 937
 938   menu = menu_holder_get_menu (holder);
 939   gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, 0);
 940 }
 941
 942 #define BUS_NAME "org.gtk.TestMenus"
 943 #define OBJ_PATH "/org/gtk/TestMenus"
 944
 945 static gboolean
 946 on_delete_event (GtkWidget   *widget,
 947                  GdkEvent    *event,
 948                  gpointer     user_data)
 949 {
 950   gtk_main_quit ();
 951   return TRUE;
 952 }
 953
 954 int
 955 main (int argc, char *argv[])
 956 {
 957   GtkWidget *window;
 958   GtkWidget *box;
 959   GtkWidget *button;
 960   GtkWidget *tv;
 961   GtkWidget *buttons;
 962   MenuHolder *holder;
 963   GMenuModel *model;
 964   GActionGroup *group;
 965   GDBusConnection *bus;
 966   GError *error = NULL;
 967   gboolean do_export = FALSE;
 968   gboolean do_import = FALSE;
 969   GOptionEntry entries[] = {
 970     { "export", 0, 0, G_OPTION_ARG_NONE, &do_export, "Export actions and menus over D-Bus", NULL },
 971     { "import", 0, 0, G_OPTION_ARG_NONE, &do_import, "Use exported actions and menus", NULL },
 972     { NULL, }
 973   };
 974
 975   gtk_init_with_args (&argc, &argv, NULL, entries, NULL, NULL);
 976
 977   if (do_export && do_import)
 978     {
 979        g_error ("can't have it both ways\n");
 980        exit (1);
 981     }
 982
 983   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 984   g_signal_connect (window, "delete-event", G_CALLBACK(on_delete_event), NULL);
 985   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
 986   gtk_container_add (GTK_CONTAINER (window), box);
 987
 988   bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
 989
 990   if (do_import)
 991     {
 992       g_print ("Getting menus from the bus...\n");
 993       model = (GMenuModel*)g_menu_proxy_get (bus, BUS_NAME, OBJ_PATH);
 994       g_print ("Getting actions from the bus...\n");
 995       group = (GActionGroup*)g_dbus_action_group_new_sync (bus, BUS_NAME, OBJ_PATH, 0, NULL, NULL);
 996     }
 997   else
 998     {
 999       group = get_group ();
1000       model = get_model ();
1001
1002       tv = create_action_treeview (group);
1003       gtk_container_add (GTK_CONTAINER (box), tv);
1004       buttons = create_add_remove_buttons (group, model, tv);
1005       gtk_container_add (GTK_CONTAINER (box), buttons);
1006     }
1007
1008   if (do_export)
1009     {
1010 #if 0
1011       g_print ("Exporting menus on the bus...\n");
1012       if (!g_menu_exporter_export (bus, OBJ_PATH, model, &error))
1013         {
1014           g_warning ("Menu export failed: %s", error->message);
1015           exit (1);
1016         }
1017       g_print ("Exporting actions on the bus...\n");
1018       if (!g_action_group_exporter_export (bus, OBJ_PATH, group, &error))
1019         {
1020           g_warning ("Action export failed: %s", error->message);
1021           exit (1);
1022         }
1023       g_bus_own_name_on_connection (bus, BUS_NAME, 0, NULL, NULL, NULL, NULL);
1024 #endif
1025     }
1026   else
1027     {
1028       holder = menu_holder_new (model, group);
1029       button = gtk_button_new_with_label ("Click here");
1030       g_signal_connect (button, "clicked",
1031                         G_CALLBACK (button_clicked), holder);
1032       gtk_container_add (GTK_CONTAINER (box), button);
1033     }
1034
1035   gtk_widget_show_all (window);
1036
1037   gtk_main ();
1038
1039   return 0;
1040 }
1041
1042 /* Epilogue {{{1 */
1043 /* vim:set foldmethod=marker: */