← Back to branch summary

~centralelyon2010/inkscape/imagelinks2

« back to all changes in this revision

Viewing changes to src/ui/context-menu.cpp

  • Committer: JazzyNico
  • Date: 2011-08-29 20:25:30 UTC
  • Revision ID: nicoduf@yahoo.fr-20110829202530-6deuoz11q90usldv
Code refactoring and merging with trunk (revision 10599).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ui/context-menu.cpp
1
 
#define __CONTEXT_MENU_C__
2
 
 
3
1
/*
4
2
 * Unser-interface related object extension
5
3
 *
6
4
 * Authors:
7
5
 *   Lauris Kaplinski <lauris@kaplinski.com>
 
6
 *   Jon A. Cruz <jon@joncruz.org>
 
7
 *   Abhishek Sharma
8
8
 *
9
9
 * This code is in public domain
10
10
 */
21
21
#include "preferences.h"
22
22
#include "ui/dialog/dialog-manager.h"
23
23
 
 
24
using Inkscape::DocumentUndo;
 
25
 
24
26
static void sp_object_type_menu(GType type, SPObject *object, SPDesktop *desktop, GtkMenu *menu);
25
27
 
26
28
/* Append object-specific part to context menu */
40
42
 
41
43
/* Implementation */
42
44
 
43
 
#include <gtk/gtkmenuitem.h>
 
45
#include <gtk/gtk.h>
44
46
 
45
47
#include <glibmm/i18n.h>
46
48
 
47
49
#include "sp-anchor.h"
48
50
#include "sp-image.h"
 
51
#include "sp-text.h"
49
52
 
50
53
#include "document.h"
51
54
#include "desktop-handles.h"
53
56
#include "selection-chemistry.h"
54
57
#include "dialogs/item-properties.h"
55
58
#include "dialogs/object-attributes.h"
 
59
#include "dialogs/text-edit.h"
 
60
#include "dialogs/spellcheck.h"
56
61
 
57
62
#include "sp-path.h"
58
63
#include "sp-clippath.h"
64
69
static void sp_anchor_menu(SPObject *object, SPDesktop *desktop, GtkMenu *menu);
65
70
static void sp_image_menu(SPObject *object, SPDesktop *desktop, GtkMenu *menu);
66
71
static void sp_shape_menu(SPObject *object, SPDesktop *desktop, GtkMenu *menu);
 
72
static void sp_text_menu(SPObject *object, SPDesktop *desktop, GtkMenu *menu);
67
73
 
68
74
static void
69
75
sp_object_type_menu(GType type, SPObject *object, SPDesktop *desktop, GtkMenu *menu)
77
83
        g_hash_table_insert(t2m, GUINT_TO_POINTER(SP_TYPE_ANCHOR), (void*)sp_anchor_menu);
78
84
        g_hash_table_insert(t2m, GUINT_TO_POINTER(SP_TYPE_IMAGE), (void*)sp_image_menu);
79
85
        g_hash_table_insert(t2m, GUINT_TO_POINTER(SP_TYPE_SHAPE), (void*)sp_shape_menu);
 
86
        g_hash_table_insert(t2m, GUINT_TO_POINTER(SP_TYPE_TEXT), (void*)sp_text_menu);
80
87
    }
81
88
    handler = (void (*)(SPObject*, SPDesktop*, GtkMenu*))g_hash_table_lookup(t2m, GUINT_TO_POINTER(type));
82
89
    if (handler) handler(object, desktop, menu);
102
109
    item = (SPItem *) object;
103
110
 
104
111
    /* Item dialog */
105
 
    w = gtk_menu_item_new_with_mnemonic(_("Object _Properties"));
106
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
107
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_item_properties), item);
 
112
    w = gtk_menu_item_new_with_mnemonic(_("_Object Properties..."));
 
113
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
114
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_item_properties), item);
108
115
    gtk_widget_show(w);
109
 
    gtk_menu_append(GTK_MENU(m), w);
 
116
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
110
117
    /* Separator */
111
118
    w = gtk_menu_item_new();
112
119
    gtk_widget_show(w);
