cut-n-paste/toolbar-editor/egg-toolbar-editor.c

   1 /*
   2  *  Copyright (C) 2003 Marco Pesenti Gritti
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2, or (at your option)
   7  *  any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  *
  18  *  $Id$
  19  */
  20
  21 #include "config.h"
  22
  23 #include "egg-toolbar-editor.h"
  24 #include "egg-editable-toolbar.h"
  25
  26 #include <string.h>
  27 #include <libxml/tree.h>
  28 #include <gtk/gtkimage.h>
  29 #include <gtk/gtkeventbox.h>
  30 #include <gtk/gtkdnd.h>
  31 #include <gtk/gtkscrolledwindow.h>
  32 #include <gtk/gtklabel.h>
  33 #include <gtk/gtktable.h>
  34 #include <gtk/gtkstock.h>
  35 #include <gtk/gtkhbox.h>
  36 #include <gtk/gtk.h>
  37 #include <glib/gi18n.h>
  38
  39 static const GtkTargetEntry dest_drag_types[] = {
  40   {EGG_TOOLBAR_ITEM_TYPE, GTK_TARGET_SAME_APP, 0},
  41 };
  42
  43 static const GtkTargetEntry source_drag_types[] = {
  44   {EGG_TOOLBAR_ITEM_TYPE, GTK_TARGET_SAME_APP, 0},
  45 };
  46
  47 static void egg_toolbar_editor_class_init       (EggToolbarEditorClass *klass);
  48 static void egg_toolbar_editor_init             (EggToolbarEditor *t);
  49 static void egg_toolbar_editor_finalize         (GObject *object);
  50 static void update_editor_sheet                 (EggToolbarEditor *editor);
  51
  52 enum
  53 {
  54   PROP_0,
  55   PROP_UI_MANAGER,
  56   PROP_TOOLBARS_MODEL
  57 };
  58
  59 static GObjectClass *parent_class = NULL;
  60
  61 #define EGG_TOOLBAR_EDITOR_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EGG_TYPE_TOOLBAR_EDITOR, EggToolbarEditorPrivate))
  62
  63 struct EggToolbarEditorPrivate
  64 {
  65   GtkUIManager *manager;
  66   EggToolbarsModel *model;
  67
  68   GtkWidget *table;
  69   GtkWidget *scrolled_window;
  70   GList     *actions_list;
  71   GList     *factory_list;
  72 };
  73
  74 GType
  75 egg_toolbar_editor_get_type (void)
  76 {
  77   static GType type = 0;
  78
  79   if (G_UNLIKELY (type == 0))
  80     {
  81       const GTypeInfo our_info = {
  82         sizeof (EggToolbarEditorClass),
  83         NULL,                   /* base_init */
  84         NULL,                   /* base_finalize */
  85         (GClassInitFunc) egg_toolbar_editor_class_init,
  86         NULL,
  87         NULL,                   /* class_data */
  88         sizeof (EggToolbarEditor),
  89         0,                      /* n_preallocs */
  90         (GInstanceInitFunc) egg_toolbar_editor_init
  91       };
  92
  93       type = g_type_register_static (GTK_TYPE_VBOX,
  94                                      "EggToolbarEditor",
  95                                      &our_info, 0);
  96     }
  97
  98   return type;
  99 }
 100
 101 static gint
 102 compare_items (gconstpointer a,
 103                gconstpointer b)
 104 {
 105   const GtkWidget *item1 = a;
 106   const GtkWidget *item2 = b;
 107
 108   char *key1 = g_object_get_data (G_OBJECT (item1),
 109                                   "egg-collate-key");
 110   char *key2 = g_object_get_data (G_OBJECT (item2),
 111                                   "egg-collate-key");
 112
 113   return strcmp (key1, key2);
 114 }
 115
 116 static GtkAction *
 117 find_action (EggToolbarEditor *t,
 118              const char       *name)
 119 {
 120   GList *l;
 121   GtkAction *action = NULL;
 122
 123   l = gtk_ui_manager_get_action_groups (t->priv->manager);
 124
 125   g_return_val_if_fail (EGG_IS_TOOLBAR_EDITOR (t), NULL);
 126   g_return_val_if_fail (name != NULL, NULL);
 127
 128   for (; l != NULL; l = l->next)
 129     {
 130       GtkAction *tmp;
 131
 132       tmp = gtk_action_group_get_action (GTK_ACTION_GROUP (l->data), name);
 133       if (tmp)
 134         action = tmp;
 135     }
 136
 137   return action;
 138 }
 139
 140 static void
 141 egg_toolbar_editor_set_ui_manager (EggToolbarEditor *t,
 142                                    GtkUIManager     *manager)
 143 {
 144   g_return_if_fail (GTK_IS_UI_MANAGER (manager));
 145
 146   t->priv->manager = g_object_ref (manager);
 147 }
 148
 149 static void
 150 item_added_or_removed_cb (EggToolbarsModel   *model,
 151                           int                 tpos,
 152                           int                 ipos,
 153                           EggToolbarEditor   *editor)
 154 {
 155   update_editor_sheet (editor);
 156 }
 157
 158 static void
 159 toolbar_removed_cb (EggToolbarsModel   *model,
 160                     int                 position,
 161                     EggToolbarEditor   *editor)
 162 {
 163   update_editor_sheet (editor);
 164 }
 165
 166 static void
 167 egg_toolbar_editor_set_model (EggToolbarEditor *t,
 168                               EggToolbarsModel *model)
 169 {
 170   g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (t));
 171
 172   t->priv->model = g_object_ref (model);
 173
 174   update_editor_sheet (t);
 175
 176   g_signal_connect_object (model, "item_added",
 177                            G_CALLBACK (item_added_or_removed_cb), t, 0);
 178   g_signal_connect_object (model, "item_removed",
 179                            G_CALLBACK (item_added_or_removed_cb), t, 0);
 180   g_signal_connect_object (model, "toolbar_removed",
 181                            G_CALLBACK (toolbar_removed_cb), t, 0);
 182 }
 183
 184 static void
 185 egg_toolbar_editor_set_property (GObject      *object,
 186                                  guint         prop_id,
 187                                  const GValue *value,
 188                                  GParamSpec   *pspec)
 189 {
 190   EggToolbarEditor *t = EGG_TOOLBAR_EDITOR (object);
 191
 192   switch (prop_id)
 193     {
 194     case PROP_UI_MANAGER:
 195       egg_toolbar_editor_set_ui_manager (t, g_value_get_object (value));
 196       break;
 197     case PROP_TOOLBARS_MODEL:
 198       egg_toolbar_editor_set_model (t, g_value_get_object (value));
 199       break;
 200     }
 201 }
 202
 203 static void
 204 egg_toolbar_editor_get_property (GObject    *object,
 205                                  guint       prop_id,
 206                                  GValue     *value,
 207                                  GParamSpec *pspec)
 208 {
 209   EggToolbarEditor *t = EGG_TOOLBAR_EDITOR (object);
 210
 211   switch (prop_id)
 212     {
 213     case PROP_UI_MANAGER:
 214       g_value_set_object (value, t->priv->manager);
 215       break;
 216     case PROP_TOOLBARS_MODEL:
 217       g_value_set_object (value, t->priv->model);
 218       break;
 219     }
 220 }
 221
 222 static void
 223 egg_toolbar_editor_class_init (EggToolbarEditorClass *klass)
 224 {
 225   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 226
 227   parent_class = g_type_class_peek_parent (klass);
 228
 229   object_class->finalize = egg_toolbar_editor_finalize;
 230   object_class->set_property = egg_toolbar_editor_set_property;
 231   object_class->get_property = egg_toolbar_editor_get_property;
 232
 233   g_object_class_install_property (object_class,
 234                                    PROP_UI_MANAGER,
 235                                    g_param_spec_object ("ui-manager",
 236                                                         "UI-Manager",
 237                                                         "UI Manager",
 238                                                         GTK_TYPE_UI_MANAGER,
 239                                                         G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 240                                                         G_PARAM_CONSTRUCT_ONLY));
 241  g_object_class_install_property (object_class,
 242                                   PROP_TOOLBARS_MODEL,
 243                                   g_param_spec_object ("model",
 244                                                        "Model",
 245                                                        "Toolbars Model",
 246                                                        EGG_TYPE_TOOLBARS_MODEL,
 247                                                        G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 248                                                        G_PARAM_CONSTRUCT_ONLY));
 249
 250   g_type_class_add_private (object_class, sizeof (EggToolbarEditorPrivate));
 251 }
 252
 253 static void
 254 egg_toolbar_editor_finalize (GObject *object)
 255 {
 256   EggToolbarEditor *editor = EGG_TOOLBAR_EDITOR (object);
 257
 258   if (editor->priv->manager)
 259     {
 260       g_object_unref (editor->priv->manager);
 261     }
 262
 263   if (editor->priv->model)
 264     {
 265       g_object_unref (editor->priv->model);
 266     }
 267
 268   g_list_free (editor->priv->actions_list);
 269   g_list_free (editor->priv->factory_list);
 270
 271   G_OBJECT_CLASS (parent_class)->finalize (object);
 272 }
 273
 274 GtkWidget *
 275 egg_toolbar_editor_new (GtkUIManager *manager,
 276                         EggToolbarsModel *model)
 277 {
 278   return GTK_WIDGET (g_object_new (EGG_TYPE_TOOLBAR_EDITOR,
 279                                    "ui-manager", manager,
 280                                    "model", model,
 281                                    NULL));
 282 }
 283
 284 static void
 285 drag_begin_cb (GtkWidget          *widget,
 286                GdkDragContext     *context)
 287 {
 288   gtk_widget_hide (widget);
 289 }
 290
 291 static void
 292 drag_end_cb (GtkWidget          *widget,
 293              GdkDragContext     *context)
 294 {
 295   gtk_widget_show (widget);
 296 }
 297
 298 static void
 299 drag_data_get_cb (GtkWidget          *widget,
 300                   GdkDragContext     *context,
 301                   GtkSelectionData   *selection_data,
 302                   guint               info,
 303                   guint32             time,
 304                   EggToolbarEditor   *editor)
 305 {
 306   const char *target;
 307
 308   target = g_object_get_data (G_OBJECT (widget), "egg-item-name");
 309   g_return_if_fail (target != NULL);
 310
 311   gtk_selection_data_set (selection_data, selection_data->target, 8,
 312                           (const guchar *) target, strlen (target));
 313 }
 314
 315 static gchar *
 316 elide_underscores (const gchar *original)
 317 {
 318   gchar *q, *result;
 319   const gchar *p;
 320   gboolean last_underscore;
 321
 322   q = result = g_malloc (strlen (original) + 1);
 323   last_underscore = FALSE;
 324
 325   for (p = original; *p; p++)
 326     {
 327       if (!last_underscore && *p == '_')
 328         last_underscore = TRUE;
 329       else
 330         {
 331           last_underscore = FALSE;
 332           *q++ = *p;
 333         }
 334     }
 335
 336   *q = '\0';
 337
 338   return result;
 339 }
 340
 341 static void
 342 set_drag_cursor (GtkWidget *widget)
 343 {
 344   GdkCursor *cursor;
 345
 346   /* FIXME multihead */
 347   cursor = gdk_cursor_new (GDK_HAND2);
 348
 349   gdk_window_set_cursor (widget->window, cursor);
 350   gdk_cursor_unref (cursor);
 351 }
 352
 353 static void
 354 event_box_realize_cb (GtkWidget *widget, GtkImage *icon)
 355 {
 356   GtkImageType type;
 357
 358   set_drag_cursor (widget);
 359
 360   type = gtk_image_get_storage_type (icon);
 361   if (type == GTK_IMAGE_STOCK)
 362     {
 363       gchar *stock_id;
 364       GdkPixbuf *pixbuf;
 365       gtk_image_get_stock (icon, &stock_id, NULL);
 366       pixbuf = gtk_widget_render_icon (widget, stock_id,
 367                                        GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
 368       gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
 369       g_object_unref (pixbuf);
 370     }
 371   else if (type == GTK_IMAGE_PIXBUF)
 372     {
 373       GdkPixbuf *pixbuf = gtk_image_get_pixbuf (icon);
 374       gtk_drag_source_set_icon_pixbuf (widget, pixbuf);
 375     }
 376 }
 377
 378 static GtkWidget *
 379 editor_create_item (EggToolbarEditor *editor,
 380                     GtkImage         *icon,
 381                     const char       *label_text,
 382                     GdkDragAction     action)
 383 {
 384   GtkWidget *event_box;
 385   GtkWidget *vbox;
 386   GtkWidget *label;
 387   gchar *label_no_mnemonic = NULL;
 388
 389   event_box = gtk_event_box_new ();
 390   gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
 391   gtk_widget_show (event_box);
 392   gtk_drag_source_set (event_box,
 393                        GDK_BUTTON1_MASK,
 394                        source_drag_types, G_N_ELEMENTS (source_drag_types), action);
 395   g_signal_connect (event_box, "drag_data_get",
 396                     G_CALLBACK (drag_data_get_cb), editor);
 397   g_signal_connect_after (event_box, "realize",
 398                           G_CALLBACK (event_box_realize_cb), icon);
 399
 400   if (action == GDK_ACTION_MOVE)
 401     {
 402       g_signal_connect (event_box, "drag_begin",
 403                         G_CALLBACK (drag_begin_cb), NULL);
 404       g_signal_connect (event_box, "drag_end",
 405                         G_CALLBACK (drag_end_cb), NULL);
 406     }
 407
 408   vbox = gtk_vbox_new (0, FALSE);
 409   gtk_widget_show (vbox);
 410   gtk_container_add (GTK_CONTAINER (event_box), vbox);
 411
 412   gtk_widget_show (GTK_WIDGET (icon));
 413   gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (icon), FALSE, TRUE, 0);
 414   label_no_mnemonic = elide_underscores (label_text);
 415   label = gtk_label_new (label_no_mnemonic);
 416   g_free (label_no_mnemonic);
 417   gtk_widget_show (label);
 418   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
 419
 420   return event_box;
 421 }
 422
 423 static GtkWidget *
 424 editor_create_item_from_name (EggToolbarEditor *editor,
 425                               const char *      name,
 426                               GdkDragAction     drag_action)
 427 {
 428   GtkWidget *item;
 429   const char *item_name;
 430   const char *stock_id;
 431   const char *short_label;
 432   const char *collate_key;
 433
 434   if (strcmp (name, "_separator") == 0)
 435     {
 436       GtkWidget *icon;
 437
 438       icon = _egg_editable_toolbar_new_separator_image ();
 439       short_label = _("Separator");
 440       item_name = strdup (name);
 441       collate_key = g_utf8_collate_key (short_label, -1);
 442       item = editor_create_item (editor, GTK_IMAGE (icon),
 443                                  short_label, drag_action);
 444     }
 445   else
 446     {
 447       GValue value = { 0, };
 448       GtkAction *action;
 449       GtkWidget *icon;
 450
 451       action = find_action (editor, name);
 452       g_return_val_if_fail (action != NULL, NULL);
 453
 454       g_value_init (&value, G_TYPE_STRING);
 455       g_object_get_property (G_OBJECT (action), "stock_id", &value);
 456       stock_id = g_value_get_string (&value);
 457       icon = gtk_image_new_from_stock (stock_id ? stock_id : GTK_STOCK_DND,
 458                                        GTK_ICON_SIZE_LARGE_TOOLBAR);
 459       g_value_unset (&value);
 460
 461       g_value_init (&value, G_TYPE_STRING);
 462       g_object_get_property (G_OBJECT (action), "short_label", &value);
 463       short_label = g_value_get_string (&value);
 464
 465       item_name = strdup (name);
 466       collate_key = g_utf8_collate_key (short_label, -1);
 467       item = editor_create_item (editor, GTK_IMAGE (icon),
 468                                  short_label, drag_action);
 469       g_value_unset (&value);
 470     }
 471
 472   g_object_set_data_full (G_OBJECT (item), "egg-collate-key",
 473                           (gpointer) collate_key, g_free);
 474   g_object_set_data_full (G_OBJECT (item), "egg-item-name",
 475                           (gpointer) item_name, g_free);
 476
 477   return item;
 478 }
 479
 480 static gint
 481 append_table (GtkTable *table, GList *items, gint y, gint width)
 482 {
 483   if (items != NULL)
 484     {
 485       gint x = 0, height;
 486       GtkWidget *alignment;
 487       GtkWidget *item;
 488
 489       height = g_list_length (items) / width + 1;
 490       gtk_table_resize (table, height, width);
 491
 492       if (y > 0)
 493         {
 494           item = gtk_hseparator_new ();
 495           alignment = gtk_alignment_new (0.5, 0.5, 1.0, 0.0);
 496           gtk_container_add (GTK_CONTAINER (alignment), item);
 497           gtk_widget_show (alignment);
 498           gtk_widget_show (item);
 499
 500           gtk_table_attach_defaults (table, alignment, 0, width, y-1, y+1);
 501         }
 502
 503       for (; items != NULL; items = items->next)
 504         {
 505           item = items->data;
 506           alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
 507           gtk_container_add (GTK_CONTAINER (alignment), item);
 508           gtk_widget_show (alignment);
 509           gtk_widget_show (item);
 510
 511           if (x >= width)
 512             {
 513               x = 0;
 514               y++;
 515             }
 516           gtk_table_attach_defaults (table, alignment, x, x+1, y, y+1);
 517           x++;
 518         }
 519
 520       y++;
 521     }
 522   return y;
 523 }
 524
 525 static void
 526 update_editor_sheet (EggToolbarEditor *editor)
 527 {
 528   gint y;
 529   GPtrArray *items;
 530   GList *to_move = NULL, *to_copy = NULL;
 531   GtkWidget *table;
 532   GtkWidget *viewport;
 533
 534   g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (editor));
 535
 536   /* Create new table. */
 537   table = gtk_table_new (0, 0, TRUE);
 538   editor->priv->table = table;
 539   gtk_container_set_border_width (GTK_CONTAINER (table), 12);
 540   gtk_table_set_row_spacings (GTK_TABLE (table), 24);
 541   gtk_widget_show (table);
 542   gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL,
 543                      dest_drag_types, G_N_ELEMENTS (dest_drag_types),
 544                      GDK_ACTION_MOVE | GDK_ACTION_COPY);
 545
 546   /* Build two lists of items (one for copying, one for moving). */
 547   items = egg_toolbars_model_get_name_avail (editor->priv->model);
 548   while (items->len > 0)
 549     {
 550       GtkWidget *item;
 551       const char *name;
 552       gint flags;
 553
 554       name = g_ptr_array_index (items, 0);
 555       g_ptr_array_remove_index_fast (items, 0);
 556
 557       flags = egg_toolbars_model_get_name_flags (editor->priv->model, name);
 558       if ((flags & EGG_TB_MODEL_NAME_INFINITE) == 0)
 559         {
 560           item = editor_create_item_from_name (editor, name, GDK_ACTION_MOVE);
 561           if (item != NULL)
 562             to_move = g_list_insert_sorted (to_move, item, compare_items);
 563         }
 564       else
 565         {
 566           item = editor_create_item_from_name (editor, name, GDK_ACTION_COPY);
 567           if (item != NULL)
 568             to_copy = g_list_insert_sorted (to_copy, item, compare_items);
 569         }
 570     }
 571
 572   /* Add them to the sheet. */
 573   y = 0;
 574   y = append_table (GTK_TABLE (table), to_move, y, 4);
 575   y = append_table (GTK_TABLE (table), to_copy, y, 4);
 576
 577   g_list_free (to_move);
 578   g_list_free (to_copy);
 579   g_ptr_array_free (items, TRUE);
 580
 581   /* Delete old table. */
 582   viewport = GTK_BIN (editor->priv->scrolled_window)->child;
 583   if (viewport)
 584     {
 585       gtk_container_remove (GTK_CONTAINER (viewport),
 586                             GTK_BIN (viewport)->child);
 587     }
 588
 589   /* Add table to window. */
 590   gtk_scrolled_window_add_with_viewport
 591     (GTK_SCROLLED_WINDOW (editor->priv->scrolled_window), table);
 592
 593 }
 594
 595 static void
 596 setup_editor (EggToolbarEditor *editor)
 597 {
 598   GtkWidget *scrolled_window;
 599
 600   gtk_container_set_border_width (GTK_CONTAINER (editor), 12);
 601   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 602   editor->priv->scrolled_window = scrolled_window;
 603   gtk_widget_show (scrolled_window);
 604   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 605                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 606   gtk_box_pack_start (GTK_BOX (editor), scrolled_window, TRUE, TRUE, 0);
 607 }
 608
 609 static void
 610 egg_toolbar_editor_init (EggToolbarEditor *t)
 611 {
 612   t->priv = EGG_TOOLBAR_EDITOR_GET_PRIVATE (t);
 613
 614   t->priv->manager = NULL;
 615   t->priv->actions_list = NULL;
 616
 617   setup_editor (t);
 618 }
 619