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 "ui/context-menu.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( Inkscape::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_desktop_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                     bool updatePerformed = false;
1012
1013                     if ( data->length > 14 ) {
1014                         int flags = dataVals[4];
1015
1016                         // piggie-backed palette entry info
1017                         int index = dataVals[5];
1018                         Glib::ustring palName;
1019                         for ( int i = 0; i < dataVals[6]; i++ ) {
1020                             palName += (gunichar)dataVals[7+i];
1021                         }
1022
1023                         // Now hook in a magic tag of some sort.
1024                         if ( !palName.empty() && (flags & 1) ) {
1025                             gchar* str = g_strdup_printf("%d|", index);
1026                             palName.insert( 0, str );
1027                             g_free(str);
1028                             str = 0;
1029
1030                             sp_object_setAttribute( SP_OBJECT(item),
1031                                                     (drag_context->action != GDK_ACTION_MOVE) ? "inkscape:x-fill-tag":"inkscape:x-stroke-tag",
1032                                                     palName.c_str(),
1033                                                     false );
1034                             item->updateRepr();
1035
1036                             sp_repr_css_set_property( css, (drag_context->action != GDK_ACTION_MOVE) ? "fill":"stroke", c );
1037                             updatePerformed = true;
1038                         }
1039                     }
1040
1041                     if ( !updatePerformed ) {
1042                         sp_repr_css_set_property( css, (drag_context->action != GDK_ACTION_MOVE) ? "fill":"stroke", c );
1043                     }
1044
1045                     sp_desktop_apply_css_recursive( item, css, true );
1046                     item->updateRepr();
1047
1048                     SPDocument *doc = SP_ACTIVE_DOCUMENT;
1049                     sp_document_done( doc );
1050
1051                     if ( srgbProf ) {
1052                         cmsCloseProfile( srgbProf );
1053                     }
1054                 }
1055             }
1056         }
1057         break;
1058 #endif // ENABLE_LCMS
1059
1060         case APP_X_COLOR:
1061         {
1062             SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1063             int destX = 0;
1064             int destY = 0;
1065             gtk_widget_translate_coordinates( widget, &(desktop->canvas->widget), x, y, &destX, &destY );
1066             NR::Point where( sp_canvas_window_to_world( desktop->canvas, NR::Point( destX, destY ) ) );
1067
1068             SPItem *item = desktop->item_at_point( where, true );
1069             if ( item )
1070             {
1071                 if ( data->length == 8 ) {
1072                     gchar c[64] = {0};
1073                     // Careful about endian issues.
1074                     guint16* dataVals = (guint16*)data->data;
1075                     sp_svg_write_color( c, 64,
1076                                         SP_RGBA32_U_COMPOSE(
1077                                             0x0ff & (dataVals[0] >> 8),
1078                                             0x0ff & (dataVals[1] >> 8),
1079                                             0x0ff & (dataVals[2] >> 8),
1080                                             0xff // can't have transparency in the color itself
1081                                             //0x0ff & (data->data[3] >> 8),
1082                                             ));
1083                     SPCSSAttr *css = sp_repr_css_attr_new();
1084                     sp_repr_css_set_property( css, (drag_context->action != GDK_ACTION_MOVE) ? "fill":"stroke", c );
1085
1086                     sp_desktop_apply_css_recursive( item, css, true );
1087                     item->updateRepr();
1088
1089                     SPDocument *doc = SP_ACTIVE_DOCUMENT;
1090                     sp_document_done( doc );
1091                 }
1092             }
1093         }
1094         break;
1095
1096         case SVG_DATA:
1097         case SVG_XML_DATA: {
1098             gchar *svgdata = (gchar *)data->data;
1099
1100             SPDocument *doc = SP_ACTIVE_DOCUMENT;
1101
1102             Inkscape::XML::Document *rnewdoc = sp_repr_read_mem(svgdata, data->length, SP_SVG_NS_URI);
1103
1104             if (rnewdoc == NULL) {
1105                 sp_ui_error_dialog(_("Could not parse SVG data"));
1106                 return;
1107             }
1108
1109             Inkscape::XML::Node *repr = sp_repr_document_root(rnewdoc);
1110             gchar const *style = repr->attribute("style");
1111
1112             Inkscape::XML::Node *newgroup = sp_repr_new("svg:g");
1113             newgroup->setAttribute("style", style);
1114
1115             for (Inkscape::XML::Node *child = repr->firstChild(); child != NULL; child = child->next()) {
1116                 Inkscape::XML::Node *newchild = child->duplicate();
1117                 newgroup->appendChild(newchild);
1118             }
1119
1120             Inkscape::GC::release(rnewdoc);
1121
1122             SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1123             // Add it to the current layer
1124
1125             // Greg's edits to add intelligent positioning of svg drops
1126             SPObject *new_obj = NULL;
1127             new_obj = desktop->currentLayer()->appendChildRepr(newgroup);
1128
1129             Inkscape::Selection *selection = sp_desktop_selection(desktop);
1130             selection->set(SP_ITEM(new_obj));
1131             // To move the imported object, we must temporarily set the "transform pattern with
1132             // object" option.
1133             {
1134                 int const saved_pref = prefs_get_int_attribute("options.transform", "pattern", 1);
1135                 prefs_set_int_attribute("options.transform", "pattern", 1);
1136                 sp_document_ensure_up_to_date(sp_desktop_document(desktop));
1137                 NR::Point m( desktop->point() - selection->bounds().midpoint() );
1138                 sp_selection_move_relative(selection, m);
1139                 prefs_set_int_attribute("options.transform", "pattern", saved_pref);
1140             }
1141
1142             Inkscape::GC::release(newgroup);
1143             sp_document_done(doc);
1144             break;
1145         }
1146
1147         case URI_LIST: {
1148             gchar *uri = (gchar *)data->data;
1149             sp_ui_import_files(uri);
1150             break;
1151         }
1152
1153         case PNG_DATA:
1154         case JPEG_DATA:
1155         case IMAGE_DATA: {
1156             char tmp[1024];
1157
1158             StringOutputStream outs;
1159             Base64OutputStream b64out(outs);
1160             b64out.setColumnWidth(0);
1161
1162             SPDocument *doc = SP_ACTIVE_DOCUMENT;
1163
1164             Inkscape::XML::Node *newImage = sp_repr_new("svg:image");
1165
1166             for ( int i = 0; i < data->length; i++ ) {
1167                 b64out.put( data->data[i] );
1168             }
1169             b64out.close();
1170
1171
1172             Glib::ustring str = outs.getString();
1173
1174             snprintf( tmp, sizeof(tmp), "data:%s;base64,", gdk_atom_name(data->type) );
1175             str.insert( 0, tmp );
1176             newImage->setAttribute("xlink:href", str.c_str());
1177
1178             GError *error = NULL;
1179             GdkPixbufLoader *loader = gdk_pixbuf_loader_new_with_mime_type( gdk_atom_name(data->type), &error );
1180             if ( loader ) {
1181                 error = NULL;
1182                 if ( gdk_pixbuf_loader_write( loader, data->data, data->length, &error) ) {
1183                     GdkPixbuf *pbuf = gdk_pixbuf_loader_get_pixbuf(loader);
1184                     if ( pbuf ) {
1185                         int width = gdk_pixbuf_get_width(pbuf);
1186                         int height = gdk_pixbuf_get_height(pbuf);
1187                         snprintf( tmp, sizeof(tmp), "%d", width );
1188                         newImage->setAttribute("width", tmp);
1189
1190                         snprintf( tmp, sizeof(tmp), "%d", height );
1191                         newImage->setAttribute("height", tmp);
1192                     }
1193                 }
1194             }
1195
1196             SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1197
1198             // Add it to the current layer
1199             desktop->currentLayer()->appendChildRepr(newImage);
1200
1201             Inkscape::GC::release(newImage);
1202             sp_document_done( doc );
1203             break;
1204         }
1205     }
1206 }
1207
1208 static void
1209 sp_ui_import_files(gchar *buffer)
1210 {
1211     GList *list = gnome_uri_list_extract_filenames(buffer);
1212     if (!list)
1213         return;
1214     g_list_foreach(list, sp_ui_import_one_file_with_check, NULL);
1215     g_list_foreach(list, (GFunc) g_free, NULL);
1216     g_list_free(list);
1217 }
1218
1219 static void
1220 sp_ui_import_one_file_with_check(gpointer filename, gpointer unused)
1221 {
1222     if (filename) {
1223         if (strlen((char const *)filename) > 2)
1224             sp_ui_import_one_file((char const *)filename);
1225     }
1226 }
1227
1228 static void
1229 sp_ui_import_one_file(char const *filename)
1230 {
1231     SPDocument *doc = SP_ACTIVE_DOCUMENT;
1232     if (!doc) return;
1233
1234     if (filename == NULL) return;
1235
1236     // Pass off to common implementation
1237     // TODO might need to get the proper type of Inkscape::Extension::Extension
1238     file_import( doc, filename, NULL );
1239 }
1240
1241 void
1242 sp_ui_error_dialog(gchar const *message)
1243 {
1244     GtkWidget *dlg;
1245     gchar *safeMsg = Inkscape::IO::sanitizeString(message);
1246
1247     dlg = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR,
1248                                  GTK_BUTTONS_CLOSE, safeMsg);
1249     sp_transientize(dlg);
1250     gtk_window_set_resizable(GTK_WINDOW(dlg), FALSE);
1251     gtk_dialog_run(GTK_DIALOG(dlg));
1252     gtk_widget_destroy(dlg);
1253     g_free(safeMsg);
1254 }
1255
1256 bool
1257 sp_ui_overwrite_file(gchar const *filename)
1258 {
1259     bool return_value = FALSE;
1260     GtkWidget *dialog;
1261     GtkWidget *hbox;
1262     GtkWidget *boxdata;
1263     gchar *title;
1264     gchar *text;
1265
1266     if (Inkscape::IO::file_test(filename, G_FILE_TEST_EXISTS)) {
1267
1268         title = g_strdup_printf(_("Overwrite %s"), filename);
1269         dialog = gtk_dialog_new_with_buttons(title,
1270                                              NULL,
1271                                              (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
1272                                              GTK_STOCK_NO,
1273                                              GTK_RESPONSE_NO,
1274                                              GTK_STOCK_YES,
1275                                              GTK_RESPONSE_YES,
1276                                              NULL);
1277         gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_YES);
1278
1279         sp_transientize(dialog);
1280         gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
1281
1282         hbox = gtk_hbox_new(FALSE, 5);
1283
1284         // TODO - replace with Inkscape-specific call
1285         boxdata = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG);
1286
1287         gtk_widget_show(boxdata);
1288         gtk_box_pack_start(GTK_BOX(hbox), boxdata, TRUE, TRUE, 5);
1289         text = g_strdup_printf(_("The file %s already exists.  Do you want to overwrite that file with the current document?"), filename);
1290         boxdata = gtk_label_new(text);
1291         gtk_label_set_line_wrap(GTK_LABEL(boxdata), TRUE);
1292         gtk_widget_show(boxdata);
1293         gtk_box_pack_start(GTK_BOX(hbox), boxdata, FALSE, FALSE, 5);
1294         gtk_widget_show(hbox);
1295         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 5);
1296
1297         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES) {
1298             return_value = TRUE;
1299         } else {
1300             return_value = FALSE;
1301         }
1302
1303         gtk_widget_destroy(dialog);
1304         g_free(title);
1305         g_free(text);
1306     } else {
1307         return_value = TRUE;
1308     }
1309
1310     return return_value;
1311 }
1312
1313 static void
1314 sp_ui_menu_item_set_sensitive(SPAction *action, unsigned int sensitive, void *data)
1315 {
1316     return gtk_widget_set_sensitive(GTK_WIDGET(data), sensitive);
1317 }
1318
1319 /*
1320   Local Variables:
1321   mode:c++
1322   c-file-style:"stroustrup"
1323   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1324   indent-tabs-mode:nil
1325   fill-column:99
1326   End:
1327 */
1328 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :