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