113
 
    gtk_menu_append(GTK_MENU(m), w);
 
120
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
114
121
    /* Select item */
115
122
    w = gtk_menu_item_new_with_mnemonic(_("_Select This"));
116
123
    if (sp_desktop_selection(desktop)->includes(item)) {
117
124
        gtk_widget_set_sensitive(w, FALSE);
118
125
    } else {
119
 
        gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
120
 
        gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_item_select_this), item);
 
126
        g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
127
        g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_item_select_this), item);
121
128
    }
122
129
    gtk_widget_show(w);
123
 
    gtk_menu_append(GTK_MENU(m), w);
 
130
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
124
131
    /* Create link */
125
132
    w = gtk_menu_item_new_with_mnemonic(_("_Create Link"));
126
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
127
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_item_create_link), item);
 
133
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
134
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_item_create_link), item);
128
135
    gtk_widget_set_sensitive(w, !SP_IS_ANCHOR(item));
129
136
    gtk_widget_show(w);
130
 
    gtk_menu_append(GTK_MENU(m), w);
 
137
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
131
138
    /* Set mask */
132
139
    w = gtk_menu_item_new_with_mnemonic(_("Set Mask"));
133
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
134
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_set_mask), item);
 
140
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
141
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_set_mask), item);
135
142
    if ((item && item->mask_ref && item->mask_ref->getObject()) || (item->clip_ref && item->clip_ref->getObject())) {
136
143
        gtk_widget_set_sensitive(w, FALSE);
137
144
    } else {
138
145
        gtk_widget_set_sensitive(w, TRUE);
139
146
    }
140
147
    gtk_widget_show(w);
141
 
    gtk_menu_append(GTK_MENU(m), w);
 
148
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
142
149
    /* Release mask */
143
150
    w = gtk_menu_item_new_with_mnemonic(_("Release Mask"));
144
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
145
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_release_mask), item);
 
151
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
152
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_release_mask), item);
146
153
    if (item && item->mask_ref && item->mask_ref->getObject()) {
147
154
        gtk_widget_set_sensitive(w, TRUE);
148
155
    } else {
149
156
        gtk_widget_set_sensitive(w, FALSE);
150
157
    }
151
158
    gtk_widget_show(w);
152
 
    gtk_menu_append(GTK_MENU(m), w);
 
159
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
153
160
    /* Set Clip */
154
 
    w = gtk_menu_item_new_with_mnemonic(_("Set Clip"));
155
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
156
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_set_clip), item);
 
161
    w = gtk_menu_item_new_with_mnemonic(_("Set _Clip"));
 
162
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
163
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_set_clip), item);
157
164
    if ((item && item->mask_ref && item->mask_ref->getObject()) || (item->clip_ref && item->clip_ref->getObject())) {
158
165
        gtk_widget_set_sensitive(w, FALSE);
159
166
    } else {
160
167
        gtk_widget_set_sensitive(w, TRUE);
161
168
    }
162
169
    gtk_widget_show(w);
163
 
    gtk_menu_append(GTK_MENU(m), w);
 
170
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
164
171
    /* Release Clip */
165
 
    w = gtk_menu_item_new_with_mnemonic(_("Release Clip"));
166
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
167
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_release_clip), item);
 
172
    w = gtk_menu_item_new_with_mnemonic(_("Release C_lip"));
 
173
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
174
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_release_clip), item);
168
175
    if (item && item->clip_ref && item->clip_ref->getObject()) {
169
176
        gtk_widget_set_sensitive(w, TRUE);
170
177
    } else {
171
178
        gtk_widget_set_sensitive(w, FALSE);
172
179
    }
173
180
    gtk_widget_show(w);
174
 
    gtk_menu_append(GTK_MENU(m), w);
 
181
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
175
182
 
176
183
}
177
184
 
182
189
 
183
190
    g_assert(SP_IS_ITEM(item));
184
191
 
185
 
    desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
192
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
186
193
    g_return_if_fail(desktop != NULL);
187
194
 
188
195
    sp_desktop_selection(desktop)->set(item);
198
205
 
199
206
    g_assert(SP_IS_ITEM(item));
