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

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <gtk/gtk.h>
   4
   5 struct { const gchar *filename; guint merge_id; } merge_ids[] = {
   6   { "merge-1.ui", 0 },
   7   { "merge-2.ui", 0 },
   8   { "merge-3.ui", 0 }
   9 };
  10
  11 static void
  12 dump_tree (GtkWidget    *button,
  13            GtkUIManager *merge)
  14 {
  15   gchar *dump;
  16
  17   dump = gtk_ui_manager_get_ui (merge);
  18   g_message (dump);
  19   g_free (dump);
  20 }
  21
  22 static void
  23 toggle_tearoffs (GtkWidget    *button,
  24                  GtkUIManager *merge)
  25 {
  26   gboolean add_tearoffs;
  27
  28   add_tearoffs = gtk_ui_manager_get_add_tearoffs (merge);
  29
  30   gtk_ui_manager_set_add_tearoffs (merge, !add_tearoffs);
  31 }
  32
  33 static void
  34 toggle_dynamic (GtkWidget    *button,
  35                 GtkUIManager *merge)
  36 {
  37   GtkAction *dyn;
  38   static GtkActionGroup *dynamic = NULL;
  39   static guint merge_id = 0;
  40
  41   if (!dynamic)
  42     {
  43       dynamic = gtk_action_group_new ("dynamic");
  44       gtk_ui_manager_insert_action_group (merge, dynamic, 0);
  45       dyn = g_object_new (GTK_TYPE_ACTION,
  46                           "name", "dyn1",
  47                           "label", "Dynamic action 1",
  48                           "stock_id", GTK_STOCK_COPY,
  49                           NULL);
  50       gtk_action_group_add_action (dynamic, dyn);
  51       dyn = g_object_new (GTK_TYPE_ACTION,
  52                           "name", "dyn2",
  53                           "label", "Dynamic action 2",
  54                           "stock_id", GTK_STOCK_EXECUTE,
  55                           NULL);
  56       gtk_action_group_add_action (dynamic, dyn);
  57     }
  58
  59   if (merge_id == 0)
  60     {
  61       merge_id = gtk_ui_manager_new_merge_id (merge);
  62       gtk_ui_manager_add_ui (merge, merge_id, "/toolbar1/ToolbarPlaceholder",
  63                              "dyn1", "dyn1", 0, 0);
  64       gtk_ui_manager_add_ui (merge, merge_id, "/toolbar1/ToolbarPlaceholder",
  65                              "dynsep", NULL, GTK_UI_MANAGER_SEPARATOR, 0);
  66       gtk_ui_manager_add_ui (merge, merge_id, "/toolbar1/ToolbarPlaceholder",
  67                              "dyn2", "dyn2", 0, 0);
  68
  69       gtk_ui_manager_add_ui (merge, merge_id, "/menubar/EditMenu",
  70                              "dyn1menu", "dyn1", GTK_UI_MANAGER_MENU, 0);
  71       gtk_ui_manager_add_ui (merge, merge_id, "/menubar/EditMenu/dyn1menu",
  72                              "dyn1", "dyn1", GTK_UI_MANAGER_MENUITEM, 0);
  73       gtk_ui_manager_add_ui (merge, merge_id, "/menubar/EditMenu/dyn1menu",
  74                              "dyn2", "dyn2", GTK_UI_MANAGER_AUTO, TRUE);
  75     }
  76   else
  77     {
  78       gtk_ui_manager_remove_ui (merge, merge_id);
  79       merge_id = 0;
  80     }
  81 }
  82
  83
  84 static void
  85 activate_action (GtkAction *action)
  86 {
  87   const gchar *name = gtk_action_get_name (action);
  88   const gchar *typename = G_OBJECT_TYPE_NAME (action);
  89
  90   g_message ("Action %s (type=%s) activated", name, typename);
  91 }
  92
  93 static void
  94 toggle_action (GtkAction *action)
  95 {
  96   const gchar *name = gtk_action_get_name (action);
  97   const gchar *typename = G_OBJECT_TYPE_NAME (action);
  98
  99   g_message ("ToggleAction %s (type=%s) toggled (active=%d)", name, typename,
 100              gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
 101 }
 102
 103
 104 static void
 105 radio_action_changed (GtkAction *action, GtkRadioAction *current)
 106 {
 107   g_message ("RadioAction %s (type=%s) activated (active=%d) (value %d)",
 108              gtk_action_get_name (GTK_ACTION (current)),
 109              G_OBJECT_TYPE_NAME (GTK_ACTION (current)),
 110              gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (current)),
 111              gtk_radio_action_get_current_value (current));
 112 }
 113
 114 static GtkActionEntry entries[] = {
 115   { "FileMenuAction", NULL, "_File" },
 116   { "EditMenuAction", NULL, "_Edit" },
 117   { "HelpMenuAction", NULL, "_Help" },
 118   { "JustifyMenuAction", NULL, "_Justify" },
 119   { "Test", NULL, "Test" },
 120
 121   { "QuitAction",  GTK_STOCK_QUIT,  NULL,     "<control>q", NULL, G_CALLBACK (gtk_main_quit) },
 122   { "NewAction",   GTK_STOCK_NEW,   NULL,     "<control>n", NULL, G_CALLBACK (activate_action) },
 123   { "New2Action",  GTK_STOCK_NEW,   NULL,     "<control>m", NULL, G_CALLBACK (activate_action) },
 124   { "OpenAction",  GTK_STOCK_OPEN,  NULL,     "<control>o", NULL, G_CALLBACK (activate_action) },
 125   { "CutAction",   GTK_STOCK_CUT,   NULL,     "<control>x", NULL, G_CALLBACK (activate_action) },
 126   { "CopyAction",  GTK_STOCK_COPY,  NULL,     "<control>c", NULL, G_CALLBACK (activate_action) },
 127   { "PasteAction", GTK_STOCK_PASTE, NULL,     "<control>v", NULL, G_CALLBACK (activate_action) },
 128   { "AboutAction", NULL,            "_About", NULL,         NULL, G_CALLBACK (activate_action) },
 129 };
 130 static guint n_entries = G_N_ELEMENTS (entries);
 131
 132 static GtkToggleActionEntry toggle_entries[] = {
 133   { "BoldAction",  GTK_STOCK_BOLD,  "_Bold",  "<control>b", NULL, G_CALLBACK (toggle_action),
 134     TRUE },
 135 };
 136 static guint n_toggle_entries = G_N_ELEMENTS (toggle_entries);
 137
 138 enum {
 139   JUSTIFY_LEFT,
 140   JUSTIFY_CENTER,
 141   JUSTIFY_RIGHT,
 142   JUSTIFY_FILL
 143 };
 144
 145 static GtkRadioActionEntry radio_entries[] = {
 146   { "justify-left", GTK_STOCK_JUSTIFY_LEFT, NULL, "<control>L",
 147     "Left justify the text", JUSTIFY_LEFT },
 148   { "justify-center", GTK_STOCK_JUSTIFY_CENTER, NULL, "<control>E",
 149     "Center justify the text", JUSTIFY_CENTER },
 150   { "justify-right", GTK_STOCK_JUSTIFY_RIGHT, NULL, "<control>R",
 151     "Right justify the text", JUSTIFY_RIGHT },
 152   { "justify-fill", GTK_STOCK_JUSTIFY_FILL, NULL, "<control>J",
 153     "Fill justify the text", JUSTIFY_FILL },
 154 };
 155 static guint n_radio_entries = G_N_ELEMENTS (radio_entries);
 156
 157 static void
 158 add_widget (GtkUIManager *merge,
 159             GtkWidget    *widget,
 160             GtkBox       *box)
 161 {
 162   GtkWidget *handle_box;
 163
 164   if (GTK_IS_TOOLBAR (widget))
 165     {
 166       handle_box = gtk_handle_box_new ();
 167       gtk_widget_show (handle_box);
 168       gtk_container_add (GTK_CONTAINER (handle_box), widget);
 169       gtk_box_pack_start (box, handle_box, FALSE, FALSE, 0);
 170       g_signal_connect_swapped (widget, "destroy",
 171                                 G_CALLBACK (gtk_widget_destroy), handle_box);
 172     }
 173   else
 174     gtk_box_pack_start (box, widget, FALSE, FALSE, 0);
 175
 176   gtk_widget_show (widget);
 177 }
 178
 179 static void
 180 toggle_merge (GtkWidget    *button,
 181               GtkUIManager *merge)
 182 {
 183   gint mergenum;
 184
 185   mergenum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "mergenum"));
 186
 187   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
 188     {
 189       GError *err = NULL;
 190
 191       g_message ("merging %s", merge_ids[mergenum].filename);
 192       merge_ids[mergenum].merge_id =
 193         gtk_ui_manager_add_ui_from_file (merge, merge_ids[mergenum].filename, &err);
 194       if (err != NULL)
 195         {
 196           GtkWidget *dialog;
 197
 198           dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (button)),
 199                                            0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
 200                                            "could not merge %s: %s", merge_ids[mergenum].filename,
 201                                            err->message);
 202
 203           g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_object_destroy), NULL);
 204           gtk_widget_show (dialog);
 205
 206           g_clear_error (&err);
 207         }
 208     }
 209   else
 210     {
 211       g_message ("unmerging %s (merge_id=%u)", merge_ids[mergenum].filename,
 212                  merge_ids[mergenum].merge_id);
 213       gtk_ui_manager_remove_ui (merge, merge_ids[mergenum].merge_id);
 214     }
 215 }
 216
 217 static void
 218 set_name_func (GtkTreeViewColumn *tree_column,
 219                GtkCellRenderer   *cell,
 220                GtkTreeModel      *tree_model,
 221                GtkTreeIter       *iter,
 222                gpointer           data)
 223 {
 224   GtkAction *action;
 225   char *name;
 226
 227   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 228   g_object_get (G_OBJECT (action), "name", &name, NULL);
 229   g_object_set (G_OBJECT (cell), "text", name, NULL);
 230   g_free (name);
 231   g_object_unref (action);
 232 }
 233
 234 static void
 235 set_sensitive_func (GtkTreeViewColumn *tree_column,
 236                     GtkCellRenderer   *cell,
 237                     GtkTreeModel      *tree_model,
 238                     GtkTreeIter       *iter,
 239                     gpointer           data)
 240 {
 241   GtkAction *action;
 242   gboolean sensitive;
 243
 244   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 245   g_object_get (G_OBJECT (action), "sensitive", &sensitive, NULL);
 246   g_object_set (G_OBJECT (cell), "active", sensitive, NULL);
 247   g_object_unref (action);
 248 }
 249
 250
 251 static void
 252 set_visible_func (GtkTreeViewColumn *tree_column,
 253                   GtkCellRenderer   *cell,
 254                   GtkTreeModel      *tree_model,
 255                   GtkTreeIter       *iter,
 256                   gpointer           data)
 257 {
 258   GtkAction *action;
 259   gboolean visible;
 260
 261   gtk_tree_model_get (tree_model, iter, 0, &action, -1);
 262   g_object_get (G_OBJECT (action), "visible", &visible, NULL);
 263   g_object_set (G_OBJECT (cell), "active", visible, NULL);
 264   g_object_unref (action);
 265 }
 266
 267 static void
 268 sensitivity_toggled (GtkCellRendererToggle *cell,
 269                      const gchar           *path_str,
 270                      GtkTreeModel          *model)
 271 {
 272   GtkTreePath *path;
 273   GtkTreeIter iter;
 274   GtkAction *action;
 275   gboolean sensitive;
 276
 277   path = gtk_tree_path_new_from_string (path_str);
 278   gtk_tree_model_get_iter (model, &iter, path);
 279
 280   gtk_tree_model_get (model, &iter, 0, &action, -1);
 281   g_object_get (G_OBJECT (action), "sensitive", &sensitive, NULL);
 282   g_object_set (G_OBJECT (action), "sensitive", !sensitive, NULL);
 283   gtk_tree_model_row_changed (model, path, &iter);
 284   gtk_tree_path_free (path);
 285 }
 286
 287 static void
 288 visibility_toggled (GtkCellRendererToggle *cell,
 289                     const gchar           *path_str,
 290                     GtkTreeModel          *model)
 291 {
 292   GtkTreePath *path;
 293   GtkTreeIter iter;
 294   GtkAction *action;
 295   gboolean visible;
 296
 297   path = gtk_tree_path_new_from_string (path_str);
 298   gtk_tree_model_get_iter (model, &iter, path);
 299
 300   gtk_tree_model_get (model, &iter, 0, &action, -1);
 301   g_object_get (G_OBJECT (action), "visible", &visible, NULL);
 302   g_object_set (G_OBJECT (action), "visible", !visible, NULL);
 303   gtk_tree_model_row_changed (model, path, &iter);
 304   gtk_tree_path_free (path);
 305 }
 306
 307 static gint
 308 iter_compare_func (GtkTreeModel *model,
 309                    GtkTreeIter  *a,
 310                    GtkTreeIter  *b,
 311                    gpointer      user_data)
 312 {
 313   GValue a_value = { 0, }, b_value = { 0, };
 314   GtkAction *a_action, *b_action;
 315   const gchar *a_name, *b_name;
 316   gint retval = 0;
 317
 318   gtk_tree_model_get_value (model, a, 0, &a_value);
 319   gtk_tree_model_get_value (model, b, 0, &b_value);
 320   a_action = GTK_ACTION (g_value_get_object (&a_value));
 321   b_action = GTK_ACTION (g_value_get_object (&b_value));
 322
 323   a_name = gtk_action_get_name (a_action);
 324   b_name = gtk_action_get_name (b_action);
 325   if (a_name == NULL && b_name == NULL)
 326     retval = 0;
 327   else if (a_name == NULL)
 328     retval = -1;
 329   else if (b_name == NULL)
 330     retval = 1;
 331   else
 332     retval = strcmp (a_name, b_name);
 333
 334   g_value_unset (&b_value);
 335   g_value_unset (&a_value);
 336
 337   return retval;
 338 }
 339
 340 static GtkWidget *
 341 create_tree_view (GtkUIManager *merge)
 342 {
 343   GtkWidget *tree_view, *sw;
 344   GtkListStore *store;
 345   GList *p;
 346   GtkCellRenderer *cell;
 347
 348   store = gtk_list_store_new (1, GTK_TYPE_ACTION);
 349   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), 0,
 350                                    iter_compare_func, NULL, NULL);
 351   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 0,
 352                                         GTK_SORT_ASCENDING);
 353
 354   for (p = gtk_ui_manager_get_action_groups (merge); p; p = p->next)
 355     {
 356       GList *actions, *l;
 357
 358       actions = gtk_action_group_list_actions (p->data);
 359
 360       for (l = actions; l; l = l->next)
 361         {
 362           GtkTreeIter iter;
 363
 364           gtk_list_store_append (store, &iter);
 365           gtk_list_store_set (store, &iter, 0, l->data, -1);
 366         }
 367     }
 368
 369   tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
 370   g_object_unref (store);
 371
 372   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 373                                               -1, "Action",
 374                                               gtk_cell_renderer_text_new (),
 375                                               set_name_func, NULL, NULL);
 376
 377   gtk_tree_view_column_set_sort_column_id (gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), 0), 0);
 378
 379   cell = gtk_cell_renderer_toggle_new ();
 380   g_signal_connect (cell, "toggled", G_CALLBACK (sensitivity_toggled), store);
 381   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 382                                               -1, "Sensitive",
 383                                               cell,
 384                                               set_sensitive_func, NULL, NULL);
 385
 386   cell = gtk_cell_renderer_toggle_new ();
 387   g_signal_connect (cell, "toggled", G_CALLBACK (visibility_toggled), store);
 388   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (tree_view),
 389                                               -1, "Visible",
 390                                               cell,
 391                                               set_visible_func, NULL, NULL);
 392
 393   sw = gtk_scrolled_window_new (NULL, NULL);
 394   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 395                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 396   gtk_container_add (GTK_CONTAINER (sw), tree_view);
 397
 398   return sw;
 399 }
 400
 401 static gboolean
 402 area_press (GtkWidget      *drawing_area,
 403             GdkEventButton *event,
 404             GtkUIManager   *merge)
 405 {
 406   gtk_widget_grab_focus (drawing_area);
 407
 408   if (event->button == 3 &&
 409       event->type == GDK_BUTTON_PRESS)
 410     {
 411       GtkWidget *menu = gtk_ui_manager_get_widget (merge, "/FileMenu");
 412
 413       if (GTK_IS_MENU (menu))
 414         {
 415           gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
 416                           NULL, drawing_area,
 417                           3, event->time);
 418           return TRUE;
 419         }
 420     }
 421
 422   return FALSE;
 423
 424 }
 425
 426 static void
 427 activate_path (GtkWidget      *button,
 428                GtkUIManager   *merge)
 429 {
 430   GtkAction *action = gtk_ui_manager_get_action (merge,
 431                                                  "/menubar/HelpMenu/About");
 432   if (action)
 433     gtk_action_activate (action);
 434   else
 435     g_message ("no action found");
 436 }
 437
 438 int
 439 main (int argc, char **argv)
 440 {
 441   GtkActionGroup *action_group;
 442   GtkUIManager *merge;
 443   GtkWidget *window, *table, *frame, *menu_box, *vbox, *view;
 444   GtkWidget *button, *area;
 445   gint i;
 446
 447   gtk_init (&argc, &argv);
 448
 449   action_group = gtk_action_group_new ("TestActions");
 450   gtk_action_group_add_actions (action_group,
 451                                 entries, n_entries,
 452                                 NULL);
 453   gtk_action_group_add_toggle_actions (action_group,
 454                                        toggle_entries, n_toggle_entries,
 455                                        NULL);
 456   gtk_action_group_add_radio_actions (action_group,
 457                                       radio_entries, n_radio_entries,
 458                                       JUSTIFY_LEFT,
 459                                       G_CALLBACK (radio_action_changed), NULL);
 460
 461   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 462   gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
 463   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 464
 465   table = gtk_table_new (2, 2, FALSE);
 466   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
 467   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
 468   gtk_container_set_border_width (GTK_CONTAINER (table), 2);
 469   gtk_container_add (GTK_CONTAINER (window), table);
 470
 471   frame = gtk_frame_new ("Menus and Toolbars");
 472   gtk_table_attach (GTK_TABLE (table), frame, 0,2, 1,2,
 473                     GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
 474
 475   menu_box = gtk_vbox_new (FALSE, 0);
 476   gtk_container_set_border_width (GTK_CONTAINER (menu_box), 2);
 477   gtk_container_add (GTK_CONTAINER (frame), menu_box);
 478
 479   area = gtk_drawing_area_new ();
 480   gtk_widget_set_events (area, GDK_BUTTON_PRESS_MASK);
 481   gtk_widget_set_size_request (area, -1, 40);
 482   gtk_box_pack_end (GTK_BOX (menu_box), area, FALSE, FALSE, 0);
 483   gtk_widget_show (area);
 484
 485   button = gtk_button_new ();
 486   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 487   gtk_action_connect_proxy (gtk_action_group_get_action (action_group, "AboutAction"),
 488                             button);
 489   gtk_widget_show (button);
 490   merge = gtk_ui_manager_new ();
 491
 492   button = gtk_check_button_new ();
 493   gtk_box_pack_end (GTK_BOX (menu_box), button, FALSE, FALSE, 0);
 494   gtk_action_connect_proxy (gtk_action_group_get_action (action_group, "BoldAction"),
 495                             button);
 496   gtk_widget_show (button);
 497   merge = gtk_ui_manager_new ();
 498
 499   g_signal_connect (area, "button_press_event",
 500                     G_CALLBACK (area_press), merge);
 501
 502   gtk_ui_manager_insert_action_group (merge, action_group, 0);
 503   g_signal_connect (merge, "add_widget", G_CALLBACK (add_widget), menu_box);
 504
 505   gtk_window_add_accel_group (GTK_WINDOW (window),
 506                               gtk_ui_manager_get_accel_group (merge));
 507
 508   frame = gtk_frame_new ("UI Files");
 509   gtk_table_attach (GTK_TABLE (table), frame, 0,1, 0,1,
 510                     GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
 511
 512   vbox = gtk_vbox_new (FALSE, 2);
 513   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
 514   gtk_container_add (GTK_CONTAINER (frame), vbox);
 515
 516   for (i = 0; i < G_N_ELEMENTS (merge_ids); i++)
 517     {
 518       button = gtk_check_button_new_with_label (merge_ids[i].filename);
 519       g_object_set_data (G_OBJECT (button), "mergenum", GINT_TO_POINTER (i));
 520       g_signal_connect (button, "toggled", G_CALLBACK (toggle_merge), merge);
 521       gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 522       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 523     }
 524
 525   button = gtk_check_button_new_with_label ("Tearoffs");
 526   g_signal_connect (button, "clicked", G_CALLBACK (toggle_tearoffs), merge);
 527   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 528
 529   button = gtk_check_button_new_with_label ("Dynamic");
 530   g_signal_connect (button, "clicked", G_CALLBACK (toggle_dynamic), merge);
 531   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 532
 533   button = gtk_button_new_with_label ("Activate path");
 534   g_signal_connect (button, "clicked", G_CALLBACK (activate_path), merge);
 535   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 536
 537   button = gtk_button_new_with_label ("Dump Tree");
 538   g_signal_connect (button, "clicked", G_CALLBACK (dump_tree), merge);
 539   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 540
 541   view = create_tree_view (merge);
 542   gtk_table_attach (GTK_TABLE (table), view, 1,2, 0,1,
 543                     GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
 544
 545   gtk_widget_show_all (window);
 546   gtk_main ();
 547
 548
 549   return 0;
 550 }