src/dialogs/stroke-style.cpp

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