200
207
 
201
 
    desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
208
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
202
209
    g_return_if_fail(desktop != NULL);
203
210
 
204
211
        sp_selection_set_mask(desktop, false, false);
212
219
 
213
220
    g_assert(SP_IS_ITEM(item));
214
221
 
215
 
    desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
222
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
216
223
    g_return_if_fail(desktop != NULL);
217
224
 
218
225
    sp_selection_unset_mask(desktop, false);
226
233
 
227
234
    g_assert(SP_IS_ITEM(item));
228
235
 
229
 
    desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
236
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
230
237
    g_return_if_fail(desktop != NULL);
231
238
 
232
239
        sp_selection_set_mask(desktop, true, false);
240
247
 
241
248
    g_assert(SP_IS_ITEM(item));
242
249
 
243
 
    desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
250
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
244
251
    g_return_if_fail(desktop != NULL);
245
252
 
246
253
    sp_selection_unset_mask(desktop, true);
254
261
 
255
262
    g_assert(SP_IS_ITEM(item));
256
263
 
257
 
    desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
264
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
258
265
    g_return_if_fail(desktop != NULL);
259
266
 
260
267
    sp_desktop_selection(desktop)->set(item);
266
273
    g_assert(SP_IS_ITEM(item));
267
274
    g_assert(!SP_IS_ANCHOR(item));
268
275
 
269
 
    SPDesktop *desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
276
    SPDesktop *desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
270
277
    g_return_if_fail(desktop != NULL);
271
278
 
272
 
    Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
 
279
    Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
273
280
    Inkscape::XML::Node *repr = xml_doc->createElement("svg:a");
274
 
    SP_OBJECT_REPR(SP_OBJECT_PARENT(item))->addChild(repr, SP_OBJECT_REPR(item));
275
 
    SPObject *object = SP_OBJECT_DOCUMENT(item)->getObjectByRepr(repr);
 
281
    item->parent->getRepr()->addChild(repr, item->getRepr());
 
282
    SPObject *object = item->document->getObjectByRepr(repr);
276
283
    g_return_if_fail(SP_IS_ANCHOR(object));
277
284
 
278
 
    const char *id = SP_OBJECT_REPR(item)->attribute("id");
279
 
    Inkscape::XML::Node *child = SP_OBJECT_REPR(item)->duplicate(xml_doc);
280
 
    SP_OBJECT(item)->deleteObject(false);
 
285
    const char *id = item->getRepr()->attribute("id");
 
286
    Inkscape::XML::Node *child = item->getRepr()->duplicate(xml_doc);
 
287
    item->deleteObject(false);
281
288
    repr->addChild(child, NULL);
282
289
    child->setAttribute("id", id);
283
290
 
284
291
    Inkscape::GC::release(repr);
285
292
    Inkscape::GC::release(child);
286
293
 
287
 
    sp_document_done(SP_OBJECT_DOCUMENT(object), SP_VERB_NONE,
288
 
                     _("Create link"));
 
294
    DocumentUndo::done(object->document, SP_VERB_NONE,
 
295
                       _("Create link"));
289
296
 
290
297
    sp_object_attributes_dialog(object, "SPAnchor");
291
298
 
304
311
 
305
312
    /* "Ungroup" */
306
313
    w = gtk_menu_item_new_with_mnemonic(_("_Ungroup"));
307
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
308
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_item_group_ungroup_activate), item);
 
314
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
315
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_item_group_ungroup_activate), item);
309
316
    gtk_widget_show(w);
310
 
    gtk_menu_append(GTK_MENU(menu), w);
 
317
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), w);
311
318
}
312
319
 
313
320
static void
318
325
 
319
326
    g_assert(SP_IS_GROUP(group));
320
327
 
321
 
    desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
328
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
322
329
    g_return_if_fail(desktop != NULL);
323
330
 
324
331
    children = NULL;
343
350
    item = (SPItem *) object;
344
351
 
345
352
    /* Link dialog */
346
 
    w = gtk_menu_item_new_with_mnemonic(_("Link _Properties"));
