1 #define __SP_STROKE_STYLE_C__
3 /**
4 * \brief Stroke style dialog
5 *
6 * Authors:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * Bryce Harrington <brycehar@bryceharrington.org>
9 * bulia byak <buliabyak@users.sf.net>
10 *
11 * Copyright (C) 2001-2005 authors
12 * Copyright (C) 2001 Ximian, Inc.
13 * Copyright (C) 2004 John Cliff
14 *
15 * Released under GNU GPL, read the file 'COPYING' for more information
16 */
18 #define noSP_SS_VERBOSE
20 #ifdef HAVE_CONFIG_H
21 # include "config.h"
22 #endif
26 #include <glib/gmem.h>
27 #include <gtk/gtk.h>
29 #include <glibmm/i18n.h>
30 #include "helper/unit-menu.h"
31 #include "helper/units.h"
32 #include "svg/css-ostringstream.h"
33 #include "widgets/sp-widget.h"
34 #include "widgets/spw-utilities.h"
35 #include "sp-linear-gradient.h"
36 #include "sp-radial-gradient.h"
37 #include "marker.h"
38 #include "sp-pattern.h"
39 #include "widgets/paint-selector.h"
40 #include "widgets/dash-selector.h"
41 #include "style.h"
42 #include "gradient-chemistry.h"
43 #include "sp-namedview.h"
44 #include "desktop-handles.h"
45 #include "desktop-style.h"
46 #include "selection.h"
47 #include "inkscape.h"
48 #include "inkscape-stock.h"
49 #include "dialogs/dialog-events.h"
50 #include "sp-text.h"
51 #include "sp-rect.h"
52 #include "document-private.h"
53 #include "display/nr-arena.h"
54 #include "display/nr-arena-item.h"
55 #include "path-prefix.h"
56 #include "widgets/icon.h"
57 #include "helper/stock-items.h"
58 #include "io/sys.h"
59 #include "ui/cache/svg_preview_cache.h"
61 #include "dialogs/stroke-style.h"
64 /* Paint */
66 static void sp_stroke_style_paint_construct(SPWidget *spw, SPPaintSelector *psel);
67 static void sp_stroke_style_paint_selection_modified (SPWidget *spw, Inkscape::Selection *selection, guint flags, SPPaintSelector *psel);
68 static void sp_stroke_style_paint_selection_changed (SPWidget *spw, Inkscape::Selection *selection, SPPaintSelector *psel);
69 static void sp_stroke_style_paint_update(SPWidget *spw);
71 static void sp_stroke_style_paint_mode_changed(SPPaintSelector *psel, SPPaintSelectorMode mode, SPWidget *spw);
72 static void sp_stroke_style_paint_dragged(SPPaintSelector *psel, SPWidget *spw);
73 static void sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw);
75 static void sp_stroke_style_widget_change_subselection ( Inkscape::Application *inkscape, SPDesktop *desktop, SPWidget *spw );
76 static void sp_stroke_style_widget_transientize_callback(Inkscape::Application *inkscape,
77 SPDesktop *desktop,
78 SPWidget *spw );
80 /** Marker selection option menus */
81 static GtkWidget * marker_start_menu = NULL;
82 static GtkWidget * marker_mid_menu = NULL;
83 static GtkWidget * marker_end_menu = NULL;
85 static SPObject *ink_extract_marker_name(gchar const *n);
86 static void ink_markers_menu_update(SPWidget* spw);
88 static Inkscape::UI::Cache::SvgPreview svg_preview_cache;
90 /**
91 * Create the stroke style widget, and hook up all the signals.
92 */
93 GtkWidget *
94 sp_stroke_style_paint_widget_new(void)
95 {
96 GtkWidget *spw, *psel;
98 spw = sp_widget_new_global(INKSCAPE);
100 psel = sp_paint_selector_new(false); // without fillrule selector
101 gtk_widget_show(psel);
102 gtk_container_add(GTK_CONTAINER(spw), psel);
103 gtk_object_set_data(GTK_OBJECT(spw), "paint-selector", psel);
105 gtk_signal_connect(GTK_OBJECT(spw), "construct",
106 GTK_SIGNAL_FUNC(sp_stroke_style_paint_construct),
107 psel);
108 gtk_signal_connect(GTK_OBJECT(spw), "modify_selection",
109 GTK_SIGNAL_FUNC(sp_stroke_style_paint_selection_modified),
110 psel);
111 gtk_signal_connect(GTK_OBJECT(spw), "change_selection",
112 GTK_SIGNAL_FUNC(sp_stroke_style_paint_selection_changed),
113 psel);
115 g_signal_connect (INKSCAPE, "change_subselection", G_CALLBACK (sp_stroke_style_widget_change_subselection), spw);
117 g_signal_connect (G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK (sp_stroke_style_widget_transientize_callback), spw );
119 gtk_signal_connect(GTK_OBJECT(psel), "mode_changed",
120 GTK_SIGNAL_FUNC(sp_stroke_style_paint_mode_changed),
121 spw);
122 gtk_signal_connect(GTK_OBJECT(psel), "dragged",
123 GTK_SIGNAL_FUNC(sp_stroke_style_paint_dragged),
124 spw);
125 gtk_signal_connect(GTK_OBJECT(psel), "changed",
126 GTK_SIGNAL_FUNC(sp_stroke_style_paint_changed),
127 spw);
129 sp_stroke_style_paint_update (SP_WIDGET(spw));
130 return spw;
131 }
133 /**
134 * On construction, simply does an update of the stroke style paint object.
135 */
136 static void
137 sp_stroke_style_paint_construct(SPWidget *spw, SPPaintSelector */*psel*/)
138 {
139 #ifdef SP_SS_VERBOSE
140 g_print( "Stroke style widget constructed: inkscape %p repr %p\n",
141 spw->inkscape, spw->repr );
142 #endif
143 if (spw->inkscape) {
144 sp_stroke_style_paint_update (spw);
145 }
146 }
148 /**
149 * On signal modified, invokes an update of the stroke style paint object.
150 */
151 static void
152 sp_stroke_style_paint_selection_modified( SPWidget *spw,
153 Inkscape::Selection */*selection*/,
154 guint flags,
155 SPPaintSelector */*psel*/ )
156 {
157 if (flags & ( SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG |
158 SP_OBJECT_STYLE_MODIFIED_FLAG) ) {
159 sp_stroke_style_paint_update(spw);
160 }
161 }
164 /**
165 * On signal selection changed, invokes an update of the stroke style paint object.
166 */
167 static void
168 sp_stroke_style_paint_selection_changed( SPWidget *spw,
169 Inkscape::Selection */*selection*/,
170 SPPaintSelector */*psel*/ )
171 {
172 sp_stroke_style_paint_update (spw);
173 }
176 /**
177 * On signal change subselection, invoke an update of the stroke style widget.
178 */
179 static void
180 sp_stroke_style_widget_change_subselection( Inkscape::Application */*inkscape*/,
181 SPDesktop */*desktop*/,
182 SPWidget *spw )
183 {
184 sp_stroke_style_paint_update (spw);
185 }
187 /**
188 * Gets the active stroke style property, then sets the appropriate color, alpha, gradient,
189 * pattern, etc. for the paint-selector.
190 */
191 static void
192 sp_stroke_style_paint_update (SPWidget *spw)
193 {
194 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
195 return;
196 }
198 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
200 SPPaintSelector *psel = SP_PAINT_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "paint-selector"));
202 // create temporary style
203 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
204 // query into it
205 int result = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKE);
207 switch (result) {
208 case QUERY_STYLE_NOTHING:
209 {
210 /* No paint at all */
211 sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_EMPTY);
212 break;
213 }
215 case QUERY_STYLE_SINGLE:
216 case QUERY_STYLE_MULTIPLE_AVERAGED: // TODO: treat this slightly differently, e.g. display "averaged" somewhere in paint selector
217 case QUERY_STYLE_MULTIPLE_SAME:
218 {
219 SPPaintSelectorMode pselmode = sp_style_determine_paint_selector_mode (query, false);
220 sp_paint_selector_set_mode (psel, pselmode);
222 if (query->stroke.set && query->stroke.isPaintserver()) {
224 SPPaintServer *server = SP_STYLE_STROKE_SERVER (query);
226 if (SP_IS_LINEARGRADIENT (server)) {
227 SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
228 sp_paint_selector_set_gradient_linear (psel, vector);
230 SPLinearGradient *lg = SP_LINEARGRADIENT (server);
231 sp_paint_selector_set_gradient_properties (psel,
232 SP_GRADIENT_UNITS (lg),
233 SP_GRADIENT_SPREAD (lg));
234 } else if (SP_IS_RADIALGRADIENT (server)) {
235 SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
236 sp_paint_selector_set_gradient_radial (psel, vector);
238 SPRadialGradient *rg = SP_RADIALGRADIENT (server);
239 sp_paint_selector_set_gradient_properties (psel,
240 SP_GRADIENT_UNITS (rg),
241 SP_GRADIENT_SPREAD (rg));
242 } else if (SP_IS_PATTERN (server)) {
243 SPPattern *pat = pattern_getroot (SP_PATTERN (server));
244 sp_update_pattern_list (psel, pat);
245 }
246 } else if (query->stroke.set && query->stroke.isColor()) {
247 sp_paint_selector_set_color_alpha (psel, &query->stroke.value.color, SP_SCALE24_TO_FLOAT (query->stroke_opacity.value));
249 }
250 break;
251 }
253 case QUERY_STYLE_MULTIPLE_DIFFERENT:
254 {
255 sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
256 break;
257 }
258 }
260 sp_style_unref(query);
262 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
263 }
265 /**
266 * When the mode is changed, invoke a regular changed handler.
267 */
268 static void
269 sp_stroke_style_paint_mode_changed( SPPaintSelector *psel,
270 SPPaintSelectorMode /*mode*/,
271 SPWidget *spw )
272 {
273 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
274 return;
275 }
277 /* TODO: Does this work?
278 * Not really, here we have to get old color back from object
279 * Instead of relying on paint widget having meaningful colors set
280 */
281 sp_stroke_style_paint_changed(psel, spw);
282 }
284 static gchar const *const undo_label_1 = "stroke:flatcolor:1";
285 static gchar const *const undo_label_2 = "stroke:flatcolor:2";
286 static gchar const *undo_label = undo_label_1;
288 /**
289 * When a drag callback occurs on a paint selector object, if it is a RGB or CMYK
290 * color mode, then set the stroke opacity to psel's flat color.
291 */
292 static void
293 sp_stroke_style_paint_dragged(SPPaintSelector *psel, SPWidget *spw)
294 {
295 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
296 return;
297 }
299 switch (psel->mode) {
300 case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
301 case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
302 {
303 sp_paint_selector_set_flat_color (psel, SP_ACTIVE_DESKTOP, "stroke", "stroke-opacity");
304 sp_document_maybe_done (sp_desktop_document(SP_ACTIVE_DESKTOP), undo_label, SP_VERB_DIALOG_FILL_STROKE,
305 _("Set stroke color"));
306 break;
307 }
309 default:
310 g_warning( "file %s: line %d: Paint %d should not emit 'dragged'",
311 __FILE__, __LINE__, psel->mode);
312 break;
313 }
314 }
316 /**
317 * When the stroke style's paint settings change, this handler updates the
318 * repr's stroke css style and applies the style to relevant drawing items.
319 */
320 static void
321 sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
322 {
323 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
324 return;
325 }
326 g_object_set_data (G_OBJECT (spw), "update", GINT_TO_POINTER (TRUE));
328 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
329 SPDocument *document = sp_desktop_document (desktop);
330 Inkscape::Selection *selection = sp_desktop_selection (desktop);
332 GSList const *items = selection->itemList();
334 switch (psel->mode) {
335 case SP_PAINT_SELECTOR_MODE_EMPTY:
336 // This should not happen.
337 g_warning ( "file %s: line %d: Paint %d should not emit 'changed'",
338 __FILE__, __LINE__, psel->mode);
339 break;
340 case SP_PAINT_SELECTOR_MODE_MULTIPLE:
341 // This happens when you switch multiple objects with different gradients to flat color;
342 // nothing to do here.
343 break;
345 case SP_PAINT_SELECTOR_MODE_NONE:
346 {
347 SPCSSAttr *css = sp_repr_css_attr_new();
348 sp_repr_css_set_property(css, "stroke", "none");
350 sp_desktop_set_style (desktop, css);
352 sp_repr_css_attr_unref(css);
354 sp_document_done(document, SP_VERB_DIALOG_FILL_STROKE,
355 _("Remove stroke"));
356 break;
357 }
359 case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
360 case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
361 {
362 sp_paint_selector_set_flat_color (psel, desktop, "stroke", "stroke-opacity");
363 sp_document_maybe_done (sp_desktop_document(desktop), undo_label, SP_VERB_DIALOG_FILL_STROKE,
364 _("Set stroke color"));
366 // on release, toggle undo_label so that the next drag will not be lumped with this one
367 if (undo_label == undo_label_1)
368 undo_label = undo_label_2;
369 else
370 undo_label = undo_label_1;
372 break;
373 }
375 case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
376 case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
377 if (items) {
378 SPGradientType const gradient_type = ( psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR
379 ? SP_GRADIENT_TYPE_LINEAR
380 : SP_GRADIENT_TYPE_RADIAL );
381 SPGradient *vector = sp_paint_selector_get_gradient_vector(psel);
382 if (!vector) {
383 /* No vector in paint selector should mean that we just changed mode */
385 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
386 int result = objects_query_fillstroke ((GSList *) items, query, false);
387 guint32 common_rgb = 0;
388 if (result == QUERY_STYLE_MULTIPLE_SAME) {
389 if (!query->fill.isColor()) {
390 common_rgb = sp_desktop_get_color(desktop, false);
391 } else {
392 common_rgb = query->stroke.value.color.toRGBA32( 0xff );
393 }
394 vector = sp_document_default_gradient_vector(document, common_rgb);
395 }
396 sp_style_unref(query);
398 for (GSList const *i = items; i != NULL; i = i->next) {
399 if (!vector) {
400 sp_item_set_gradient(SP_ITEM(i->data),
401 sp_gradient_vector_for_object(document, desktop, SP_OBJECT(i->data), false),
402 gradient_type, false);
403 } else {
404 sp_item_set_gradient(SP_ITEM(i->data), vector, gradient_type, false);
405 }
406 }
407 } else {
408 vector = sp_gradient_ensure_vector_normalized(vector);
409 for (GSList const *i = items; i != NULL; i = i->next) {
410 SPGradient *gr = sp_item_set_gradient(SP_ITEM(i->data), vector, gradient_type, false);
411 sp_gradient_selector_attrs_to_gradient(gr, psel);
412 }
413 }
415 sp_document_done(document, SP_VERB_DIALOG_FILL_STROKE,
416 _("Set gradient on stroke"));
417 }
418 break;
420 case SP_PAINT_SELECTOR_MODE_PATTERN:
422 if (items) {
424 SPPattern *pattern = sp_paint_selector_get_pattern (psel);
425 if (!pattern) {
427 /* No Pattern in paint selector should mean that we just
428 * changed mode - dont do jack.
429 */
431 } else {
432 Inkscape::XML::Node *patrepr = SP_OBJECT_REPR(pattern);
433 SPCSSAttr *css = sp_repr_css_attr_new ();
434 gchar *urltext = g_strdup_printf ("url(#%s)", patrepr->attribute("id"));
435 sp_repr_css_set_property (css, "stroke", urltext);
437 for (GSList const *i = items; i != NULL; i = i->next) {
438 Inkscape::XML::Node *selrepr = SP_OBJECT_REPR (i->data);
439 SPObject *selobj = SP_OBJECT (i->data);
440 if (!selrepr)
441 continue;
443 SPStyle *style = SP_OBJECT_STYLE (selobj);
444 if (style && style->stroke.isPaintserver()) {
445 SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (selobj);
446 if (SP_IS_PATTERN (server) && pattern_getroot (SP_PATTERN(server)) == pattern)
447 // only if this object's pattern is not rooted in our selected pattern, apply
448 continue;
449 }
451 sp_repr_css_change_recursive (selrepr, css, "style");
452 }
454 sp_repr_css_attr_unref (css);
455 g_free (urltext);
457 } // end if
459 sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE,
460 _("Set pattern on stroke"));
461 } // end if
463 break;
465 case SP_PAINT_SELECTOR_MODE_UNSET:
466 if (items) {
467 SPCSSAttr *css = sp_repr_css_attr_new ();
468 sp_repr_css_unset_property (css, "stroke");
469 sp_repr_css_unset_property (css, "stroke-opacity");
470 sp_repr_css_unset_property (css, "stroke-width");
471 sp_repr_css_unset_property (css, "stroke-miterlimit");
472 sp_repr_css_unset_property (css, "stroke-linejoin");
473 sp_repr_css_unset_property (css, "stroke-linecap");
474 sp_repr_css_unset_property (css, "stroke-dashoffset");
475 sp_repr_css_unset_property (css, "stroke-dasharray");
477 sp_desktop_set_style (desktop, css);
478 sp_repr_css_attr_unref (css);
480 sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE,
481 _("Unset stroke"));
482 }
483 break;
485 default:
486 g_warning( "file %s: line %d: Paint selector should not be in "
487 "mode %d",
488 __FILE__, __LINE__,
489 psel->mode );
490 break;
491 }
493 g_object_set_data (G_OBJECT (spw), "update", GINT_TO_POINTER (FALSE));
494 }
500 /* Line */
502 static void sp_stroke_style_line_construct(SPWidget *spw, gpointer data);
503 static void sp_stroke_style_line_selection_modified (SPWidget *spw,
504 Inkscape::Selection *selection,
505 guint flags,
506 gpointer data);
508 static void sp_stroke_style_line_selection_changed (SPWidget *spw,
509 Inkscape::Selection *selection,
510 gpointer data );
512 static void sp_stroke_style_line_update(SPWidget *spw, Inkscape::Selection *sel);
514 static void sp_stroke_style_set_join_buttons(SPWidget *spw,
515 GtkWidget *active);
517 static void sp_stroke_style_set_cap_buttons(SPWidget *spw,
518 GtkWidget *active);
520 static void sp_stroke_style_width_changed(GtkAdjustment *adj, SPWidget *spw);
521 static void sp_stroke_style_miterlimit_changed(GtkAdjustment *adj, SPWidget *spw);
522 static void sp_stroke_style_any_toggled(GtkToggleButton *tb, SPWidget *spw);
523 static void sp_stroke_style_line_dash_changed(SPDashSelector *dsel,
524 SPWidget *spw);
526 static void sp_stroke_style_update_marker_menus(SPWidget *spw, GSList const *objects);
529 /**
530 * Helper function for creating radio buttons. This should probably be re-thought out
531 * when reimplementing this with Gtkmm.
532 */
533 static GtkWidget *
534 sp_stroke_radio_button(GtkWidget *tb, char const *icon,
535 GtkWidget *hb, GtkWidget *spw,
536 gchar const *key, gchar const *data)
537 {
538 g_assert(icon != NULL);
539 g_assert(hb != NULL);
540 g_assert(spw != NULL);
542 if (tb == NULL) {
543 tb = gtk_radio_button_new(NULL);
544 } else {
545 tb = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(tb)) );
546 }
548 gtk_widget_show(tb);
549 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(tb), FALSE);
550 gtk_box_pack_start(GTK_BOX(hb), tb, FALSE, FALSE, 0);
551 gtk_object_set_data(GTK_OBJECT(spw), icon, tb);
552 gtk_object_set_data(GTK_OBJECT(tb), key, (gpointer*)data);
553 gtk_signal_connect(GTK_OBJECT(tb), "toggled",
554 GTK_SIGNAL_FUNC(sp_stroke_style_any_toggled),
555 spw);
556 GtkWidget *px = sp_icon_new(Inkscape::ICON_SIZE_LARGE_TOOLBAR, icon);
557 g_assert(px != NULL);
558 gtk_widget_show(px);
559 gtk_container_add(GTK_CONTAINER(tb), px);
561 return tb;
563 }
565 static void
566 sp_stroke_style_widget_transientize_callback(Inkscape::Application */*inkscape*/,
567 SPDesktop */*desktop*/,
568 SPWidget */*spw*/ )
569 {
570 // TODO: Either of these will cause crashes sometimes
571 // sp_stroke_style_line_update( SP_WIDGET(spw), desktop ? sp_desktop_selection(desktop) : NULL);
572 // ink_markers_menu_update(spw);
573 }
575 /**
576 * Creates a copy of the marker named mname, determines its visible and renderable
577 * area in menu_id's bounding box, and then renders it. This allows us to fill in
578 * preview images of each marker in the marker menu.
579 */
580 static GtkWidget *
581 sp_marker_prev_new(unsigned psize, gchar const *mname,
582 SPDocument *source, SPDocument *sandbox,
583 gchar const *menu_id, NRArena const */*arena*/, unsigned /*visionkey*/, NRArenaItem *root)
584 {
585 // Retrieve the marker named 'mname' from the source SVG document
586 SPObject const *marker = source->getObjectById(mname);
587 if (marker == NULL)
588 return NULL;
590 // Create a copy repr of the marker with id="sample"
591 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(sandbox);
592 Inkscape::XML::Node *mrepr = SP_OBJECT_REPR (marker)->duplicate(xml_doc);
593 mrepr->setAttribute("id", "sample");
595 // Replace the old sample in the sandbox by the new one
596 Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (sandbox->getObjectById("defs"));
597 SPObject *oldmarker = sandbox->getObjectById("sample");
598 if (oldmarker)
599 oldmarker->deleteObject(false);
600 defsrepr->appendChild(mrepr);
601 Inkscape::GC::release(mrepr);
603 // Uncomment this to get the sandbox documents saved (useful for debugging)
604 //FILE *fp = fopen (g_strconcat(menu_id, mname, ".svg", NULL), "w");
605 //sp_repr_save_stream (sp_document_repr_doc (sandbox), fp);
606 //fclose (fp);
608 // object to render; note that the id is the same as that of the menu we're building
609 SPObject *object = sandbox->getObjectById(menu_id);
610 sp_document_root (sandbox)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
611 sp_document_ensure_up_to_date(sandbox);
613 if (object == NULL || !SP_IS_ITEM(object))
614 return NULL; // sandbox broken?
616 // Find object's bbox in document
617 NR::Matrix const i2doc(sp_item_i2doc_affine(SP_ITEM(object)));
618 NR::Maybe<NR::Rect> dbox = SP_ITEM(object)->getBounds(i2doc);
620 if (!dbox) {
621 return NULL;
622 }
624 /* Update to renderable state */
625 double sf = 0.8;
626 GdkPixbuf* pixbuf = NULL;
628 gchar *cache_name = g_strconcat(menu_id, mname, NULL);
629 Glib::ustring key = svg_preview_cache.cache_key(source->uri, cache_name, psize);
630 g_free (cache_name);
631 pixbuf = svg_preview_cache.get_preview_from_cache(key);
633 if (pixbuf == NULL) {
634 pixbuf = render_pixbuf(root, sf, *dbox, psize);
635 svg_preview_cache.set_preview_in_cache(key, pixbuf);
636 }
638 // Create widget
639 GtkWidget *pb = gtk_image_new_from_pixbuf(pixbuf);
641 return pb;
642 }
645 /**
646 * Returns a list of markers in the defs of the given source document as a GSList object
647 * Returns NULL if there are no markers in the document.
648 */
649 GSList *
650 ink_marker_list_get (SPDocument *source)
651 {
652 if (source == NULL)
653 return NULL;
655 GSList *ml = NULL;
656 SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS (source);
657 for ( SPObject *child = sp_object_first_child(SP_OBJECT(defs));
658 child != NULL;
659 child = SP_OBJECT_NEXT (child) )
660 {
661 if (SP_IS_MARKER(child)) {
662 ml = g_slist_prepend (ml, child);
663 }
664 }
665 return ml;
666 }
668 #define MARKER_ITEM_MARGIN 0
670 /**
671 * Adds previews of markers in marker_list to the given menu widget
672 */
673 static void
674 sp_marker_menu_build (GtkWidget *m, GSList *marker_list, SPDocument *source, SPDocument *sandbox, gchar const *menu_id)
675 {
676 // Do this here, outside of loop, to speed up preview generation:
677 NRArena const *arena = NRArena::create();
678 unsigned const visionkey = sp_item_display_key_new(1);
679 NRArenaItem *root = sp_item_invoke_show( SP_ITEM(SP_DOCUMENT_ROOT (sandbox)), (NRArena *) arena, visionkey, SP_ITEM_SHOW_DISPLAY );
681 for (; marker_list != NULL; marker_list = marker_list->next) {
682 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) marker_list->data);
683 GtkWidget *i = gtk_menu_item_new();
684 gtk_widget_show(i);
686 if (repr->attribute("inkscape:stockid"))
687 g_object_set_data (G_OBJECT(i), "stockid", (void *) "true");
688 else
689 g_object_set_data (G_OBJECT(i), "stockid", (void *) "false");
691 gchar const *markid = repr->attribute("id");
692 g_object_set_data (G_OBJECT(i), "marker", (void *) markid);
694 GtkWidget *hb = gtk_hbox_new(FALSE, MARKER_ITEM_MARGIN);
695 gtk_widget_show(hb);
697 // generate preview
699 GtkWidget *prv = sp_marker_prev_new (22, markid, source, sandbox, menu_id, arena, visionkey, root);
700 gtk_widget_show(prv);
701 gtk_box_pack_start(GTK_BOX(hb), prv, FALSE, FALSE, 6);
703 // create label
704 GtkWidget *l = gtk_label_new(repr->attribute("id"));
705 gtk_widget_show(l);
706 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
708 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
710 gtk_widget_show(hb);
711 gtk_container_add(GTK_CONTAINER(i), hb);
713 gtk_menu_append(GTK_MENU(m), i);
714 }
715 }
717 /**
718 * sp_marker_list_from_doc()
719 *
720 * \brief Pick up all markers from source, except those that are in
721 * current_doc (if non-NULL), and add items to the m menu
722 *
723 */
724 static void
725 sp_marker_list_from_doc (GtkWidget *m, SPDocument */*current_doc*/, SPDocument *source, SPDocument */*markers_doc*/, SPDocument *sandbox, gchar const *menu_id)
726 {
727 GSList *ml = ink_marker_list_get(source);
728 GSList *clean_ml = NULL;
730 for (; ml != NULL; ml = ml->next) {
731 if (!SP_IS_MARKER(ml->data))
732 continue;
734 // Add to the list of markers we really do wish to show
735 clean_ml = g_slist_prepend (clean_ml, ml->data);
736 }
737 sp_marker_menu_build (m, clean_ml, source, sandbox, menu_id);
739 g_slist_free (ml);
740 g_slist_free (clean_ml);
741 }
744 /**
745 * Returns a new document containing default start, mid, and end markers.
746 */
747 SPDocument *
748 ink_markers_preview_doc ()
749 {
750 gchar const *buffer = "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\" xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">"
751 " <defs id=\"defs\" />"
753 " <g id=\"marker-start\">"
754 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:url(#sample);marker-mid:none;marker-end:none\""
755 " d=\"M 12.5,13 L 25,13\" id=\"path1\" />"
756 " <rect style=\"fill:none;stroke:none\" id=\"rect2\""
757 " width=\"25\" height=\"25\" x=\"0\" y=\"0\" />"
758 " </g>"
760 " <g id=\"marker-mid\">"
761 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:none;marker-mid:url(#sample);marker-end:none\""
762 " d=\"M 0,113 L 12.5,113 L 25,113\" id=\"path11\" />"
763 " <rect style=\"fill:none;stroke:none\" id=\"rect22\""
764 " width=\"25\" height=\"25\" x=\"0\" y=\"100\" />"
765 " </g>"
767 " <g id=\"marker-end\">"
768 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:none;marker-mid:none;marker-end:url(#sample)\""
769 " d=\"M 0,213 L 12.5,213\" id=\"path111\" />"
770 " <rect style=\"fill:none;stroke:none\" id=\"rect222\""
771 " width=\"25\" height=\"25\" x=\"0\" y=\"200\" />"
772 " </g>"
774 "</svg>";
776 return sp_document_new_from_mem (buffer, strlen(buffer), FALSE);
777 }
779 static void
780 ink_marker_menu_create_menu(GtkWidget *m, gchar const *menu_id, SPDocument *doc, SPDocument *sandbox)
781 {
782 static SPDocument *markers_doc = NULL;
784 // add "None"
785 GtkWidget *i = gtk_menu_item_new();
786 gtk_widget_show(i);
788 g_object_set_data(G_OBJECT(i), "marker", (void *) "none");
790 GtkWidget *hb = gtk_hbox_new(FALSE, MARKER_ITEM_MARGIN);
791 gtk_widget_show(hb);
793 GtkWidget *l = gtk_label_new( _("None") );
794 gtk_widget_show(l);
795 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
797 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
799 gtk_widget_show(hb);
800 gtk_container_add(GTK_CONTAINER(i), hb);
801 gtk_menu_append(GTK_MENU(m), i);
803 // find and load markers.svg
804 if (markers_doc == NULL) {
805 char *markers_source = g_build_filename(INKSCAPE_MARKERSDIR, "markers.svg", NULL);
806 if (Inkscape::IO::file_test(markers_source, G_FILE_TEST_IS_REGULAR)) {
807 markers_doc = sp_document_new(markers_source, FALSE);
808 }
809 g_free(markers_source);
810 }
812 // suck in from current doc
813 sp_marker_list_from_doc ( m, NULL, doc, markers_doc, sandbox, menu_id );
815 // add separator
816 {
817 GtkWidget *i = gtk_separator_menu_item_new();
818 gtk_widget_show(i);
819 gtk_menu_append(GTK_MENU(m), i);
820 }
822 // suck in from markers.svg
823 if (markers_doc) {
824 sp_document_ensure_up_to_date(doc);
825 sp_marker_list_from_doc ( m, doc, markers_doc, NULL, sandbox, menu_id );
826 }
828 }
831 /**
832 * Creates a menu widget to display markers from markers.svg
833 */
834 static GtkWidget *
835 ink_marker_menu( GtkWidget */*tbl*/, gchar const *menu_id, SPDocument *sandbox)
836 {
837 SPDesktop *desktop = inkscape_active_desktop();
838 SPDocument *doc = sp_desktop_document(desktop);
839 GtkWidget *mnu = gtk_option_menu_new();
841 /* Create new menu widget */
842 GtkWidget *m = gtk_menu_new();
843 gtk_widget_show(m);
845 g_object_set_data(G_OBJECT(mnu), "updating", (gpointer) FALSE);
847 if (!doc) {
848 GtkWidget *i = gtk_menu_item_new_with_label(_("No document selected"));
849 gtk_widget_show(i);
850 gtk_menu_append(GTK_MENU(m), i);
851 gtk_widget_set_sensitive(mnu, FALSE);
853 } else {
854 ink_marker_menu_create_menu(m, menu_id, doc, sandbox);
856 gtk_widget_set_sensitive(mnu, TRUE);
857 }
859 gtk_object_set_data(GTK_OBJECT(mnu), "menu_id", const_cast<gchar *>(menu_id));
860 gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
862 /* Set history */
863 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
865 return mnu;
866 }
869 /**
870 * Handles when user selects one of the markers from the marker menu.
871 * Defines a uri string to refer to it, then applies it to all selected
872 * items in the current desktop.
873 */
874 static void
875 sp_marker_select(GtkOptionMenu *mnu, GtkWidget *spw)
876 {
877 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
878 return;
879 }
881 SPDesktop *desktop = inkscape_active_desktop();
882 SPDocument *document = sp_desktop_document(desktop);
883 if (!document) {
884 return;
885 }
887 /* Get Marker */
888 if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
889 "marker"))
890 {
891 return;
892 }
893 gchar *markid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
894 "marker");
895 gchar const *marker = "";
896 if (strcmp(markid, "none")){
897 gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
898 "stockid");
900 gchar *markurn = markid;
901 if (!strcmp(stockid,"true")) markurn = g_strconcat("urn:inkscape:marker:",markid,NULL);
902 SPObject *mark = get_stock_item(markurn);
903 if (mark) {
904 Inkscape::XML::Node *repr = SP_OBJECT_REPR(mark);
905 marker = g_strconcat("url(#", repr->attribute("id"), ")", NULL);
906 }
907 } else {
908 marker = markid;
909 }
911 SPCSSAttr *css = sp_repr_css_attr_new();
912 gchar const *menu_id = (gchar const *) g_object_get_data(G_OBJECT(mnu), "menu_id");
913 sp_repr_css_set_property(css, menu_id, marker);
915 // Also update the marker dropdown menus, so the document's markers
916 // show up at the top of the menu
917 // sp_stroke_style_line_update( SP_WIDGET(spw), desktop ? sp_desktop_selection(desktop) : NULL);
918 ink_markers_menu_update(SP_WIDGET(spw));
920 Inkscape::Selection *selection = sp_desktop_selection(desktop);
921 GSList const *items = selection->itemList();
922 for (; items != NULL; items = items->next) {
923 SPItem *item = (SPItem *) items->data;
924 if (!SP_IS_SHAPE(item) || SP_IS_RECT(item)) // can't set marker to rect, until it's converted to using <path>
925 continue;
926 Inkscape::XML::Node *selrepr = SP_OBJECT_REPR((SPItem *) items->data);
927 if (selrepr) {
928 sp_repr_css_change_recursive(selrepr, css, "style");
929 }
930 SP_OBJECT(items->data)->requestModified(SP_OBJECT_MODIFIED_FLAG);
931 SP_OBJECT(items->data)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
932 }
934 sp_repr_css_attr_unref(css);
936 sp_document_done(document, SP_VERB_DIALOG_FILL_STROKE,
937 _("Set markers"));
939 };
941 static int
942 ink_marker_menu_get_pos(GtkMenu *mnu, gchar const *markname)
943 {
944 if (markname == NULL)
945 markname = (gchar const *) g_object_get_data(G_OBJECT(gtk_menu_get_active(mnu)), "marker");
947 if (markname == NULL)
948 return 0;
950 GList const *kids = GTK_MENU_SHELL(mnu)->children;
951 int i = 0;
952 for (; kids != NULL; kids = kids->next) {
953 gchar const *mark = (gchar const *) g_object_get_data(G_OBJECT(kids->data), "marker");
954 if ( mark && strcmp(mark, markname) == 0 ) {
955 break;
956 }
957 i++;
958 }
959 return i;
960 }
962 static void
963 ink_markers_menu_update(SPWidget* spw) {
964 SPDesktop *desktop = inkscape_active_desktop();
965 SPDocument *document = sp_desktop_document(desktop);
966 SPDocument *sandbox = ink_markers_preview_doc ();
967 GtkWidget *m;
968 int pos;
970 gtk_signal_handler_block_by_func( GTK_OBJECT(marker_start_menu), GTK_SIGNAL_FUNC(sp_marker_select), spw);
971 pos = ink_marker_menu_get_pos(GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(marker_start_menu))), NULL);
972 m = gtk_menu_new();
973 gtk_widget_show(m);
974 ink_marker_menu_create_menu(m, "marker-start", document, sandbox);
975 gtk_option_menu_remove_menu(GTK_OPTION_MENU(marker_start_menu));
976 gtk_option_menu_set_menu(GTK_OPTION_MENU(marker_start_menu), m);
977 gtk_option_menu_set_history(GTK_OPTION_MENU(marker_start_menu), pos);
978 gtk_signal_handler_unblock_by_func( GTK_OBJECT(marker_start_menu), GTK_SIGNAL_FUNC(sp_marker_select), spw);
980 gtk_signal_handler_block_by_func( GTK_OBJECT(marker_mid_menu), GTK_SIGNAL_FUNC(sp_marker_select), spw);
981 pos = ink_marker_menu_get_pos(GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(marker_mid_menu))), NULL);
982 m = gtk_menu_new();
983 gtk_widget_show(m);
984 ink_marker_menu_create_menu(m, "marker-mid", document, sandbox);
985 gtk_option_menu_remove_menu(GTK_OPTION_MENU(marker_mid_menu));
986 gtk_option_menu_set_menu(GTK_OPTION_MENU(marker_mid_menu), m);
987 gtk_option_menu_set_history(GTK_OPTION_MENU(marker_mid_menu), pos);
988 gtk_signal_handler_unblock_by_func( GTK_OBJECT(marker_mid_menu), GTK_SIGNAL_FUNC(sp_marker_select), spw);
990 gtk_signal_handler_block_by_func( GTK_OBJECT(marker_end_menu), GTK_SIGNAL_FUNC(sp_marker_select), spw);
991 pos = ink_marker_menu_get_pos(GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(marker_end_menu))), NULL);
992 m = gtk_menu_new();
993 gtk_widget_show(m);
994 ink_marker_menu_create_menu(m, "marker-end", document, sandbox);
995 gtk_option_menu_remove_menu(GTK_OPTION_MENU(marker_end_menu));
996 gtk_option_menu_set_menu(GTK_OPTION_MENU(marker_end_menu), m);
997 gtk_option_menu_set_history(GTK_OPTION_MENU(marker_end_menu), pos);
998 gtk_signal_handler_unblock_by_func( GTK_OBJECT(marker_end_menu), GTK_SIGNAL_FUNC(sp_marker_select), spw);
999 }
1001 /**
1002 * Sets the stroke width units for all selected items.
1003 * Also handles absolute and dimensionless units.
1004 */
1005 static gboolean stroke_width_set_unit(SPUnitSelector *,
1006 SPUnit const *old,
1007 SPUnit const *new_units,
1008 GObject *spw)
1009 {
1010 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1012 if (!desktop) {
1013 return FALSE;
1014 }
1016 Inkscape::Selection *selection = sp_desktop_selection (desktop);
1018 if (selection->isEmpty())
1019 return FALSE;
1021 GSList const *objects = selection->itemList();
1023 if ((old->base == SP_UNIT_ABSOLUTE || old->base == SP_UNIT_DEVICE) &&
1024 (new_units->base == SP_UNIT_DIMENSIONLESS)) {
1026 /* Absolute to percentage */
1027 g_object_set_data (spw, "update", GUINT_TO_POINTER (TRUE));
1029 GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data (spw, "width"));
1030 float w = sp_units_get_pixels (a->value, *old);
1032 gdouble average = stroke_average_width (objects);
1034 if (average == NR_HUGE || average == 0)
1035 return FALSE;
1037 gtk_adjustment_set_value (a, 100.0 * w / average);
1039 g_object_set_data (spw, "update", GUINT_TO_POINTER (FALSE));
1040 return TRUE;
1042 } else if ((old->base == SP_UNIT_DIMENSIONLESS) &&
1043 (new_units->base == SP_UNIT_ABSOLUTE || new_units->base == SP_UNIT_DEVICE)) {
1045 /* Percentage to absolute */
1046 g_object_set_data (spw, "update", GUINT_TO_POINTER (TRUE));
1048 GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data (spw, "width"));
1050 gdouble average = stroke_average_width (objects);
1052 gtk_adjustment_set_value (a, sp_pixels_get_units (0.01 * a->value * average, *new_units));
1054 g_object_set_data (spw, "update", GUINT_TO_POINTER (FALSE));
1055 return TRUE;
1056 }
1058 return FALSE;
1059 }
1062 /**
1063 * \brief Creates a new widget for the line stroke style.
1064 *
1065 */
1066 GtkWidget *
1067 sp_stroke_style_line_widget_new(void)
1068 {
1069 GtkWidget *spw, *f, *t, *hb, *sb, *us, *tb, *ds;
1070 GtkObject *a;
1072 GtkTooltips *tt = gtk_tooltips_new();
1074 spw = sp_widget_new_global(INKSCAPE);
1076 f = gtk_hbox_new (FALSE, 0);
1077 gtk_widget_show(f);
1078 gtk_container_add(GTK_CONTAINER(spw), f);
1080 t = gtk_table_new(3, 6, FALSE);
1081 gtk_widget_show(t);
1082 gtk_container_set_border_width(GTK_CONTAINER(t), 4);
1083 gtk_table_set_row_spacings(GTK_TABLE(t), 4);
1084 gtk_container_add(GTK_CONTAINER(f), t);
1085 gtk_object_set_data(GTK_OBJECT(spw), "stroke", t);
1087 gint i = 0;
1089 /* Stroke width */
1090 spw_label(t, _("Width:"), 0, i);
1092 hb = spw_hbox(t, 3, 1, i);
1094 // TODO: when this is gtkmmified, use an Inkscape::UI::Widget::ScalarUnit instead of the separate
1095 // spinbutton and unit selector for stroke width. In sp_stroke_style_line_update, use
1096 // setHundredPercent to remember the aeraged width corresponding to 100%. Then the
1097 // stroke_width_set_unit will be removed (because ScalarUnit takes care of conversions itself), and
1098 // with it, the two remaining calls of stroke_average_width, allowing us to get rid of that
1099 // function in desktop-style.
1101 a = gtk_adjustment_new(1.0, 0.0, 1000.0, 0.1, 10.0, 10.0);
1102 gtk_object_set_data(GTK_OBJECT(spw), "width", a);
1103 sb = gtk_spin_button_new(GTK_ADJUSTMENT(a), 0.1, 3);
1104 gtk_tooltips_set_tip(tt, sb, _("Stroke width"), NULL);
1105 gtk_widget_show(sb);
1107 sp_dialog_defocus_on_enter(sb);
1109 gtk_box_pack_start(GTK_BOX(hb), sb, FALSE, FALSE, 0);
1110 us = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
1111 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1112 if (desktop)
1113 sp_unit_selector_set_unit (SP_UNIT_SELECTOR(us), sp_desktop_namedview(desktop)->doc_units);
1114 sp_unit_selector_add_unit(SP_UNIT_SELECTOR(us), &sp_unit_get_by_id(SP_UNIT_PERCENT), 0);
1115 g_signal_connect ( G_OBJECT (us), "set_unit", G_CALLBACK (stroke_width_set_unit), spw );
1116 gtk_widget_show(us);
1117 sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), GTK_ADJUSTMENT(a) );
1118 gtk_box_pack_start(GTK_BOX(hb), us, FALSE, FALSE, 0);
1119 gtk_object_set_data(GTK_OBJECT(spw), "units", us);
1121 gtk_signal_connect( GTK_OBJECT(a), "value_changed", GTK_SIGNAL_FUNC(sp_stroke_style_width_changed), spw );
1122 i++;
1124 /* Join type */
1125 // TRANSLATORS: The line join style specifies the shape to be used at the
1126 // corners of paths. It can be "miter", "round" or "bevel".
1127 spw_label(t, _("Join:"), 0, i);
1129 hb = spw_hbox(t, 3, 1, i);
1131 tb = NULL;
1133 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_MITER,
1134 hb, spw, "join", "miter");
1136 // TRANSLATORS: Miter join: joining lines with a sharp (pointed) corner.
1137 // For an example, draw a triangle with a large stroke width and modify the
1138 // "Join" option (in the Fill and Stroke dialog).
1139 gtk_tooltips_set_tip(tt, tb, _("Miter join"), NULL);
1141 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_ROUND,
1142 hb, spw, "join", "round");
1144 // TRANSLATORS: Round join: joining lines with a rounded corner.
1145 // For an example, draw a triangle with a large stroke width and modify the
1146 // "Join" option (in the Fill and Stroke dialog).
1147 gtk_tooltips_set_tip(tt, tb, _("Round join"), NULL);
1149 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_BEVEL,
1150 hb, spw, "join", "bevel");
1152 // TRANSLATORS: Bevel join: joining lines with a blunted (flattened) corner.
1153 // For an example, draw a triangle with a large stroke width and modify the
1154 // "Join" option (in the Fill and Stroke dialog).
1155 gtk_tooltips_set_tip(tt, tb, _("Bevel join"), NULL);
1157 i++;
1159 /* Miterlimit */
1160 // TRANSLATORS: Miter limit: only for "miter join", this limits the length
1161 // of the sharp "spike" when the lines connect at too sharp an angle.
1162 // When two line segments meet at a sharp angle, a miter join results in a
1163 // spike that extends well beyond the connection point. The purpose of the
1164 // miter limit is to cut off such spikes (i.e. convert them into bevels)
1165 // when they become too long.
1166 spw_label(t, _("Miter limit:"), 0, i);
1168 hb = spw_hbox(t, 3, 1, i);
1170 a = gtk_adjustment_new(4.0, 0.0, 100.0, 0.1, 10.0, 10.0);
1171 gtk_object_set_data(GTK_OBJECT(spw), "miterlimit", a);
1173 sb = gtk_spin_button_new(GTK_ADJUSTMENT(a), 0.1, 2);
1174 gtk_tooltips_set_tip(tt, sb, _("Maximum length of the miter (in units of stroke width)"), NULL);
1175 gtk_widget_show(sb);
1176 gtk_object_set_data(GTK_OBJECT(spw), "miterlimit_sb", sb);
1177 sp_dialog_defocus_on_enter(sb);
1179 gtk_box_pack_start(GTK_BOX(hb), sb, FALSE, FALSE, 0);
1181 gtk_signal_connect( GTK_OBJECT(a), "value_changed",
1182 GTK_SIGNAL_FUNC(sp_stroke_style_miterlimit_changed), spw );
1183 i++;
1185 /* Cap type */
1186 // TRANSLATORS: cap type specifies the shape for the ends of lines
1187 spw_label(t, _("Cap:"), 0, i);
1189 hb = spw_hbox(t, 3, 1, i);
1191 tb = NULL;
1193 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_BUTT,
1194 hb, spw, "cap", "butt");
1196 // TRANSLATORS: Butt cap: the line shape does not extend beyond the end point
1197 // of the line; the ends of the line are square
1198 gtk_tooltips_set_tip(tt, tb, _("Butt cap"), NULL);
1200 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_ROUND,
1201 hb, spw, "cap", "round");
1203 // TRANSLATORS: Round cap: the line shape extends beyond the end point of the
1204 // line; the ends of the line are rounded
1205 gtk_tooltips_set_tip(tt, tb, _("Round cap"), NULL);
1207 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_SQUARE,
1208 hb, spw, "cap", "square");
1210 // TRANSLATORS: Square cap: the line shape extends beyond the end point of the
1211 // line; the ends of the line are square
1212 gtk_tooltips_set_tip(tt, tb, _("Square cap"), NULL);
1214 i++;
1217 /* Dash */
1218 spw_label(t, _("Dashes:"), 0, i);
1219 ds = sp_dash_selector_new( inkscape_get_repr( INKSCAPE,
1220 "palette.dashes") );
1222 gtk_widget_show(ds);
1223 gtk_table_attach( GTK_TABLE(t), ds, 1, 4, i, i+1,
1224 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1225 (GtkAttachOptions)0, 0, 0 );
1226 gtk_object_set_data(GTK_OBJECT(spw), "dash", ds);
1227 gtk_signal_connect( GTK_OBJECT(ds), "changed",
1228 GTK_SIGNAL_FUNC(sp_stroke_style_line_dash_changed),
1229 spw );
1230 i++;
1232 /* Drop down marker selectors*/
1234 // doing this here once, instead of for each preview, to speed things up
1235 SPDocument *sandbox = ink_markers_preview_doc ();
1237 // TRANSLATORS: Path markers are an SVG feature that allows you to attach arbitrary shapes
1238 // (arrowheads, bullets, faces, whatever) to the start, end, or middle nodes of a path.
1239 spw_label(t, _("Start Markers:"), 0, i);
1240 marker_start_menu = ink_marker_menu( spw ,"marker-start", sandbox);
1241 gtk_signal_connect( GTK_OBJECT(marker_start_menu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1242 gtk_widget_show(marker_start_menu);
1243 gtk_table_attach( GTK_TABLE(t), marker_start_menu, 1, 4, i, i+1,
1244 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1245 (GtkAttachOptions)0, 0, 0 );
1246 gtk_object_set_data(GTK_OBJECT(spw), "start_mark_menu", marker_start_menu);
1248 i++;
1249 spw_label(t, _("Mid Markers:"), 0, i);
1250 marker_mid_menu = ink_marker_menu( spw ,"marker-mid", sandbox);
1251 gtk_signal_connect( GTK_OBJECT(marker_mid_menu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1252 gtk_widget_show(marker_mid_menu);
1253 gtk_table_attach( GTK_TABLE(t), marker_mid_menu, 1, 4, i, i+1,
1254 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1255 (GtkAttachOptions)0, 0, 0 );
1256 gtk_object_set_data(GTK_OBJECT(spw), "mid_mark_menu", marker_mid_menu);
1258 i++;
1259 spw_label(t, _("End Markers:"), 0, i);
1260 marker_end_menu = ink_marker_menu( spw ,"marker-end", sandbox);
1261 gtk_signal_connect( GTK_OBJECT(marker_end_menu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1262 gtk_widget_show(marker_end_menu);
1263 gtk_table_attach( GTK_TABLE(t), marker_end_menu, 1, 4, i, i+1,
1264 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1265 (GtkAttachOptions)0, 0, 0 );
1266 gtk_object_set_data(GTK_OBJECT(spw), "end_mark_menu", marker_end_menu);
1268 i++;
1270 gtk_signal_connect( GTK_OBJECT(spw), "construct",
1271 GTK_SIGNAL_FUNC(sp_stroke_style_line_construct),
1272 NULL );
1273 gtk_signal_connect( GTK_OBJECT(spw), "modify_selection",
1274 GTK_SIGNAL_FUNC(sp_stroke_style_line_selection_modified),
1275 NULL );
1276 gtk_signal_connect( GTK_OBJECT(spw), "change_selection",
1277 GTK_SIGNAL_FUNC(sp_stroke_style_line_selection_changed),
1278 NULL );
1280 sp_stroke_style_line_update( SP_WIDGET(spw), desktop ? sp_desktop_selection(desktop) : NULL);
1282 return spw;
1283 }
1286 /**
1287 * Callback for when the stroke style widget is called. It causes
1288 * the stroke line style to be updated.
1289 */
1290 static void
1291 sp_stroke_style_line_construct(SPWidget *spw, gpointer /*data*/)
1292 {
1293 #ifdef SP_SS_VERBOSE
1294 g_print( "Stroke style widget constructed: inkscape %p repr %p\n",
1295 spw->inkscape, spw->repr );
1296 #endif
1297 if (spw->inkscape) {
1298 sp_stroke_style_line_update(spw,
1299 ( SP_ACTIVE_DESKTOP
1300 ? sp_desktop_selection(SP_ACTIVE_DESKTOP)
1301 : NULL ));
1302 }
1303 }
1305 /**
1306 * Callback for when stroke style widget is modified.
1307 * Triggers update action.
1308 */
1309 static void
1310 sp_stroke_style_line_selection_modified( SPWidget *spw,
1311 Inkscape::Selection *selection,
1312 guint flags,
1313 gpointer /*data*/ )
1314 {
1315 if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG)) {
1316 sp_stroke_style_line_update (spw, selection);
1317 }
1319 }
1321 /**
1322 * Callback for when stroke style widget is changed.
1323 * Triggers update action.
1324 */
1325 static void
1326 sp_stroke_style_line_selection_changed( SPWidget *spw,
1327 Inkscape::Selection *selection,
1328 gpointer /*data*/ )
1329 {
1330 sp_stroke_style_line_update (spw, selection);
1331 }
1334 /**
1335 * Sets selector widgets' dash style from an SPStyle object.
1336 */
1337 static void
1338 sp_dash_selector_set_from_style (GtkWidget *dsel, SPStyle *style)
1339 {
1340 if (style->stroke_dash.n_dash > 0) {
1341 double d[64];
1342 int len = MIN(style->stroke_dash.n_dash, 64);
1343 for (int i = 0; i < len; i++) {
1344 if (style->stroke_width.computed != 0)
1345 d[i] = style->stroke_dash.dash[i] / style->stroke_width.computed;
1346 else
1347 d[i] = style->stroke_dash.dash[i]; // is there a better thing to do for stroke_width==0?
1348 }
1349 sp_dash_selector_set_dash(SP_DASH_SELECTOR(dsel), len, d,
1350 style->stroke_width.computed != 0?
1351 style->stroke_dash.offset / style->stroke_width.computed :
1352 style->stroke_dash.offset);
1353 } else {
1354 sp_dash_selector_set_dash(SP_DASH_SELECTOR(dsel), 0, NULL, 0.0);
1355 }
1356 }
1358 /**
1359 * Sets the join type for a line, and updates the stroke style widget's buttons
1360 */
1361 static void
1362 sp_jointype_set (SPWidget *spw, unsigned const jointype)
1363 {
1364 GtkWidget *tb = NULL;
1365 switch (jointype) {
1366 case SP_STROKE_LINEJOIN_MITER:
1367 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_MITER));
1368 break;
1369 case SP_STROKE_LINEJOIN_ROUND:
1370 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_ROUND));
1371 break;
1372 case SP_STROKE_LINEJOIN_BEVEL:
1373 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_BEVEL));
1374 break;
1375 default:
1376 break;
1377 }
1378 sp_stroke_style_set_join_buttons (spw, tb);
1379 }
1381 /**
1382 * Sets the cap type for a line, and updates the stroke style widget's buttons
1383 */
1384 static void
1385 sp_captype_set (SPWidget *spw, unsigned const captype)
1386 {
1387 GtkWidget *tb = NULL;
1388 switch (captype) {
1389 case SP_STROKE_LINECAP_BUTT:
1390 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_BUTT));
1391 break;
1392 case SP_STROKE_LINECAP_ROUND:
1393 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_ROUND));
1394 break;
1395 case SP_STROKE_LINECAP_SQUARE:
1396 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_SQUARE));
1397 break;
1398 default:
1399 break;
1400 }
1401 sp_stroke_style_set_cap_buttons (spw, tb);
1402 }
1404 /**
1405 * Callback for when stroke style widget is updated, including markers, cap type,
1406 * join type, etc.
1407 */
1408 static void
1409 sp_stroke_style_line_update(SPWidget *spw, Inkscape::Selection *sel)
1410 {
1411 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1412 return;
1413 }
1415 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
1417 GtkWidget *sset = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "stroke"));
1418 GtkObject *width = GTK_OBJECT(gtk_object_get_data(GTK_OBJECT(spw), "width"));
1419 GtkObject *ml = GTK_OBJECT(gtk_object_get_data(GTK_OBJECT(spw), "miterlimit"));
1420 GtkWidget *us = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "units"));
1421 GtkWidget *dsel = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "dash"));
1423 // create temporary style
1424 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
1425 // query into it
1426 int result_sw = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEWIDTH);
1427 int result_ml = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEMITERLIMIT);
1428 int result_cap = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKECAP);
1429 int result_join = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEJOIN);
1431 if (result_sw == QUERY_STYLE_NOTHING) {
1432 /* No objects stroked, set insensitive */
1433 gtk_widget_set_sensitive(sset, FALSE);
1435 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
1436 return;
1437 } else {
1438 gtk_widget_set_sensitive(sset, TRUE);
1440 SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
1442 if (result_sw == QUERY_STYLE_MULTIPLE_AVERAGED) {
1443 sp_unit_selector_set_unit(SP_UNIT_SELECTOR(us), &sp_unit_get_by_id(SP_UNIT_PERCENT));
1444 } else {
1445 // same width, or only one object; no sense to keep percent, switch to absolute
1446 if (unit->base != SP_UNIT_ABSOLUTE && unit->base != SP_UNIT_DEVICE) {
1447 sp_unit_selector_set_unit(SP_UNIT_SELECTOR(us), sp_desktop_namedview(SP_ACTIVE_DESKTOP)->doc_units);
1448 }
1449 }
1451 unit = sp_unit_selector_get_unit (SP_UNIT_SELECTOR (us));
1453 if (unit->base == SP_UNIT_ABSOLUTE || unit->base == SP_UNIT_DEVICE) {
1454 double avgwidth = sp_pixels_get_units (query->stroke_width.computed, *unit);
1455 gtk_adjustment_set_value(GTK_ADJUSTMENT(width), avgwidth);
1456 } else {
1457 gtk_adjustment_set_value(GTK_ADJUSTMENT(width), 100);
1458 }
1459 }
1461 if (result_ml != QUERY_STYLE_NOTHING)
1462 gtk_adjustment_set_value(GTK_ADJUSTMENT(ml), query->stroke_miterlimit.value); // TODO: reflect averagedness?
1464 if (result_join != QUERY_STYLE_MULTIPLE_DIFFERENT) {
1465 sp_jointype_set (spw, query->stroke_linejoin.value);
1466 } else {
1467 sp_stroke_style_set_join_buttons(spw, NULL);
1468 }
1470 if (result_cap != QUERY_STYLE_MULTIPLE_DIFFERENT) {
1471 sp_captype_set (spw, query->stroke_linecap.value);
1472 } else {
1473 sp_stroke_style_set_cap_buttons(spw, NULL);
1474 }
1476 sp_style_unref(query);
1478 if (!sel || sel->isEmpty())
1479 return;
1481 GSList const *objects = sel->itemList();
1482 SPObject * const object = SP_OBJECT(objects->data);
1483 SPStyle * const style = SP_OBJECT_STYLE(object);
1485 /* Markers */
1486 sp_stroke_style_update_marker_menus(spw, objects); // FIXME: make this desktop query too
1488 /* Dash */
1489 sp_dash_selector_set_from_style (dsel, style); // FIXME: make this desktop query too
1491 gtk_widget_set_sensitive(sset, TRUE);
1493 gtk_object_set_data(GTK_OBJECT(spw), "update",
1494 GINT_TO_POINTER(FALSE));
1495 }
1497 /**
1498 * Sets a line's dash properties in a CSS style object.
1499 */
1500 static void
1501 sp_stroke_style_set_scaled_dash(SPCSSAttr *css,
1502 int ndash, double *dash, double offset,
1503 double scale)
1504 {
1505 if (ndash > 0) {
1506 Inkscape::CSSOStringStream osarray;
1507 for (int i = 0; i < ndash; i++) {
1508 osarray << dash[i] * scale;
1509 if (i < (ndash - 1)) {
1510 osarray << ",";
1511 }
1512 }
1513 sp_repr_css_set_property(css, "stroke-dasharray", osarray.str().c_str());
1515 Inkscape::CSSOStringStream osoffset;
1516 osoffset << offset * scale;
1517 sp_repr_css_set_property(css, "stroke-dashoffset", osoffset.str().c_str());
1518 } else {
1519 sp_repr_css_set_property(css, "stroke-dasharray", "none");
1520 sp_repr_css_set_property(css, "stroke-dashoffset", NULL);
1521 }
1522 }
1524 /**
1525 * Sets line properties like width, dashes, markers, etc. on all currently selected items.
1526 */
1527 static void
1528 sp_stroke_style_scale_line(SPWidget *spw)
1529 {
1530 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1531 return;
1532 }
1534 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
1536 GtkAdjustment *wadj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(spw), "width"));
1537 SPUnitSelector *us = SP_UNIT_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "units"));
1538 SPDashSelector *dsel = SP_DASH_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "dash"));
1539 GtkAdjustment *ml = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(spw), "miterlimit"));
1541 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1542 SPDocument *document = sp_desktop_document (desktop);
1543 Inkscape::Selection *selection = sp_desktop_selection (desktop);
1545 GSList const *items = selection->itemList();
1547 /* TODO: Create some standardized method */
1548 SPCSSAttr *css = sp_repr_css_attr_new();
1550 if (items) {
1552 double width_typed = wadj->value;
1553 double const miterlimit = ml->value;
1555 SPUnit const *const unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
1557 double *dash, offset;
1558 int ndash;
1559 sp_dash_selector_get_dash(dsel, &ndash, &dash, &offset);
1561 for (GSList const *i = items; i != NULL; i = i->next) {
1562 /* Set stroke width */
1563 double width;
1564 if (unit->base == SP_UNIT_ABSOLUTE || unit->base == SP_UNIT_DEVICE) {
1565 width = sp_units_get_pixels (width_typed, *unit);
1566 } else { // percentage
1567 gdouble old_w = SP_OBJECT_STYLE (i->data)->stroke_width.computed;
1568 width = old_w * width_typed / 100;
1569 }
1571 {
1572 Inkscape::CSSOStringStream os_width;
1573 os_width << width;
1574 sp_repr_css_set_property(css, "stroke-width", os_width.str().c_str());
1575 }
1577 {
1578 Inkscape::CSSOStringStream os_ml;
1579 os_ml << miterlimit;
1580 sp_repr_css_set_property(css, "stroke-miterlimit", os_ml.str().c_str());
1581 }
1583 /* Set dash */
1584 sp_stroke_style_set_scaled_dash(css, ndash, dash, offset, width);
1586 sp_desktop_apply_css_recursive (SP_OBJECT(i->data), css, true);
1587 }
1589 g_free(dash);
1591 if (unit->base != SP_UNIT_ABSOLUTE && unit->base != SP_UNIT_DEVICE) {
1592 // reset to 100 percent
1593 gtk_adjustment_set_value (wadj, 100.0);
1594 }
1596 }
1598 // we have already changed the items, so set style without changing selection
1599 // FIXME: move the above stroke-setting stuff, including percentages, to desktop-style
1600 sp_desktop_set_style (desktop, css, false);
1602 sp_repr_css_attr_unref(css);
1604 sp_document_done(document, SP_VERB_DIALOG_FILL_STROKE,
1605 _("Set stroke style"));
1607 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
1608 }
1611 /**
1612 * Callback for when the stroke style's width changes.
1613 * Causes all line styles to be applied to all selected items.
1614 */
1615 static void
1616 sp_stroke_style_width_changed(GtkAdjustment */*adj*/, SPWidget *spw)
1617 {
1618 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1619 return;
1620 }
1622 sp_stroke_style_scale_line(spw);
1623 }
1625 /**
1626 * Callback for when the stroke style's miterlimit changes.
1627 * Causes all line styles to be applied to all selected items.
1628 */
1629 static void
1630 sp_stroke_style_miterlimit_changed(GtkAdjustment */*adj*/, SPWidget *spw)
1631 {
1632 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1633 return;
1634 }
1636 sp_stroke_style_scale_line(spw);
1637 }
1639 /**
1640 * Callback for when the stroke style's dash changes.
1641 * Causes all line styles to be applied to all selected items.
1642 */
1643 static void
1644 sp_stroke_style_line_dash_changed(SPDashSelector */*dsel*/, SPWidget *spw)
1645 {
1646 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1647 return;
1648 }
1650 sp_stroke_style_scale_line(spw);
1651 }
1655 /**
1656 * \brief This routine handles toggle events for buttons in the stroke style
1657 * dialog.
1658 * When activated, this routine gets the data for the various widgets, and then
1659 * calls the respective routines to update css properties, etc.
1660 *
1661 */
1662 static void
1663 sp_stroke_style_any_toggled(GtkToggleButton *tb, SPWidget *spw)
1664 {
1665 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1666 return;
1667 }
1669 if (gtk_toggle_button_get_active(tb)) {
1671 gchar const *join
1672 = static_cast<gchar const *>(gtk_object_get_data(GTK_OBJECT(tb), "join"));
1673 gchar const *cap
1674 = static_cast<gchar const *>(gtk_object_get_data(GTK_OBJECT(tb), "cap"));
1676 if (join) {
1677 GtkWidget *ml = GTK_WIDGET(g_object_get_data(G_OBJECT(spw), "miterlimit_sb"));
1678 gtk_widget_set_sensitive (ml, !strcmp(join, "miter"));
1679 }
1681 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1683 /* TODO: Create some standardized method */
1684 SPCSSAttr *css = sp_repr_css_attr_new();
1686 if (join) {
1687 sp_repr_css_set_property(css, "stroke-linejoin", join);
1689 sp_desktop_set_style (desktop, css);
1691 sp_stroke_style_set_join_buttons(spw, GTK_WIDGET(tb));
1692 } else if (cap) {
1693 sp_repr_css_set_property(css, "stroke-linecap", cap);
1695 sp_desktop_set_style (desktop, css);
1697 sp_stroke_style_set_cap_buttons(spw, GTK_WIDGET(tb));
1698 }
1700 sp_repr_css_attr_unref(css);
1702 sp_document_done(sp_desktop_document(desktop), SP_VERB_DIALOG_FILL_STROKE,
1703 _("Set stroke style"));
1704 }
1705 }
1708 /**
1709 * Updates the join style toggle buttons
1710 */
1711 static void
1712 sp_stroke_style_set_join_buttons(SPWidget *spw, GtkWidget *active)
1713 {
1714 GtkWidget *tb;
1716 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1717 INKSCAPE_STOCK_JOIN_MITER) );
1718 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1720 GtkWidget *ml = GTK_WIDGET(g_object_get_data(G_OBJECT(spw), "miterlimit_sb"));
1721 gtk_widget_set_sensitive(ml, (active == tb));
1723 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1724 INKSCAPE_STOCK_JOIN_ROUND) );
1725 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1726 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1727 INKSCAPE_STOCK_JOIN_BEVEL) );
1728 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1729 }
1733 /**
1734 * Updates the cap style toggle buttons
1735 */
1736 static void
1737 sp_stroke_style_set_cap_buttons(SPWidget *spw, GtkWidget *active)
1738 {
1739 GtkWidget *tb;
1741 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1742 INKSCAPE_STOCK_CAP_BUTT));
1743 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1744 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1745 INKSCAPE_STOCK_CAP_ROUND) );
1746 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1747 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1748 INKSCAPE_STOCK_CAP_SQUARE) );
1749 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1750 }
1752 /**
1753 * Sets the current marker in the marker menu.
1754 */
1755 static void
1756 ink_marker_menu_set_current(SPObject *marker, GtkOptionMenu *mnu)
1757 {
1758 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
1760 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(mnu));
1761 if (marker != NULL) {
1762 bool mark_is_stock = false;
1763 if (SP_OBJECT_REPR(marker)->attribute("inkscape:stockid"))
1764 mark_is_stock = true;
1766 gchar *markname;
1767 if (mark_is_stock)
1768 markname = g_strdup(SP_OBJECT_REPR(marker)->attribute("inkscape:stockid"));
1769 else
1770 markname = g_strdup(SP_OBJECT_REPR(marker)->attribute("id"));
1772 int markpos = ink_marker_menu_get_pos(m, markname);
1773 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), markpos);
1775 g_free (markname);
1776 }
1777 else {
1778 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
1779 }
1780 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
1781 }
1783 /**
1784 * Updates the marker menus to highlight the appropriate marker and scroll to
1785 * that marker.
1786 */
1787 static void
1788 sp_stroke_style_update_marker_menus( SPWidget *spw,
1789 GSList const *objects)
1790 {
1791 struct { char const *key; int loc; } const keyloc[] = {
1792 { "start_mark_menu", SP_MARKER_LOC_START },
1793 { "mid_mark_menu", SP_MARKER_LOC_MID },
1794 { "end_mark_menu", SP_MARKER_LOC_END }
1795 };
1797 bool all_texts = true;
1798 for (GSList *i = (GSList *) objects; i != NULL; i = i->next) {
1799 if (!SP_IS_TEXT (i->data)) {
1800 all_texts = false;
1801 }
1802 }
1804 for (unsigned i = 0; i < G_N_ELEMENTS(keyloc); ++i) {
1805 GtkOptionMenu *mnu = (GtkOptionMenu *) g_object_get_data(G_OBJECT(spw), keyloc[i].key);
1806 if (all_texts) {
1807 // Per SVG spec, text objects cannot have markers; disable menus if only texts are selected
1808 gtk_widget_set_sensitive (GTK_WIDGET(mnu), FALSE);
1809 } else {
1810 gtk_widget_set_sensitive (GTK_WIDGET(mnu), TRUE);
1811 }
1812 }
1814 // We show markers of the first object in the list only
1815 // FIXME: use the first in the list that has the marker of each type, if any
1816 SPObject *object = SP_OBJECT(objects->data);
1818 for (unsigned i = 0; i < G_N_ELEMENTS(keyloc); ++i) {
1819 // For all three marker types,
1821 // find the corresponding menu
1822 GtkOptionMenu *mnu = (GtkOptionMenu *) g_object_get_data(G_OBJECT(spw), keyloc[i].key);
1824 // Quit if we're in update state
1825 if (gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
1826 return;
1827 }
1829 if (object->style->marker[keyloc[i].loc].value != NULL && !all_texts) {
1830 // If the object has this type of markers,
1832 // Extract the name of the marker that the object uses
1833 SPObject *marker = ink_extract_marker_name(object->style->marker[keyloc[i].loc].value);
1834 // Scroll the menu to that marker
1835 ink_marker_menu_set_current (marker, mnu);
1837 } else {
1838 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
1839 }
1840 }
1841 }
1844 /**
1845 * Extract the actual name of the link
1846 * e.g. get mTriangle from url(#mTriangle).
1847 * \return Buffer containing the actual name, allocated from GLib;
1848 * the caller should free the buffer when they no longer need it.
1849 */
1850 static SPObject*
1851 ink_extract_marker_name(gchar const *n)
1852 {
1853 gchar const *p = n;
1854 while (*p != '\0' && *p != '#') {
1855 p++;
1856 }
1858 if (*p == '\0' || p[1] == '\0') {
1859 return NULL;
1860 }
1862 p++;
1863 int c = 0;
1864 while (p[c] != '\0' && p[c] != ')') {
1865 c++;
1866 }
1868 if (p[c] == '\0') {
1869 return NULL;
1870 }
1872 gchar* b = g_strdup(p);
1873 b[c] = '\0';
1875 SPDesktop *desktop = inkscape_active_desktop();
1876 SPDocument *doc = sp_desktop_document(desktop);
1877 SPObject *marker = doc->getObjectById(b);
1878 return marker;
1879 }
1882 /*
1883 Local Variables:
1884 mode:c++
1885 c-file-style:"stroustrup"
1886 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1887 indent-tabs-mode:nil
1888 fill-column:99
1889 End:
1890 */
1891 // vim: filetype=c++:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :