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