347
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
348
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_anchor_link_properties), item);
 
353
    w = gtk_menu_item_new_with_mnemonic(_("Link _Properties..."));
 
354
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
355
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_anchor_link_properties), item);
349
356
    gtk_widget_show(w);
350
 
    gtk_menu_append(GTK_MENU(m), w);
 
357
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
351
358
    /* Select item */
352
359
    w = gtk_menu_item_new_with_mnemonic(_("_Follow Link"));
353
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_anchor_link_follow), item);
 
360
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_anchor_link_follow), item);
354
361
    gtk_widget_show(w);
355
 
    gtk_menu_append(GTK_MENU(m), w);
 
362
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
356
363
    /* Reset transformations */
357
364
    w = gtk_menu_item_new_with_mnemonic(_("_Remove Link"));
358
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
359
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_anchor_link_remove), item);
 
365
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
366
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_anchor_link_remove), item);
360
367
    gtk_widget_show(w);
361
 
    gtk_menu_append(GTK_MENU(m), w);
 
368
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
362
369
}
363
370
 
364
371
static void
365
372
sp_anchor_link_properties(GtkMenuItem */*menuitem*/, SPAnchor *anchor)
366
373
{
367
 
    sp_object_attributes_dialog(SP_OBJECT(anchor), "Link");
 
374
    sp_object_attributes_dialog(anchor, "Link");
368
375
}
369
376
 
370
377
static void
402
409
    GtkWidget *w;
403
410
 
404
411
    /* Link dialog */
405
 
    w = gtk_menu_item_new_with_mnemonic(_("Image _Properties"));
406
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
407
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_image_image_properties), item);
 
412
    w = gtk_menu_item_new_with_mnemonic(_("Image _Properties..."));
 
413
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
414
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_image_image_properties), item);
408
415
    gtk_widget_show(w);
409
 
    gtk_menu_append(GTK_MENU(m), w);
 
416
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
410
417
 
411
418
    w = gtk_menu_item_new_with_mnemonic(_("Edit Externally..."));
412
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
413
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_image_image_edit), item);
 
419
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
420
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_image_image_edit), item);
414
421
    gtk_widget_show(w);
415
 
    gtk_menu_append(GTK_MENU(m), w);
416
 
    Inkscape::XML::Node *ir = SP_OBJECT_REPR(object);
 
422
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
 
423
    Inkscape::XML::Node *ir = object->getRepr();
417
424
    const gchar *href = ir->attribute("xlink:href");
