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