src/widgets/paint-selector.cpp

   1 /** \file
   2  * SPPaintSelector: Generic paint selector widget.
   3  */
   4
   5 /*
   6  * Authors:
   7  *   Lauris Kaplinski
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *   John Cliff <simarilius@yahoo.com>
  10  *   Jon A. Cruz <jon@joncruz.org>
  11  *
  12  * Copyright (C) Lauris Kaplinski 2002
  13  * Copyright (C) 2010 Authors
  14 */
  15
  16 #define noSP_PS_VERBOSE
  17
  18 #ifdef HAVE_CONFIG_H
  19 # include "config.h"
  20 #endif
  21
  22 #include <cstring>
  23 #include <string>
  24
  25 #include <gtk/gtkhbox.h>
  26 #include <gtk/gtkradiobutton.h>
  27 #include <gtk/gtkframe.h>
  28 #include <gtk/gtklabel.h>
  29 #include <gtk/gtkoptionmenu.h>
  30 #include <gtk/gtktooltips.h>
  31 #include <gtk/gtkmenuitem.h>
  32 #include <gtk/gtkseparatormenuitem.h>
  33
  34 #include "../sp-pattern.h"
  35 #include <glibmm/i18n.h>
  36 #include "../widgets/icon.h"
  37 #include "widgets/widget-sizes.h"
  38 #include "xml/repr.h"
  39
  40 #include "sp-color-notebook.h"
  41 #include "sp-linear-gradient-fns.h"
  42 #include "sp-radial-gradient-fns.h"
  43 /* fixme: Move it from dialogs to here */
  44 #include "gradient-selector.h"
  45 #include <inkscape.h>
  46 #include <document-private.h>
  47 #include <desktop-style.h>
  48 #include <style.h>
  49 #include "svg/svg-color.h"
  50 #include "svg/css-ostringstream.h"
  51 #include "path-prefix.h"
  52 #include "io/sys.h"
  53 #include "helper/stock-items.h"
  54 #include "ui/icon-names.h"
  55
  56 #include "paint-selector.h"
  57
  58 #ifdef SP_PS_VERBOSE
  59 #include "svg/svg-icc-color.h"
  60 #endif // SP_PS_VERBOSE
  61
  62 enum {
  63     MODE_CHANGED,
  64     GRABBED,
  65     DRAGGED,
  66     RELEASED,
  67     CHANGED,
  68     FILLRULE_CHANGED,
  69     LAST_SIGNAL
  70 };
  71
  72 static void sp_paint_selector_class_init(SPPaintSelectorClass *klass);
  73 static void sp_paint_selector_init(SPPaintSelector *slider);
  74 static void sp_paint_selector_destroy(GtkObject *object);
  75
  76 static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel, gchar const *px, SPPaintSelectorMode mode, GtkTooltips *tt, gchar const *tip);
  77 static void sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
  78 static void sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
  79
  80 static void sp_paint_selector_set_mode_empty(SPPaintSelector *psel);
  81 static void sp_paint_selector_set_mode_multiple(SPPaintSelector *psel);
  82 static void sp_paint_selector_set_mode_none(SPPaintSelector *psel);
  83 static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode);
  84 static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode);
  85 static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode);
  86 static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelectorMode mode);
  87 static void sp_paint_selector_set_mode_unset(SPPaintSelector *psel);
  88
  89
  90 static void sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active);
  91
  92 static GtkVBoxClass *parent_class;
  93 static guint psel_signals[LAST_SIGNAL] = {0};
  94
  95 #ifdef SP_PS_VERBOSE
  96 static gchar const* modeStrings[] = {
  97     "MODE_EMPTY",
  98     "MODE_MULTIPLE",
  99     "MODE_NONE",
 100     "MODE_COLOR_RGB",
 101     "MODE_COLOR_CMYK",
 102     "MODE_GRADIENT_LINEAR",
 103     "MODE_GRADIENT_RADIAL",
 104     "MODE_PATTERN",
 105     "MODE_SWATCH",
 106     "MODE_UNSET",
 107     ".",
 108     ".",
 109     ".",
 110 };
 111 #endif
 112
 113 static bool isPaintModeGradient( SPPaintSelectorMode mode )
 114 {
 115     bool isGrad = (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 116         (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL) ||
 117         (mode == SP_PAINT_SELECTOR_MODE_SWATCH);
 118
 119     return isGrad;
 120 }
 121
 122 static SPGradientSelector *getGradientFromData(SPPaintSelector *psel)
 123 {
 124     gchar const* key = (psel->mode == SP_PAINT_SELECTOR_MODE_SWATCH) ? "swatch-selector" : "gradient-selector";
 125     SPGradientSelector *grad = reinterpret_cast<SPGradientSelector*>(gtk_object_get_data(GTK_OBJECT(psel->selector), key));
 126     return grad;
 127 }
 128
 129 GType sp_paint_selector_get_type(void)
 130 {
 131     static GtkType type = 0;
 132     if (!type) {
 133         GTypeInfo info = {
 134             sizeof(SPPaintSelectorClass),
 135             0, // base_init
 136             0, // base_finalize
 137             (GClassInitFunc)sp_paint_selector_class_init,
 138             0, // class_finalize
 139             0, // class_data
 140             sizeof(SPPaintSelector),
 141             0, // n_preallocs
 142             (GInstanceInitFunc)sp_paint_selector_init,
 143             0 // value_table
 144         };
 145         type = g_type_register_static(GTK_TYPE_VBOX, "SPPaintSelector", &info, static_cast<GTypeFlags>(0));
 146     }
 147     return type;
 148 }
 149
 150 static void
 151 sp_paint_selector_class_init(SPPaintSelectorClass *klass)
 152 {
 153     GtkObjectClass *object_class;
 154     GtkWidgetClass *widget_class;
 155
 156     object_class = (GtkObjectClass *) klass;
 157     widget_class = (GtkWidgetClass *) klass;
 158
 159     parent_class = (GtkVBoxClass*)gtk_type_class(GTK_TYPE_VBOX);
 160
 161     psel_signals[MODE_CHANGED] = gtk_signal_new("mode_changed",
 162                                                 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 163                                                 GTK_CLASS_TYPE(object_class),
 164                                                 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, mode_changed),
 165                                                 gtk_marshal_NONE__UINT,
 166                                                 GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
 167     psel_signals[GRABBED] =  gtk_signal_new("grabbed",
 168                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 169                                             GTK_CLASS_TYPE(object_class),
 170                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, grabbed),
 171                                             gtk_marshal_NONE__NONE,
 172                                             GTK_TYPE_NONE, 0);
 173     psel_signals[DRAGGED] =  gtk_signal_new("dragged",
 174                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 175                                             GTK_CLASS_TYPE(object_class),
 176                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, dragged),
 177                                             gtk_marshal_NONE__NONE,
 178                                             GTK_TYPE_NONE, 0);
 179     psel_signals[RELEASED] = gtk_signal_new("released",
 180                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 181                                             GTK_CLASS_TYPE(object_class),
 182                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, released),
 183                                             gtk_marshal_NONE__NONE,
 184                                             GTK_TYPE_NONE, 0);
 185     psel_signals[CHANGED] =  gtk_signal_new("changed",
 186                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 187                                             GTK_CLASS_TYPE(object_class),
 188                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, changed),
 189                                             gtk_marshal_NONE__NONE,
 190                                             GTK_TYPE_NONE, 0);
 191     psel_signals[FILLRULE_CHANGED] = gtk_signal_new("fillrule_changed",
 192                                                     (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 193                                                     GTK_CLASS_TYPE(object_class),
 194                                                     GTK_SIGNAL_OFFSET(SPPaintSelectorClass, fillrule_changed),
 195                                                     gtk_marshal_NONE__UINT,
 196                                                     GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
 197
 198     object_class->destroy = sp_paint_selector_destroy;
 199 }
 200
 201 #define XPAD 4
 202 #define YPAD 1
 203
 204 static void
 205 sp_paint_selector_init(SPPaintSelector *psel)
 206 {
 207     GtkTooltips *tt = gtk_tooltips_new();
 208
 209     psel->mode = (SPPaintSelectorMode)-1; // huh?  do you mean 0xff?  --  I think this means "not in the enum"
 210
 211     /* Paint style button box */
 212     psel->style = gtk_hbox_new(FALSE, 0);
 213     gtk_widget_show(psel->style);
 214     gtk_container_set_border_width(GTK_CONTAINER(psel->style), 4);
 215     gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0);
 216
 217     /* Buttons */
 218     psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_NONE,
 219                                                     SP_PAINT_SELECTOR_MODE_NONE, tt, _("No paint"));
 220     psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_SOLID,
 221                                                      SP_PAINT_SELECTOR_MODE_COLOR_RGB, tt, _("Flat color"));
 222     psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_GRADIENT_LINEAR,
 223                                                         SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR, tt, _("Linear gradient"));
 224     psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_GRADIENT_RADIAL,
 225                                                       SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL, tt, _("Radial gradient"));
 226     psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_PATTERN,
 227                                                        SP_PAINT_SELECTOR_MODE_PATTERN, tt, _("Pattern"));
 228     psel->swatch = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_SWATCH,
 229                                                        SP_PAINT_SELECTOR_MODE_SWATCH, tt, _("Swatch"));
 230     psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_UNKNOWN,
 231                                                      SP_PAINT_SELECTOR_MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)"));
 232
 233     /* Fillrule */
 234     {
 235         psel->fillrulebox = gtk_hbox_new(FALSE, 0);
 236         gtk_box_pack_end(GTK_BOX(psel->style), psel->fillrulebox, FALSE, FALSE, 0);
 237
 238         GtkWidget *w;
 239         psel->evenodd = gtk_radio_button_new(NULL);
 240         gtk_button_set_relief(GTK_BUTTON(psel->evenodd), GTK_RELIEF_NONE);
 241         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->evenodd), FALSE);
 242         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
 243         gtk_tooltips_set_tip(tt, psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"), NULL);
 244         gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_EVENODD));
 245         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_EVEN_ODD);
 246         gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
 247         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
 248         gtk_signal_connect(GTK_OBJECT(psel->evenodd), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
 249
 250         psel->nonzero = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(psel->evenodd)));
 251         gtk_button_set_relief(GTK_BUTTON(psel->nonzero), GTK_RELIEF_NONE);
 252         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->nonzero), FALSE);
 253         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
 254         gtk_tooltips_set_tip(tt, psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"), NULL);
 255         gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_NONZERO));
 256         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_NONZERO);
 257         gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
 258         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
 259         gtk_signal_connect(GTK_OBJECT(psel->nonzero), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
 260     }
 261
 262     /* Frame */
 263     psel->frame = gtk_frame_new("");
 264     gtk_widget_show(psel->frame);
 265     gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0);
 266     gtk_box_pack_start(GTK_BOX(psel), psel->frame, TRUE, TRUE, 0);
 267
 268     /* Last used color */
 269     psel->color.set( 0.0, 0.0, 0.0 );
 270     psel->alpha = 1.0;
 271 }
 272
 273 static void
 274 sp_paint_selector_destroy(GtkObject *object)
 275 {
 276     SPPaintSelector *psel = SP_PAINT_SELECTOR(object);
 277
 278     // clean up our long-living pattern menu
 279     g_object_set_data(G_OBJECT(psel),"patternmenu",NULL);
 280
 281     if (((GtkObjectClass *) parent_class)->destroy)
 282         (* ((GtkObjectClass *) parent_class)->destroy)(object);
 283 }
 284
 285 static GtkWidget *
 286 sp_paint_selector_style_button_add(SPPaintSelector *psel,
 287                                    gchar const *pixmap, SPPaintSelectorMode mode,
 288                                    GtkTooltips *tt, gchar const *tip)
 289 {
 290     GtkWidget *b, *w;
 291
 292     b = gtk_toggle_button_new();
 293     gtk_tooltips_set_tip(tt, b, tip, NULL);
 294     gtk_widget_show(b);
 295
 296     gtk_container_set_border_width(GTK_CONTAINER(b), 0);
 297
 298     gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
 299
 300     gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(b), FALSE);
 301     gtk_object_set_data(GTK_OBJECT(b), "mode", GUINT_TO_POINTER(mode));
 302
 303     w = sp_icon_new(Inkscape::ICON_SIZE_BUTTON, pixmap);
 304     gtk_widget_show(w);
 305     gtk_container_add(GTK_CONTAINER(b), w);
 306
 307     gtk_box_pack_start(GTK_BOX(psel->style), b, FALSE, FALSE, 0);
 308     gtk_signal_connect(GTK_OBJECT(b), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_style_button_toggled), psel);
 309
 310     return b;
 311 }
 312
 313 static void
 314 sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 315 {
 316     if (!psel->update && gtk_toggle_button_get_active(tb)) {
 317         sp_paint_selector_set_mode(psel, (SPPaintSelectorMode)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode")));
 318     }
 319 }
 320
 321 static void
 322 sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 323 {
 324     if (!psel->update && gtk_toggle_button_get_active(tb)) {
 325         SPPaintSelectorFillRule fr = (SPPaintSelectorFillRule)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode"));
 326         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[FILLRULE_CHANGED], fr);
 327     }
 328 }
 329
 330 void
 331 sp_paint_selector_show_fillrule(SPPaintSelector *psel, bool is_fill)
 332 {
 333     if (psel->fillrulebox) {
 334         if (is_fill) {
 335             gtk_widget_show_all(psel->fillrulebox);
 336         } else {
 337             gtk_widget_destroy(psel->fillrulebox);
 338             psel->fillrulebox = NULL;
 339         }
 340     }
 341 }
 342
 343
 344 GtkWidget *
 345 sp_paint_selector_new(bool is_fill)
 346 {
 347     SPPaintSelector *psel;
 348
 349     psel = (SPPaintSelector*)gtk_type_new(SP_TYPE_PAINT_SELECTOR);
 350
 351     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
 352
 353     // This silliness is here because I don't know how to pass a parameter to the
 354     // GtkObject "constructor" (sp_paint_selector_init). Remove it when paint_selector
 355     // becomes a normal class.
 356     sp_paint_selector_show_fillrule(psel, is_fill);
 357
 358     return GTK_WIDGET(psel);
 359 }
 360
 361 void
 362 sp_paint_selector_set_mode(SPPaintSelector *psel, SPPaintSelectorMode mode)
 363 {
 364     if (psel->mode != mode) {
 365         psel->update = TRUE;
 366 #ifdef SP_PS_VERBOSE
 367         g_print("Mode change %d -> %d   %s -> %s\n", psel->mode, mode, modeStrings[psel->mode], modeStrings[mode]);
 368 #endif
 369         switch (mode) {
 370             case SP_PAINT_SELECTOR_MODE_EMPTY:
 371                 sp_paint_selector_set_mode_empty(psel);
 372                 break;
 373             case SP_PAINT_SELECTOR_MODE_MULTIPLE:
 374                 sp_paint_selector_set_mode_multiple(psel);
 375                 break;
 376             case SP_PAINT_SELECTOR_MODE_NONE:
 377                 sp_paint_selector_set_mode_none(psel);
 378                 break;
 379             case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
 380             case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
 381                 sp_paint_selector_set_mode_color(psel, mode);
 382                 break;
 383             case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
 384             case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
 385                 sp_paint_selector_set_mode_gradient(psel, mode);
 386                 break;
 387             case SP_PAINT_SELECTOR_MODE_PATTERN:
 388                 sp_paint_selector_set_mode_pattern(psel, mode);
 389                 break;
 390             case SP_PAINT_SELECTOR_MODE_SWATCH:
 391                 sp_paint_selector_set_mode_swatch(psel, mode);
 392                 break;
 393             case SP_PAINT_SELECTOR_MODE_UNSET:
 394                 sp_paint_selector_set_mode_unset(psel);
 395                 break;
 396             default:
 397                 g_warning("file %s: line %d: Unknown paint mode %d", __FILE__, __LINE__, mode);
 398                 break;
 399         }
 400         psel->mode = mode;
 401         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[MODE_CHANGED], psel->mode);
 402         psel->update = FALSE;
 403     }
 404 }
 405
 406 void
 407 sp_paint_selector_set_fillrule(SPPaintSelector *psel, SPPaintSelectorFillRule fillrule)
 408 {
 409     if (psel->fillrulebox) {
 410         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->evenodd), (fillrule == SP_PAINT_SELECTOR_FILLRULE_EVENODD));
 411         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->nonzero), (fillrule == SP_PAINT_SELECTOR_FILLRULE_NONZERO));
 412     }
 413 }
 414
 415 void
 416 sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, float alpha)
 417 {
 418     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 419     SPColorSelector *csel;
 420     guint32 rgba;
 421
 422 /*
 423     if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
 424     {
 425 #ifdef SP_PS_VERBOSE
 426         g_print("PaintSelector set CMYKA\n");
 427 #endif
 428         sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_CMYK);
 429     }
 430     else
 431 */
 432     {
 433 #ifdef SP_PS_VERBOSE
 434         g_print("PaintSelector set RGBA\n");
 435 #endif
 436         sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_RGB);
 437     }
 438
 439     csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 440     rgba = color->toRGBA32( alpha );
 441     csel->base->setColorAlpha( *color, alpha );
 442 }
 443
 444 void sp_paint_selector_set_swatch(SPPaintSelector *psel, SPGradient *vector )
 445 {
 446 #ifdef SP_PS_VERBOSE
 447     g_print("PaintSelector set SWATCH\n");
 448 #endif
 449     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_SWATCH);
 450
 451     SPGradientSelector *gsel = static_cast<SPGradientSelector*>(gtk_object_get_data(GTK_OBJECT(psel->selector), "swatch-selector"));
 452
 453     gsel->setVector((vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector);
 454 }
 455
 456 void
 457 sp_paint_selector_set_gradient_linear(SPPaintSelector *psel, SPGradient *vector)
 458 {
 459 #ifdef SP_PS_VERBOSE
 460     g_print("PaintSelector set GRADIENT LINEAR\n");
 461 #endif
 462     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR);
 463
 464     SPGradientSelector *gsel = getGradientFromData(psel);
 465
 466     gsel->setMode(SPGradientSelector::MODE_LINEAR);
 467     gsel->setVector((vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector);
 468 }
 469
 470 void
 471 sp_paint_selector_set_gradient_radial(SPPaintSelector *psel, SPGradient *vector)
 472 {
 473 #ifdef SP_PS_VERBOSE
 474     g_print("PaintSelector set GRADIENT RADIAL\n");
 475 #endif
 476     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL);
 477
 478     SPGradientSelector *gsel = getGradientFromData(psel);
 479
 480     gsel->setMode(SPGradientSelector::MODE_RADIAL);
 481
 482     gsel->setVector((vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector);
 483 }
 484
 485 void sp_paint_selector_set_gradient_properties(SPPaintSelector *psel, SPGradientUnits units, SPGradientSpread spread)
 486 {
 487     g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
 488     g_return_if_fail(isPaintModeGradient(psel->mode));
 489
 490     SPGradientSelector *gsel = getGradientFromData(psel);
 491     gsel->setUnits(units);
 492     gsel->setSpread(spread);
 493 }
 494
 495 void sp_paint_selector_get_gradient_properties(SPPaintSelector *psel, SPGradientUnits *units, SPGradientSpread *spread)
 496 {
 497     g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
 498     g_return_if_fail(isPaintModeGradient(psel->mode));
 499
 500     SPGradientSelector *gsel = getGradientFromData(psel);
 501     if (units) {
 502         *units = gsel->getUnits();
 503     }
 504     if (spread) {
 505         *spread = gsel->getSpread();
 506     }
 507 }
 508
 509 /**
 510  * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
 511  */
 512 void
 513 sp_paint_selector_get_color_alpha(SPPaintSelector *psel, SPColor *color, gfloat *alpha)
 514 {
 515     SPColorSelector *csel;
 516
 517     csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 518
 519     csel->base->getColorAlpha( *color, alpha );
 520
 521     g_assert( !alpha
 522               || ( ( 0.0 <= *alpha )
 523                    && ( *alpha <= 1.0 ) ) );
 524 }
 525
 526 SPGradient *sp_paint_selector_get_gradient_vector(SPPaintSelector *psel)
 527 {
 528     SPGradient* vect = 0;
 529
 530     if (isPaintModeGradient(psel->mode)) {
 531         SPGradientSelector *gsel = getGradientFromData(psel);
 532         vect = gsel->getVector();
 533     }
 534
 535     return vect;
 536 }
 537
 538 void
 539 sp_gradient_selector_attrs_to_gradient(SPGradient *gr, SPPaintSelector *psel)
 540 {
 541     SPGradientUnits units = SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX;
 542     SPGradientSpread spread = SP_GRADIENT_SPREAD_PAD;
 543     sp_paint_selector_get_gradient_properties(psel, &units, &spread);
 544     sp_gradient_set_units(gr, units);
 545     sp_gradient_set_spread(gr, spread);
 546     SP_OBJECT(gr)->updateRepr();
 547 }
 548
 549 static void
 550 sp_paint_selector_clear_frame(SPPaintSelector *psel)
 551 {
 552     g_return_if_fail( psel != NULL);
 553
 554     if (psel->selector) {
 555
 556         /* before we destroy the frame contents, we must detach
 557          * the patternmenu so that Gtk doesn't gtk_widget_destroy
 558          * all the children of the menu.  (We also have a g_object_ref
 559          * count set on it too so that the gtk_container_remove doesn't
 560          * end up destroying it.
 561          */
 562         GtkWidget *patterns = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
 563         if (patterns != NULL) {
 564             GtkWidget * parent = gtk_widget_get_parent( GTK_WIDGET(patterns));
 565             if ( parent != NULL ) {
 566                 g_assert( GTK_IS_CONTAINER(parent) );
 567                 gtk_container_remove( GTK_CONTAINER(parent), patterns );
 568             }
 569         }
 570
 571         gtk_widget_destroy(psel->selector);
 572         psel->selector = NULL;
 573     }
 574 }
 575
 576 static void
 577 sp_paint_selector_set_mode_empty(SPPaintSelector *psel)
 578 {
 579     sp_paint_selector_set_style_buttons(psel, NULL);
 580     gtk_widget_set_sensitive(psel->style, FALSE);
 581
 582     sp_paint_selector_clear_frame(psel);
 583
 584     gtk_frame_set_label(GTK_FRAME(psel->frame), _("No objects"));
 585 }
 586
 587 static void
 588 sp_paint_selector_set_mode_multiple(SPPaintSelector *psel)
 589 {
 590     sp_paint_selector_set_style_buttons(psel, NULL);
 591     gtk_widget_set_sensitive(psel->style, TRUE);
 592
 593     sp_paint_selector_clear_frame(psel);
 594
 595     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Multiple styles"));
 596 }
 597
 598 static void
 599 sp_paint_selector_set_mode_unset(SPPaintSelector *psel)
 600 {
 601     sp_paint_selector_set_style_buttons(psel, psel->unset);
 602     gtk_widget_set_sensitive(psel->style, TRUE);
 603
 604     sp_paint_selector_clear_frame(psel);
 605
 606     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Paint is undefined"));
 607 }
 608
 609 static void
 610 sp_paint_selector_set_mode_none(SPPaintSelector *psel)
 611 {
 612     sp_paint_selector_set_style_buttons(psel, psel->none);
 613     gtk_widget_set_sensitive(psel->style, TRUE);
 614
 615     sp_paint_selector_clear_frame(psel);
 616
 617     gtk_frame_set_label(GTK_FRAME(psel->frame), _("No paint"));
 618 }
 619
 620 /* Color paint */
 621
 622 static void
 623 sp_paint_selector_color_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
 624 {
 625     (void)csel;
 626     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 627 }
 628
 629 static void
 630 sp_paint_selector_color_dragged(SPColorSelector *csel, SPPaintSelector *psel)
 631 {
 632     (void)csel;
 633     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 634 }
 635
 636 static void
 637 sp_paint_selector_color_released(SPColorSelector *csel, SPPaintSelector *psel)
 638 {
 639     (void)csel;
 640     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 641 }
 642
 643 static void
 644 sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
 645 {
 646     csel->base->getColorAlpha( psel->color, &psel->alpha );
 647
 648     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 649 }
 650
 651 static void
 652 sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode)
 653 {
 654     (void)mode;
 655     GtkWidget *csel;
 656
 657     sp_paint_selector_set_style_buttons(psel, psel->solid);
 658     gtk_widget_set_sensitive(psel->style, TRUE);
 659
 660     if ((psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_RGB) || (psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_CMYK)) {
 661         /* Already have color selector */
 662         csel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 663     } else {
 664
 665         sp_paint_selector_clear_frame(psel);
 666         /* Create new color selector */
 667         /* Create vbox */
 668         GtkWidget *vb = gtk_vbox_new(FALSE, 4);
 669         gtk_widget_show(vb);
 670
 671         /* Color selector */
 672         csel = sp_color_selector_new( SP_TYPE_COLOR_NOTEBOOK );
 673         gtk_widget_show(csel);
 674         gtk_object_set_data(GTK_OBJECT(vb), "color-selector", csel);
 675         gtk_box_pack_start(GTK_BOX(vb), csel, TRUE, TRUE, 0);
 676         gtk_signal_connect(GTK_OBJECT(csel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_color_grabbed), psel);
 677         gtk_signal_connect(GTK_OBJECT(csel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_color_dragged), psel);
 678         gtk_signal_connect(GTK_OBJECT(csel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_color_released), psel);
 679         gtk_signal_connect(GTK_OBJECT(csel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_color_changed), psel);
 680         /* Pack everything to frame */
 681         gtk_container_add(GTK_CONTAINER(psel->frame), vb);
 682         psel->selector = vb;
 683
 684         /* Set color */
 685         SP_COLOR_SELECTOR( csel )->base->setColorAlpha( psel->color, psel->alpha );
 686
 687     }
 688
 689     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Flat color"));
 690 #ifdef SP_PS_VERBOSE
 691     g_print("Color req\n");
 692 #endif
 693 }
 694
 695 /* Gradient */
 696
 697 static void
 698 sp_paint_selector_gradient_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
 699 {
 700     (void)csel;
 701     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 702 }
 703
 704 static void
 705 sp_paint_selector_gradient_dragged(SPColorSelector *csel, SPPaintSelector *psel)
 706 {
 707     (void)csel;
 708     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 709 }
 710
 711 static void
 712 sp_paint_selector_gradient_released(SPColorSelector *csel, SPPaintSelector *psel)
 713 {
 714     (void)csel;
 715     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 716 }
 717
 718 static void
 719 sp_paint_selector_gradient_changed(SPColorSelector *csel, SPPaintSelector *psel)
 720 {
 721     (void)csel;
 722     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 723 }
 724
 725 static void
 726 sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode)
 727 {
 728     GtkWidget *gsel;
 729
 730     /* fixme: We do not need function-wide gsel at all */
 731
 732     if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
 733         sp_paint_selector_set_style_buttons(psel, psel->gradient);
 734     } else {
 735         sp_paint_selector_set_style_buttons(psel, psel->radial);
 736     }
 737     gtk_widget_set_sensitive(psel->style, TRUE);
 738
 739     if ((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) || (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL)) {
 740         /* Already have gradient selector */
 741         gsel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 742     } else {
 743         sp_paint_selector_clear_frame(psel);
 744         /* Create new gradient selector */
 745         gsel = sp_gradient_selector_new();
 746         gtk_widget_show(gsel);
 747         gtk_signal_connect(GTK_OBJECT(gsel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_grabbed), psel);
 748         gtk_signal_connect(GTK_OBJECT(gsel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_dragged), psel);
 749         gtk_signal_connect(GTK_OBJECT(gsel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_released), psel);
 750         gtk_signal_connect(GTK_OBJECT(gsel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_changed), psel);
 751         /* Pack everything to frame */
 752         gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
 753         psel->selector = gsel;
 754         gtk_object_set_data(GTK_OBJECT(psel->selector), "gradient-selector", gsel);
 755     }
 756
 757     /* Actually we have to set option menu history here */
 758     if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
 759         SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_LINEAR);
 760         //sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
 761         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Linear gradient"));
 762     } else {
 763         SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_RADIAL);
 764         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Radial gradient"));
 765     }
 766 #ifdef SP_PS_VERBOSE
 767     g_print("Gradient req\n");
 768 #endif
 769 }
 770
 771 static void
 772 sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
 773 {
 774     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->none), (active == psel->none));
 775     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->solid), (active == psel->solid));
 776     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->gradient), (active == psel->gradient));
 777     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->radial), (active == psel->radial));
 778     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->pattern), (active == psel->pattern));
 779     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->swatch), (active == psel->swatch));
 780     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->unset), (active == psel->unset));
 781 }
 782
 783 static void
 784 sp_psel_pattern_destroy(GtkWidget *widget,  SPPaintSelector *psel)
 785 {
 786     (void)psel;
 787     // drop our reference to the pattern menu widget
 788     g_object_unref( G_OBJECT(widget) );
 789 }
 790
 791 static void
 792 sp_psel_pattern_change(GtkWidget *widget,  SPPaintSelector *psel)
 793 {
 794     (void)widget;
 795     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 796 }
 797
 798
 799
 800 /**
 801  *  Returns a list of patterns in the defs of the given source document as a GSList object
 802  *  Returns NULL if there are no patterns in the document.
 803  */
 804 GSList *
 805 ink_pattern_list_get (SPDocument *source)
 806 {
 807     if (source == NULL)
 808         return NULL;
 809
 810     GSList *pl = NULL;
 811     GSList const *patterns = sp_document_get_resource_list(source, "pattern");
 812     for (GSList *l = (GSList *) patterns; l != NULL; l = l->next) {
 813         if (SP_PATTERN(l->data) == pattern_getroot(SP_PATTERN(l->data))) {  // only if this is a root pattern
 814             pl = g_slist_prepend(pl, l->data);
 815         }
 816     }
 817
 818     pl = g_slist_reverse(pl);
 819     return pl;
 820 }
 821
 822 /**
 823  * Adds menu items for pattern list - derived from marker code, left hb etc in to make addition of previews easier at some point.
 824  */
 825 static void
 826 sp_pattern_menu_build (GtkWidget *m, GSList *pattern_list, SPDocument */*source*/)
 827 {
 828
 829     for (; pattern_list != NULL; pattern_list = pattern_list->next) {
 830         Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) pattern_list->data);
 831                 GtkWidget *i = gtk_menu_item_new();
 832                 gtk_widget_show(i);
 833
 834         if (repr->attribute("inkscape:stockid"))
 835             g_object_set_data (G_OBJECT(i), "stockid", (void *) "true");
 836         else
 837             g_object_set_data (G_OBJECT(i), "stockid", (void *) "false");
 838
 839         gchar const *patid = repr->attribute("id");
 840         g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
 841
 842                 GtkWidget *hb = gtk_hbox_new(FALSE, 4);
 843                 gtk_widget_show(hb);
 844
 845         // create label
 846                 GtkWidget *l;
 847                 if (repr->attribute("inkscape:stockid"))
 848                     l = gtk_label_new(_(repr->attribute("inkscape:stockid")));
 849                 else
 850                     l = gtk_label_new(_(repr->attribute("id")));
 851                 gtk_widget_show(l);
 852                 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
 853
 854                 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
 855
 856                 gtk_widget_show(hb);
 857                 gtk_container_add(GTK_CONTAINER(i), hb);
 858
 859                 gtk_menu_append(GTK_MENU(m), i);
 860             }
 861         }
 862
 863 /**
 864  * sp_pattern_list_from_doc()
 865  *
 866  * \brief Pick up all patterns from source, except those that are in
 867  * current_doc (if non-NULL), and add items to the pattern menu
 868  *
 869  */
 870 static void
 871 sp_pattern_list_from_doc (GtkWidget *m, SPDocument *current_doc, SPDocument *source, SPDocument *pattern_doc)
 872 {
 873     (void)current_doc;
 874     (void)pattern_doc;
 875     GSList *pl = ink_pattern_list_get(source);
 876     GSList *clean_pl = NULL;
 877
 878     for (; pl != NULL; pl = pl->next) {
 879         if (!SP_IS_PATTERN(pl->data))
 880             continue;
 881
 882         // Add to the list of patterns we really do wish to show
 883         clean_pl = g_slist_prepend (clean_pl, pl->data);
 884     }
 885
 886     sp_pattern_menu_build (m, clean_pl, source);
 887
 888     g_slist_free (pl);
 889     g_slist_free (clean_pl);
 890 }
 891
 892
 893
 894
 895 static void
 896 ink_pattern_menu_populate_menu(GtkWidget *m, SPDocument *doc)
 897 {
 898     static SPDocument *patterns_doc = NULL;
 899
 900     // find and load patterns.svg
 901     if (patterns_doc == NULL) {
 902         char *patterns_source = g_build_filename(INKSCAPE_PATTERNSDIR, "patterns.svg", NULL);
 903         if (Inkscape::IO::file_test(patterns_source, G_FILE_TEST_IS_REGULAR)) {
 904             patterns_doc = sp_document_new(patterns_source, FALSE);
 905         }
 906         g_free(patterns_source);
 907     }
 908
 909     // suck in from current doc
 910     sp_pattern_list_from_doc ( m, NULL, doc, patterns_doc );
 911
 912     // add separator
 913     {
 914         GtkWidget *i = gtk_separator_menu_item_new();
 915         gchar const *patid = "";
 916         g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
 917         gtk_widget_show(i);
 918         gtk_menu_append(GTK_MENU(m), i);
 919     }
 920
 921     // suck in from patterns.svg
 922     if (patterns_doc) {
 923         sp_document_ensure_up_to_date(doc);
 924         sp_pattern_list_from_doc ( m, doc, patterns_doc, NULL );
 925     }
 926
 927 }
 928
 929
 930 static GtkWidget*
 931 ink_pattern_menu(GtkWidget *mnu)
 932 {
 933    /* Create new menu widget */
 934     GtkWidget *m = gtk_menu_new();
 935     gtk_widget_show(m);
 936     SPDocument *doc = SP_ACTIVE_DOCUMENT;
 937
 938     if (!doc) {
 939         GtkWidget *i;
 940         i = gtk_menu_item_new_with_label(_("No document selected"));
 941         gtk_widget_show(i);
 942         gtk_menu_append(GTK_MENU(m), i);
 943         gtk_widget_set_sensitive(mnu, FALSE);
 944     } else {
 945
 946        ink_pattern_menu_populate_menu(m, doc);
 947         gtk_widget_set_sensitive(mnu, TRUE);
 948
 949     }
 950     gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
 951
 952     /* Set history */
 953     gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 954     return mnu;
 955 }
 956
 957
 958 /*update pattern list*/
 959 void
 960 sp_update_pattern_list( SPPaintSelector *psel,  SPPattern *pattern)
 961 {
 962     if (psel->update) return;
 963     GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
 964     g_assert( mnu != NULL );
 965
 966     /* Clear existing menu if any */
 967     gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
 968
 969     ink_pattern_menu(mnu);
 970
 971     /* Set history */
 972
 973     if (pattern && !gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
 974
 975         gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
 976
 977         gchar *patname = (gchar *) SP_OBJECT_REPR(pattern)->attribute("id");
 978
 979         GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
 980
 981         GList *kids = GTK_MENU_SHELL(m)->children;
 982
 983         int patpos = 0;
 984         int i = 0;
 985
 986         for (; kids != NULL; kids = kids->next) {
 987
 988             gchar *men_pat = (gchar *) g_object_get_data(G_OBJECT(kids->data), "pattern");
 989             if ( strcmp(men_pat, patname) == 0 ) {
 990                 patpos = i;
 991             }
 992             i++;
 993         }
 994
 995
 996         gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), patpos);
 997         gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
 998     }
 999     //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