418
425
    if ( (!href) || ((strncmp(href, "data:", 5) == 0)) ) {
419
426
        gtk_widget_set_sensitive( w, FALSE );
423
430
static void
424
431
sp_image_image_properties(GtkMenuItem */*menuitem*/, SPAnchor *anchor)
425
432
{
426
 
    sp_object_attributes_dialog(SP_OBJECT(anchor), "Image");
 
433
    sp_object_attributes_dialog(anchor, "Image");
427
434
}
428
435
 
429
436
static gchar* getImageEditorName() {
430
437
    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
431
438
    gchar* value = 0;
432
 
    Glib::ustring choices = prefs->getString("/options/bitmapeditor/choices");
 
439
    Glib::ustring choices = prefs->getString("/options/bitmapeditor/value");
433
440
    if (!choices.empty()) {
434
 
        gchar** splits = g_strsplit(choices.data(), ",", 0);
435
 
        gint numIems = g_strv_length(splits);
436
 
 
437
 
        int setting = prefs->getIntLimited("/options/bitmapeditor/value", 0, 0, numIems);
438
 
        value = g_strdup(splits[setting]);
439
 
 
440
 
        g_strfreev(splits);
 
441
        value = g_strdup(choices.c_str());
441
442
    }
442
 
 
443
443
    if (!value) {
444
444
        value = g_strdup("gimp");
445
445
    }
448
448
 
449
449
static void sp_image_image_edit(GtkMenuItem *menuitem, SPAnchor *anchor)
450
450
{
451
 
    SPObject* obj = SP_OBJECT(anchor);
452
 
    Inkscape::XML::Node *ir = SP_OBJECT_REPR(obj);
 
451
    SPObject* obj = anchor;
 
452
    Inkscape::XML::Node *ir = obj->getRepr();
453
453
    const gchar *href = ir->attribute("xlink:href");
454
454
 
455
455
    GError* errThing = 0;
456
 
    gchar* editorBin = getImageEditorName();
457
 
    gchar const* args[] = {editorBin, href, 0};
458
 
    g_spawn_async(0, // working dir
459
 
                  const_cast<gchar **>(args),
460
 
                  0, //envp
461
 
                  G_SPAWN_SEARCH_PATH,
462
 
                  0, // child_setup
463
 
                  0, // user_data
464
 
                  0, //GPid *child_pid
465
 
                  &errThing);
 
456
    Glib::ustring cmdline = getImageEditorName();
 
457
    Glib::ustring fullname;
 
458
    
 
459
#ifdef WIN32
 
460
    // g_spawn_command_line_sync parsing is done according to Unix shell rules,
 
461
    // not Windows command interpreter rules. Thus we need to enclose the
 
462
    // executable path with sigle quotes.
 
463
    int index = cmdline.find(".exe");
 
464
    if ( index < 0 ) index = cmdline.find(".bat");
 
465
    if ( index < 0 ) index = cmdline.find(".com");
 
466
    if ( index >= 0 ) {
 
467
        Glib::ustring editorBin = cmdline.substr(0, index + 4).c_str();
 
468
                                Glib::ustring args = cmdline.substr(index + 4, cmdline.length()).c_str();
 
469
        editorBin.insert(0, "'");
 
470
        editorBin.append("'");
 
471
        cmdline = editorBin;
 
472
        cmdline.append(args);
 
473
    } else {
 
474
        // Enclose the whole command line if no executable path can be extracted.
 
475
        cmdline.insert(0, "'");
 
476
        cmdline.append("'");
 
477
    }
 
478
#endif
 
479
 
 
480
    if (strncmp (href,"file:",5) == 0) {
 
481
    // URI to filename conversion
 
482
      fullname = g_filename_from_uri(href, NULL, NULL);
 
483
    } else {
 
484
      fullname.append(href);
 
485
    }
 
486
    
 
487
    cmdline.append(" '");
 
488
    cmdline.append(fullname.c_str());
 
489
    cmdline.append("'");
 
490
 
 
491
    //printf("##Command line: %s\n", cmdline.c_str());
 
492
 
 
493
    g_spawn_command_line_async(cmdline.c_str(),
 
494
                  &errThing); 
 
495
 
466
496
    if ( errThing ) {
467
497
        g_warning("Problem launching editor (%d). %s", errThing->code, errThing->message);
468
 
        SPDesktop *desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
 
498
        SPDesktop *desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
469
499
        desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, errThing->message);
470
500
        g_error_free(errThing);
471
501
        errThing = 0;
472
502
    }
473
 
    g_free(editorBin);
 
503
}
 
504
 
 
505
/* Fill and Stroke entry */
 
506
 
 
507
static void
 
508
sp_fill_settings(GtkMenuItem *menuitem, SPItem *item)
 
509
{
 
510
    SPDesktop *desktop;
 
511
 
 
512
    g_assert(SP_IS_ITEM(item));
 
513
 
 
514
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
 
515
    g_return_if_fail(desktop != NULL);
 
516
 
 
517
    if (sp_desktop_selection(desktop)->isEmpty()) {
 
518
        sp_desktop_selection(desktop)->set(item);
 
519
    }
 
520
 
 
521
    desktop->_dlg_mgr->showDialog("FillAndStroke");
474
522
}
475
523
 
476
524
/* SPShape */
477
525
 
478
526
static void
479
 
sp_shape_fill_settings(GtkMenuItem *menuitem, SPItem *item)
480
 
{
481
 
    SPDesktop *desktop;
482
 
 
483
 
    g_assert(SP_IS_ITEM(item));
484
 
 
485
 
    desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
486
 
    g_return_if_fail(desktop != NULL);
487
 
 
488
 
    if (sp_desktop_selection(desktop)->isEmpty()) {
489
 
        sp_desktop_selection(desktop)->set(item);
490
 
    }
491
 
 
492
 
    desktop->_dlg_mgr->showDialog("FillAndStroke");
493
 
}
494
 
 
495
 
static void
496
527
sp_shape_menu(SPObject *object, SPDesktop *desktop, GtkMenu *m)
497
528
{
498
529
    SPItem *item;
501
532
    item = (SPItem *) object;
502
533
 
503
534
    /* Item dialog */
504
 
    w = gtk_menu_item_new_with_mnemonic(_("_Fill and Stroke"));
505
 
    gtk_object_set_data(GTK_OBJECT(w), "desktop", desktop);
506
 
    gtk_signal_connect(GTK_OBJECT(w), "activate", GTK_SIGNAL_FUNC(sp_shape_fill_settings), item);
507
 
    gtk_widget_show(w);
508
 
    gtk_menu_append(GTK_MENU(m), w);
509
 
}
510
 
 
511
 
 
 
535
    w = gtk_menu_item_new_with_mnemonic(_("_Fill and Stroke..."));
 
536
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
537
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_fill_settings), item);
 
