src/interface.cpp

   1 #define __SP_INTERFACE_C__
   2
   3 /**
   4  * Main UI stuff
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   Frank Felfe <innerspace@iname.com>
   9  *   bulia byak <buliabyak@users.sf.net>
  10  *
  11  * Copyright (C) 1999-2005 authors
  12  * Copyright (C) 2001-2002 Ximian, Inc.
  13  * Copyright (C) 2004 David Turner
  14  *
  15  * Released under GNU GPL, read the file 'COPYING' for more information
  16  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 # include "config.h"
  20 #endif
  21
  22 #include <gtk/gtk.h>
  23 #include "inkscape-private.h"
  24 #include "extension/effect.h"
  25 #include "widgets/icon.h"
  26 #include "prefs-utils.h"
  27 #include "path-prefix.h"
  28
  29 #include "shortcuts.h"
  30
  31 #include "document.h"
  32 #include "desktop-handles.h"
  33 #include "file.h"
  34 #include "interface.h"
  35 #include "desktop.h"
  36 #include "object-ui.h"
  37 #include "selection.h"
  38 #include "selection-chemistry.h"
  39 #include "svg-view-widget.h"
  40 #include "widgets/desktop-widget.h"
  41 #include "sp-item-group.h"
  42 #include "sp-namedview.h"
  43
  44 #include "helper/action.h"
  45 #include "helper/gnome-utils.h"
  46 #include "helper/window.h"
  47
  48 #include "io/sys.h"
  49 #include "io/stringstream.h"
  50 #include "io/base64stream.h"
  51
  52 #include "dialogs/dialog-events.h"
  53
  54 #include "message-context.h"
  55
  56 // Added for color drag-n-drop
  57 #if ENABLE_LCMS
  58 #include "lcms.h"
  59 #endif // ENABLE_LCMS
  60 #include "display/sp-canvas.h"
  61 #include "color.h"
  62 #include "svg/svg-color.h"
  63 #include "desktop-style.h"
  64 #include "style.h"
  65
  66
  67 using Inkscape::IO::StringOutputStream;
  68 using Inkscape::IO::Base64OutputStream;
  69
  70 /* forward declaration */
  71 static gint sp_ui_delete(GtkWidget *widget, GdkEvent *event, Inkscape::UI::View::View *view);
  72
  73 /* Drag and Drop */
  74 typedef enum {
  75     URI_LIST,
  76     SVG_XML_DATA,
  77     SVG_DATA,
  78     PNG_DATA,
  79     JPEG_DATA,
  80     IMAGE_DATA,
  81     APP_X_INKY_COLOR,
  82     APP_X_COLOR
  83 } ui_drop_target_info;
  84
  85 static GtkTargetEntry ui_drop_target_entries [] = {
  86     {"text/uri-list", 0, URI_LIST},
  87     {"image/svg+xml", 0, SVG_XML_DATA},
  88     {"image/svg",     0, SVG_DATA},
  89     {"image/png",     0, PNG_DATA},
  90     {"image/jpeg",    0, JPEG_DATA},
  91 #if ENABLE_LCMS
  92     {"application/x-inkscape-color", 0, APP_X_INKY_COLOR},
  93 #endif // ENABLE_LCMS
  94     {"application/x-color", 0, APP_X_COLOR}
  95 };
  96
  97 static GtkTargetEntry *completeDropTargets = 0;
  98 static int completeDropTargetsCount = 0;
  99
 100 #define ENTRIES_SIZE(n) sizeof(n)/sizeof(n[0])
 101 static guint nui_drop_target_entries = ENTRIES_SIZE(ui_drop_target_entries);
 102 static void sp_ui_import_files(gchar *buffer);
 103 static void sp_ui_import_one_file(char const *filename);
 104 static void sp_ui_import_one_file_with_check(gpointer filename, gpointer unused);
 105 static void sp_ui_drag_data_received(GtkWidget *widget,
 106                                      GdkDragContext *drag_context,
 107                                      gint x, gint y,
 108                                      GtkSelectionData *data,
 109                                      guint info,
 110                                      guint event_time,
 111                                      gpointer user_data);
 112 static void sp_ui_menu_item_set_sensitive(SPAction *action,
 113                                           unsigned int sensitive,
 114                                           void *data);
 115
 116 SPActionEventVector menu_item_event_vector = {
 117     {NULL},
 118     NULL,
 119     NULL, /* set_active */
 120     sp_ui_menu_item_set_sensitive, /* set_sensitive */
 121     NULL  /* set_shortcut */
 122 };
 123
 124 void
 125 sp_create_window(SPViewWidget *vw, gboolean editable)
 126 {
 127     GtkWidget *w, *hb;
 128
 129     g_return_if_fail(vw != NULL);
 130     g_return_if_fail(SP_IS_VIEW_WIDGET(vw));
 131
 132     w = sp_window_new("", TRUE);
 133
 134     if (editable) {
 135       g_object_set_data(G_OBJECT(vw), "window", w);
 136       reinterpret_cast<SPDesktopWidget*>(vw)->window =
 137         static_cast<GtkWindow*>((void*)w);
 138     }
 139
 140     hb = gtk_hbox_new(FALSE, 0);
 141     gtk_widget_show(hb);
 142     gtk_container_add(GTK_CONTAINER(w), hb);
 143     g_object_set_data(G_OBJECT(w), "hbox", hb);
 144
 145     /* fixme: */
 146     if (editable) {
 147         gtk_window_set_default_size((GtkWindow *) w, 640, 480);
 148         g_object_set_data(G_OBJECT(w), "desktop", SP_DESKTOP_WIDGET(vw)->desktop);
 149         g_object_set_data(G_OBJECT(w), "desktopwidget", vw);
 150         g_signal_connect(G_OBJECT(w), "delete_event", G_CALLBACK(sp_ui_delete), vw->view);
 151         g_signal_connect(G_OBJECT(w), "focus_in_event", G_CALLBACK(sp_desktop_widget_set_focus), vw);
 152     } else {
 153         gtk_window_set_policy(GTK_WINDOW(w), TRUE, TRUE, TRUE);
 154     }
 155
 156     gtk_box_pack_end(GTK_BOX(hb), GTK_WIDGET(vw), TRUE, TRUE, 0);
 157     gtk_widget_show(GTK_WIDGET(vw));
 158
 159
 160     if ( completeDropTargets == 0 || completeDropTargetsCount == 0 )
 161     {
 162         std::vector<gchar*> types;
 163
 164         GSList *list = gdk_pixbuf_get_formats();
 165         while ( list ) {
 166             int i = 0;
 167             GdkPixbufFormat *one = (GdkPixbufFormat*)list->data;
 168             gchar** typesXX = gdk_pixbuf_format_get_mime_types(one);
 169             for ( i = 0; typesXX[i]; i++ ) {
 170                 types.push_back(g_strdup(typesXX[i]));
 171             }
 172             g_strfreev(typesXX);
 173
 174             list = g_slist_next(list);
 175         }
 176         completeDropTargetsCount = nui_drop_target_entries + types.size();
 177         completeDropTargets = new GtkTargetEntry[completeDropTargetsCount];
 178         for ( int i = 0; i < (int)nui_drop_target_entries; i++ ) {
 179             completeDropTargets[i] = ui_drop_target_entries[i];
 180         }
 181         int pos = nui_drop_target_entries;
 182
 183         for (std::vector<gchar*>::iterator it = types.begin() ; it != types.end() ; it++) {
 184             completeDropTargets[pos].target = *it;
 185             completeDropTargets[pos].flags = 0;
 186             completeDropTargets[pos].info = IMAGE_DATA;
 187             pos++;
 188         }
 189     }
 190
 191     gtk_drag_dest_set(w,
 192                       GTK_DEST_DEFAULT_ALL,
 193                       completeDropTargets,
 194                       completeDropTargetsCount,
 195                       GdkDragAction(GDK_ACTION_COPY | GDK_ACTION_MOVE));
 196     g_signal_connect(G_OBJECT(w),
 197                      "drag_data_received",
 198                      G_CALLBACK(sp_ui_drag_data_received),
 199                      NULL);
 200     gtk_widget_show(w);
 201
 202     // needed because the first ACTIVATE_DESKTOP was sent when there was no window yet
 203     inkscape_reactivate_desktop(SP_DESKTOP_WIDGET(vw)->desktop);
 204 }
 205
 206 void
 207 sp_ui_new_view()
 208 {
 209     SPDocument *document;
 210     SPViewWidget *dtw;
 211
 212     document = SP_ACTIVE_DOCUMENT;
 213     if (!document) return;
 214
 215     dtw = sp_desktop_widget_new(sp_document_namedview(document, NULL));
 216     g_return_if_fail(dtw != NULL);
 217
 218     sp_create_window(dtw, TRUE);
 219     sp_namedview_window_from_document(static_cast<SPDesktop*>(dtw->view));
 220 }
 221
 222 /* TODO: not yet working */
 223 /* To be re-enabled (by adding to menu) once it works. */
 224 void
 225 sp_ui_new_view_preview()
 226 {
 227     SPDocument *document;
 228     SPViewWidget *dtw;
 229
 230     document = SP_ACTIVE_DOCUMENT;
 231     if (!document) return;
 232
 233     dtw = (SPViewWidget *) sp_svg_view_widget_new(document);
 234     g_return_if_fail(dtw != NULL);
 235     sp_svg_view_widget_set_resize(SP_SVG_VIEW_WIDGET(dtw), TRUE, 400.0, 400.0);
 236
 237     sp_create_window(dtw, FALSE);
 238 }
 239
 240 /**
 241  * \param widget unused
 242  */
 243 void
 244 sp_ui_close_view(GtkWidget *widget)
 245 {
 246     if (SP_ACTIVE_DESKTOP == NULL) {
 247         return;
 248     }
 249     if ((SP_ACTIVE_DESKTOP)->shutdown()) {
 250         return;
 251     }
 252     SP_ACTIVE_DESKTOP->destroyWidget();
 253 }
 254
 255
 256 /**
 257  *  sp_ui_close_all
 258  *
 259  *  This function is called to exit the program, and iterates through all
 260  *  open document view windows, attempting to close each in turn.  If the
 261  *  view has unsaved information, the user will be prompted to save,
 262  *  discard, or cancel.
 263  *
 264  *  Returns FALSE if the user cancels the close_all operation, TRUE
 265  *  otherwise.
 266  */
 267 unsigned int
 268 sp_ui_close_all(void)
 269 {
 270     /* Iterate through all the windows, destroying each in the order they
 271        become active */
 272     while (SP_ACTIVE_DESKTOP) {
 273         if ((SP_ACTIVE_DESKTOP)->shutdown()) {
 274             /* The user cancelled the operation, so end doing the close */
 275             return FALSE;
 276         }
 277         SP_ACTIVE_DESKTOP->destroyWidget();
 278     }
 279
 280     return TRUE;
 281 }
 282
 283 static gint
 284 sp_ui_delete(GtkWidget *widget, GdkEvent *event, Inkscape::UI::View::View *view)
 285 {
 286     return view->shutdown();
 287 }
 288
 289 /*
 290  * Some day when the right-click menus are ready to start working
 291  * smarter with the verbs, we'll need to change this NULL being
 292  * sent to sp_action_perform to something useful, or set some kind
 293  * of global "right-clicked position" variable for actions to
 294  * investigate when they're called.
 295  */
 296 static void
 297 sp_ui_menu_activate(void *object, SPAction *action)
 298 {
 299     sp_action_perform(action, NULL);
 300 }
 301
 302 static void
 303 sp_ui_menu_select_action(void *object, SPAction *action)
 304 {
 305     action->view->tipsMessageContext()->set(Inkscape::NORMAL_MESSAGE, action->tip);
 306 }
 307
 308 static void
 309 sp_ui_menu_deselect_action(void *object, SPAction *action)
 310 {
 311     action->view->tipsMessageContext()->clear();
 312 }
 313
 314 static void
 315 sp_ui_menu_select(gpointer object, gpointer tip)
 316 {
 317     Inkscape::UI::View::View *view = static_cast<Inkscape::UI::View::View*> (g_object_get_data(G_OBJECT(object), "view"));
 318     view->tipsMessageContext()->set(Inkscape::NORMAL_MESSAGE, (gchar *)tip);
 319 }
 320
 321 static void
 322 sp_ui_menu_deselect(gpointer object)
 323 {
 324     Inkscape::UI::View::View *view = static_cast<Inkscape::UI::View::View*>  (g_object_get_data(G_OBJECT(object), "view"));
 325     view->tipsMessageContext()->clear();
 326 }
 327
 328 /**
 329  * sp_ui_menuitem_add_icon
 330  *
 331  * Creates and attaches a scaled icon to the given menu item.
 332  *
 333  */
 334 void
 335 sp_ui_menuitem_add_icon( GtkWidget *item, gchar *icon_name )
 336 {
 337     GtkWidget *icon;
 338
 339     icon = sp_icon_new( GTK_ICON_SIZE_MENU, icon_name );
 340     gtk_widget_show(icon);
 341     gtk_image_menu_item_set_image((GtkImageMenuItem *) item, icon);
 342 } // end of sp_ui_menu_add_icon
 343
 344 /**
 345  * sp_ui_menu_append_item
 346  *
 347  * Appends a UI item with specific info for Inkscape/Sodipodi.
 348  *
 349  */
 350 static GtkWidget *
 351 sp_ui_menu_append_item( GtkMenu *menu, gchar const *stock,
 352                         gchar const *label, gchar const *tip, Inkscape::UI::View::View *view, GCallback callback,
 353                         gpointer data, gboolean with_mnemonic = TRUE )
 354 {
 355     GtkWidget *item;
 356
 357     if (stock) {
 358         item = gtk_image_menu_item_new_from_stock(stock, NULL);
 359     } else if (label) {
 360         item = (with_mnemonic)
 361             ? gtk_image_menu_item_new_with_mnemonic(label) :
 362             gtk_image_menu_item_new_with_label(label);
 363     } else {
 364         item = gtk_separator_menu_item_new();
 365     }
 366
 367     gtk_widget_show(item);
 368
 369     if (callback) {
 370         g_signal_connect(G_OBJECT(item), "activate", callback, data);
 371     }
 372
 373     if (tip && view) {
 374         g_object_set_data(G_OBJECT(item), "view", (gpointer) view);
 375         g_signal_connect( G_OBJECT(item), "select", G_CALLBACK(sp_ui_menu_select), (gpointer) tip );
 376         g_signal_connect( G_OBJECT(item), "deselect", G_CALLBACK(sp_ui_menu_deselect), NULL);
 377     }
 378
 379     gtk_menu_append(GTK_MENU(menu), item);
 380
 381     return item;
 382
 383 } // end of sp_ui_menu_append_item()
 384
 385 /**
 386 \brief  a wrapper around gdk_keyval_name producing (when possible) characters, not names
 387  */
 388 static gchar const *
 389 sp_key_name(guint keyval)
 390 {
 391     /* TODO: Compare with the definition of gtk_accel_label_refetch in gtk/gtkaccellabel.c (or
 392        simply use GtkAccelLabel as the TODO comment in sp_ui_shortcut_string suggests). */
 393     gchar const *n = gdk_keyval_name(gdk_keyval_to_upper(keyval));
 394
 395     if      (!strcmp(n, "asciicircum"))  return "^";
 396     else if (!strcmp(n, "parenleft"  ))  return "(";
 397     else if (!strcmp(n, "parenright" ))  return ")";
 398     else if (!strcmp(n, "plus"       ))  return "+";
 399     else if (!strcmp(n, "minus"      ))  return "-";
 400     else if (!strcmp(n, "asterisk"   ))  return "*";
 401     else if (!strcmp(n, "KP_Multiply"))  return "*";
 402     else if (!strcmp(n, "Delete"     ))  return "Del";
 403     else if (!strcmp(n, "Page_Up"    ))  return "PgUp";
 404     else if (!strcmp(n, "Page_Down"  ))  return "PgDn";
 405     else if (!strcmp(n, "grave"      ))  return "`";
 406     else if (!strcmp(n, "numbersign" ))  return "#";
 407     else if (!strcmp(n, "bar" ))  return "|";
 408     else if (!strcmp(n, "slash" ))  return "/";
 409     else if (!strcmp(n, "exclam" ))  return "!";
 410     else return n;
 411 }
 412
 413
 414 /**
 415  * \param shortcut A GDK keyval OR'd with SP_SHORTCUT_blah_MASK values.
 416  * \param c Points to a buffer at least 256 bytes long.
 417  */
 418 void
 419 sp_ui_shortcut_string(unsigned const shortcut, gchar *const c)
 420 {
 421     /* TODO: This function shouldn't exist.  Our callers should use GtkAccelLabel instead of
 422      * a generic GtkLabel containing this string, and should call gtk_widget_add_accelerator.
 423      * Will probably need to change sp_shortcut_invoke callers.
 424      *
 425      * The existing gtk_label_new_with_mnemonic call can be replaced with
 426      * g_object_new(GTK_TYPE_ACCEL_LABEL, NULL) followed by
 427      * gtk_label_set_text_with_mnemonic(lbl, str).
 428      */
 429     static GtkAccelLabelClass const &accel_lbl_cls
 430         = *(GtkAccelLabelClass const *) g_type_class_peek_static(GTK_TYPE_ACCEL_LABEL);
 431
 432     struct { unsigned test; char const *name; } const modifier_tbl[] = {
 433         { SP_SHORTCUT_SHIFT_MASK,   accel_lbl_cls.mod_name_shift   },
 434         { SP_SHORTCUT_CONTROL_MASK, accel_lbl_cls.mod_name_control },
 435         { SP_SHORTCUT_ALT_MASK,     accel_lbl_cls.mod_name_alt     }
 436     };
 437
 438     gchar *p = c;
 439     gchar *end = p + 256;
 440
 441     for (unsigned i = 0; i < G_N_ELEMENTS(modifier_tbl); ++i) {
 442         if ((shortcut & modifier_tbl[i].test)
 443             && (p < end))
 444         {
 445             p += g_snprintf(p, end - p, "%s%s",
 446                             modifier_tbl[i].name,
 447                             accel_lbl_cls.mod_separator);
 448         }
 449     }
 450     if (p < end) {
 451         p += g_snprintf(p, end - p, "%s", sp_key_name(shortcut & 0xffffff));
 452     }
 453     end[-1] = '\0';  // snprintf doesn't guarantee to nul-terminate the string.
 454 }
 455
 456 void
 457 sp_ui_dialog_title_string(Inkscape::Verb *verb, gchar *c)
 458 {
 459     SPAction     *action;
 460     unsigned int shortcut;
 461     gchar        *s;
 462     gchar        key[256];
 463     gchar        *atitle;
 464
 465     action = verb->get_action(NULL);
 466     if (!action)
 467         return;
 468
 469     atitle = sp_action_get_title(action);
 470
 471     s = g_stpcpy(c, atitle);
 472
 473     g_free(atitle);
 474
 475     shortcut = sp_shortcut_get_primary(verb);
 476     if (shortcut) {
 477         s = g_stpcpy(s, " (");
 478         sp_ui_shortcut_string(shortcut, key);
 479         s = g_stpcpy(s, key);
 480         s = g_stpcpy(s, ")");
 481     }
 482 }
 483
 484
 485 /**
 486  * sp_ui_menu_append_item_from_verb
 487  *
 488  * Appends a custom menu UI from a verb.
 489  *
 490  */
 491
 492 static GtkWidget *
 493 sp_ui_menu_append_item_from_verb(GtkMenu *menu, Inkscape::Verb *verb, Inkscape::UI::View::View *view, bool radio = false, GSList *group = NULL)
 494 {
 495     SPAction *action;
 496     GtkWidget *item;
 497
 498     if (verb->get_code() == SP_VERB_NONE) {
 499
 500         item = gtk_separator_menu_item_new();
 501
 502     } else {
 503         unsigned int shortcut;
 504
 505         action = verb->get_action(view);
 506
 507         if (!action) return NULL;
 508
 509         shortcut = sp_shortcut_get_primary(verb);
 510         if (shortcut) {
 511             gchar c[256];
 512             sp_ui_shortcut_string(shortcut, c);
 513             GtkWidget *const hb = gtk_hbox_new(FALSE, 16);
 514             GtkWidget *const name_lbl = gtk_label_new("");
 515             gtk_label_set_markup_with_mnemonic(GTK_LABEL(name_lbl), action->name);
 516             gtk_misc_set_alignment((GtkMisc *) name_lbl, 0.0, 0.5);
 517             gtk_box_pack_start((GtkBox *) hb, name_lbl, TRUE, TRUE, 0);
 518             GtkWidget *const accel_lbl = gtk_label_new(c);
 519             gtk_misc_set_alignment((GtkMisc *) accel_lbl, 1.0, 0.5);
 520             gtk_box_pack_end((GtkBox *) hb, accel_lbl, FALSE, FALSE, 0);
 521             gtk_widget_show_all(hb);
 522             if (radio) {
 523                 item = gtk_radio_menu_item_new (group);
 524             } else {
 525                 item = gtk_image_menu_item_new();
 526             }
 527             gtk_container_add((GtkContainer *) item, hb);
 528         } else {
 529             if (radio) {
 530                 item = gtk_radio_menu_item_new (group);
 531             } else {
 532                 item = gtk_image_menu_item_new ();
 533             }
 534             GtkWidget *const name_lbl = gtk_label_new("");
 535             gtk_label_set_markup_with_mnemonic(GTK_LABEL(name_lbl), action->name);
 536             gtk_misc_set_alignment((GtkMisc *) name_lbl, 0.0, 0.5);
 537             gtk_container_add((GtkContainer *) item, name_lbl);
 538         }
 539
 540         nr_active_object_add_listener((NRActiveObject *)action, (NRObjectEventVector *)&menu_item_event_vector, sizeof(SPActionEventVector), item);
 541         if (!action->sensitive) {
 542             gtk_widget_set_sensitive(item, FALSE);
 543         }
 544
 545         if (action->image) {
 546             sp_ui_menuitem_add_icon(item, action->image);
 547         }
 548         gtk_widget_set_events(item, GDK_KEY_PRESS_MASK);
 549         g_signal_connect( G_OBJECT(item), "activate",
 550                           G_CALLBACK(sp_ui_menu_activate), action );
 551
 552         g_signal_connect( G_OBJECT(item), "select", G_CALLBACK(sp_ui_menu_select_action), action );
 553         g_signal_connect( G_OBJECT(item), "deselect", G_CALLBACK(sp_ui_menu_deselect_action), action );
 554     }
 555
 556     gtk_widget_show(item);
 557     gtk_menu_append(GTK_MENU(menu), item);
 558
 559     return item;
 560
 561 } // end of sp_ui_menu_append_item_from_verb
 562
 563
 564 static void
 565 checkitem_toggled(GtkCheckMenuItem *menuitem, gpointer user_data)
 566 {
 567     gchar const *pref = (gchar const *) user_data;
 568     Inkscape::UI::View::View *view = (Inkscape::UI::View::View *) g_object_get_data(G_OBJECT(menuitem), "view");
 569
 570     gchar const *pref_path;
 571     if (reinterpret_cast<SPDesktop*>(view)->is_fullscreen)
 572         pref_path = g_strconcat("fullscreen.", pref, NULL);
 573     else
 574         pref_path = g_strconcat("window.", pref, NULL);
 575
 576     gboolean checked = gtk_check_menu_item_get_active(menuitem);
 577     prefs_set_int_attribute(pref_path, "state", checked);
 578
 579     reinterpret_cast<SPDesktop*>(view)->layoutWidget();
 580 }
 581
 582 static gboolean
 583 checkitem_update(GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
 584 {
 585     GtkCheckMenuItem *menuitem=GTK_CHECK_MENU_ITEM(widget);
 586
 587     gchar const *pref = (gchar const *) user_data;
 588     Inkscape::UI::View::View *view = (Inkscape::UI::View::View *) g_object_get_data(G_OBJECT(menuitem), "view");
 589
 590     gchar const *pref_path;
 591     if (static_cast<SPDesktop*>(view)->is_fullscreen)
 592         pref_path = g_strconcat("fullscreen.", pref, NULL);
 593     else
 594         pref_path = g_strconcat("window.", pref, NULL);
 595
 596     gint ison = prefs_get_int_attribute_limited(pref_path, "state", 1, 0, 1);
 597
 598     g_signal_handlers_block_by_func(G_OBJECT(menuitem), (gpointer)(GCallback)checkitem_toggled, user_data);
 599     gtk_check_menu_item_set_active(menuitem, ison);
 600     g_signal_handlers_unblock_by_func(G_OBJECT(menuitem), (gpointer)(GCallback)checkitem_toggled, user_data);
 601
 602     return FALSE;
 603 }
 604
 605
 606 void
 607 sp_ui_menu_append_check_item_from_verb(GtkMenu *menu, Inkscape::UI::View::View *view, gchar const *label, gchar const *tip, gchar const *pref,
 608                                        void (*callback_toggle)(GtkCheckMenuItem *, gpointer user_data),
 609                                        gboolean (*callback_update)(GtkWidget *widget, GdkEventExpose *event, gpointer user_data),
 610                                        Inkscape::Verb *verb)
 611 {
 612     GtkWidget *item;
 613
 614     unsigned int shortcut = 0;
 615     SPAction *action = NULL;
 616
 617     if (verb) {
 618         shortcut = sp_shortcut_get_primary(verb);
 619         action = verb->get_action(view);
 620     }
 621
 622     if (verb && shortcut) {
 623         gchar c[256];
 624         sp_ui_shortcut_string(shortcut, c);
 625
 626         GtkWidget *hb = gtk_hbox_new(FALSE, 16);
 627
 628         {
 629             GtkWidget *l = gtk_label_new_with_mnemonic(action ? action->name : label);
 630             gtk_misc_set_alignment((GtkMisc *) l, 0.0, 0.5);
 631             gtk_box_pack_start((GtkBox *) hb, l, TRUE, TRUE, 0);
 632         }
 633
 634         {
 635             GtkWidget *l = gtk_label_new(c);
 636             gtk_misc_set_alignment((GtkMisc *) l, 1.0, 0.5);
 637             gtk_box_pack_end((GtkBox *) hb, l, FALSE, FALSE, 0);
 638         }
 639
 640         gtk_widget_show_all(hb);
 641
 642         item = gtk_check_menu_item_new();
 643         gtk_container_add((GtkContainer *) item, hb);
 644     } else {
 645         GtkWidget *l = gtk_label_new_with_mnemonic(action ? action->name : label);
 646         gtk_misc_set_alignment((GtkMisc *) l, 0.0, 0.5);
 647         item = gtk_check_menu_item_new();
 648         gtk_container_add((GtkContainer *) item, l);
 649     }
 650 #if 0
 651     nr_active_object_add_listener((NRActiveObject *)action, (NRObjectEventVector *)&menu_item_event_vector, sizeof(SPActionEventVector), item);
 652     if (!action->sensitive) {
 653         gtk_widget_set_sensitive(item, FALSE);
 654     }
 655 #endif
 656     gtk_widget_show(item);
 657
 658     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 659
 660     g_object_set_data(G_OBJECT(item), "view", (gpointer) view);
 661
 662     g_signal_connect( G_OBJECT(item), "toggled", (GCallback) callback_toggle, (void *) pref);
 663     g_signal_connect( G_OBJECT(item), "expose_event", (GCallback) callback_update, (void *) pref);
 664
 665     g_signal_connect( G_OBJECT(item), "select", G_CALLBACK(sp_ui_menu_select), (gpointer) (action ? action->tip : tip));
 666     g_signal_connect( G_OBJECT(item), "deselect", G_CALLBACK(sp_ui_menu_deselect), NULL);
 667 }
 668
 669 static void
 670 sp_recent_open(GtkWidget *widget, gchar const *uri)
 671 {
 672     sp_file_open(uri, NULL);
 673 }
 674
 675 static void
 676 sp_file_new_from_template(GtkWidget *widget, gchar const *uri)
 677 {
 678     sp_file_new(uri);
 679 }
 680
 681 void
 682 sp_menu_append_new_templates(GtkWidget *menu, Inkscape::UI::View::View *view)
 683 {
 684     std::list<gchar *> sources;
 685     sources.push_back( profile_path("templates") ); // first try user's local dir
 686     sources.push_back( g_strdup(INKSCAPE_TEMPLATESDIR) ); // then the system templates dir
 687
 688     // Use this loop to iterate through a list of possible document locations.
 689     while (!sources.empty()) {
 690         gchar *dirname = sources.front();
 691
 692         if ( Inkscape::IO::file_test( dirname, (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR) ) ) {
 693             GError *err = 0;
 694             GDir *dir = g_dir_open(dirname, 0, &err);
 695
 696             if (dir) {
 697                 for (gchar const *file = g_dir_read_name(dir); file != NULL; file = g_dir_read_name(dir)) {
 698                     if (!g_str_has_suffix(file, ".svg"))
 699                         continue; // skip non-svg files
 700
 701                     gchar *basename = g_path_get_basename(file);
 702                     if (g_str_has_suffix(basename, ".svg") && g_str_has_prefix(basename, "default."))
 703                         continue; // skip default.*.svg (i.e. default.svg and translations) - it's in the menu already
 704
 705                     gchar const *filepath = g_build_filename(dirname, file, NULL);
 706                     gchar *dupfile = g_strndup(file, strlen(file) - 4);
 707                     gchar *filename =  g_filename_to_utf8(dupfile,  -1, NULL, NULL, NULL);
 708                     g_free(dupfile);
 709                     GtkWidget *item = gtk_menu_item_new_with_label(filename);
 710                     g_free(filename);
 711
 712                     gtk_widget_show(item);
 713                     // how does "filepath" ever get freed?
 714                     g_signal_connect(G_OBJECT(item),
 715                                      "activate",
 716                                      G_CALLBACK(sp_file_new_from_template),
 717                                      (gpointer) filepath);
 718
 719                     if (view) {
 720                         // set null tip for now; later use a description from the template file
 721                         g_object_set_data(G_OBJECT(item), "view", (gpointer) view);
 722                         g_signal_connect( G_OBJECT(item), "select", G_CALLBACK(sp_ui_menu_select), (gpointer) NULL );
 723                         g_signal_connect( G_OBJECT(item), "deselect", G_CALLBACK(sp_ui_menu_deselect), NULL);
 724                     }
 725
 726                     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 727                 }
 728                 g_dir_close(dir);
 729             }
 730         }
 731
 732         // toss the dirname
 733         g_free(dirname);
 734         sources.pop_front();
 735     }
 736 }
 737
 738 void
 739 sp_menu_append_recent_documents(GtkWidget *menu, Inkscape::UI::View::View* /* view */)
 740 {
 741     gchar const **recent = prefs_get_recent_files();
 742     if (recent) {
 743         int i;
 744
 745         for (i = 0; recent[i] != NULL; i += 2) {
 746             gchar const *uri = recent[i];
 747             gchar const *name = recent[i + 1];
 748
 749             GtkWidget *item = gtk_menu_item_new_with_label(name);
 750             gtk_widget_show(item);
 751             g_signal_connect(G_OBJECT(item),
 752                              "activate",
 753                              G_CALLBACK(sp_recent_open),
 754                              (gpointer)uri);
 755             gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 756         }
 757
 758         g_free(recent);
 759     } else {
 760         GtkWidget *item = gtk_menu_item_new_with_label(_("None"));
 761         gtk_widget_show(item);
 762         gtk_widget_set_sensitive(item, FALSE);
 763         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 764     }
 765 }
 766
 767 void
 768 sp_ui_checkboxes_menus(GtkMenu *m, Inkscape::UI::View::View *view)
 769 {
 770     //sp_ui_menu_append_check_item_from_verb(m, view, _("_Menu"), _("Show or hide the menu bar"), "menu",
 771     //                                       checkitem_toggled, checkitem_update, 0);
 772     sp_ui_menu_append_check_item_from_verb(m, view, _("Commands Bar"), _("Show or hide the Commands bar (under the menu)"), "commands",
 773                                            checkitem_toggled, checkitem_update, 0);
 774     sp_ui_menu_append_check_item_from_verb(m, view, _("Tool Controls Bar"), _("Show or hide the Tool Controls bar"), "toppanel",
 775                                            checkitem_toggled, checkitem_update, 0);
 776     sp_ui_menu_append_check_item_from_verb(m, view, _("_Toolbox"), _("Show or hide the main toolbox (on the left)"), "toolbox",
 777                                            checkitem_toggled, checkitem_update, 0);
 778     sp_ui_menu_append_check_item_from_verb(m, view, NULL, NULL, "rulers",
 779                                            checkitem_toggled, checkitem_update, Inkscape::Verb::get(SP_VERB_TOGGLE_RULERS));
 780     sp_ui_menu_append_check_item_from_verb(m, view, NULL, NULL, "scrollbars",
 781                                            checkitem_toggled, checkitem_update, Inkscape::Verb::get(SP_VERB_TOGGLE_SCROLLBARS));
 782     sp_ui_menu_append_check_item_from_verb(m, view, _("_Statusbar"), _("Show or hide the statusbar (at the bottom of the window)"), "statusbar",
 783                                            checkitem_toggled, checkitem_update, 0);
 784     sp_ui_menu_append_check_item_from_verb(m, view, _("_Palette"), _("Show or hide the color palette"), "panels",
 785                                            checkitem_toggled, checkitem_update, 0);
 786 }
 787
 788 /** \brief  This function turns XML into a menu
 789     \param  menus  This is the XML that defines the menu
 790     \param  menu   Menu to be added to
 791     \param  view   The View that this menu is being built for
 792
 793     This function is realitively simple as it just goes through the XML
 794     and parses the individual elements.  In the case of a submenu, it
 795     just calls itself recursively.  Because it is only reasonable to have
 796     a couple of submenus, it is unlikely this will go more than two or
 797     three times.
 798
 799     In the case of an unreconginzed verb, a menu item is made to identify
 800     the verb that is missing, and display that.  The menu item is also made
 801     insensitive.
 802 */
 803 void
 804 sp_ui_build_dyn_menus(Inkscape::XML::Node *menus, GtkWidget *menu, Inkscape::UI::View::View *view)
 805 {
 806     if (menus == NULL) return;
 807     if (menu == NULL)  return;
 808     GSList *group = NULL;
 809
 810     for (Inkscape::XML::Node *menu_pntr = menus;
 811          menu_pntr != NULL;
 812          menu_pntr = menu_pntr->next()) {
 813         if (!strcmp(menu_pntr->name(), "submenu")) {
 814             if (!strcmp(menu_pntr->attribute("name"), "Effects") && !prefs_get_int_attribute("extensions", "show-effects-menu", 0)) {
 815                 continue;
 816             }
 817             GtkWidget *mitem = gtk_menu_item_new_with_mnemonic(_(menu_pntr->attribute("name")));
 818             GtkWidget *submenu = gtk_menu_new();
 819             sp_ui_build_dyn_menus(menu_pntr->firstChild(), submenu, view);
 820             gtk_menu_item_set_submenu(GTK_MENU_ITEM(mitem), GTK_WIDGET(submenu));
 821             gtk_menu_shell_append(GTK_MENU_SHELL(menu), mitem);
 822             continue;
 823         }
 824         if (!strcmp(menu_pntr->name(), "verb")) {
 825             gchar const *verb_name = menu_pntr->attribute("verb-id");
 826             Inkscape::Verb *verb = Inkscape::Verb::getbyid(verb_name);
 827
 828             if (verb != NULL) {
 829                 if (menu_pntr->attribute("radio") != NULL) {
 830                     GtkWidget *item = sp_ui_menu_append_item_from_verb (GTK_MENU(menu), verb, view, true, group);
 831                     group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(item));
 832                     if (menu_pntr->attribute("default") != NULL) {
 833                         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE);
 834                     }
 835                 } else {
 836                     sp_ui_menu_append_item_from_verb(GTK_MENU(menu), verb, view);
 837                     group = NULL;
 838                 }
 839             } else {
 840                 gchar string[120];
 841                 g_snprintf(string, 120, _("Verb \"%s\" Unknown"), verb_name);
 842                 string[119] = '\0'; /* may not be terminated */
 843                 GtkWidget *item = gtk_menu_item_new_with_label(string);
 844                 gtk_widget_set_sensitive(item, false);
 845                 gtk_widget_show(item);
 846                 gtk_menu_append(GTK_MENU(menu), item);
 847             }
 848             continue;
 849         }
 850         if (!strcmp(menu_pntr->name(), "separator")
 851                 // This was spelt wrong in the original version
 852                 // and so this is for backward compatibility.  It can
 853                 // probably be dropped after the 0.44 release.
 854              || !strcmp(menu_pntr->name(), "seperator")) {
 855             GtkWidget *item = gtk_separator_menu_item_new();
 856             gtk_widget_show(item);
 857             gtk_menu_append(GTK_MENU(menu), item);
 858             continue;
 859         }
 860         if (!strcmp(menu_pntr->name(), "template-list")) {
 861             sp_menu_append_new_templates(menu, view);
 862             continue;
 863         }
 864         if (!strcmp(menu_pntr->name(), "recent-file-list")) {
 865             sp_menu_append_recent_documents(menu, view);
 866             continue;
 867         }
 868         if (!strcmp(menu_pntr->name(), "objects-checkboxes")) {
 869             sp_ui_checkboxes_menus(GTK_MENU(menu), view);
 870             continue;
 871         }
 872     }
 873 }
 874
 875 /** \brief  Build the main tool bar
 876     \param  view  View to build the bar for
 877
 878     Currently the main tool bar is built as a dynamic XML menu using
 879     \c sp_ui_build_dyn_menus.  This function builds the bar, and then
 880     pass it to get items attached to it.
 881 */
 882 GtkWidget *
 883 sp_ui_main_menubar(Inkscape::UI::View::View *view)
 884 {
 885     GtkWidget *mbar = gtk_menu_bar_new();
 886
 887     sp_ui_build_dyn_menus(inkscape_get_menus(INKSCAPE), mbar, view);
 888
 889     return mbar;
 890 }
 891
 892 static void leave_group(GtkMenuItem *, SPDesktop *desktop) {
 893     desktop->setCurrentLayer(SP_OBJECT_PARENT(desktop->currentLayer()));
 894 }
 895
 896 static void enter_group(GtkMenuItem *mi, SPDesktop *desktop) {
 897     desktop->setCurrentLayer(reinterpret_cast<SPObject *>(g_object_get_data(G_OBJECT(mi), "group")));
 898     SP_DT_SELECTION(desktop)->clear();
 899 }
 900
 901 GtkWidget *
 902 sp_ui_context_menu(Inkscape::UI::View::View *view, SPItem *item)
 903 {
 904     GtkWidget *m;
 905     SPDesktop *dt;
 906
 907     dt = static_cast<SPDesktop*>(view);
 908
 909     m = gtk_menu_new();
 910
 911     /* Undo and Redo */
 912     sp_ui_menu_append_item_from_verb(GTK_MENU(m), Inkscape::Verb::get(SP_VERB_EDIT_UNDO), view);
 913     sp_ui_menu_append_item_from_verb(GTK_MENU(m), Inkscape::Verb::get(SP_VERB_EDIT_REDO), view);
 914
 915     /* Separator */
 916     sp_ui_menu_append_item(GTK_MENU(m), NULL, NULL, NULL, NULL, NULL, NULL);
 917
 918     sp_ui_menu_append_item_from_verb(GTK_MENU(m), Inkscape::Verb::get(SP_VERB_EDIT_CUT), view);
 919     sp_ui_menu_append_item_from_verb(GTK_MENU(m), Inkscape::Verb::get(SP_VERB_EDIT_COPY), view);
 920     sp_ui_menu_append_item_from_verb(GTK_MENU(m), Inkscape::Verb::get(SP_VERB_EDIT_PASTE), view);
 921
 922     /* Separator */
 923     sp_ui_menu_append_item(GTK_MENU(m), NULL, NULL, NULL, NULL, NULL, NULL);
 924
 925     sp_ui_menu_append_item_from_verb(GTK_MENU(m), Inkscape::Verb::get(SP_VERB_EDIT_DUPLICATE), view);
 926     sp_ui_menu_append_item_from_verb(GTK_MENU(m), Inkscape::Verb::get(SP_VERB_EDIT_DELETE), view);
 927
 928     /* Item menu */
 929     if (item) {
 930         sp_ui_menu_append_item(GTK_MENU(m), NULL, NULL, NULL, NULL, NULL, NULL);
 931         sp_object_menu((SPObject *) item, dt, GTK_MENU(m));
 932     }
 933
 934     /* layer menu */
 935     SPGroup *group=NULL;
 936     if (item) {
 937         if (SP_IS_GROUP(item)) {
 938             group = SP_GROUP(item);
 939         } else if ( item != dt->currentRoot() && SP_IS_GROUP(SP_OBJECT_PARENT(item)) ) {
 940             group = SP_GROUP(SP_OBJECT_PARENT(item));
 941         }
 942     }
 943
 944     if (( group && group != dt->currentLayer() ) ||
 945         ( dt->currentLayer() != dt->currentRoot() ) ) {
 946         sp_ui_menu_append_item(GTK_MENU(m), NULL, NULL, NULL, NULL, NULL, NULL);
 947     }
 948
 949     if ( group && group != dt->currentLayer() ) {
 950         /* TRANSLATORS: #%s is the id of the group e.g. <g id="#g7">, not a number. */
 951         gchar *label=g_strdup_printf(_("Enter group #%s"), SP_OBJECT_ID(group));
 952         GtkWidget *w = gtk_menu_item_new_with_label(label);
 953         g_free(label);
 954         g_object_set_data(G_OBJECT(w), "group", group);
 955         g_signal_connect(G_OBJECT(w), "activate", GCallback(enter_group), dt);
 956         gtk_widget_show(w);
 957         gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
 958     }
 959
 960     if ( dt->currentLayer() != dt->currentRoot() ) {
 961         if ( SP_OBJECT_PARENT(dt->currentLayer()) != dt->currentRoot() ) {
 962             GtkWidget *w = gtk_menu_item_new_with_label(_("Go to parent"));
 963             g_signal_connect(G_OBJECT(w), "activate", GCallback(leave_group), dt);
 964             gtk_widget_show(w);
 965             gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
 966
 967         }
 968     }
 969
 970     return m;
 971 }
 972
 973 /* Drag and Drop */
 974 void
 975 sp_ui_drag_data_received(GtkWidget *widget,
 976                          GdkDragContext *drag_context,
 977                          gint x, gint y,
 978                          GtkSelectionData *data,
 979                          guint info,
 980                          guint event_time,
 981                          gpointer user_data)
 982 {
 983     switch (info) {
 984 #if ENABLE_LCMS
 985         case APP_X_INKY_COLOR:
 986         {
 987             SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 988             int destX = 0;
 989             int destY = 0;
 990             gtk_widget_translate_coordinates( widget, &(desktop->canvas->widget), x, y, &destX, &destY );
 991             NR::Point where( sp_canvas_window_to_world( desktop->canvas, NR::Point( destX, destY ) ) );
 992
 993             SPItem *item = desktop->item_at_point( where, true );
 994             if ( item )
 995             {
 996                 if ( data->length >= 8 ) {
 997                     cmsHPROFILE srgbProf = cmsCreate_sRGBProfile();
 998
 999                     gchar c[64] = {0};
1000                     // Careful about endian issues.
1001                     guint16* dataVals = (guint16*)data->data;
1002                     sp_svg_write_color( c, 64,
1003                                         SP_RGBA32_U_COMPOSE(
1004                                             0x0ff & (dataVals[0] >> 8),
1005                                             0x0ff & (dataVals[1] >> 8),
1006                                             0x0ff & (dataVals[2] >> 8),
1007                                             0xff // can't have transparency in the color itself
1008                                             //0x0ff & (data->data[3] >> 8),
1009                                             ));
1010                     SPCSSAttr *css = sp_repr_css_attr_new();
1011                     sp_repr_css_set_property( css, (drag_context->action != GDK_ACTION_MOVE) ? "fill":"stroke", c );
1012
1013                     sp_desktop_apply_css_recursive( item, css, true );
1014                     item->updateRepr();
1015
1016                     if ( data->length > 14 ) {
1017                         int flags = dataVals[4];
1018
1019                         // piggie-backed palette entry info
1020                         int index = dataVals[5];
1021                         Glib::ustring palName;
1022                         for ( int i = 0; i < dataVals[6]; i++ ) {
1023                             palName += (gunichar)dataVals[7+i];
1024                         }
1025
1026                         // Now hook in a magic tag of some sort.
1027                         if ( !palName.empty() && (flags & 1) ) {
1028                             gchar* str = g_strdup_printf("%d|", index);
1029                             palName.insert( 0, str );
1030                             g_free(str);
1031                             str = 0;
1032
1033                             sp_object_setAttribute( SP_OBJECT(item),
1034                                                     (drag_context->action != GDK_ACTION_MOVE) ? "inkscape:x-fill-tag":"inkscape:x-stroke-tag",
1035                                                     palName.c_str(),
1036                                                     false );
1037                             item->updateRepr();
1038                         }
1039                     }
1040
1041                     SPDocument *doc = SP_ACTIVE_DOCUMENT;
1042                     sp_document_done( doc );
1043
1044                     if ( srgbProf ) {
1045                         cmsCloseProfile( srgbProf );
1046                     }
1047                 }
1048             }
1049         }
1050         break;
1051 #endif // ENABLE_LCMS
1052
1053         case APP_X_COLOR:
1054         {
1055             SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1056             int destX = 0;
1057             int destY = 0;
1058             gtk_widget_translate_coordinates( widget, &(desktop->canvas->widget), x, y, &destX, &destY );
1059             NR::Point where( sp_canvas_window_to_world( desktop->canvas, NR::Point( destX, destY ) ) );
1060
1061             SPItem *item = desktop->item_at_point( where, true );
1062             if ( item )
1063             {
1064                 if ( data->length == 8 ) {
1065                     gchar c[64] = {0};
1066                     // Careful about endian issues.
1067                     guint16* dataVals = (guint16*)data->data;
1068                     sp_svg_write_color( c, 64,
1069                                         SP_RGBA32_U_COMPOSE(
1070                                             0x0ff & (dataVals[0] >> 8),
1071                                             0x0ff & (dataVals[1] >> 8),
1072                                             0x0ff & (dataVals[2] >> 8),
1073                                             0xff // can't have transparency in the color itself
1074                                             //0x0ff & (data->data[3] >> 8),
1075                                             ));
1076                     SPCSSAttr *css = sp_repr_css_attr_new();
1077                     sp_repr_css_set_property( css, (drag_context->action != GDK_ACTION_MOVE) ? "fill":"stroke", c );
1078
1079                     sp_desktop_apply_css_recursive( item, css, true );
1080                     item->updateRepr();
1081
1082                     SPDocument *doc = SP_ACTIVE_DOCUMENT;
1083                     sp_document_done( doc );
1084                 }
1085             }
1086         }
1087         break;
1088
1089         case SVG_DATA:
1090         case SVG_XML_DATA: {
1091             gchar *svgdata = (gchar *)data->data;
1092
1093             SPDocument *doc = SP_ACTIVE_DOCUMENT;
1094
1095             Inkscape::XML::Document *rnewdoc = sp_repr_read_mem(svgdata, data->length, SP_SVG_NS_URI);
1096
1097             if (rnewdoc == NULL) {
1098                 sp_ui_error_dialog(_("Could not parse SVG data"));
1099                 return;
1100             }
1101
1102             Inkscape::XML::Node *repr = sp_repr_document_root(rnewdoc);
1103             gchar const *style = repr->attribute("style");
1104
1105             Inkscape::XML::Node *newgroup = sp_repr_new("svg:g");
1106             newgroup->setAttribute("style", style);
1107
1108             for (Inkscape::XML::Node *child = repr->firstChild(); child != NULL; child = child->next()) {
1109                 Inkscape::XML::Node *newchild = child->duplicate();
1110                 newgroup->appendChild(newchild);
1111             }
1112
1113             Inkscape::GC::release(rnewdoc);
1114
1115             SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1116             // Add it to the current layer
1117
1118             // Greg's edits to add intelligent positioning of svg drops
1119             SPObject *new_obj = NULL;
1120             new_obj = desktop->currentLayer()->appendChildRepr(newgroup);
1121
1122             Inkscape::Selection *selection = SP_DT_SELECTION(desktop);
1123             selection->set(SP_ITEM(new_obj));
1124             // To move the imported object, we must temporarily set the "transform pattern with
1125             // object" option.
1126             {
1127                 int const saved_pref = prefs_get_int_attribute("options.transform", "pattern", 1);
1128                 prefs_set_int_attribute("options.transform", "pattern", 1);
1129                 sp_document_ensure_up_to_date(SP_DT_DOCUMENT(desktop));
1130                 NR::Point m( desktop->point() - selection->bounds().midpoint() );
1131                 sp_selection_move_relative(selection, m);
1132                 prefs_set_int_attribute("options.transform", "pattern", saved_pref);
1133             }
1134
1135             Inkscape::GC::release(newgroup);
1136             sp_document_done(doc);
1137             break;
1138         }
1139
1140         case URI_LIST: {
1141             gchar *uri = (gchar *)data->data;
1142             sp_ui_import_files(uri);
1143             break;
1144         }
1145
1146         case PNG_DATA:
1147         case JPEG_DATA:
1148         case IMAGE_DATA: {
1149             char tmp[1024];
1150
1151             StringOutputStream outs;
1152             Base64OutputStream b64out(outs);
1153             b64out.setColumnWidth(0);
1154
1155             SPDocument *doc = SP_ACTIVE_DOCUMENT;
1156
1157             Inkscape::XML::Node *newImage = sp_repr_new("svg:image");
1158
1159             for ( int i = 0; i < data->length; i++ ) {
1160                 b64out.put( data->data[i] );
1161             }
1162             b64out.close();
1163
1164
1165             Glib::ustring str = outs.getString();
1166
1167             snprintf( tmp, sizeof(tmp), "data:%s;base64,", gdk_atom_name(data->type) );
1168             str.insert( 0, tmp );
1169             newImage->setAttribute("xlink:href", str.c_str());
1170
1171             GError *error = NULL;
1172             GdkPixbufLoader *loader = gdk_pixbuf_loader_new_with_mime_type( gdk_atom_name(data->type), &error );
1173             if ( loader ) {
1174                 error = NULL;
1175                 if ( gdk_pixbuf_loader_write( loader, data->data, data->length, &error) ) {
1176                     GdkPixbuf *pbuf = gdk_pixbuf_loader_get_pixbuf(loader);
1177                     if ( pbuf ) {
1178                         int width = gdk_pixbuf_get_width(pbuf);
1179                         int height = gdk_pixbuf_get_height(pbuf);
1180                         snprintf( tmp, sizeof(tmp), "%d", width );
1181                         newImage->setAttribute("width", tmp);
1182
1183                         snprintf( tmp, sizeof(tmp), "%d", height );
1184                         newImage->setAttribute("height", tmp);
1185                     }
1186                 }
1187             }
1188
1189             SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1190
1191             // Add it to the current layer
1192             desktop->currentLayer()->appendChildRepr(newImage);
1193
1194             Inkscape::GC::release(newImage);
1195             sp_document_done( doc );
1196             break;
1197         }
1198     }
1199 }
1200
1201 static void
1202 sp_ui_import_files(gchar *buffer)
1203 {
1204     GList *list = gnome_uri_list_extract_filenames(buffer);
1205     if (!list)
1206         return;
1207     g_list_foreach(list, sp_ui_import_one_file_with_check, NULL);
1208     g_list_foreach(list, (GFunc) g_free, NULL);
1209     g_list_free(list);
1210 }
1211
1212 static void
1213 sp_ui_import_one_file_with_check(gpointer filename, gpointer unused)
1214 {
1215     if (filename) {
1216         if (strlen((char const *)filename) > 2)
1217             sp_ui_import_one_file((char const *)filename);
1218     }
1219 }
1220
1221 static void
1222 sp_ui_import_one_file(char const *filename)
1223 {
1224     SPDocument *doc = SP_ACTIVE_DOCUMENT;
1225     if (!doc) return;
1226
1227     if (filename == NULL) return;
1228
1229     // Pass off to common implementation
1230     // TODO might need to get the proper type of Inkscape::Extension::Extension
1231     file_import( doc, filename, NULL );
1232 }
1233
1234 void
1235 sp_ui_error_dialog(gchar const *message)
1236 {
1237     GtkWidget *dlg;
1238     gchar *safeMsg = Inkscape::IO::sanitizeString(message);
1239
1240     dlg = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR,
1241                                  GTK_BUTTONS_CLOSE, safeMsg);
1242     sp_transientize(dlg);
1243     gtk_window_set_resizable(GTK_WINDOW(dlg), FALSE);
1244     gtk_dialog_run(GTK_DIALOG(dlg));
1245     gtk_widget_destroy(dlg);
1246     g_free(safeMsg);
1247 }
1248
1249 bool
1250 sp_ui_overwrite_file(gchar const *filename)
1251 {
1252     bool return_value = FALSE;
1253     GtkWidget *dialog;
1254     GtkWidget *hbox;
1255     GtkWidget *boxdata;
1256     gchar *title;
1257     gchar *text;
1258
1259     if (Inkscape::IO::file_test(filename, G_FILE_TEST_EXISTS)) {
1260
1261         title = g_strdup_printf(_("Overwrite %s"), filename);
1262         dialog = gtk_dialog_new_with_buttons(title,
1263                                              NULL,
1264                                              (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
1265                                              GTK_STOCK_NO,
1266                                              GTK_RESPONSE_NO,
1267                                              GTK_STOCK_YES,
1268                                              GTK_RESPONSE_YES,
1269                                              NULL);
1270         gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_YES);
1271
1272         sp_transientize(dialog);
1273         gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
1274
1275         hbox = gtk_hbox_new(FALSE, 5);
1276         boxdata = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG);
1277         gtk_widget_show(boxdata);
1278         gtk_box_pack_start(GTK_BOX(hbox), boxdata, TRUE, TRUE, 5);
1279         text = g_strdup_printf(_("The file %s already exists.  Do you want to overwrite that file with the current document?"), filename);
1280         boxdata = gtk_label_new(text);
1281         gtk_label_set_line_wrap(GTK_LABEL(boxdata), TRUE);
1282         gtk_widget_show(boxdata);
1283         gtk_box_pack_start(GTK_BOX(hbox), boxdata, FALSE, FALSE, 5);
1284         gtk_widget_show(hbox);
1285         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 5);
1286
1287         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES) {
1288             return_value = TRUE;
1289         } else {
1290             return_value = FALSE;
1291         }
1292
1293         gtk_widget_destroy(dialog);
1294         g_free(title);
1295         g_free(text);
1296     } else {
1297         return_value = TRUE;
1298     }
1299
1300     return return_value;
1301 }
1302
1303 static void
1304 sp_ui_menu_item_set_sensitive(SPAction *action, unsigned int sensitive, void *data)
1305 {
1306     return gtk_widget_set_sensitive(GTK_WIDGET(data), sensitive);
1307 }
1308
1309 /*
1310   Local Variables:
1311   mode:c++
1312   c-file-style:"stroustrup"
1313   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1314   indent-tabs-mode:nil
1315   fill-column:99
1316   End:
1317 */
1318 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :