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