1000 }
1001
1002 static void
1003 sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode)
1004 {
1005     if (mode == SP_PAINT_SELECTOR_MODE_PATTERN)
1006         sp_paint_selector_set_style_buttons(psel, psel->pattern);
1007
1008     gtk_widget_set_sensitive(psel->style, TRUE);
1009
1010     GtkWidget *tbl = NULL;
1011
1012     if (psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN){
1013         /* Already have pattern menu */
1014         tbl = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "pattern-selector");
1015     } else {
1016         sp_paint_selector_clear_frame(psel);
1017
1018         /* Create vbox */
1019         tbl = gtk_vbox_new(FALSE, 4);
1020         gtk_widget_show(tbl);
1021
1022         {
1023             GtkWidget *hb = gtk_hbox_new(FALSE, 1);
1024
1025             GtkWidget *mnu = gtk_option_menu_new();
1026             ink_pattern_menu(mnu);
1027             gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_psel_pattern_change), psel);
1028             gtk_signal_connect(GTK_OBJECT(mnu), "destroy", GTK_SIGNAL_FUNC(sp_psel_pattern_destroy), psel);
1029             gtk_object_set_data(GTK_OBJECT(psel), "patternmenu", mnu);
1030             g_object_ref( G_OBJECT(mnu));
1031
1032             gtk_container_add(GTK_CONTAINER(hb), mnu);
1033             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1034         }
1035
1036         {
1037             GtkWidget *hb = gtk_hbox_new(FALSE, 0);
1038             GtkWidget *l = gtk_label_new(NULL);
1039             gtk_label_set_markup(GTK_LABEL(l), _("Use the <b>Node tool</b> to adjust position, scale, and rotation of the pattern on canvas. Use <b>Object &gt; Pattern &gt; Objects to Pattern</b> to create a new pattern from selection."));
1040             gtk_label_set_line_wrap(GTK_LABEL(l), true);
1041             gtk_widget_set_size_request(l, 180, -1);
1042             gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
1043             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1044         }
1045
1046         gtk_widget_show_all(tbl);
1047
1048         gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
1049         psel->selector = tbl;
1050         gtk_object_set_data(GTK_OBJECT(psel->selector), "pattern-selector", tbl);
1051
1052         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Pattern fill"));
1053     }
1054 #ifdef SP_PS_VERBOSE
1055     g_print("Pattern req\n");
1056 #endif
1057 }
1058
1059 SPPattern *
1060 sp_paint_selector_get_pattern(SPPaintSelector *psel)
1061 {
1062     SPPattern *pat;
1063     g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN) , NULL);
1064
1065     GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(psel), "patternmenu");
1066     /* no pattern menu if we were just selected */
1067     if ( patmnu == NULL ) return NULL;
1068
1069     GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(patmnu)));
1070
1071     /* Get Pattern */
1072     if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern"))
1073     {
1074         return NULL;
1075     }
1076     gchar *patid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
1077                                                 "pattern");
1078     //gchar *pattern = "";
1079     if (strcmp(patid, "none")){
1080
1081        gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
1082                                                 "stockid");
1083        gchar *paturn = patid;
1084        if (!strcmp(stockid,"true")) paturn = g_strconcat("urn:inkscape:pattern:",patid,NULL);
1085        SPObject *pat_obj = get_stock_item(paturn);
1086        if (pat_obj) {
1087             pat = SP_PATTERN(pat_obj);
1088         }
1089     } else {
1090     pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
1091     }
1092
1093     if SP_IS_PATTERN(pat) return pat;
1094     return NULL;
1095 }
1096
1097 static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelectorMode mode)
1098 {
1099     if (mode == SP_PAINT_SELECTOR_MODE_SWATCH) {
1100         sp_paint_selector_set_style_buttons(psel, psel->swatch);
1101     }
1102
1103     gtk_widget_set_sensitive(psel->style, TRUE);
1104
1105     GtkWidget *tbl = 0;
1106
1107     if (psel->mode == SP_PAINT_SELECTOR_MODE_SWATCH){
1108         /* Already have pattern menu */
1109         tbl = static_cast<GtkWidget*>(gtk_object_get_data(GTK_OBJECT(psel->selector), "swatch-selector"));
1110     } else {
1111         sp_paint_selector_clear_frame(psel);
1112         /* Create new gradient selector */
1113         GtkWidget *gsel = sp_gradient_selector_new();
1114         SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_SWATCH);
1115         gtk_widget_show(gsel);
1116         gtk_signal_connect(GTK_OBJECT(gsel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_grabbed), psel);
1117         gtk_signal_connect(GTK_OBJECT(gsel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_dragged), psel);
1118         gtk_signal_connect(GTK_OBJECT(gsel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_released), psel);
1119         gtk_signal_connect(GTK_OBJECT(gsel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_changed), psel);
1120         // Pack everything to frame
1121         gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
1122         psel->selector = gsel;
1123         gtk_object_set_data(GTK_OBJECT(psel->selector), "swatch-selector", gsel);
1124
1125         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Swatch fill"));
1126     }
1127 #ifdef SP_PS_VERBOSE
1128     g_print("Swatch req\n");
1129 #endif
1130 }
1131
1132 void
1133 sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property)
1134 {
1135     SPCSSAttr *css = sp_repr_css_attr_new();
1136
1137     SPColor color;
1138     gfloat alpha;
1139     sp_paint_selector_get_color_alpha(psel, &color, &alpha);
1140
1141     std::string colorStr = color.toString();
1142
1143 #ifdef SP_PS_VERBOSE
1144     guint32 rgba = color.toRGBA32( alpha );
1145     g_message("sp_paint_selector_set_flat_color() to '%s' from 0x%08x::%s",
1146               colorStr.c_str(),
1147               rgba,
1148               (color.icc?color.icc->colorProfile.c_str():"<null>") );
1149 #endif // SP_PS_VERBOSE
1150
1151     sp_repr_css_set_property(css, color_property, colorStr.c_str());
1152     Inkscape::CSSOStringStream osalpha;
1153     osalpha << alpha;
1154     sp_repr_css_set_property(css, opacity_property, osalpha.str().c_str());
1155
1156     sp_desktop_set_style(desktop, css);
1157
1158     sp_repr_css_attr_unref(css);
1159 }
1160
1161 SPPaintSelectorMode sp_style_determine_paint_selector_mode(SPStyle *style, bool isfill)
1162 {
1163     SPPaintSelectorMode mode = SP_PAINT_SELECTOR_MODE_UNSET;
1164     SPIPaint& target = isfill ? style->fill : style->stroke;
1165
1166     if ( !target.set ) {
1167         mode = SP_PAINT_SELECTOR_MODE_UNSET;
1168     } else if ( target.isPaintserver() ) {
1169         SPPaintServer *server = isfill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
1170
1171
1172 #ifdef SP_PS_VERBOSE
1173         g_message("==== server:%p %s  grad:%s   swatch:%s", server, server->getId(), (SP_IS_GRADIENT(server)?"Y":"n"), (SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()?"Y":"n"));
1174 #endif // SP_PS_VERBOSE
1175
1176
1177         if (server && SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()) {
1178             mode = SP_PAINT_SELECTOR_MODE_SWATCH;
1179         } else if (SP_IS_LINEARGRADIENT(server)) {
1180             mode = SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR;
1181         } else if (SP_IS_RADIALGRADIENT(server)) {
1182             mode = SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL;
1183         } else if (SP_IS_PATTERN(server)) {
1184             mode = SP_PAINT_SELECTOR_MODE_PATTERN;
1185         } else {
1186             g_warning( "file %s: line %d: Unknown paintserver", __FILE__, __LINE__ );
1187             mode = SP_PAINT_SELECTOR_MODE_NONE;
1188         }
1189     } else if ( target.isColor() ) {
1190         mode = SP_PAINT_SELECTOR_MODE_COLOR_RGB; // so far only rgb can be read from svg
1191     } else if ( target.isNone() ) {
1192         mode = SP_PAINT_SELECTOR_MODE_NONE;
1193     } else {
1194         g_warning( "file %s: line %d: Unknown paint type", __FILE__, __LINE__ );
1195         mode = SP_PAINT_SELECTOR_MODE_NONE;
1196     }
1197
1198     return mode;
1199 }
1200
1201 /*
1202   Local Variables:
1203   mode:c++
1204   c-file-style:"stroustrup"
1205   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1206   indent-tabs-mode:nil
1207   fill-column:99
1208   End:
1209 */
1210 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :