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