80099eb82718809fa03371e46b4f87555abe4310
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 <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 "sp-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"
60 #include "dialogs/stroke-style.h"
62 /* Paint */
64 static void sp_stroke_style_paint_construct(SPWidget *spw, SPPaintSelector *psel);
65 static void sp_stroke_style_paint_selection_modified (SPWidget *spw, Inkscape::Selection *selection, guint flags, SPPaintSelector *psel);
66 static void sp_stroke_style_paint_selection_changed (SPWidget *spw, Inkscape::Selection *selection, SPPaintSelector *psel);
67 static void sp_stroke_style_paint_update(SPWidget *spw);
69 static void sp_stroke_style_paint_mode_changed(SPPaintSelector *psel, SPPaintSelectorMode mode, SPWidget *spw);
70 static void sp_stroke_style_paint_dragged(SPPaintSelector *psel, SPWidget *spw);
71 static void sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw);
73 static void sp_stroke_style_widget_change_subselection ( Inkscape::Application *inkscape, SPDesktop *desktop, SPWidget *spw );
75 GtkWidget *
76 sp_stroke_style_paint_widget_new(void)
77 {
78 GtkWidget *spw, *psel;
80 spw = sp_widget_new_global(INKSCAPE);
82 psel = sp_paint_selector_new(false); // without fillrule selector
83 gtk_widget_show(psel);
84 gtk_container_add(GTK_CONTAINER(spw), psel);
85 gtk_object_set_data(GTK_OBJECT(spw), "paint-selector", psel);
87 gtk_signal_connect(GTK_OBJECT(spw), "construct",
88 GTK_SIGNAL_FUNC(sp_stroke_style_paint_construct),
89 psel);
90 gtk_signal_connect(GTK_OBJECT(spw), "modify_selection",
91 GTK_SIGNAL_FUNC(sp_stroke_style_paint_selection_modified),
92 psel);
93 gtk_signal_connect(GTK_OBJECT(spw), "change_selection",
94 GTK_SIGNAL_FUNC(sp_stroke_style_paint_selection_changed),
95 psel);
97 g_signal_connect (INKSCAPE, "change_subselection", G_CALLBACK (sp_stroke_style_widget_change_subselection), spw);
99 gtk_signal_connect(GTK_OBJECT(psel), "mode_changed",
100 GTK_SIGNAL_FUNC(sp_stroke_style_paint_mode_changed),
101 spw);
102 gtk_signal_connect(GTK_OBJECT(psel), "dragged",
103 GTK_SIGNAL_FUNC(sp_stroke_style_paint_dragged),
104 spw);
105 gtk_signal_connect(GTK_OBJECT(psel), "changed",
106 GTK_SIGNAL_FUNC(sp_stroke_style_paint_changed),
107 spw);
109 sp_stroke_style_paint_update (SP_WIDGET(spw));
110 return spw;
111 }
113 static void
114 sp_stroke_style_paint_construct(SPWidget *spw, SPPaintSelector *psel)
115 {
116 #ifdef SP_SS_VERBOSE
117 g_print( "Stroke style widget constructed: inkscape %p repr %p\n",
118 spw->inkscape, spw->repr );
119 #endif
120 if (spw->inkscape) {
121 sp_stroke_style_paint_update (spw);
122 }
123 }
125 static void
126 sp_stroke_style_paint_selection_modified ( SPWidget *spw,
127 Inkscape::Selection *selection,
128 guint flags,
129 SPPaintSelector *psel)
130 {
131 if (flags & ( SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG |
132 SP_OBJECT_STYLE_MODIFIED_FLAG) ) {
133 sp_stroke_style_paint_update(spw);
134 }
135 }
138 static void
139 sp_stroke_style_paint_selection_changed ( SPWidget *spw,
140 Inkscape::Selection *selection,
141 SPPaintSelector *psel )
142 {
143 sp_stroke_style_paint_update (spw);
144 }
146 static void
147 sp_stroke_style_widget_change_subselection ( Inkscape::Application *inkscape,
148 SPDesktop *desktop,
149 SPWidget *spw )
150 {
151 sp_stroke_style_paint_update (spw);
152 }
154 static void
155 sp_stroke_style_paint_update (SPWidget *spw)
156 {
157 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
158 return;
159 }
161 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
163 SPPaintSelector *psel = SP_PAINT_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "paint-selector"));
165 // create temporary style
166 SPStyle *query = sp_style_new ();
167 // query into it
168 int result = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKE);
170 switch (result) {
171 case QUERY_STYLE_NOTHING:
172 {
173 /* No paint at all */
174 sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_EMPTY);
175 break;
176 }
178 case QUERY_STYLE_SINGLE:
179 case QUERY_STYLE_MULTIPLE_AVERAGED: // TODO: treat this slightly differently, e.g. display "averaged" somewhere in paint selector
180 case QUERY_STYLE_MULTIPLE_SAME:
181 {
182 SPPaintSelectorMode pselmode = sp_style_determine_paint_selector_mode (query, false);
183 sp_paint_selector_set_mode (psel, pselmode);
185 if (query->stroke.set && query->stroke.type == SP_PAINT_TYPE_COLOR) {
186 gfloat d[3];
187 sp_color_get_rgb_floatv (&query->stroke.value.color, d);
188 SPColor color;
189 sp_color_set_rgb_float (&color, d[0], d[1], d[2]);
190 sp_paint_selector_set_color_alpha (psel, &color, SP_SCALE24_TO_FLOAT (query->stroke_opacity.value));
192 } else if (query->stroke.set && query->stroke.type == SP_PAINT_TYPE_PAINTSERVER) {
194 SPPaintServer *server = SP_STYLE_STROKE_SERVER (query);
196 if (SP_IS_LINEARGRADIENT (server)) {
197 SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
198 sp_paint_selector_set_gradient_linear (psel, vector);
200 SPLinearGradient *lg = SP_LINEARGRADIENT (server);
201 sp_paint_selector_set_gradient_properties (psel,
202 SP_GRADIENT_UNITS (lg),
203 SP_GRADIENT_SPREAD (lg));
204 } else if (SP_IS_RADIALGRADIENT (server)) {
205 SPGradient *vector = sp_gradient_get_vector (SP_GRADIENT (server), FALSE);
206 sp_paint_selector_set_gradient_radial (psel, vector);
208 SPRadialGradient *rg = SP_RADIALGRADIENT (server);
209 sp_paint_selector_set_gradient_properties (psel,
210 SP_GRADIENT_UNITS (rg),
211 SP_GRADIENT_SPREAD (rg));
212 } else if (SP_IS_PATTERN (server)) {
213 SPPattern *pat = pattern_getroot (SP_PATTERN (server));
214 sp_update_pattern_list (psel, pat);
215 }
216 }
217 break;
218 }
220 case QUERY_STYLE_MULTIPLE_DIFFERENT:
221 {
222 sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
223 break;
224 }
225 }
227 g_free (query);
229 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
230 }
232 static void
233 sp_stroke_style_paint_mode_changed( SPPaintSelector *psel,
234 SPPaintSelectorMode mode,
235 SPWidget *spw )
236 {
237 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
238 return;
239 }
241 /* TODO: Does this work?
242 * Not really, here we have to get old color back from object
243 * Instead of relying on paint widget having meaningful colors set
244 */
245 sp_stroke_style_paint_changed(psel, spw);
246 }
248 static gchar *undo_label_1 = "stroke:flatcolor:1";
249 static gchar *undo_label_2 = "stroke:flatcolor:2";
250 static gchar *undo_label = undo_label_1;
252 static void
253 sp_stroke_style_paint_dragged(SPPaintSelector *psel, SPWidget *spw)
254 {
255 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
256 return;
257 }
259 switch (psel->mode) {
260 case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
261 case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
262 {
263 sp_paint_selector_set_flat_color (psel, SP_ACTIVE_DESKTOP, "stroke", "stroke-opacity");
264 sp_document_maybe_done (sp_desktop_document(SP_ACTIVE_DESKTOP), undo_label, SP_VERB_NONE,
265 /* TODO: annotate */ "stroke-style.cpp:265");
266 break;
267 }
269 default:
270 g_warning( "file %s: line %d: Paint %d should not emit 'dragged'",
271 __FILE__, __LINE__, psel->mode);
272 break;
273 }
274 }
276 static void
277 sp_stroke_style_paint_changed(SPPaintSelector *psel, SPWidget *spw)
278 {
279 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
280 return;
281 }
282 g_object_set_data (G_OBJECT (spw), "update", GINT_TO_POINTER (TRUE));
284 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
285 SPDocument *document = sp_desktop_document (desktop);
286 Inkscape::Selection *selection = sp_desktop_selection (desktop);
288 GSList const *items = selection->itemList();
290 switch (psel->mode) {
291 case SP_PAINT_SELECTOR_MODE_EMPTY:
292 // This should not happen.
293 g_warning ( "file %s: line %d: Paint %d should not emit 'changed'",
294 __FILE__, __LINE__, psel->mode);
295 break;
296 case SP_PAINT_SELECTOR_MODE_MULTIPLE:
297 // This happens when you switch multiple objects with different gradients to flat color;
298 // nothing to do here.
299 break;
301 case SP_PAINT_SELECTOR_MODE_NONE:
302 {
303 SPCSSAttr *css = sp_repr_css_attr_new();
304 sp_repr_css_set_property(css, "stroke", "none");
306 sp_desktop_set_style (desktop, css);
308 sp_repr_css_attr_unref(css);
310 sp_document_done(document, SP_VERB_DIALOG_FILL_STROKE,
311 /* TODO: annotate */ "stroke-style.cpp:311");
312 break;
313 }
315 case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
316 case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
317 {
318 sp_paint_selector_set_flat_color (psel, desktop, "stroke", "stroke-opacity");
319 sp_document_maybe_done (sp_desktop_document(desktop), undo_label, SP_VERB_DIALOG_FILL_STROKE,
320 /* TODO: annotate */ "stroke-style.cpp:320");
322 // on release, toggle undo_label so that the next drag will not be lumped with this one
323 if (undo_label == undo_label_1)
324 undo_label = undo_label_2;
325 else
326 undo_label = undo_label_1;
328 break;
329 }
331 case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
332 case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
333 if (items) {
334 SPGradientType const gradient_type = ( psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR
335 ? SP_GRADIENT_TYPE_LINEAR
336 : SP_GRADIENT_TYPE_RADIAL );
337 SPGradient *vector = sp_paint_selector_get_gradient_vector(psel);
338 if (!vector) {
339 /* No vector in paint selector should mean that we just changed mode */
341 SPStyle *query = sp_style_new ();
342 int result = objects_query_fillstroke ((GSList *) items, query, false);
343 guint32 common_rgb = 0;
344 if (result == QUERY_STYLE_MULTIPLE_SAME) {
345 if (query->fill.type != SP_PAINT_TYPE_COLOR) {
346 common_rgb = sp_desktop_get_color(desktop, false);
347 } else {
348 common_rgb = sp_color_get_rgba32_ualpha(&query->stroke.value.color, 0xff);
349 }
350 vector = sp_document_default_gradient_vector(document, common_rgb);
351 }
352 g_free (query);
354 for (GSList const *i = items; i != NULL; i = i->next) {
355 if (!vector) {
356 sp_item_set_gradient(SP_ITEM(i->data),
357 sp_gradient_vector_for_object(document, desktop, SP_OBJECT(i->data), false),
358 gradient_type, false);
359 } else {
360 sp_item_set_gradient(SP_ITEM(i->data), vector, gradient_type, false);
361 }
362 }
363 } else {
364 vector = sp_gradient_ensure_vector_normalized(vector);
365 for (GSList const *i = items; i != NULL; i = i->next) {
366 SPGradient *gr = sp_item_set_gradient(SP_ITEM(i->data), vector, gradient_type, false);
367 sp_gradient_selector_attrs_to_gradient(gr, psel);
368 }
369 }
371 sp_document_done(document, SP_VERB_DIALOG_FILL_STROKE,
372 /* TODO: annotate */ "stroke-style.cpp:372");
373 }
374 break;
376 case SP_PAINT_SELECTOR_MODE_PATTERN:
378 if (items) {
380 SPPattern *pattern = sp_paint_selector_get_pattern (psel);
381 if (!pattern) {
383 /* No Pattern in paint selector should mean that we just
384 * changed mode - dont do jack.
385 */
387 } else {
388 Inkscape::XML::Node *patrepr = SP_OBJECT_REPR(pattern);
389 SPCSSAttr *css = sp_repr_css_attr_new ();
390 gchar *urltext = g_strdup_printf ("url(#%s)", patrepr->attribute("id"));
391 sp_repr_css_set_property (css, "stroke", urltext);
393 for (GSList const *i = items; i != NULL; i = i->next) {
394 Inkscape::XML::Node *selrepr = SP_OBJECT_REPR (i->data);
395 SPObject *selobj = SP_OBJECT (i->data);
396 if (!selrepr)
397 continue;
399 SPStyle *style = SP_OBJECT_STYLE (selobj);
400 if (style && style->stroke.type == SP_PAINT_TYPE_PAINTSERVER) {
401 SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (selobj);
402 if (SP_IS_PATTERN (server) && pattern_getroot (SP_PATTERN(server)) == pattern)
403 // only if this object's pattern is not rooted in our selected pattern, apply
404 continue;
405 }
407 sp_repr_css_change_recursive (selrepr, css, "style");
408 }
410 sp_repr_css_attr_unref (css);
411 g_free (urltext);
413 } // end if
415 sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE,
416 /* TODO: annotate */ "stroke-style.cpp:416");
417 } // end if
419 break;
421 case SP_PAINT_SELECTOR_MODE_UNSET:
422 if (items) {
423 SPCSSAttr *css = sp_repr_css_attr_new ();
424 sp_repr_css_unset_property (css, "stroke");
426 sp_desktop_set_style (desktop, css);
427 sp_repr_css_attr_unref (css);
429 sp_document_done (document, SP_VERB_DIALOG_FILL_STROKE,
430 /* TODO: annotate */ "stroke-style.cpp:430");
431 }
432 break;
434 default:
435 g_warning( "file %s: line %d: Paint selector should not be in "
436 "mode %d",
437 __FILE__, __LINE__,
438 psel->mode );
439 break;
440 }
442 g_object_set_data (G_OBJECT (spw), "update", GINT_TO_POINTER (FALSE));
443 }
449 /* Line */
451 static void sp_stroke_style_line_construct(SPWidget *spw, gpointer data);
452 static void sp_stroke_style_line_selection_modified (SPWidget *spw,
453 Inkscape::Selection *selection,
454 guint flags,
455 gpointer data);
457 static void sp_stroke_style_line_selection_changed (SPWidget *spw,
458 Inkscape::Selection *selection,
459 gpointer data );
461 static void sp_stroke_style_line_update(SPWidget *spw, Inkscape::Selection *sel);
463 static void sp_stroke_style_set_join_buttons(SPWidget *spw,
464 GtkWidget *active);
466 static void sp_stroke_style_set_cap_buttons(SPWidget *spw,
467 GtkWidget *active);
469 static void sp_stroke_style_width_changed(GtkAdjustment *adj, SPWidget *spw);
470 static void sp_stroke_style_miterlimit_changed(GtkAdjustment *adj, SPWidget *spw);
471 static void sp_stroke_style_any_toggled(GtkToggleButton *tb, SPWidget *spw);
472 static void sp_stroke_style_line_dash_changed(SPDashSelector *dsel,
473 SPWidget *spw);
475 static void sp_stroke_style_update_marker_menus(SPWidget *spw, GSList const *objects);
477 static SPObject *ink_extract_marker_name(gchar const *n);
480 /**
481 * Helper function for creating radio buttons. This should probably be re-thought out
482 * when reimplementing this with Gtkmm.
483 */
484 static GtkWidget *
485 sp_stroke_radio_button(GtkWidget *tb, char const *icon,
486 GtkWidget *hb, GtkWidget *spw,
487 gchar const *key, gchar const *data)
488 {
489 g_assert(icon != NULL);
490 g_assert(hb != NULL);
491 g_assert(spw != NULL);
493 if (tb == NULL) {
494 tb = gtk_radio_button_new(NULL);
495 } else {
496 tb = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(tb)) );
497 }
499 gtk_widget_show(tb);
500 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(tb), FALSE);
501 gtk_box_pack_start(GTK_BOX(hb), tb, FALSE, FALSE, 0);
502 gtk_object_set_data(GTK_OBJECT(spw), icon, tb);
503 gtk_object_set_data(GTK_OBJECT(tb), key, (gpointer*)data);
504 gtk_signal_connect(GTK_OBJECT(tb), "toggled",
505 GTK_SIGNAL_FUNC(sp_stroke_style_any_toggled),
506 spw);
507 GtkWidget *px = sp_icon_new(Inkscape::ICON_SIZE_LARGE_TOOLBAR, icon);
508 g_assert(px != NULL);
509 gtk_widget_show(px);
510 gtk_container_add(GTK_CONTAINER(tb), px);
512 return tb;
514 }
516 static GtkWidget *
517 sp_marker_prev_new(unsigned size, gchar const *mname,
518 SPDocument *source, SPDocument *sandbox,
519 gchar *menu_id, NRArena const *arena, unsigned visionkey, NRArenaItem *root)
520 {
521 // the object of the marker
522 SPObject const *marker = source->getObjectById(mname);
523 if (marker == NULL)
524 return NULL;
526 // the repr of the marker; make a copy with id="sample"
527 Inkscape::XML::Node *mrepr = SP_OBJECT_REPR (marker)->duplicate();
528 mrepr->setAttribute("id", "sample");
530 // replace the old sample in the sandbox by the new one
531 Inkscape::XML::Node *defsrepr = SP_OBJECT_REPR (sandbox->getObjectById("defs"));
532 SPObject *oldmarker = sandbox->getObjectById("sample");
533 if (oldmarker)
534 oldmarker->deleteObject(false);
535 defsrepr->appendChild(mrepr);
536 Inkscape::GC::release(mrepr);
538 // Uncomment this to get the sandbox documents saved (useful for debugging)
539 //FILE *fp = fopen (g_strconcat(mname, ".svg", NULL), "w");
540 //sp_repr_save_stream (sp_document_repr_doc (sandbox), fp);
541 //fclose (fp);
543 // object to render; note that the id is the same as that of the menu we're building
544 SPObject *object = sandbox->getObjectById(menu_id);
545 sp_document_root (sandbox)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
546 sp_document_ensure_up_to_date(sandbox);
548 if (object == NULL || !SP_IS_ITEM(object))
549 return NULL; // sandbox broken?
551 // Find object's bbox in document
552 NR::Matrix const i2doc(sp_item_i2doc_affine(SP_ITEM(object)));
554 NR::Rect const dbox = SP_ITEM(object)->invokeBbox(i2doc);
556 if (dbox.isEmpty()) {
557 return NULL;
558 }
560 /* Update to renderable state */
561 NRMatrix t;
562 double sf = 0.8;
563 nr_matrix_set_scale(&t, sf, sf);
564 nr_arena_item_set_transform(root, &t);
565 NRGC gc(NULL);
566 nr_matrix_set_identity(&gc.transform);
567 nr_arena_item_invoke_update( root, NULL, &gc,
568 NR_ARENA_ITEM_STATE_ALL,
569 NR_ARENA_ITEM_STATE_NONE );
571 /* Item integer bbox in points */
572 NRRectL ibox;
573 ibox.x0 = (int) floor(sf * dbox.min()[NR::X] + 0.5);
574 ibox.y0 = (int) floor(sf * dbox.min()[NR::Y] + 0.5);
575 ibox.x1 = (int) floor(sf * dbox.max()[NR::X] + 0.5);
576 ibox.y1 = (int) floor(sf * dbox.max()[NR::Y] + 0.5);
578 /* Find visible area */
579 int width = ibox.x1 - ibox.x0;
580 int height = ibox.y1 - ibox.y0;
581 int dx = size;
582 int dy = size;
583 dx=(dx - width)/2; // watch out for size, since 'unsigned'-'signed' can cause problems if the result is negative
584 dy=(dy - height)/2;
586 NRRectL area;
587 area.x0 = ibox.x0 - dx;
588 area.y0 = ibox.y0 - dy;
589 area.x1 = area.x0 + size;
590 area.y1 = area.y0 + size;
592 /* Actual renderable area */
593 NRRectL ua;
594 ua.x0 = MAX(ibox.x0, area.x0);
595 ua.y0 = MAX(ibox.y0, area.y0);
596 ua.x1 = MIN(ibox.x1, area.x1);
597 ua.y1 = MIN(ibox.y1, area.y1);
599 /* Set up pixblock */
600 guchar *px = g_new(guchar, 4 * size * size);
601 memset(px, 0x00, 4 * size * size);
603 /* Render */
604 NRPixBlock B;
605 nr_pixblock_setup_extern( &B, NR_PIXBLOCK_MODE_R8G8B8A8N,
606 ua.x0, ua.y0, ua.x1, ua.y1,
607 px + 4 * size * (ua.y0 - area.y0) +
608 4 * (ua.x0 - area.x0),
609 4 * size, FALSE, FALSE );
610 nr_arena_item_invoke_render( root, &ua, &B,
611 NR_ARENA_ITEM_RENDER_NO_CACHE );
612 nr_pixblock_release(&B);
614 // Create widget
615 GtkWidget *pb = gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_data(px,
616 GDK_COLORSPACE_RGB,
617 TRUE,
618 8, size, size, size * 4,
619 (GdkPixbufDestroyNotify)g_free,
620 NULL));
621 return pb;
622 }
625 #define MARKER_ITEM_MARGIN 0
628 /**
629 * sp_marker_list_from_doc()
630 *
631 * \brief Pick up all markers from source, except those that are in
632 * current_doc (if non-NULL), and add items to the m menu
633 *
634 */
635 static void
636 sp_marker_list_from_doc (GtkWidget *m, SPDocument *current_doc, SPDocument *source, SPDocument *markers_doc, SPDocument *sandbox, gchar *menu_id)
637 {
639 // search through defs
640 GSList *ml = NULL;
641 SPDefs *defs= (SPDefs *) SP_DOCUMENT_DEFS (source);
642 for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(defs)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT (ochild) ) {
643 if (SP_IS_MARKER(ochild)) {
644 ml = g_slist_prepend (ml, ochild);
645 }
646 }
648 // Do this here, outside of loop, to speed up preview generation:
649 /* Create new arena */
650 NRArena const *arena = NRArena::create();
651 /* Create ArenaItem and set transform */
652 unsigned const visionkey = sp_item_display_key_new(1);
653 NRArenaItem *root = sp_item_invoke_show( SP_ITEM(SP_DOCUMENT_ROOT (sandbox)), (NRArena *) arena, visionkey, SP_ITEM_SHOW_DISPLAY );
655 for (; ml != NULL; ml = ml->next) {
657 if (!SP_IS_MARKER(ml->data))
658 continue;
660 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) ml->data);
662 bool stock_dupe = false;
664 if (markers_doc && repr->attribute("inkscape:stockid")) {
665 // find out if markers_doc has a marker with the same stockid, and if so, skip this
666 for (SPObject *child = sp_object_first_child(SP_OBJECT(SP_DOCUMENT_DEFS(markers_doc))) ;
667 child != NULL;
668 child = SP_OBJECT_NEXT(child) )
669 {
670 if (SP_IS_MARKER(child) &&
671 SP_OBJECT_REPR(child)->attribute("inkscape:stockid") &&
672 !strcmp(repr->attribute("inkscape:stockid"), SP_OBJECT_REPR(child)->attribute("inkscape:stockid"))) {
673 stock_dupe = true;
674 }
675 }
676 }
678 if (stock_dupe) // stock item, dont add to list from current doc
679 continue;
681 GtkWidget *i = gtk_menu_item_new();
682 gtk_widget_show(i);
684 if (repr->attribute("inkscape:stockid"))
685 g_object_set_data (G_OBJECT(i), "stockid", (void *) "true");
686 else
687 g_object_set_data (G_OBJECT(i), "stockid", (void *) "false");
689 gchar const *markid = repr->attribute("id");
690 g_object_set_data (G_OBJECT(i), "marker", (void *) markid);
692 GtkWidget *hb = gtk_hbox_new(FALSE, MARKER_ITEM_MARGIN);
693 gtk_widget_show(hb);
695 // generate preview
696 GtkWidget *prv = sp_marker_prev_new (22, markid, source, sandbox, menu_id, arena, visionkey, root);
697 gtk_widget_show(prv);
698 gtk_box_pack_start(GTK_BOX(hb), prv, FALSE, FALSE, 6);
700 // create label
701 GtkWidget *l = gtk_label_new(repr->attribute("id"));
702 gtk_widget_show(l);
703 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
705 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
707 gtk_widget_show(hb);
708 gtk_container_add(GTK_CONTAINER(i), hb);
710 gtk_menu_append(GTK_MENU(m), i);
711 }
713 g_slist_free (ml);
714 }
717 SPDocument *
718 ink_markers_preview_doc ()
719 {
720 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\">"
721 " <defs id=\"defs\" />"
723 " <g id=\"marker-start\">"
724 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:url(#sample);marker-mid:none;marker-end:none\""
725 " d=\"M 12.5,13 L 25,13\" id=\"path1\" />"
726 " <rect style=\"fill:none;stroke:none\" id=\"rect2\""
727 " width=\"25\" height=\"25\" x=\"0\" y=\"0\" />"
728 " </g>"
730 " <g id=\"marker-mid\">"
731 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:none;marker-mid:url(#sample);marker-end:none\""
732 " d=\"M 0,113 L 12.5,113 L 25,113\" id=\"path11\" />"
733 " <rect style=\"fill:none;stroke:none\" id=\"rect22\""
734 " width=\"25\" height=\"25\" x=\"0\" y=\"100\" />"
735 " </g>"
737 " <g id=\"marker-end\">"
738 " <path style=\"fill:none;stroke:black;stroke-width:1.7;marker-start:none;marker-mid:none;marker-end:url(#sample)\""
739 " d=\"M 0,213 L 12.5,213\" id=\"path111\" />"
740 " <rect style=\"fill:none;stroke:none\" id=\"rect222\""
741 " width=\"25\" height=\"25\" x=\"0\" y=\"200\" />"
742 " </g>"
744 "</svg>";
746 return sp_document_new_from_mem (buffer, strlen(buffer), FALSE);
747 }
751 static GtkWidget *
752 ink_marker_menu( GtkWidget *tbl, gchar *menu_id, SPDocument *sandbox)
753 {
754 SPDesktop *desktop = inkscape_active_desktop();
755 SPDocument *doc = sp_desktop_document(desktop);
756 GtkWidget *mnu = gtk_option_menu_new();
758 /* Create new menu widget */
759 GtkWidget *m = gtk_menu_new();
760 gtk_widget_show(m);
762 g_object_set_data(G_OBJECT(mnu), "updating", (gpointer) FALSE);
764 if (!doc) {
765 GtkWidget *i = gtk_menu_item_new_with_label(_("No document selected"));
766 gtk_widget_show(i);
767 gtk_menu_append(GTK_MENU(m), i);
768 gtk_widget_set_sensitive(mnu, FALSE);
770 } else {
772 // add "None"
773 {
774 GtkWidget *i = gtk_menu_item_new();
775 gtk_widget_show(i);
777 g_object_set_data(G_OBJECT(i), "marker", (void *) "none");
779 GtkWidget *hb = gtk_hbox_new(FALSE, MARKER_ITEM_MARGIN);
780 gtk_widget_show(hb);
782 GtkWidget *l = gtk_label_new( _("None") );
783 gtk_widget_show(l);
784 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
786 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
788 gtk_widget_show(hb);
789 gtk_container_add(GTK_CONTAINER(i), hb);
790 gtk_menu_append(GTK_MENU(m), i);
791 }
793 // find and load markers.svg
794 static SPDocument *markers_doc = NULL;
795 char *markers_source = g_build_filename(INKSCAPE_MARKERSDIR, "markers.svg", NULL);
796 if (Inkscape::IO::file_test(markers_source, G_FILE_TEST_IS_REGULAR)) {
797 markers_doc = sp_document_new(markers_source, FALSE);
798 }
799 g_free(markers_source);
801 // suck in from current doc
802 sp_marker_list_from_doc ( m, NULL, doc, markers_doc, sandbox, menu_id );
804 // add separator
805 {
806 GtkWidget *i = gtk_separator_menu_item_new();
807 gtk_widget_show(i);
808 gtk_menu_append(GTK_MENU(m), i);
809 }
811 // suck in from markers.svg
812 if (markers_doc) {
813 sp_document_ensure_up_to_date(doc);
814 sp_marker_list_from_doc ( m, doc, markers_doc, NULL, sandbox, menu_id );
815 }
817 gtk_widget_set_sensitive(mnu, TRUE);
818 }
820 gtk_object_set_data(GTK_OBJECT(mnu), "menu_id", menu_id);
821 gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
823 /* Set history */
824 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
826 return mnu;
827 }
830 /*user selected existing marker from list*/
831 static void
832 sp_marker_select(GtkOptionMenu *mnu, GtkWidget *spw)
833 {
834 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
835 return;
836 }
838 SPDesktop *desktop = inkscape_active_desktop();
839 SPDocument *document = sp_desktop_document(desktop);
840 if (!document) {
841 return;
842 }
844 /* Get Marker */
845 if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
846 "marker"))
847 {
848 return;
849 }
850 gchar *markid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
851 "marker");
852 gchar *marker = "";
853 if (strcmp(markid, "none")){
854 gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))),
855 "stockid");
857 gchar *markurn = markid;
858 if (!strcmp(stockid,"true")) markurn = g_strconcat("urn:inkscape:marker:",markid,NULL);
859 SPObject *mark = get_stock_item(markurn);
860 if (mark) {
861 Inkscape::XML::Node *repr = SP_OBJECT_REPR(mark);
862 marker = g_strconcat("url(#", repr->attribute("id"), ")", NULL);
863 }
864 } else {
865 marker = markid;
866 }
868 SPCSSAttr *css = sp_repr_css_attr_new();
869 gchar *menu_id = (gchar *) g_object_get_data(G_OBJECT(mnu), "menu_id");
870 sp_repr_css_set_property(css, menu_id, marker);
872 Inkscape::Selection *selection = sp_desktop_selection(desktop);
873 GSList const *items = selection->itemList();
874 for (; items != NULL; items = items->next) {
875 SPItem *item = (SPItem *) items->data;
876 if (!SP_IS_SHAPE(item) || SP_IS_RECT(item)) // can't set marker to rect, until it's converted to using <path>
877 continue;
878 Inkscape::XML::Node *selrepr = SP_OBJECT_REPR((SPItem *) items->data);
879 if (selrepr) {
880 sp_repr_css_change_recursive(selrepr, css, "style");
881 }
882 SP_OBJECT(items->data)->requestModified(SP_OBJECT_MODIFIED_FLAG);
883 SP_OBJECT(items->data)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
884 }
886 sp_repr_css_attr_unref(css);
888 sp_document_done(document, SP_VERB_DIALOG_FILL_STROKE,
889 /* TODO: annotate */ "stroke-style.cpp:889");
890 }
892 static gboolean stroke_width_set_unit(SPUnitSelector *,
893 SPUnit const *old,
894 SPUnit const *new_units,
895 GObject *spw)
896 {
897 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
899 if (!desktop) {
900 return FALSE;
901 }
903 Inkscape::Selection *selection = sp_desktop_selection (desktop);
905 if (selection->isEmpty())
906 return FALSE;
908 GSList const *objects = selection->itemList();
910 if ((old->base == SP_UNIT_ABSOLUTE || old->base == SP_UNIT_DEVICE) &&
911 (new_units->base == SP_UNIT_DIMENSIONLESS)) {
913 /* Absolute to percentage */
914 g_object_set_data (spw, "update", GUINT_TO_POINTER (TRUE));
916 GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data (spw, "width"));
917 float w = sp_units_get_pixels (a->value, *old);
919 gdouble average = stroke_average_width (objects);
921 if (average == NR_HUGE || average == 0)
922 return FALSE;
924 gtk_adjustment_set_value (a, 100.0 * w / average);
926 g_object_set_data (spw, "update", GUINT_TO_POINTER (FALSE));
927 return TRUE;
929 } else if ((old->base == SP_UNIT_DIMENSIONLESS) &&
930 (new_units->base == SP_UNIT_ABSOLUTE || new_units->base == SP_UNIT_DEVICE)) {
932 /* Percentage to absolute */
933 g_object_set_data (spw, "update", GUINT_TO_POINTER (TRUE));
935 GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data (spw, "width"));
937 gdouble average = stroke_average_width (objects);
939 gtk_adjustment_set_value (a, sp_pixels_get_units (0.01 * a->value * average, *new_units));
941 g_object_set_data (spw, "update", GUINT_TO_POINTER (FALSE));
942 return TRUE;
943 }
945 return FALSE;
946 }
949 /**
950 * \brief Creates a new widget for the line stroke style.
951 *
952 */
953 GtkWidget *
954 sp_stroke_style_line_widget_new(void)
955 {
956 GtkWidget *spw, *f, *t, *hb, *sb, *us, *tb, *ds;
957 GtkObject *a;
959 GtkTooltips *tt = gtk_tooltips_new();
961 spw = sp_widget_new_global(INKSCAPE);
963 f = gtk_hbox_new (FALSE, 0);
964 gtk_widget_show(f);
965 gtk_container_add(GTK_CONTAINER(spw), f);
967 t = gtk_table_new(3, 6, FALSE);
968 gtk_widget_show(t);
969 gtk_container_set_border_width(GTK_CONTAINER(t), 4);
970 gtk_table_set_row_spacings(GTK_TABLE(t), 4);
971 gtk_container_add(GTK_CONTAINER(f), t);
972 gtk_object_set_data(GTK_OBJECT(spw), "stroke", t);
974 gint i = 0;
976 /* Stroke width */
977 spw_label(t, _("Width:"), 0, i);
979 hb = spw_hbox(t, 3, 1, i);
981 // TODO: when this is gtkmmified, use an Inkscape::UI::Widget::ScalarUnit instead of the separate
982 // spinbutton and unit selector for stroke width. In sp_stroke_style_line_update, use
983 // setHundredPercent to remember the aeraged width corresponding to 100%. Then the
984 // stroke_width_set_unit will be removed (because ScalarUnit takes care of conversions itself), and
985 // with it, the two remaining calls of stroke_average_width, allowing us to get rid of that
986 // function in desktop-style.
988 a = gtk_adjustment_new(1.0, 0.0, 1000.0, 0.1, 10.0, 10.0);
989 gtk_object_set_data(GTK_OBJECT(spw), "width", a);
990 sb = gtk_spin_button_new(GTK_ADJUSTMENT(a), 0.1, 3);
991 gtk_tooltips_set_tip(tt, sb, _("Stroke width"), NULL);
992 gtk_widget_show(sb);
994 sp_dialog_defocus_on_enter(sb);
996 gtk_box_pack_start(GTK_BOX(hb), sb, FALSE, FALSE, 0);
997 us = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
998 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
999 if (desktop)
1000 sp_unit_selector_set_unit (SP_UNIT_SELECTOR(us), sp_desktop_namedview(desktop)->doc_units);
1001 sp_unit_selector_add_unit(SP_UNIT_SELECTOR(us), &sp_unit_get_by_id(SP_UNIT_PERCENT), 0);
1002 g_signal_connect ( G_OBJECT (us), "set_unit", G_CALLBACK (stroke_width_set_unit), spw );
1003 gtk_widget_show(us);
1004 sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), GTK_ADJUSTMENT(a) );
1005 gtk_box_pack_start(GTK_BOX(hb), us, FALSE, FALSE, 0);
1006 gtk_object_set_data(GTK_OBJECT(spw), "units", us);
1008 gtk_signal_connect( GTK_OBJECT(a), "value_changed", GTK_SIGNAL_FUNC(sp_stroke_style_width_changed), spw );
1009 i++;
1011 /* Join type */
1012 // TRANSLATORS: The line join style specifies the shape to be used at the
1013 // corners of paths. It can be "miter", "round" or "bevel".
1014 spw_label(t, _("Join:"), 0, i);
1016 hb = spw_hbox(t, 3, 1, i);
1018 tb = NULL;
1020 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_MITER,
1021 hb, spw, "join", "miter");
1023 // TRANSLATORS: Miter join: joining lines with a sharp (pointed) 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, _("Miter join"), NULL);
1028 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_ROUND,
1029 hb, spw, "join", "round");
1031 // TRANSLATORS: Round join: joining lines with a rounded 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, _("Round join"), NULL);
1036 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_BEVEL,
1037 hb, spw, "join", "bevel");
1039 // TRANSLATORS: Bevel join: joining lines with a blunted (flattened) corner.
1040 // For an example, draw a triangle with a large stroke width and modify the
1041 // "Join" option (in the Fill and Stroke dialog).
1042 gtk_tooltips_set_tip(tt, tb, _("Bevel join"), NULL);
1044 i++;
1046 /* Miterlimit */
1047 // TRANSLATORS: Miter limit: only for "miter join", this limits the length
1048 // of the sharp "spike" when the lines connect at too sharp an angle.
1049 // When two line segments meet at a sharp angle, a miter join results in a
1050 // spike that extends well beyond the connection point. The purpose of the
1051 // miter limit is to cut off such spikes (i.e. convert them into bevels)
1052 // when they become too long.
1053 spw_label(t, _("Miter limit:"), 0, i);
1055 hb = spw_hbox(t, 3, 1, i);
1057 a = gtk_adjustment_new(4.0, 0.0, 100.0, 0.1, 10.0, 10.0);
1058 gtk_object_set_data(GTK_OBJECT(spw), "miterlimit", a);
1060 sb = gtk_spin_button_new(GTK_ADJUSTMENT(a), 0.1, 2);
1061 gtk_tooltips_set_tip(tt, sb, _("Maximum length of the miter (in units of stroke width)"), NULL);
1062 gtk_widget_show(sb);
1063 gtk_object_set_data(GTK_OBJECT(spw), "miterlimit_sb", sb);
1064 sp_dialog_defocus_on_enter(sb);
1066 gtk_box_pack_start(GTK_BOX(hb), sb, FALSE, FALSE, 0);
1068 gtk_signal_connect( GTK_OBJECT(a), "value_changed",
1069 GTK_SIGNAL_FUNC(sp_stroke_style_miterlimit_changed), spw );
1070 i++;
1072 /* Cap type */
1073 // TRANSLATORS: cap type specifies the shape for the ends of lines
1074 spw_label(t, _("Cap:"), 0, i);
1076 hb = spw_hbox(t, 3, 1, i);
1078 tb = NULL;
1080 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_BUTT,
1081 hb, spw, "cap", "butt");
1083 // TRANSLATORS: Butt cap: the line shape does not extend beyond the end point
1084 // of the line; the ends of the line are square
1085 gtk_tooltips_set_tip(tt, tb, _("Butt cap"), NULL);
1087 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_ROUND,
1088 hb, spw, "cap", "round");
1090 // TRANSLATORS: Round cap: the line shape extends beyond the end point of the
1091 // line; the ends of the line are rounded
1092 gtk_tooltips_set_tip(tt, tb, _("Round cap"), NULL);
1094 tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_SQUARE,
1095 hb, spw, "cap", "square");
1097 // TRANSLATORS: Square cap: the line shape extends beyond the end point of the
1098 // line; the ends of the line are square
1099 gtk_tooltips_set_tip(tt, tb, _("Square cap"), NULL);
1101 i++;
1104 /* Dash */
1105 spw_label(t, _("Dashes:"), 0, i);
1106 ds = sp_dash_selector_new( inkscape_get_repr( INKSCAPE,
1107 "palette.dashes") );
1109 gtk_widget_show(ds);
1110 gtk_table_attach( GTK_TABLE(t), ds, 1, 4, i, i+1,
1111 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1112 (GtkAttachOptions)0, 0, 0 );
1113 gtk_object_set_data(GTK_OBJECT(spw), "dash", ds);
1114 gtk_signal_connect( GTK_OBJECT(ds), "changed",
1115 GTK_SIGNAL_FUNC(sp_stroke_style_line_dash_changed),
1116 spw );
1117 i++;
1119 /* Drop down marker selectors*/
1121 // doing this here once, instead of for each preview, to speed things up
1122 SPDocument *sandbox = ink_markers_preview_doc ();
1124 // TRANSLATORS: Path markers are an SVG feature that allows you to attach arbitrary shapes
1125 // (arrowheads, bullets, faces, whatever) to the start, end, or middle nodes of a path.
1126 spw_label(t, _("Start Markers:"), 0, i);
1127 GtkWidget *mnu = ink_marker_menu( spw ,"marker-start", sandbox);
1128 gtk_signal_connect( GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1129 gtk_widget_show(mnu);
1130 gtk_table_attach( GTK_TABLE(t), mnu, 1, 4, i, i+1,
1131 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1132 (GtkAttachOptions)0, 0, 0 );
1133 gtk_object_set_data(GTK_OBJECT(spw), "start_mark_menu", mnu);
1135 i++;
1136 spw_label(t, _("Mid Markers:"), 0, i);
1137 mnu = NULL;
1138 mnu = ink_marker_menu( spw ,"marker-mid", sandbox);
1139 gtk_signal_connect( GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1140 gtk_widget_show(mnu);
1141 gtk_table_attach( GTK_TABLE(t), mnu, 1, 4, i, i+1,
1142 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1143 (GtkAttachOptions)0, 0, 0 );
1144 gtk_object_set_data(GTK_OBJECT(spw), "mid_mark_menu", mnu);
1146 i++;
1147 spw_label(t, _("End Markers:"), 0, i);
1148 mnu = NULL;
1149 mnu = ink_marker_menu( spw ,"marker-end", sandbox);
1150 gtk_signal_connect( GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_marker_select), spw );
1151 gtk_widget_show(mnu);
1152 gtk_table_attach( GTK_TABLE(t), mnu, 1, 4, i, i+1,
1153 (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1154 (GtkAttachOptions)0, 0, 0 );
1155 gtk_object_set_data(GTK_OBJECT(spw), "end_mark_menu", mnu);
1157 i++;
1159 gtk_signal_connect( GTK_OBJECT(spw), "construct",
1160 GTK_SIGNAL_FUNC(sp_stroke_style_line_construct),
1161 NULL );
1162 gtk_signal_connect( GTK_OBJECT(spw), "modify_selection",
1163 GTK_SIGNAL_FUNC(sp_stroke_style_line_selection_modified),
1164 NULL );
1165 gtk_signal_connect( GTK_OBJECT(spw), "change_selection",
1166 GTK_SIGNAL_FUNC(sp_stroke_style_line_selection_changed),
1167 NULL );
1169 sp_stroke_style_line_update( SP_WIDGET(spw), desktop ? sp_desktop_selection(desktop) : NULL);
1171 return spw;
1172 }
1176 static void
1177 sp_stroke_style_line_construct(SPWidget *spw, gpointer data)
1178 {
1180 #ifdef SP_SS_VERBOSE
1181 g_print( "Stroke style widget constructed: inkscape %p repr %p\n",
1182 spw->inkscape, spw->repr );
1183 #endif
1184 if (spw->inkscape) {
1185 sp_stroke_style_line_update(spw,
1186 ( SP_ACTIVE_DESKTOP
1187 ? sp_desktop_selection(SP_ACTIVE_DESKTOP)
1188 : NULL ));
1189 }
1190 }
1192 static void
1193 sp_stroke_style_line_selection_modified ( SPWidget *spw,
1194 Inkscape::Selection *selection,
1195 guint flags,
1196 gpointer data )
1197 {
1198 if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG)) {
1199 sp_stroke_style_line_update (spw, selection);
1200 }
1202 }
1204 static void
1205 sp_stroke_style_line_selection_changed ( SPWidget *spw,
1206 Inkscape::Selection *selection,
1207 gpointer data )
1208 {
1209 sp_stroke_style_line_update (spw, selection);
1210 }
1213 static void
1214 sp_dash_selector_set_from_style (GtkWidget *dsel, SPStyle *style)
1215 {
1216 if (style->stroke_dash.n_dash > 0) {
1217 double d[64];
1218 int len = MIN(style->stroke_dash.n_dash, 64);
1219 for (int i = 0; i < len; i++) {
1220 if (style->stroke_width.computed != 0)
1221 d[i] = style->stroke_dash.dash[i] / style->stroke_width.computed;
1222 else
1223 d[i] = style->stroke_dash.dash[i]; // is there a better thing to do for stroke_width==0?
1224 }
1225 sp_dash_selector_set_dash(SP_DASH_SELECTOR(dsel), len, d,
1226 style->stroke_width.computed != 0?
1227 style->stroke_dash.offset / style->stroke_width.computed :
1228 style->stroke_dash.offset);
1229 } else {
1230 sp_dash_selector_set_dash(SP_DASH_SELECTOR(dsel), 0, NULL, 0.0);
1231 }
1232 }
1234 static void
1235 sp_jointype_set (SPWidget *spw, unsigned const jointype)
1236 {
1237 GtkWidget *tb = NULL;
1238 switch (jointype) {
1239 case SP_STROKE_LINEJOIN_MITER:
1240 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_MITER));
1241 break;
1242 case SP_STROKE_LINEJOIN_ROUND:
1243 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_ROUND));
1244 break;
1245 case SP_STROKE_LINEJOIN_BEVEL:
1246 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_JOIN_BEVEL));
1247 break;
1248 default:
1249 break;
1250 }
1251 sp_stroke_style_set_join_buttons (spw, tb);
1252 }
1254 static void
1255 sp_captype_set (SPWidget *spw, unsigned const captype)
1256 {
1257 GtkWidget *tb = NULL;
1258 switch (captype) {
1259 case SP_STROKE_LINECAP_BUTT:
1260 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_BUTT));
1261 break;
1262 case SP_STROKE_LINECAP_ROUND:
1263 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_ROUND));
1264 break;
1265 case SP_STROKE_LINECAP_SQUARE:
1266 tb = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), INKSCAPE_STOCK_CAP_SQUARE));
1267 break;
1268 default:
1269 break;
1270 }
1271 sp_stroke_style_set_cap_buttons (spw, tb);
1272 }
1274 static void
1275 sp_stroke_style_line_update(SPWidget *spw, Inkscape::Selection *sel)
1276 {
1277 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1278 return;
1279 }
1281 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
1283 GtkWidget *sset = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "stroke"));
1284 GtkObject *width = GTK_OBJECT(gtk_object_get_data(GTK_OBJECT(spw), "width"));
1285 GtkObject *ml = GTK_OBJECT(gtk_object_get_data(GTK_OBJECT(spw), "miterlimit"));
1286 GtkWidget *us = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "units"));
1287 GtkWidget *dsel = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "dash"));
1289 // create temporary style
1290 SPStyle *query = sp_style_new ();
1291 // query into it
1292 int result_sw = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEWIDTH);
1293 int result_ml = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEMITERLIMIT);
1294 int result_cap = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKECAP);
1295 int result_join = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_STROKEJOIN);
1297 if (result_sw == QUERY_STYLE_NOTHING) {
1298 /* No objects stroked, set insensitive */
1299 gtk_widget_set_sensitive(sset, FALSE);
1301 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
1302 return;
1303 } else {
1304 gtk_widget_set_sensitive(sset, TRUE);
1306 SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
1308 if (result_sw == QUERY_STYLE_MULTIPLE_AVERAGED) {
1309 sp_unit_selector_set_unit(SP_UNIT_SELECTOR(us), &sp_unit_get_by_id(SP_UNIT_PERCENT));
1310 } else {
1311 // same width, or only one object; no sense to keep percent, switch to absolute
1312 if (unit->base != SP_UNIT_ABSOLUTE && unit->base != SP_UNIT_DEVICE) {
1313 sp_unit_selector_set_unit(SP_UNIT_SELECTOR(us), sp_desktop_namedview(SP_ACTIVE_DESKTOP)->doc_units);
1314 }
1315 }
1317 unit = sp_unit_selector_get_unit (SP_UNIT_SELECTOR (us));
1319 if (unit->base == SP_UNIT_ABSOLUTE || unit->base == SP_UNIT_DEVICE) {
1320 double avgwidth = sp_pixels_get_units (query->stroke_width.computed, *unit);
1321 gtk_adjustment_set_value(GTK_ADJUSTMENT(width), avgwidth);
1322 } else {
1323 gtk_adjustment_set_value(GTK_ADJUSTMENT(width), 100);
1324 }
1325 }
1327 if (result_ml != QUERY_STYLE_NOTHING)
1328 gtk_adjustment_set_value(GTK_ADJUSTMENT(ml), query->stroke_miterlimit.value); // TODO: reflect averagedness?
1330 if (result_join != QUERY_STYLE_MULTIPLE_DIFFERENT) {
1331 sp_jointype_set (spw, query->stroke_linejoin.value);
1332 } else {
1333 sp_stroke_style_set_join_buttons(spw, NULL);
1334 }
1336 if (result_cap != QUERY_STYLE_MULTIPLE_DIFFERENT) {
1337 sp_captype_set (spw, query->stroke_linecap.value);
1338 } else {
1339 sp_stroke_style_set_cap_buttons(spw, NULL);
1340 }
1342 g_free (query);
1344 GSList const *objects = sel->itemList();
1345 SPObject * const object = SP_OBJECT(objects->data);
1346 SPStyle * const style = SP_OBJECT_STYLE(object);
1348 /* Markers */
1349 sp_stroke_style_update_marker_menus(spw, objects); // FIXME: make this desktop query too
1351 /* Dash */
1352 sp_dash_selector_set_from_style (dsel, style); // FIXME: make this desktop query too
1354 gtk_widget_set_sensitive(sset, TRUE);
1356 gtk_object_set_data(GTK_OBJECT(spw), "update",
1357 GINT_TO_POINTER(FALSE));
1358 }
1360 static void
1361 sp_stroke_style_set_scaled_dash(SPCSSAttr *css,
1362 int ndash, double *dash, double offset,
1363 double scale)
1364 {
1365 if (ndash > 0) {
1366 Inkscape::CSSOStringStream osarray;
1367 for (int i = 0; i < ndash; i++) {
1368 osarray << dash[i] * scale;
1369 if (i < (ndash - 1)) {
1370 osarray << ",";
1371 }
1372 }
1373 sp_repr_css_set_property(css, "stroke-dasharray", osarray.str().c_str());
1375 Inkscape::CSSOStringStream osoffset;
1376 osoffset << offset * scale;
1377 sp_repr_css_set_property(css, "stroke-dashoffset", osoffset.str().c_str());
1378 } else {
1379 sp_repr_css_set_property(css, "stroke-dasharray", "none");
1380 sp_repr_css_set_property(css, "stroke-dashoffset", NULL);
1381 }
1382 }
1384 static void
1385 sp_stroke_style_scale_line(SPWidget *spw)
1386 {
1387 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1388 return;
1389 }
1391 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(TRUE));
1393 GtkAdjustment *wadj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(spw), "width"));
1394 SPUnitSelector *us = SP_UNIT_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "units"));
1395 SPDashSelector *dsel = SP_DASH_SELECTOR(gtk_object_get_data(GTK_OBJECT(spw), "dash"));
1396 GtkAdjustment *ml = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(spw), "miterlimit"));
1398 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1399 SPDocument *document = sp_desktop_document (desktop);
1400 Inkscape::Selection *selection = sp_desktop_selection (desktop);
1402 GSList const *items = selection->itemList();
1404 /* TODO: Create some standardized method */
1405 SPCSSAttr *css = sp_repr_css_attr_new();
1407 if (items) {
1409 double width_typed = wadj->value;
1410 double const miterlimit = ml->value;
1412 SPUnit const *const unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
1414 double *dash, offset;
1415 int ndash;
1416 sp_dash_selector_get_dash(dsel, &ndash, &dash, &offset);
1418 for (GSList const *i = items; i != NULL; i = i->next) {
1419 /* Set stroke width */
1420 double width;
1421 if (unit->base == SP_UNIT_ABSOLUTE || unit->base == SP_UNIT_DEVICE) {
1422 width = sp_units_get_pixels (width_typed, *unit);
1423 } else { // percentage
1424 gdouble old_w = SP_OBJECT_STYLE (i->data)->stroke_width.computed;
1425 width = old_w * width_typed / 100;
1426 }
1428 {
1429 Inkscape::CSSOStringStream os_width;
1430 os_width << width;
1431 sp_repr_css_set_property(css, "stroke-width", os_width.str().c_str());
1432 }
1434 {
1435 Inkscape::CSSOStringStream os_ml;
1436 os_ml << miterlimit;
1437 sp_repr_css_set_property(css, "stroke-miterlimit", os_ml.str().c_str());
1438 }
1440 /* Set dash */
1441 sp_stroke_style_set_scaled_dash(css, ndash, dash, offset, width);
1443 sp_desktop_apply_css_recursive (SP_OBJECT(i->data), css, true);
1444 }
1446 g_free(dash);
1448 if (unit->base != SP_UNIT_ABSOLUTE && unit->base != SP_UNIT_DEVICE) {
1449 // reset to 100 percent
1450 gtk_adjustment_set_value (wadj, 100.0);
1451 }
1453 }
1455 // we have already changed the items, so set style without changing selection
1456 // FIXME: move the above stroke-setting stuff, including percentages, to desktop-style
1457 sp_desktop_set_style (desktop, css, false);
1459 sp_repr_css_attr_unref(css);
1461 sp_document_done(document, SP_VERB_DIALOG_FILL_STROKE,
1462 /* TODO: annotate */ "stroke-style.cpp:1462");
1464 gtk_object_set_data(GTK_OBJECT(spw), "update", GINT_TO_POINTER(FALSE));
1465 }
1469 static void
1470 sp_stroke_style_width_changed(GtkAdjustment *adj, SPWidget *spw)
1471 {
1472 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1473 return;
1474 }
1476 sp_stroke_style_scale_line(spw);
1477 }
1479 static void
1480 sp_stroke_style_miterlimit_changed(GtkAdjustment *adj, SPWidget *spw)
1481 {
1482 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1483 return;
1484 }
1486 sp_stroke_style_scale_line(spw);
1487 }
1489 static void
1490 sp_stroke_style_line_dash_changed(SPDashSelector *dsel, SPWidget *spw)
1491 {
1492 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1493 return;
1494 }
1496 sp_stroke_style_scale_line(spw);
1497 }
1501 /**
1502 * \brief This routine handles toggle events for buttons in the stroke style
1503 * dialog.
1504 * When activated, this routine gets the data for the various widgets, and then
1505 * calls the respective routines to update css properties, etc.
1506 *
1507 */
1508 static void
1509 sp_stroke_style_any_toggled(GtkToggleButton *tb, SPWidget *spw)
1510 {
1511 if (gtk_object_get_data(GTK_OBJECT(spw), "update")) {
1512 return;
1513 }
1515 if (gtk_toggle_button_get_active(tb)) {
1517 gchar const *join
1518 = static_cast<gchar const *>(gtk_object_get_data(GTK_OBJECT(tb), "join"));
1519 gchar const *cap
1520 = static_cast<gchar const *>(gtk_object_get_data(GTK_OBJECT(tb), "cap"));
1522 if (join) {
1523 GtkWidget *ml = GTK_WIDGET(g_object_get_data(G_OBJECT(spw), "miterlimit_sb"));
1524 gtk_widget_set_sensitive (ml, !strcmp(join, "miter"));
1525 }
1527 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1529 /* TODO: Create some standardized method */
1530 SPCSSAttr *css = sp_repr_css_attr_new();
1532 if (join) {
1533 sp_repr_css_set_property(css, "stroke-linejoin", join);
1535 sp_desktop_set_style (desktop, css);
1537 sp_stroke_style_set_join_buttons(spw, GTK_WIDGET(tb));
1538 } else if (cap) {
1539 sp_repr_css_set_property(css, "stroke-linecap", cap);
1541 sp_desktop_set_style (desktop, css);
1543 sp_stroke_style_set_cap_buttons(spw, GTK_WIDGET(tb));
1544 }
1546 sp_repr_css_attr_unref(css);
1548 sp_document_done(sp_desktop_document(desktop), SP_VERB_DIALOG_FILL_STROKE,
1549 /* TODO: annotate */ "stroke-style.cpp:1549");
1550 }
1551 }
1554 static void
1555 sp_stroke_style_set_join_buttons(SPWidget *spw, GtkWidget *active)
1556 {
1557 GtkWidget *tb;
1559 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1560 INKSCAPE_STOCK_JOIN_MITER) );
1561 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1563 GtkWidget *ml = GTK_WIDGET(g_object_get_data(G_OBJECT(spw), "miterlimit_sb"));
1564 gtk_widget_set_sensitive(ml, (active == tb));
1566 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1567 INKSCAPE_STOCK_JOIN_ROUND) );
1568 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1569 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1570 INKSCAPE_STOCK_JOIN_BEVEL) );
1571 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1572 }
1576 static void
1577 sp_stroke_style_set_cap_buttons(SPWidget *spw, GtkWidget *active)
1578 {
1579 GtkWidget *tb;
1581 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1582 INKSCAPE_STOCK_CAP_BUTT));
1583 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1584 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1585 INKSCAPE_STOCK_CAP_ROUND) );
1586 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1587 tb = GTK_WIDGET(gtk_object_get_data( GTK_OBJECT(spw),
1588 INKSCAPE_STOCK_CAP_SQUARE) );
1589 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tb), (active == tb));
1590 }
1592 static void
1593 ink_marker_menu_set_current(SPObject *marker, GtkOptionMenu *mnu)
1594 {
1595 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
1597 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(mnu));
1598 if (marker != NULL) {
1599 bool mark_is_stock = false;
1600 if (SP_OBJECT_REPR(marker)->attribute("inkscape:stockid"))
1601 mark_is_stock = true;
1603 gchar *markname;
1604 if (mark_is_stock)
1605 markname = g_strdup(SP_OBJECT_REPR(marker)->attribute("inkscape:stockid"));
1606 else
1607 markname = g_strdup(SP_OBJECT_REPR(marker)->attribute("id"));
1609 int markpos = 0;
1610 GList *kids = GTK_MENU_SHELL(m)->children;
1611 int i = 0;
1612 for (; kids != NULL; kids = kids->next) {
1613 gchar *mark = (gchar *) g_object_get_data(G_OBJECT(kids->data), "marker");
1614 if ( mark && strcmp(mark, markname) == 0 ) {
1615 if ( mark_is_stock && !strcmp((gchar *) g_object_get_data(G_OBJECT(kids->data), "stockid"), "true"))
1616 markpos = i;
1617 if ( !mark_is_stock && !strcmp((gchar *) g_object_get_data(G_OBJECT(kids->data), "stockid"), "false"))
1618 markpos = i;
1619 }
1620 i++;
1621 }
1622 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), markpos);
1624 g_free (markname);
1625 }
1626 else {
1627 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
1628 }
1629 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
1630 }
1632 static void
1633 sp_stroke_style_update_marker_menus( SPWidget *spw,
1634 GSList const *objects)
1635 {
1636 struct { char const *key; int loc; } const keyloc[] = {
1637 { "start_mark_menu", SP_MARKER_LOC_START },
1638 { "mid_mark_menu", SP_MARKER_LOC_MID },
1639 { "end_mark_menu", SP_MARKER_LOC_END }
1640 };
1642 bool all_texts = true;
1643 for (GSList *i = (GSList *) objects; i != NULL; i = i->next) {
1644 if (!SP_IS_TEXT (i->data)) {
1645 all_texts = false;
1646 }
1647 }
1649 for (unsigned i = 0; i < G_N_ELEMENTS(keyloc); ++i) {
1650 GtkOptionMenu *mnu = (GtkOptionMenu *) g_object_get_data(G_OBJECT(spw), keyloc[i].key);
1651 if (all_texts) {
1652 // Per SVG spec, text objects cannot have markers; disable menus if only texts are selected
1653 gtk_widget_set_sensitive (GTK_WIDGET(mnu), FALSE);
1654 } else {
1655 gtk_widget_set_sensitive (GTK_WIDGET(mnu), TRUE);
1656 }
1657 }
1659 // We show markers of the first object in the list only
1660 // FIXME: use the first in the list that has the marker of each type, if any
1661 SPObject *object = SP_OBJECT(objects->data);
1663 for (unsigned i = 0; i < G_N_ELEMENTS(keyloc); ++i) {
1664 // For all three marker types,
1666 // find the corresponding menu
1667 GtkOptionMenu *mnu = (GtkOptionMenu *) g_object_get_data(G_OBJECT(spw), keyloc[i].key);
1669 // Quit if we're in update state
1670 if (gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
1671 return;
1672 }
1674 if (object->style->marker[keyloc[i].loc].value != NULL && !all_texts) {
1675 // If the object has this type of markers,
1677 // Extract the name of the marker that the object uses
1678 SPObject *marker = ink_extract_marker_name(object->style->marker[keyloc[i].loc].value);
1679 // Scroll the menu to that marker
1680 ink_marker_menu_set_current (marker, mnu);
1682 } else {
1683 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
1684 }
1685 }
1686 }
1689 /** Extract the actual name of the link
1690 * e.g. get mTriangle from url(#mTriangle).
1691 * \return Buffer containing the actual name, allocated from GLib;
1692 * the caller should free the buffer when they no longer need it.
1693 */
1694 static SPObject*
1695 ink_extract_marker_name(gchar const *n)
1696 {
1697 gchar const *p = n;
1698 while (*p != '\0' && *p != '#') {
1699 p++;
1700 }
1702 if (*p == '\0' || p[1] == '\0') {
1703 return NULL;
1704 }
1706 p++;
1707 int c = 0;
1708 while (p[c] != '\0' && p[c] != ')') {
1709 c++;
1710 }
1712 if (p[c] == '\0') {
1713 return NULL;
1714 }
1716 gchar* b = g_strdup(p);
1717 b[c] = '\0';
1720 SPDesktop *desktop = inkscape_active_desktop();
1721 SPDocument *doc = sp_desktop_document(desktop);
1722 SPObject *marker = doc->getObjectById(b);
1723 return marker;
1724 }
1727 /*
1728 Local Variables:
1729 mode:c++
1730 c-file-style:"stroustrup"
1731 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1732 indent-tabs-mode:nil
1733 fill-column:99
1734 End:
1735 */
1736 // vim: filetype=c++:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :