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