6ad8e82c424fc81148c1b68e06809aeafb4c200e
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.com>
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 <gtk/gtk.h>
28 #include <glibmm/i18n.h>
29 #include "helper/unit-menu.h"
30 #include "helper/units.h"
31 #include "svg/css-ostringstream.h"
32 #include "widgets/sp-widget.h"
33 #include "widgets/spw-utilities.h"
34 #include "sp-linear-gradient.h"
35 #include "sp-radial-gradient.h"
36 #include "sp-marker.h"
37 #include <sp-pattern.h>
38 #include <widgets/paint-selector.h>
39 #include <widgets/dash-selector.h>
40 #include "style.h"
41 #include "gradient-chemistry.h"
42 #include "sp-namedview.h"
43 #include "desktop-handles.h"
44 #include "desktop-style.h"
45 #include "selection.h"
46 #include "inkscape.h"
47 #include "inkscape-stock.h"
48 #include "dialogs/dialog-events.h"
49 #include "sp-text.h"
50 #include "sp-rect.h"
51 #include "document-private.h"
52 #include "display/nr-arena.h"
53 #include "display/nr-arena-item.h"
54 #include "path-prefix.h"
55 #include "widgets/icon.h"
56 #include "helper/stock-items.h"
57 #include "io/sys.h"
59 #include "dialogs/stroke-style.h"
61 /* Paint */
63 static void sp_stroke_style_paint_construct(SPWidget *spw, SPPaintSelector *psel);
64 static void sp_stroke_style_paint_selection_modified (SPWidget *spw, Inkscape::Selection *selection, guint flags, SPPaintSelector *psel);
65 static void sp_stroke_style_paint_selection_changed (SPWidget *spw, Inkscape::Selection *selection, SPPaintSelector *psel);
66 static void sp_stroke_style_paint_update(SPWidget *spw);
68 static void sp_stroke_style_paint_mode_changed(SPPaintSelector *psel, SPPaintSelectorMode mode, SPWidget *spw);
69 static void sp_stroke_style_paint_dragged(SPPaintSelector *psel, SPWidget *spw);
70 static void sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw);
72 static void sp_stroke_style_widget_change_subselection ( Inkscape::Application *inkscape, SPDesktop *desktop, SPWidget *spw );
74 GtkWidget *
75 sp_stroke_style_paint_widget_new(void)
76 {
77 GtkWidget *spw, *psel;
79 spw = sp_widget_new_global(INKSCAPE);
81 psel = sp_paint_selector_new(false); // without fillrule selector
82 gtk_widget_show(psel);
83 gtk_container_add(GTK_CONTAINER(spw), psel);
84 gtk_object_set_data(GTK_OBJECT(spw), "paint-selector", psel);
86 gtk_signal_connect(GTK_OBJECT(spw), "construct",
87 GTK_SIGNAL_FUNC(sp_stroke_style_paint_construct),
88 psel);
89 gtk_signal_connect(GTK_OBJECT(spw), "modify_selection",
90 GTK_SIGNAL_FUNC(sp_stroke_style_paint_selection_modified),
91 psel);
92 gtk_signal_connect(GTK_OBJECT(spw), "change_selection",
93 GTK_SIGNAL_FUNC(sp_stroke_style_paint_selection_changed),
94 psel);
96 g_signal_connect (INKSCAPE, "change_subselection", G_CALLBACK (sp_stroke_style_widget_change_subselection), spw);
98 gtk_signal_connect(GTK_OBJECT(psel), "mode_changed",
99 GTK_SIGNAL_FUNC(sp_stroke_style_paint_mode_changed),
100 spw);
101 gtk_signal_connect(GTK_OBJECT(psel), "dragged",
102 GTK_SIGNAL_FUNC(sp_stroke_style_paint_dragged),
103 spw);
104 gtk_signal_connect(GTK_OBJECT(psel), "changed",
105 GTK_SIGNAL_FUNC(sp_stroke_style_paint_changed),
106 spw);
108 sp_stroke_style_paint_update (SP_WIDGET(spw));
109 return spw;
110 }
112 static void
113 sp_stroke_style_paint_construct(SPWidget *spw, SPPaintSelector *psel)
114 {
115 #ifdef SP_SS_VERBOSE
116 g_print( "Stroke style widget constructed: inkscape %p repr %p\n",
117 spw->inkscape, spw->repr );
118 #endif
119 if (spw->inkscape) {
120 sp_stroke_style_paint_update (spw);
121 }
122 }
124 static void
125 sp_stroke_style_paint_selection_modified ( SPWidget *spw,
126 Inkscape::Selection *selection,
127 guint flags,
128 SPPaintSelector *psel)
129 {
130 if (flags & ( SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG |
131 SP_OBJECT_STYLE_MODIFIED_FLAG) ) {
132 sp_stroke_style_paint_update(spw);
133 }
134 }
137 static void
138 sp_stroke_style_paint_selection_changed ( SPWidget *spw,
139 Inkscape::Selection *selection,
140 SPPaintSelector *psel )
141 {
142 sp_stroke_style_paint_update (spw);
143 }
145 static void
146 sp_stroke_style_widget_change_subselection ( Inkscape::Application *inkscape,
147 SPDesktop *desktop,
148 SPWidget *spw )
149 {
150 sp_stroke_style_paint_update (spw);
151 }
153 static void
154 sp_stroke_style_paint_update (SPWidget *spw)
155 {
156 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
157 return;
158 }
160 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
162 SPPaintSelector *psel = SP_PAINT_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "paint-selector"));
164 // create temporary style
165 SPStyle *query = sp_style_new ();
166 // query into it
167 int result = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKE);
169 switch (result) {
170 case QUERY_STYLE_NOTHING:
171 {
172 /* No paint at all */
173 sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_EMPTY);
174 break;
175 }
177 case QUERY_STYLE_SINGLE:
178 case QUERY_STYLE_MULTIPLE_AVERAGED: // TODO: treat this slightly differently, e.g. display "averaged" somewhere in paint selector
179 case QUERY_STYLE_MULTIPLE_SAME:
180 {
181 SPPaintSelectorMode pselmode = sp_style_determine_paint_selector_mode (query, false);
182 sp_paint_selector_set_mode (psel, pselmode);
184 if (query->stroke.set && query->stroke.type == SP_PAINT_TYPE_COLOR) {
185 gfloat d[3];
186 sp_color_get_rgb_floatv (&query->stroke.value.color, d);
187 SPColor color;
188 sp_color_set_rgb_float (&color, d[0], d[1], d[2]);
189 sp_paint_selector_set_color_alpha (psel, &color, SP_SCALE24_TO_FLOAT (query->stroke_opacity.value));
191 } else if (query->stroke.set && query->stroke.type == SP_PAINT_TYPE_PAINTSERVER) {
193 SPPaintServer *server = SP_STYLE_STROKE_SERVER (query);
195 if (SP_IS_LINEARGRADIENT (server)) {
196 SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
197 sp_paint_selector_set_gradient_linear (psel, vector);
199 SPLinearGradient *lg = SP_LINEARGRADIENT (server);
200 sp_paint_selector_set_gradient_properties (psel,
201 SP_GRADIENT_UNITS (lg),
202 SP_GRADIENT_SPREAD (lg));
203 } else if (SP_IS_RADIALGRADIENT (server)) {
204 SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
205 sp_paint_selector_set_gradient_radial (psel, vector);
207 SPRadialGradient *rg = SP_RADIALGRADIENT (server);
208 sp_paint_selector_set_gradient_properties (psel,
209 SP_GRADIENT_UNITS (rg),
210 SP_GRADIENT_SPREAD (rg));
211 } else if (SP_IS_PATTERN (server)) {
212 SPPattern *pat = pattern_getroot (SP_PATTERN (server));
213 sp_update_pattern_list (psel, pat);
214 }
215 }
216 break;
217 }
219 case QUERY_STYLE_MULTIPLE_DIFFERENT:
220 {
221 sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
222 break;
223 }
224 }
226 g_free (query);
228 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
229 }
231 static void
232 sp_stroke_style_paint_mode_changed( SPPaintSelector *psel,
233 SPPaintSelectorMode mode,
234 SPWidget *spw )
235 {
236 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
237 return;
238 }
240 /* TODO: Does this work?
241 * Not really, here we have to get old color back from object
242 * Instead of relying on paint widget having meaningful colors set
243 */
244 sp_stroke_style_paint_changed(psel, spw);
245 }
247 static gchar *undo_label_1 = "stroke:flatcolor:1";
248 static gchar *undo_label_2 = "stroke:flatcolor:2";
249 static gchar *undo_label = undo_label_1;
251 static void
252 sp_stroke_style_paint_dragged(SPPaintSelector *psel, SPWidget *spw)
253 {
254 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
255 return;
256 }
258 switch (psel->mode) {
259 case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
260 case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
261 {
262 sp_paint_selector_set_flat_color (psel, SP_ACTIVE_DESKTOP, "stroke", "stroke-opacity");
263 sp_document_maybe_done (SP_DT_DOCUMENT(SP_ACTIVE_DESKTOP), undo_label);
264 break;
265 }
267 default:
268 g_warning( "file %s: line %d: Paint %d should not emit 'dragged'",
269 __FILE__, __LINE__, psel->mode);
270 break;
271 }
272 }
274 static void
275 sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
276 {
277 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
278 return;
279 }
280 g_object_set_data (G_OBJECT (spw), "update", GINT_TO_POINTER (TRUE));
282 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
283 SPDocument *document = SP_DT_DOCUMENT (desktop);
284 Inkscape::Selection *selection = SP_DT_SELECTION (desktop);
286 GSList const *items = selection->itemList();
288 switch (psel->mode) {
289 case SP_PAINT_SELECTOR_MODE_EMPTY:
290 // This should not happen.
291 g_warning ( "file %s: line %d: Paint %d should not emit 'changed'",
292 __FILE__, __LINE__, psel->mode);
293 break;
294 case SP_PAINT_SELECTOR_MODE_MULTIPLE:
295 // This happens when you switch multiple objects with different gradients to flat color;
296 // nothing to do here.
297 break;
299 case SP_PAINT_SELECTOR_MODE_NONE:
300 {
301 SPCSSAttr *css = sp_repr_css_attr_new();
302 sp_repr_css_set_property(css, "stroke", "none");
304 sp_desktop_set_style (desktop, css);
306 sp_repr_css_attr_unref(css);
308 sp_document_done(document);
309 break;
310 }
312 case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
313 case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
314 {
315 sp_paint_selector_set_flat_color (psel, desktop, "stroke", "stroke-opacity");
316 sp_document_maybe_done (SP_DT_DOCUMENT(desktop), undo_label);
318 // on release, toggle undo_label so that the next drag will not be lumped with this one
319 if (undo_label == undo_label_1)
320 undo_label = undo_label_2;
321 else
322 undo_label = undo_label_1;
324 break;
325 }
327 case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
328 case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
329 if (items) {
330 SPGradientType const gradient_type = ( psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR
331 ? SP_GRADIENT_TYPE_LINEAR
332 : SP_GRADIENT_TYPE_RADIAL );
333 SPGradient *vector = sp_paint_selector_get_gradient_vector(psel);
334 if (!vector) {
335 /* No vector in paint selector should mean that we just changed mode */
337 SPStyle *query = sp_style_new ();
338 int result = objects_query_fillstroke ((GSList *) items, query, false);
339 guint32 common_rgb = 0;
340 if (result == QUERY_STYLE_MULTIPLE_SAME) {
341 if (query->fill.type != SP_PAINT_TYPE_COLOR) {
342 common_rgb = sp_desktop_get_color(desktop, false);
343 } else {
344 common_rgb = sp_color_get_rgba32_ualpha(&query->stroke.value.color, 0xff);
345 }
346 vector = sp_document_default_gradient_vector(document, common_rgb);
347 }
348 g_free (query);
350 for (GSList const *i = items; i != NULL; i = i->next) {
351 if (!vector) {
352 sp_item_set_gradient(SP_ITEM(i->data),
353 sp_gradient_vector_for_object(document, desktop, SP_OBJECT(i->data), false),
354 gradient_type, false);
355 } else {
356 sp_item_set_gradient(SP_ITEM(i->data), vector, gradient_type, false);
357 }
358 }
359 } else {
360 vector = sp_gradient_ensure_vector_normalized(vector);
361 for (GSList const *i = items; i != NULL; i = i->next) {
362 SPGradient *gr = sp_item_set_gradient(SP_ITEM(i->data), vector, gradient_type, false);
363 sp_gradient_selector_attrs_to_gradient(gr, psel);
364 }
365 }
367 sp_document_done(document);
368 }
369 break;
371 case SP_PAINT_SELECTOR_MODE_PATTERN:
373 if (items) {
375 SPPattern *pattern = sp_paint_selector_get_pattern (psel);
376 if (!pattern) {
378 /* No Pattern in paint selector should mean that we just
379 * changed mode - dont do jack.
380 */
382 } else {
383 Inkscape::XML::Node *patrepr = SP_OBJECT_REPR(pattern);
384 SPCSSAttr *css = sp_repr_css_attr_new ();
385 gchar *urltext = g_strdup_printf ("url(#%s)", patrepr->attribute("id"));
386 sp_repr_css_set_property (css, "stroke", urltext);
388 for (GSList const *i = items; i != NULL; i = i->next) {
389 Inkscape::XML::Node *selrepr = SP_OBJECT_REPR (i->data);
390 SPObject *selobj = SP_OBJECT (i->data);
391 if (!selrepr)
392 continue;
394 SPStyle *style = SP_OBJECT_STYLE (selobj);
395 if (style && style->stroke.type == SP_PAINT_TYPE_PAINTSERVER) {
396 SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (selobj);
397 if (SP_IS_PATTERN (server) && pattern_getroot (SP_PATTERN(server)) == pattern)
398 // only if this object's pattern is not rooted in our selected pattern, apply
399 continue;
400 }
402 sp_repr_css_change_recursive (selrepr, css, "style");
403 }
405 sp_repr_css_attr_unref (css);
406 g_free (urltext);
408 } // end if
410 sp_document_done (document);
411 } // end if
413 break;
415 case SP_PAINT_SELECTOR_MODE_UNSET:
416 if (items) {
417 SPCSSAttr *css = sp_repr_css_attr_new ();
418 sp_repr_css_unset_property (css, "stroke");
420 sp_desktop_set_style (desktop, css);
421 sp_repr_css_attr_unref (css);
423 sp_document_done (document);
424 }
425 break;
427 default:
428 g_warning( "file %s: line %d: Paint selector should not be in "
429 "mode %d",
430 __FILE__, __LINE__,
431 psel->mode );
432 break;
433 }
435 g_object_set_data (G_OBJECT (spw), "update", GINT_TO_POINTER (FALSE));
436 }
442 /* Line */
444 static void sp_stroke_style_line_construct(SPWidget *spw, gpointer data);
445 static void sp_stroke_style_line_selection_modified (SPWidget *spw,
446 Inkscape::Selection *selection,
447 guint flags,
448 gpointer data);
450 static void sp_stroke_style_line_selection_changed (SPWidget *spw,
451 Inkscape::Selection *selection,
452 gpointer data );
454 static void sp_stroke_style_line_update(SPWidget *spw, Inkscape::Selection *sel);
456 static void sp_stroke_style_set_join_buttons(SPWidget *spw,
457 GtkWidget *active);
459 static void sp_stroke_style_set_cap_buttons(SPWidget *spw,
460 GtkWidget *active);
462 static void sp_stroke_style_width_changed(GtkAdjustment *adj, SPWidget *spw);
463 static void sp_stroke_style_miterlimit_changed(GtkAdjustment *adj, SPWidget *spw);
464 static void sp_stroke_style_any_toggled(GtkToggleButton *tb, SPWidget *spw);
465 static void sp_stroke_style_line_dash_changed(SPDashSelector *dsel,
466 SPWidget *spw);
468 static void sp_stroke_style_update_marker_menus(SPWidget *spw, GSList const *objects);
470 static SPObject *ink_extract_marker_name(gchar const *n);
473 /**
474 * Helper function for creating radio buttons. This should probably be re-thought out
475 * when reimplementing this with Gtkmm.
476 */
477 static GtkWidget *
478 sp_stroke_radio_button(GtkWidget *tb, char const *icon,
479 GtkWidget *hb, GtkWidget *spw,
480 gchar const *key, gchar const *data)
481 {
482 g_assert(icon != NULL);
483 g_assert(hb != NULL);
484 g_assert(spw != NULL);
486 if (tb == NULL) {
487 tb = gtk_radio_button_new(NULL);
488 } else {
489 tb = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(tb)) );
490 }
492 gtk_widget_show(tb);
493 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(tb), FALSE);
494 gtk_box_pack_start(GTK_BOX(hb), tb, FALSE, FALSE, 0);
495 gtk_object_set_data(GTK_OBJECT(spw), icon, tb);
496 gtk_object_set_data(GTK_OBJECT(tb), key, (gpointer*)data);
497 gtk_signal_connect(GTK_OBJECT(tb), "toggled",
498 GTK_SIGNAL_FUNC(sp_stroke_style_any_toggled),
499 spw);
500 GtkWidget *px = sp_icon_new(Inkscape::ICON_SIZE_LARGE_TOOLBAR, icon);
501 g_assert(px != NULL);
502 gtk_widget_show(px);
503 gtk_container_add(GTK_CONTAINER(tb), px);
505 return tb;
507 }
509 static GtkWidget *
510 sp_marker_prev_new(unsigned size, gchar const *mname,
511 SPDocument *source, SPDocument *sandbox,
512 gchar *menu_id, NRArena const *arena, unsigned visionkey, NRArenaItem *root)
513 {
514 // the object of the marker
515 SPObject const *marker = source->getObjectById(mname);
516 if (marker == NULL)
517 return NULL;
519 // the repr of the marker; make a copy with id="sample"
520 Inkscape::XML::Node *mrepr = SP_OBJECT_REPR (marker)->duplicate();
521 mrepr->setAttribute("id", "sample");
523 // replace the old sample in the sandbox by the new one
524 Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (sandbox->getObjectById("defs"));
525 SPObject *oldmarker = sandbox->getObjectById("sample");
526 if (oldmarker)
527 oldmarker->deleteObject(false);
528 defsrepr->appendChild(mrepr);
529 Inkscape::GC::release(mrepr);
531 // Uncomment this to get the sandbox documents saved (useful for debugging)
532 //FILE *fp = fopen (g_strconcat(mname, ".svg", NULL), "w");
533 //sp_repr_save_stream (sp_document_repr_doc (sandbox), fp);
534 //fclose (fp);
536 // object to render; note that the id is the same as that of the menu we're building
537 SPObject *object = sandbox->getObjectById(menu_id);
538 sp_document_root (sandbox)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
539 sp_document_ensure_up_to_date(sandbox);
541 if (object == NULL || !SP_IS_ITEM(object))
542 return NULL; // sandbox broken?
544 // Find object's bbox in document
545 NR::Matrix const i2doc(sp_item_i2doc_affine(SP_ITEM(object)));
547 NR::Rect const dbox = SP_ITEM(object)->invokeBbox(i2doc);
549 if (dbox.isEmpty()) {
550 return NULL;
551 }
553 /* Update to renderable state */
554 NRMatrix t;
555 double sf = 0.8;
556 nr_matrix_set_scale(&t, sf, sf);
557 nr_arena_item_set_transform(root, &t);
558 NRGC gc(NULL);
559 nr_matrix_set_identity(&gc.transform);
560 nr_arena_item_invoke_update( root, NULL, &gc,
561 NR_ARENA_ITEM_STATE_ALL,
562 NR_ARENA_ITEM_STATE_NONE );
564 /* Item integer bbox in points */
565 NRRectL ibox;
566 ibox.x0 = (int) floor(sf * dbox.min()[NR::X] + 0.5);
567 ibox.y0 = (int) floor(sf * dbox.min()[NR::Y] + 0.5);
568 ibox.x1 = (int) floor(sf * dbox.max()[NR::X] + 0.5);
569 ibox.y1 = (int) floor(sf * dbox.max()[NR::Y] + 0.5);
571 /* Find visible area */
572 int width = ibox.x1 - ibox.x0;
573 int height = ibox.y1 - ibox.y0;
574 int dx = size;
575 int dy = size;
576 dx=(dx - width)/2; // watch out for size, since 'unsigned'-'signed' can cause problems if the result is negative
577 dy=(dy - height)/2;
579 NRRectL area;
580 area.x0 = ibox.x0 - dx;
581 area.y0 = ibox.y0 - dy;
582 area.x1 = area.x0 + size;
583 area.y1 = area.y0 + size;
585 /* Actual renderable area */
586 NRRectL ua;
587 ua.x0 = MAX(ibox.x0, area.x0);
588 ua.y0 = MAX(ibox.y0, area.y0);
589 ua.x1 = MIN(ibox.x1, area.x1);
590 ua.y1 = MIN(ibox.y1, area.y1);
592 /* Set up pixblock */
593 guchar *px = nr_new(guchar, 4 * size * size);
594 memset(px, 0x00, 4 * size * size);
596 /* Render */
597 NRPixBlock B;
598 nr_pixblock_setup_extern( &B, NR_PIXBLOCK_MODE_R8G8B8A8N,
599 ua.x0, ua.y0, ua.x1, ua.y1,
600 px + 4 * size * (ua.y0 - area.y0) +
601 4 * (ua.x0 - area.x0),
602 4 * size, FALSE, FALSE );
603 nr_arena_item_invoke_render( root, &ua, &B,
604 NR_ARENA_ITEM_RENDER_NO_CACHE );
605 nr_pixblock_release(&B);
607 // Create widget
608 GtkWidget *pb = gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_data(px,
609 GDK_COLORSPACE_RGB,
610 TRUE,
611 8, size, size, size * 4,
612 (GdkPixbufDestroyNotify)nr_free,
613 NULL));
614 return pb;
615 }
618 #define MARKER_ITEM_MARGIN 0
621 /**
622 * sp_marker_list_from_doc()
623 *
624 * \brief Pick up all markers from source, except those that are in
625 * current_doc (if non-NULL), and add items to the m menu
626 *
627 */
628 static void
629 sp_marker_list_from_doc (GtkWidget *m, SPDocument *current_doc, SPDocument *source, SPDocument *markers_doc, SPDocument *sandbox, gchar *menu_id)
630 {
632 // search through defs
633 GSList *ml = NULL;
634 SPDefs *defs= (SPDefs *) SP_DOCUMENT_DEFS (source);
635 for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(defs)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT (ochild) ) {
636 if (SP_IS_MARKER(ochild)) {
637 ml = g_slist_prepend (ml, ochild);
638 }
639 }
641 // Do this here, outside of loop, to speed up preview generation:
642 /* Create new arena */
643 NRArena const *arena = NRArena::create();
644 /* Create ArenaItem and set transform */
645 unsigned const visionkey = sp_item_display_key_new(1);
646 NRArenaItem *root = sp_item_invoke_show( SP_ITEM(SP_DOCUMENT_ROOT (sandbox)), (NRArena *) arena, visionkey, SP_ITEM_SHOW_DISPLAY );
648 for (; ml != NULL; ml = ml->next) {
650 if (!SP_IS_MARKER(ml->data))
651 continue;
653 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) ml->data);
655 bool stock_dupe = false;
657 if (markers_doc && repr->attribute("inkscape:stockid")) {
658 // find out if markers_doc has a marker with the same stockid, and if so, skip this
659 for (SPObject *child = sp_object_first_child(SP_OBJECT(SP_DOCUMENT_DEFS(markers_doc))) ;
660 child != NULL;
661 child = SP_OBJECT_NEXT(child) )
662 {
663 if (SP_IS_MARKER(child) &&
664 SP_OBJECT_REPR(child)->attribute("inkscape:stockid") &&
665 !strcmp(repr->attribute("inkscape:stockid"), SP_OBJECT_REPR(child)->attribute("inkscape:stockid"))) {
666 stock_dupe = true;
667 }
668 }
669 }
671 if (stock_dupe) // stock item, dont add to list from current doc
672 continue;
674 GtkWidget *i = gtk_menu_item_new();
675 gtk_widget_show(i);
677 if (repr->attribute("inkscape:stockid"))
678 g_object_set_data (G_OBJECT(i), "stockid", (void *) "true");
679 else
680 g_object_set_data (G_OBJECT(i), "stockid", (void *) "false");
682 gchar const *markid = repr->attribute("id");
683 g_object_set_data (G_OBJECT(i), "marker", (void *) markid);
685 GtkWidget *hb = gtk_hbox_new(FALSE, MARKER_ITEM_MARGIN);
686 gtk_widget_show(hb);
688 // generate preview
689 GtkWidget *prv = sp_marker_prev_new (22, markid, source, sandbox, menu_id, arena, visionkey, root);
690 gtk_widget_show(prv);
691 gtk_box_pack_start(GTK_BOX(hb), prv, FALSE, FALSE, 6);
693 // create label
694 GtkWidget *l = gtk_label_new(repr->attribute("id"));
695 gtk_widget_show(l);
696 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
698 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
700 gtk_widget_show(hb);
701 gtk_container_add(GTK_CONTAINER(i), hb);
703 gtk_menu_append(GTK_MENU(m), i);
704 }
706 g_slist_free (ml);
707 }
710 SPDocument *
711 ink_markers_preview_doc ()
712 {
713 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\">"
714 " <defs id=\"defs\" />"
716 " <g id=\"marker-start\">"
717 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:url(#sample);marker-mid:none;marker-end:none\""
718 " d=\"M 12.5,13 L 25,13\" id=\"path1\" />"
719 " <rect style=\"fill:none;stroke:none\" id=\"rect2\""
720 " width=\"25\" height=\"25\" x=\"0\" y=\"0\" />"
721 " </g>"
723 " <g id=\"marker-mid\">"
724 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:none;marker-mid:url(#sample);marker-end:none\""
725 " d=\"M 0,113 L 12.5,113 L 25,113\" id=\"path11\" />"
726 " <rect style=\"fill:none;stroke:none\" id=\"rect22\""
727 " width=\"25\" height=\"25\" x=\"0\" y=\"100\" />"
728 " </g>"
730 " <g id=\"marker-end\">"
731 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:none;marker-mid:none;marker-end:url(#sample)\""
732 " d=\"M 0,213 L 12.5,213\" id=\"path111\" />"
733 " <rect style=\"fill:none;stroke:none\" id=\"rect222\""
734 " width=\"25\" height=\"25\" x=\"0\" y=\"200\" />"
735 " </g>"
737 "</svg>";
739 return sp_document_new_from_mem (buffer, strlen(buffer), FALSE);
740 }
744 static GtkWidget *
745 ink_marker_menu( GtkWidget *tbl, gchar *menu_id, SPDocument *sandbox)
746 {
747 SPDesktop *desktop = inkscape_active_desktop();
748 SPDocument *doc = SP_DT_DOCUMENT(desktop);
749 GtkWidget *mnu = gtk_option_menu_new();
751 /* Create new menu widget */
752 GtkWidget *m = gtk_menu_new();
753 gtk_widget_show(m);
755 g_object_set_data(G_OBJECT(mnu), "updating", (gpointer) FALSE);
757 if (!doc) {
758 GtkWidget *i = gtk_menu_item_new_with_label(_("No document selected"));
759 gtk_widget_show(i);
760 gtk_menu_append(GTK_MENU(m), i);
761 gtk_widget_set_sensitive(mnu, FALSE);
763 } else {
765 // add "None"
766 {
767 GtkWidget *i = gtk_menu_item_new();
768 gtk_widget_show(i);
770 g_object_set_data(G_OBJECT(i), "marker", (void *) "none");
772 GtkWidget *hb = gtk_hbox_new(FALSE, MARKER_ITEM_MARGIN);
773 gtk_widget_show(hb);
775 GtkWidget *l = gtk_label_new( _("None") );
776 gtk_widget_show(l);
777 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
779 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
781 gtk_widget_show(hb);
782 gtk_container_add(GTK_CONTAINER(i), hb);
783 gtk_menu_append(GTK_MENU(m), i);
784 }
786 // find and load markers.svg
787 static SPDocument *markers_doc = NULL;
788 char *markers_source = g_build_filename(INKSCAPE_MARKERSDIR, "markers.svg", NULL);
789 if (Inkscape::IO::file_test(markers_source, G_FILE_TEST_IS_REGULAR)) {
790 markers_doc = sp_document_new(markers_source, FALSE);
791 }
792 g_free(markers_source);
794 // suck in from current doc
795 sp_marker_list_from_doc ( m, NULL, doc, markers_doc, sandbox, menu_id );
797 // add separator
798 {
799 GtkWidget *i = gtk_separator_menu_item_new();
800 gtk_widget_show(i);
801 gtk_menu_append(GTK_MENU(m), i);
802 }
804 // suck in from markers.svg
805 if (markers_doc) {
806 sp_document_ensure_up_to_date(doc);
807 sp_marker_list_from_doc ( m, doc, markers_doc, NULL, sandbox, menu_id );
808 }
810 gtk_widget_set_sensitive(mnu, TRUE);
811 }
813 gtk_object_set_data(GTK_OBJECT(mnu), "menu_id", menu_id);
814 gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
816 /* Set history */
817 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
819 return mnu;
820 }
823 /*user selected existing marker from list*/
824 static void
825 sp_marker_select(GtkOptionMenu *mnu, GtkWidget *spw)
826 {
827 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
828 return;
829 }
831 SPDesktop *desktop = inkscape_active_desktop();
832 SPDocument *document = SP_DT_DOCUMENT(desktop);
833 if (!document) {
834 return;
835 }
837 /* Get Marker */
838 if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
839 "marker"))
840 {
841 return;
842 }
843 gchar *markid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
844 "marker");
845 gchar *marker = "";
846 if (strcmp(markid, "none")){
847 gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
848 "stockid");
850 gchar *markurn = markid;
851 if (!strcmp(stockid,"true")) markurn = g_strconcat("urn:inkscape:marker:",markid,NULL);
852 SPObject *mark = get_stock_item(markurn);
853 if (mark) {
854 Inkscape::XML::Node *repr = SP_OBJECT_REPR(mark);
855 marker = g_strconcat("url(#", repr->attribute("id"), ")", NULL);
856 }
857 } else {
858 marker = markid;
859 }
861 SPCSSAttr *css = sp_repr_css_attr_new();
862 gchar *menu_id = (gchar *) g_object_get_data(G_OBJECT(mnu), "menu_id");
863 sp_repr_css_set_property(css, menu_id, marker);
865 Inkscape::Selection *selection = SP_DT_SELECTION(desktop);
866 GSList const *items = selection->itemList();
867 for (; items != NULL; items = items->next) {
868 SPItem *item = (SPItem *) items->data;
869 if (!SP_IS_SHAPE(item) || SP_IS_RECT(item)) // can't set marker to rect, until it's converted to using <path>
870 continue;
871 Inkscape::XML::Node *selrepr = SP_OBJECT_REPR((SPItem *) items->data);
872 if (selrepr) {
873 sp_repr_css_change_recursive(selrepr, css, "style");
874 }
875 SP_OBJECT(items->data)->requestModified(SP_OBJECT_MODIFIED_FLAG);
876 SP_OBJECT(items->data)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
877 }
879 sp_repr_css_attr_unref(css);
881 sp_document_done(document);
882 }
884 static gboolean stroke_width_set_unit(SPUnitSelector *,
885 SPUnit const *old,
886 SPUnit const *new_units,
887 GObject *spw)
888 {
889 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
891 if (!desktop) {
892 return FALSE;
893 }
895 Inkscape::Selection *selection = SP_DT_SELECTION (desktop);
897 if (selection->isEmpty())
898 return FALSE;
900 GSList const *objects = selection->itemList();
902 if ((old->base == SP_UNIT_ABSOLUTE || old->base == SP_UNIT_DEVICE) &&
903 (new_units->base == SP_UNIT_DIMENSIONLESS)) {
905 /* Absolute to percentage */
906 g_object_set_data (spw, "update", GUINT_TO_POINTER (TRUE));
908 GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data (spw, "width"));
909 float w = sp_units_get_pixels (a->value, *old);
911 gdouble average = stroke_average_width (objects);
913 if (average == NR_HUGE || average == 0)
914 return FALSE;
916 gtk_adjustment_set_value (a, 100.0 * w / average);
918 g_object_set_data (spw, "update", GUINT_TO_POINTER (FALSE));
919 return TRUE;
921 } else if ((old->base == SP_UNIT_DIMENSIONLESS) &&
922 (new_units->base == SP_UNIT_ABSOLUTE || new_units->base == SP_UNIT_DEVICE)) {
924 /* Percentage to absolute */
925 g_object_set_data (spw, "update", GUINT_TO_POINTER (TRUE));
927 GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data (spw, "width"));
929 gdouble average = stroke_average_width (objects);
931 gtk_adjustment_set_value (a, sp_pixels_get_units (0.01 * a->value * average, *new_units));
933 g_object_set_data (spw, "update", GUINT_TO_POINTER (FALSE));
934 return TRUE;
935 }
937 return FALSE;
938 }
941 /**
942 * \brief Creates a new widget for the line stroke style.
943 *
944 */
945 GtkWidget *
946 sp_stroke_style_line_widget_new(void)
947 {
948 GtkWidget *spw, *f, *t, *hb, *sb, *us, *tb, *ds;
949 GtkObject *a;
951 GtkTooltips *tt = gtk_tooltips_new();
953 spw = sp_widget_new_global(INKSCAPE);
955 f = gtk_hbox_new (FALSE, 0);
956 gtk_widget_show(f);
957 gtk_container_add(GTK_CONTAINER(spw), f);
959 t = gtk_table_new(3, 6, FALSE);
960 gtk_widget_show(t);
961 gtk_container_set_border_width(GTK_CONTAINER(t), 4);
962 gtk_table_set_row_spacings(GTK_TABLE(t), 4);
963 gtk_container_add(GTK_CONTAINER(f), t);
964 gtk_object_set_data(GTK_OBJECT(spw), "stroke", t);
966 gint i = 0;
968 /* Stroke width */
969 spw_label(t, _("Width:"), 0, i);
971 hb = spw_hbox(t, 3, 1, i);
973 // TODO: when this is gtkmmified, use an Inkscape::UI::Widget::ScalarUnit instead of the separate
974 // spinbutton and unit selector for stroke width. In sp_stroke_style_line_update, use
975 // setHundredPercent to remember the aeraged width corresponding to 100%. Then the
976 // stroke_width_set_unit will be removed (because ScalarUnit takes care of conversions itself), and
977 // with it, the two remaining calls of stroke_average_width, allowing us to get rid of that
978 // function in desktop-style.
980 a = gtk_adjustment_new(1.0, 0.0, 1000.0, 0.1, 10.0, 10.0);
981 gtk_object_set_data(GTK_OBJECT(spw), "width", a);
982 sb = gtk_spin_button_new(GTK_ADJUSTMENT(a), 0.1, 3);
983 gtk_tooltips_set_tip(tt, sb, _("Stroke width"), NULL);
984 gtk_widget_show(sb);
986 sp_dialog_defocus_on_enter(sb);
988 gtk_box_pack_start(GTK_BOX(hb), sb, FALSE, FALSE, 0);
989 us = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
990 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
991 if (desktop)
992 sp_unit_selector_set_unit (SP_UNIT_SELECTOR(us), SP_DT_NAMEDVIEW(desktop)->doc_units);
993 sp_unit_selector_add_unit(SP_UNIT_SELECTOR(us), &sp_unit_get_by_id(SP_UNIT_PERCENT), 0);
994 g_signal_connect ( G_OBJECT (us), "set_unit", G_CALLBACK (stroke_width_set_unit), spw );
995 gtk_widget_show(us);
996 sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), GTK_ADJUSTMENT(a) );
997 gtk_box_pack_start(GTK_BOX(hb), us, FALSE, FALSE, 0);
998 gtk_object_set_data(GTK_OBJECT(spw), "units", us);
1000 gtk_signal_connect( GTK_OBJECT(a), "value_changed", GTK_SIGNAL_FUNC(sp_stroke_style_width_changed), spw );
1001 i++;
1003 /* Join type */
1004 // TRANSLATORS: The line join style specifies the shape to be used at the
1005 // corners of paths. It can be "miter", "round" or "bevel".
1006 spw_label(t, _("Join:"), 0, i);
1008 hb = spw_hbox(t, 3, 1, i);
1010 tb = NULL;
1012 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_MITER,
1013 hb, spw, "join", "miter");
1015 // TRANSLATORS: Miter join: joining lines with a sharp (pointed) corner.
1016 // For an example, draw a triangle with a large stroke width and modify the
1017 // "Join" option (in the Fill and Stroke dialog).
1018 gtk_tooltips_set_tip(tt, tb, _("Miter join"), NULL);
1020 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_ROUND,
1021 hb, spw, "join", "round");
1023 // TRANSLATORS: Round join: joining lines with a rounded corner.
1024 // For an example, draw a triangle with a large stroke width and modify the
1025 // "Join" option (in the Fill and Stroke dialog).
1026 gtk_tooltips_set_tip(tt, tb, _("Round join"), NULL);
1028 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_BEVEL,
1029 hb, spw, "join", "bevel");
1031 // TRANSLATORS: Bevel join: joining lines with a blunted (flattened) corner.
1032 // For an example, draw a triangle with a large stroke width and modify the
1033 // "Join" option (in the Fill and Stroke dialog).
1034 gtk_tooltips_set_tip(tt, tb, _("Bevel join"), NULL);
1036 i++;
1038 /* Miterlimit */
1039 // TRANSLATORS: Miter limit: only for "miter join", this limits the length
1040 // of the sharp "spike" when the lines connect at too sharp an angle.
1041 // When two line segments meet at a sharp angle, a miter join results in a
1042 // spike that extends well beyond the connection point. The purpose of the
1043 // miter limit is to cut off such spikes (i.e. convert them into bevels)
1044 // when they become too long.
1045 spw_label(t, _("Miter limit:"), 0, i);
1047 hb = spw_hbox(t, 3, 1, i);
1049 a = gtk_adjustment_new(4.0, 0.0, 100.0, 0.1, 10.0, 10.0);
1050 gtk_object_set_data(GTK_OBJECT(spw), "miterlimit", a);
1052 sb = gtk_spin_button_new(GTK_ADJUSTMENT(a), 0.1, 2);
1053 gtk_tooltips_set_tip(tt, sb, _("Maximum length of the miter (in units of stroke width)"), NULL);
1054 gtk_widget_show(sb);
1055 gtk_object_set_data(GTK_OBJECT(spw), "miterlimit_sb", sb);
1056 sp_dialog_defocus_on_enter(sb);
1058 gtk_box_pack_start(GTK_BOX(hb), sb, FALSE, FALSE, 0);
1060 gtk_signal_connect( GTK_OBJECT(a), "value_changed",
1061 GTK_SIGNAL_FUNC(sp_stroke_style_miterlimit_changed), spw );
1062 i++;
1064 /* Cap type */
1065 // TRANSLATORS: cap type specifies the shape for the ends of lines
1066 spw_label(t, _("Cap:"), 0, i);
1068 hb = spw_hbox(t, 3, 1, i);
1070 tb = NULL;
1072 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_BUTT,
1073 hb, spw, "cap", "butt");
1075 // TRANSLATORS: Butt cap: the line shape does not extend beyond the end point
1076 // of the line; the ends of the line are square
1077 gtk_tooltips_set_tip(tt, tb, _("Butt cap"), NULL);
1079 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_ROUND,
1080 hb, spw, "cap", "round");
1082 // TRANSLATORS: Round cap: the line shape extends beyond the end point of the
1083 // line; the ends of the line are rounded
1084 gtk_tooltips_set_tip(tt, tb, _("Round cap"), NULL);
1086 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_SQUARE,
1087 hb, spw, "cap", "square");
1089 // TRANSLATORS: Square cap: the line shape extends beyond the end point of the
1090 // line; the ends of the line are square
1091 gtk_tooltips_set_tip(tt, tb, _("Square cap"), NULL);
1093 i++;
1096 /* Dash */
1097 spw_label(t, _("Dashes:"), 0, i);
1098 ds = sp_dash_selector_new( inkscape_get_repr( INKSCAPE,
1099 "palette.dashes") );
1101 gtk_widget_show(ds);
1102 gtk_table_attach( GTK_TABLE(t), ds, 1, 4, i, i+1,
1103 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1104 (GtkAttachOptions)0, 0, 0 );
1105 gtk_object_set_data(GTK_OBJECT(spw), "dash", ds);
1106 gtk_signal_connect( GTK_OBJECT(ds), "changed",
1107 GTK_SIGNAL_FUNC(sp_stroke_style_line_dash_changed),
1108 spw );
1109 i++;
1111 /* Drop down marker selectors*/
1113 // doing this here once, instead of for each preview, to speed things up
1114 SPDocument *sandbox = ink_markers_preview_doc ();
1116 // TRANSLATORS: Path markers are an SVG feature that allows you to attach arbitrary shapes
1117 // (arrowheads, bullets, faces, whatever) to the start, end, or middle nodes of a path.
1118 spw_label(t, _("Start Markers:"), 0, i);
1119 GtkWidget *mnu = ink_marker_menu( spw ,"marker-start", sandbox);
1120 gtk_signal_connect( GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1121 gtk_widget_show(mnu);
1122 gtk_table_attach( GTK_TABLE(t), mnu, 1, 4, i, i+1,
1123 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1124 (GtkAttachOptions)0, 0, 0 );
1125 gtk_object_set_data(GTK_OBJECT(spw), "start_mark_menu", mnu);
1127 i++;
1128 spw_label(t, _("Mid Markers:"), 0, i);
1129 mnu = NULL;
1130 mnu = ink_marker_menu( spw ,"marker-mid", sandbox);
1131 gtk_signal_connect( GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1132 gtk_widget_show(mnu);
1133 gtk_table_attach( GTK_TABLE(t), mnu, 1, 4, i, i+1,
1134 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1135 (GtkAttachOptions)0, 0, 0 );
1136 gtk_object_set_data(GTK_OBJECT(spw), "mid_mark_menu", mnu);
1138 i++;
1139 spw_label(t, _("End Markers:"), 0, i);
1140 mnu = NULL;
1141 mnu = ink_marker_menu( spw ,"marker-end", sandbox);
1142 gtk_signal_connect( GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1143 gtk_widget_show(mnu);
1144 gtk_table_attach( GTK_TABLE(t), mnu, 1, 4, i, i+1,
1145 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1146 (GtkAttachOptions)0, 0, 0 );
1147 gtk_object_set_data(GTK_OBJECT(spw), "end_mark_menu", mnu);
1149 i++;
1151 gtk_signal_connect( GTK_OBJECT(spw), "construct",
1152 GTK_SIGNAL_FUNC(sp_stroke_style_line_construct),
1153 NULL );
1154 gtk_signal_connect( GTK_OBJECT(spw), "modify_selection",
1155 GTK_SIGNAL_FUNC(sp_stroke_style_line_selection_modified),
1156 NULL );
1157 gtk_signal_connect( GTK_OBJECT(spw), "change_selection",
1158 GTK_SIGNAL_FUNC(sp_stroke_style_line_selection_changed),
1159 NULL );
1161 sp_stroke_style_line_update( SP_WIDGET(spw), desktop ? SP_DT_SELECTION(desktop) : NULL);
1163 return spw;
1164 }
1168 static void
1169 sp_stroke_style_line_construct(SPWidget *spw, gpointer data)
1170 {
1172 #ifdef SP_SS_VERBOSE
1173 g_print( "Stroke style widget constructed: inkscape %p repr %p\n",
1174 spw->inkscape, spw->repr );
1175 #endif
1176 if (spw->inkscape) {
1177 sp_stroke_style_line_update(spw,
1178 ( SP_ACTIVE_DESKTOP
1179 ? SP_DT_SELECTION(SP_ACTIVE_DESKTOP)
1180 : NULL ));
1181 }
1182 }
1184 static void
1185 sp_stroke_style_line_selection_modified ( SPWidget *spw,
1186 Inkscape::Selection *selection,
1187 guint flags,
1188 gpointer data )
1189 {
1190 if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG)) {
1191 sp_stroke_style_line_update (spw, selection);
1192 }
1194 }
1196 static void
1197 sp_stroke_style_line_selection_changed ( SPWidget *spw,
1198 Inkscape::Selection *selection,
1199 gpointer data )
1200 {
1201 sp_stroke_style_line_update (spw, selection);
1202 }
1205 static void
1206 sp_dash_selector_set_from_style (GtkWidget *dsel, SPStyle *style)
1207 {
1208 if (style->stroke_dash.n_dash > 0) {
1209 double d[64];
1210 int len = MIN(style->stroke_dash.n_dash, 64);
1211 for (int i = 0; i < len; i++) {
1212 if (style->stroke_width.computed != 0)
1213 d[i] = style->stroke_dash.dash[i] / style->stroke_width.computed;
1214 else
1215 d[i] = style->stroke_dash.dash[i]; // is there a better thing to do for stroke_width==0?
1216 }
1217 sp_dash_selector_set_dash(SP_DASH_SELECTOR(dsel), len, d,
1218 style->stroke_width.computed != 0?
1219 style->stroke_dash.offset / style->stroke_width.computed :
1220 style->stroke_dash.offset);
1221 } else {
1222 sp_dash_selector_set_dash(SP_DASH_SELECTOR(dsel), 0, NULL, 0.0);
1223 }
1224 }
1226 static void
1227 sp_jointype_set (SPWidget *spw, unsigned const jointype)
1228 {
1229 GtkWidget *tb = NULL;
1230 switch (jointype) {
1231 case SP_STROKE_LINEJOIN_MITER:
1232 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_MITER));
1233 break;
1234 case SP_STROKE_LINEJOIN_ROUND:
1235 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_ROUND));
1236 break;
1237 case SP_STROKE_LINEJOIN_BEVEL:
1238 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_BEVEL));
1239 break;
1240 default:
1241 break;
1242 }
1243 sp_stroke_style_set_join_buttons (spw, tb);
1244 }
1246 static void
1247 sp_captype_set (SPWidget *spw, unsigned const captype)
1248 {
1249 GtkWidget *tb = NULL;
1250 switch (captype) {
1251 case SP_STROKE_LINECAP_BUTT:
1252 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_BUTT));
1253 break;
1254 case SP_STROKE_LINECAP_ROUND:
1255 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_ROUND));
1256 break;
1257 case SP_STROKE_LINECAP_SQUARE:
1258 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_SQUARE));
1259 break;
1260 default:
1261 break;
1262 }
1263 sp_stroke_style_set_cap_buttons (spw, tb);
1264 }
1266 static void
1267 sp_stroke_style_line_update(SPWidget *spw, Inkscape::Selection *sel)
1268 {
1269 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1270 return;
1271 }
1273 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
1275 GtkWidget *sset = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "stroke"));
1276 GtkObject *width = GTK_OBJECT(gtk_object_get_data(GTK_OBJECT(spw), "width"));
1277 GtkObject *ml = GTK_OBJECT(gtk_object_get_data(GTK_OBJECT(spw), "miterlimit"));
1278 GtkWidget *us = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "units"));
1279 GtkWidget *dsel = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "dash"));
1281 // create temporary style
1282 SPStyle *query = sp_style_new ();
1283 // query into it
1284 int result_sw = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEWIDTH);
1285 int result_ml = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEMITERLIMIT);
1286 int result_cap = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKECAP);
1287 int result_join = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEJOIN);
1289 if (result_sw == QUERY_STYLE_NOTHING) {
1290 /* No objects stroked, set insensitive */
1291 gtk_widget_set_sensitive(sset, FALSE);
1293 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
1294 return;
1295 } else {
1296 gtk_widget_set_sensitive(sset, TRUE);
1298 SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
1300 if (result_sw == QUERY_STYLE_MULTIPLE_AVERAGED) {
1301 sp_unit_selector_set_unit(SP_UNIT_SELECTOR(us), &sp_unit_get_by_id(SP_UNIT_PERCENT));
1302 } else {
1303 // same width, or only one object; no sense to keep percent, switch to absolute
1304 if (unit->base != SP_UNIT_ABSOLUTE && unit->base != SP_UNIT_DEVICE) {
1305 sp_unit_selector_set_unit(SP_UNIT_SELECTOR(us), SP_DT_NAMEDVIEW(SP_ACTIVE_DESKTOP)->doc_units);
1306 }
1307 }
1309 unit = sp_unit_selector_get_unit (SP_UNIT_SELECTOR (us));
1311 if (unit->base == SP_UNIT_ABSOLUTE || unit->base == SP_UNIT_DEVICE) {
1312 double avgwidth = sp_pixels_get_units (query->stroke_width.computed, *unit);
1313 gtk_adjustment_set_value(GTK_ADJUSTMENT(width), avgwidth);
1314 } else {
1315 gtk_adjustment_set_value(GTK_ADJUSTMENT(width), 100);
1316 }
1317 }
1319 if (result_ml != QUERY_STYLE_NOTHING)
1320 gtk_adjustment_set_value(GTK_ADJUSTMENT(ml), query->stroke_miterlimit.value); // TODO: reflect averagedness?
1322 if (result_join != QUERY_STYLE_MULTIPLE_DIFFERENT) {
1323 sp_jointype_set (spw, query->stroke_linejoin.value);
1324 } else {
1325 sp_stroke_style_set_join_buttons(spw, NULL);
1326 }
1328 if (result_cap != QUERY_STYLE_MULTIPLE_DIFFERENT) {
1329 sp_captype_set (spw, query->stroke_linecap.value);
1330 } else {
1331 sp_stroke_style_set_cap_buttons(spw, NULL);
1332 }
1334 g_free (query);
1336 GSList const *objects = sel->itemList();
1337 SPObject * const object = SP_OBJECT(objects->data);
1338 SPStyle * const style = SP_OBJECT_STYLE(object);
1340 /* Markers */
1341 sp_stroke_style_update_marker_menus(spw, objects); // FIXME: make this desktop query too
1343 /* Dash */
1344 sp_dash_selector_set_from_style (dsel, style); // FIXME: make this desktop query too
1346 gtk_widget_set_sensitive(sset, TRUE);
1348 gtk_object_set_data(GTK_OBJECT(spw), "update",
1349 GINT_TO_POINTER(FALSE));
1350 }
1352 static void
1353 sp_stroke_style_set_scaled_dash(SPCSSAttr *css,
1354 int ndash, double *dash, double offset,
1355 double scale)
1356 {
1357 if (ndash > 0) {
1358 Inkscape::CSSOStringStream osarray;
1359 for (int i = 0; i < ndash; i++) {
1360 osarray << dash[i] * scale;
1361 if (i < (ndash - 1)) {
1362 osarray << ",";
1363 }
1364 }
1365 sp_repr_css_set_property(css, "stroke-dasharray", osarray.str().c_str());
1367 Inkscape::CSSOStringStream osoffset;
1368 osoffset << offset * scale;
1369 sp_repr_css_set_property(css, "stroke-dashoffset", osoffset.str().c_str());
1370 } else {
1371 sp_repr_css_set_property(css, "stroke-dasharray", "none");
1372 sp_repr_css_set_property(css, "stroke-dashoffset", NULL);
1373 }
1374 }
1376 static void
1377 sp_stroke_style_scale_line(SPWidget *spw)
1378 {
1379 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1380 return;
1381 }
1383 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
1385 GtkAdjustment *wadj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(spw), "width"));
1386 SPUnitSelector *us = SP_UNIT_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "units"));
1387 SPDashSelector *dsel = SP_DASH_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "dash"));
1388 GtkAdjustment *ml = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(spw), "miterlimit"));
1390 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1391 SPDocument *document = SP_DT_DOCUMENT (desktop);
1392 Inkscape::Selection *selection = SP_DT_SELECTION (desktop);
1394 GSList const *items = selection->itemList();
1396 /* TODO: Create some standardized method */
1397 SPCSSAttr *css = sp_repr_css_attr_new();
1399 if (items) {
1401 double width_typed = wadj->value;
1402 double const miterlimit = ml->value;
1404 SPUnit const *const unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
1406 double *dash, offset;
1407 int ndash;
1408 sp_dash_selector_get_dash(dsel, &ndash, &dash, &offset);
1410 for (GSList const *i = items; i != NULL; i = i->next) {
1411 /* Set stroke width */
1412 double width;
1413 if (unit->base == SP_UNIT_ABSOLUTE || unit->base == SP_UNIT_DEVICE) {
1414 width = sp_units_get_pixels (width_typed, *unit);
1415 } else { // percentage
1416 gdouble old_w = SP_OBJECT_STYLE (i->data)->stroke_width.computed;
1417 width = old_w * width_typed / 100;
1418 }
1420 {
1421 Inkscape::CSSOStringStream os_width;
1422 os_width << width;
1423 sp_repr_css_set_property(css, "stroke-width", os_width.str().c_str());
1424 }
1426 {
1427 Inkscape::CSSOStringStream os_ml;
1428 os_ml << miterlimit;
1429 sp_repr_css_set_property(css, "stroke-miterlimit", os_ml.str().c_str());
1430 }
1432 /* Set dash */
1433 sp_stroke_style_set_scaled_dash(css, ndash, dash, offset, width);
1435 sp_desktop_apply_css_recursive (SP_OBJECT(i->data), css, true);
1436 }
1438 g_free(dash);
1440 if (unit->base != SP_UNIT_ABSOLUTE && unit->base != SP_UNIT_DEVICE) {
1441 // reset to 100 percent
1442 gtk_adjustment_set_value (wadj, 100.0);
1443 }
1445 }
1447 // we have already changed the items, so set style without changing selection
1448 // FIXME: move the above stroke-setting stuff, including percentages, to desktop-style
1449 sp_desktop_set_style (desktop, css, false);
1451 sp_repr_css_attr_unref(css);
1453 sp_document_done(document);
1455 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
1456 }
1460 static void
1461 sp_stroke_style_width_changed(GtkAdjustment *adj, SPWidget *spw)
1462 {
1463 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1464 return;
1465 }
1467 sp_stroke_style_scale_line(spw);
1468 }
1470 static void
1471 sp_stroke_style_miterlimit_changed(GtkAdjustment *adj, SPWidget *spw)
1472 {
1473 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1474 return;
1475 }
1477 sp_stroke_style_scale_line(spw);
1478 }
1480 static void
1481 sp_stroke_style_line_dash_changed(SPDashSelector *dsel, SPWidget *spw)
1482 {
1483 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1484 return;
1485 }
1487 sp_stroke_style_scale_line(spw);
1488 }
1492 /**
1493 * \brief This routine handles toggle events for buttons in the stroke style
1494 * dialog.
1495 * When activated, this routine gets the data for the various widgets, and then
1496 * calls the respective routines to update css properties, etc.
1497 *
1498 */
1499 static void
1500 sp_stroke_style_any_toggled(GtkToggleButton *tb, SPWidget *spw)
1501 {
1502 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1503 return;
1504 }
1506 if (gtk_toggle_button_get_active(tb)) {
1508 gchar const *join
1509 = static_cast<gchar const *>(gtk_object_get_data(GTK_OBJECT(tb), "join"));
1510 gchar const *cap
1511 = static_cast<gchar const *>(gtk_object_get_data(GTK_OBJECT(tb), "cap"));
1513 if (join) {
1514 GtkWidget *ml = GTK_WIDGET(g_object_get_data(G_OBJECT(spw), "miterlimit_sb"));
1515 gtk_widget_set_sensitive (ml, !strcmp(join, "miter"));
1516 }
1518 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1520 /* TODO: Create some standardized method */
1521 SPCSSAttr *css = sp_repr_css_attr_new();
1523 if (join) {
1524 sp_repr_css_set_property(css, "stroke-linejoin", join);
1526 sp_desktop_set_style (desktop, css);
1528 sp_stroke_style_set_join_buttons(spw, GTK_WIDGET(tb));
1529 } else if (cap) {
1530 sp_repr_css_set_property(css, "stroke-linecap", cap);
1532 sp_desktop_set_style (desktop, css);
1534 sp_stroke_style_set_cap_buttons(spw, GTK_WIDGET(tb));
1535 }
1537 sp_repr_css_attr_unref(css);
1539 sp_document_done(SP_DT_DOCUMENT(desktop));
1540 }
1541 }
1544 static void
1545 sp_stroke_style_set_join_buttons(SPWidget *spw, GtkWidget *active)
1546 {
1547 GtkWidget *tb;
1549 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1550 INKSCAPE_STOCK_JOIN_MITER) );
1551 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1553 GtkWidget *ml = GTK_WIDGET(g_object_get_data(G_OBJECT(spw), "miterlimit_sb"));
1554 gtk_widget_set_sensitive(ml, (active == tb));
1556 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1557 INKSCAPE_STOCK_JOIN_ROUND) );
1558 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1559 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1560 INKSCAPE_STOCK_JOIN_BEVEL) );
1561 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1562 }
1566 static void
1567 sp_stroke_style_set_cap_buttons(SPWidget *spw, GtkWidget *active)
1568 {
1569 GtkWidget *tb;
1571 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1572 INKSCAPE_STOCK_CAP_BUTT));
1573 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1574 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1575 INKSCAPE_STOCK_CAP_ROUND) );
1576 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1577 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1578 INKSCAPE_STOCK_CAP_SQUARE) );
1579 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1580 }
1582 static void
1583 ink_marker_menu_set_current(SPObject *marker, GtkOptionMenu *mnu)
1584 {
1585 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
1587 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(mnu));
1588 if (marker != NULL) {
1589 bool mark_is_stock = false;
1590 if (SP_OBJECT_REPR(marker)->attribute("inkscape:stockid"))
1591 mark_is_stock = true;
1593 gchar *markname;
1594 if (mark_is_stock)
1595 markname = g_strdup(SP_OBJECT_REPR(marker)->attribute("inkscape:stockid"));
1596 else
1597 markname = g_strdup(SP_OBJECT_REPR(marker)->attribute("id"));
1599 int markpos = 0;
1600 GList *kids = GTK_MENU_SHELL(m)->children;
1601 int i = 0;
1602 for (; kids != NULL; kids = kids->next) {
1603 gchar *mark = (gchar *) g_object_get_data(G_OBJECT(kids->data), "marker");
1604 if ( mark && strcmp(mark, markname) == 0 ) {
1605 if ( mark_is_stock && !strcmp((gchar *) g_object_get_data(G_OBJECT(kids->data), "stockid"), "true"))
1606 markpos = i;
1607 if ( !mark_is_stock && !strcmp((gchar *) g_object_get_data(G_OBJECT(kids->data), "stockid"), "false"))
1608 markpos = i;
1609 }
1610 i++;
1611 }
1612 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), markpos);
1614 g_free (markname);
1615 }
1616 else {
1617 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
1618 }
1619 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
1620 }
1622 static void
1623 sp_stroke_style_update_marker_menus( SPWidget *spw,
1624 GSList const *objects)
1625 {
1626 struct { char const *key; int loc; } const keyloc[] = {
1627 { "start_mark_menu", SP_MARKER_LOC_START },
1628 { "mid_mark_menu", SP_MARKER_LOC_MID },
1629 { "end_mark_menu", SP_MARKER_LOC_END }
1630 };
1632 bool all_texts = true;
1633 for (GSList *i = (GSList *) objects; i != NULL; i = i->next) {
1634 if (!SP_IS_TEXT (i->data)) {
1635 all_texts = false;
1636 }
1637 }
1639 for (unsigned i = 0; i < G_N_ELEMENTS(keyloc); ++i) {
1640 GtkOptionMenu *mnu = (GtkOptionMenu *) g_object_get_data(G_OBJECT(spw), keyloc[i].key);
1641 if (all_texts) {
1642 // Per SVG spec, text objects cannot have markers; disable menus if only texts are selected
1643 gtk_widget_set_sensitive (GTK_WIDGET(mnu), FALSE);
1644 } else {
1645 gtk_widget_set_sensitive (GTK_WIDGET(mnu), TRUE);
1646 }
1647 }
1649 // We show markers of the first object in the list only
1650 // FIXME: use the first in the list that has the marker of each type, if any
1651 SPObject *object = SP_OBJECT(objects->data);
1653 for (unsigned i = 0; i < G_N_ELEMENTS(keyloc); ++i) {
1654 // For all three marker types,
1656 // find the corresponding menu
1657 GtkOptionMenu *mnu = (GtkOptionMenu *) g_object_get_data(G_OBJECT(spw), keyloc[i].key);
1659 // Quit if we're in update state
1660 if (gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
1661 return;
1662 }
1664 if (object->style->marker[keyloc[i].loc].value != NULL && !all_texts) {
1665 // If the object has this type of markers,
1667 // Extract the name of the marker that the object uses
1668 SPObject *marker = ink_extract_marker_name(object->style->marker[keyloc[i].loc].value);
1669 // Scroll the menu to that marker
1670 ink_marker_menu_set_current (marker, mnu);
1672 } else {
1673 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
1674 }
1675 }
1676 }
1679 /** Extract the actual name of the link
1680 * e.g. get mTriangle from url(#mTriangle).
1681 * \return Buffer containing the actual name, allocated from GLib;
1682 * the caller should free the buffer when they no longer need it.
1683 */
1684 static SPObject*
1685 ink_extract_marker_name(gchar const *n)
1686 {
1687 gchar const *p = n;
1688 while (*p != '\0' && *p != '#') {
1689 p++;
1690 }
1692 if (*p == '\0' || p[1] == '\0') {
1693 return NULL;
1694 }
1696 p++;
1697 int c = 0;
1698 while (p[c] != '\0' && p[c] != ')') {
1699 c++;
1700 }
1702 if (p[c] == '\0') {
1703 return NULL;
1704 }
1706 gchar* b = g_strdup(p);
1707 b[c] = '\0';
1710 SPDesktop *desktop = inkscape_active_desktop();
1711 SPDocument *doc = SP_DT_DOCUMENT(desktop);
1712 SPObject *marker = doc->getObjectById(b);
1713 return marker;
1714 }
1717 /*
1718 Local Variables:
1719 mode:c++
1720 c-file-style:"stroustrup"
1721 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1722 indent-tabs-mode:nil
1723 fill-column:99
1724 End:
1725 */
1726 // vim: filetype=c++:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :