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