538
    gtk_widget_show(w);
 
539
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
 
540
}
 
541
 
 
542
/* Edit Text entry */
 
543
 
 
544
static void
 
545
sp_text_settings(GtkMenuItem *menuitem, SPItem *item)
 
546
{
 
547
    SPDesktop *desktop;
 
548
 
 
549
    g_assert(SP_IS_ITEM(item));
 
550
 
 
551
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
 
552
    g_return_if_fail(desktop != NULL);
 
553
 
 
554
    if (sp_desktop_selection(desktop)->isEmpty()) {
 
555
        sp_desktop_selection(desktop)->set(item);
 
556
    }
 
557
 
 
558
    sp_text_edit_dialog();
 
559
}
 
560
 
 
561
/* Spellcheck entry */
 
562
 
 
563
static void
 
564
sp_spellcheck_settings(GtkMenuItem *menuitem, SPItem *item)
 
565
{
 
566
    SPDesktop *desktop;
 
567
 
 
568
    g_assert(SP_IS_ITEM(item));
 
569
 
 
570
    desktop = (SPDesktop*)g_object_get_data(G_OBJECT(menuitem), "desktop");
 
571
    g_return_if_fail(desktop != NULL);
 
572
 
 
573
    if (sp_desktop_selection(desktop)->isEmpty()) {
 
574
        sp_desktop_selection(desktop)->set(item);
 
575
    }
 
576
 
 
577
    sp_spellcheck_dialog();
 
578
}
 
579
 
 
580
/* SPText */
 
581
 
 
582
static void
 
583
sp_text_menu(SPObject *object, SPDesktop *desktop, GtkMenu *m)
 
584
{
 
585
    SPItem *item;
 
586
    GtkWidget *w;
 
587
 
 
588
    item = (SPItem *) object;
 
589
 
 
590
    /* Fill and Stroke dialog */
 
591
    w = gtk_menu_item_new_with_mnemonic(_("_Fill and Stroke..."));
 
592
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
593
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_fill_settings), item);
 
594
    gtk_widget_show(w);
 
595
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
 
596
    
 
597
    /* Edit Text dialog */
 
598
    w = gtk_menu_item_new_with_mnemonic(_("_Text and Font..."));
 
599
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
600
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_text_settings), item);
 
601
    gtk_widget_show(w);
 
602
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
 
603
 
 
604
    /* Spellcheck dialog */
 
605
    w = gtk_menu_item_new_with_mnemonic(_("Check Spellin_g..."));
 
606
    g_object_set_data(G_OBJECT(w), "desktop", desktop);
 
607
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(sp_spellcheck_settings), item);
 
608
    gtk_widget_show(w);
 
609
    gtk_menu_shell_append(GTK_MENU_SHELL(m), w);
 
610
}
512
611
/*
513
612
  Local Variables:
514
613
  mode:c++
518
617
  fill-column:99
519
618
  End:
520
619
*/
521
 
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
 
620
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :