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