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