src/widgets/paint-selector.cpp

   1 #define __SP_PAINT_SELECTOR_C__
   2
   3 /** \file
   4  * SPPaintSelector: Generic paint selector widget.
   5  */
   6
   7 /*
   8  * Copyright (C) Lauris Kaplinski 2002
   9  *   bulia byak <buliabyak@users.sf.net>
  10 */
  11
  12 #define noSP_PS_VERBOSE
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include "config.h"
  16 #endif
  17
  18
  19
  20 #include <gtk/gtkhbox.h>
  21 #include <gtk/gtkradiobutton.h>
  22 #include <gtk/gtkframe.h>
  23 #include <gtk/gtklabel.h>
  24 #include <gtk/gtkoptionmenu.h>
  25 #include <gtk/gtktooltips.h>
  26 #include <gtk/gtkmenuitem.h>
  27
  28 #include "../sp-pattern.h"
  29 #include <glibmm/i18n.h>
  30 #include "../widgets/icon.h"
  31 #include "../inkscape-stock.h"
  32 #include "widgets/widget-sizes.h"
  33 #include "xml/repr.h"
  34
  35 #include "sp-color-notebook.h"
  36 #include "sp-linear-gradient-fns.h"
  37 #include "sp-radial-gradient-fns.h"
  38 /* fixme: Move it from dialogs to here */
  39 #include "gradient-selector.h"
  40 #include <inkscape.h>
  41 #include <document-private.h>
  42 #include <desktop-style.h>
  43 #include <style.h>
  44 #include "svg/svg-color.h"
  45 #include "svg/css-ostringstream.h"
  46
  47 #include "paint-selector.h"
  48
  49 enum {
  50     MODE_CHANGED,
  51     GRABBED,
  52     DRAGGED,
  53     RELEASED,
  54     CHANGED,
  55     FILLRULE_CHANGED,
  56     LAST_SIGNAL
  57 };
  58
  59 static void sp_paint_selector_class_init(SPPaintSelectorClass *klass);
  60 static void sp_paint_selector_init(SPPaintSelector *slider);
  61 static void sp_paint_selector_destroy(GtkObject *object);
  62
  63 static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel, gchar const *px, SPPaintSelectorMode mode, GtkTooltips *tt, gchar const *tip);
  64 static void sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
  65 static void sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
  66
  67 static void sp_paint_selector_set_mode_empty(SPPaintSelector *psel);
  68 static void sp_paint_selector_set_mode_multiple(SPPaintSelector *psel);
  69 static void sp_paint_selector_set_mode_none(SPPaintSelector *psel);
  70 static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode);
  71 static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode);
  72 static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode);
  73 static void sp_paint_selector_set_mode_unset(SPPaintSelector *psel);
  74
  75
  76 static void sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active);
  77
  78 static GtkVBoxClass *parent_class;
  79 static guint psel_signals[LAST_SIGNAL] = {0};
  80
  81 GtkType
  82 sp_paint_selector_get_type(void)
  83 {
  84     static GtkType type = 0;
  85     if (!type) {
  86         GtkTypeInfo info = {
  87             "SPPaintSelector",
  88             sizeof(SPPaintSelector),
  89             sizeof(SPPaintSelectorClass),
  90             (GtkClassInitFunc) sp_paint_selector_class_init,
  91             (GtkObjectInitFunc) sp_paint_selector_init,
  92             NULL, NULL, NULL
  93         };
  94         type = gtk_type_unique(GTK_TYPE_VBOX, &info);
  95     }
  96     return type;
  97 }
  98
  99 static void
 100 sp_paint_selector_class_init(SPPaintSelectorClass *klass)
 101 {
 102     GtkObjectClass *object_class;
 103     GtkWidgetClass *widget_class;
 104
 105     object_class = (GtkObjectClass *) klass;
 106     widget_class = (GtkWidgetClass *) klass;
 107
 108     parent_class = (GtkVBoxClass*)gtk_type_class(GTK_TYPE_VBOX);
 109
 110     psel_signals[MODE_CHANGED] = gtk_signal_new("mode_changed",
 111                                                 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 112                                                 GTK_CLASS_TYPE(object_class),
 113                                                 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, mode_changed),
 114                                                 gtk_marshal_NONE__UINT,
 115                                                 GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
 116     psel_signals[GRABBED] =  gtk_signal_new("grabbed",
 117                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 118                                             GTK_CLASS_TYPE(object_class),
 119                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, grabbed),
 120                                             gtk_marshal_NONE__NONE,
 121                                             GTK_TYPE_NONE, 0);
 122     psel_signals[DRAGGED] =  gtk_signal_new("dragged",
 123                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 124                                             GTK_CLASS_TYPE(object_class),
 125                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, dragged),
 126                                             gtk_marshal_NONE__NONE,
 127                                             GTK_TYPE_NONE, 0);
 128     psel_signals[RELEASED] = gtk_signal_new("released",
 129                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 130                                             GTK_CLASS_TYPE(object_class),
 131                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, released),
 132                                             gtk_marshal_NONE__NONE,
 133                                             GTK_TYPE_NONE, 0);
 134     psel_signals[CHANGED] =  gtk_signal_new("changed",
 135                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 136                                             GTK_CLASS_TYPE(object_class),
 137                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, changed),
 138                                             gtk_marshal_NONE__NONE,
 139                                             GTK_TYPE_NONE, 0);
 140     psel_signals[FILLRULE_CHANGED] = gtk_signal_new("fillrule_changed",
 141                                                     (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 142                                                     GTK_CLASS_TYPE(object_class),
 143                                                     GTK_SIGNAL_OFFSET(SPPaintSelectorClass, fillrule_changed),
 144                                                     gtk_marshal_NONE__UINT,
 145                                                     GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
 146
 147     object_class->destroy = sp_paint_selector_destroy;
 148 }
 149
 150 #define XPAD 4
 151 #define YPAD 1
 152
 153 static void
 154 sp_paint_selector_init(SPPaintSelector *psel)
 155 {
 156     GtkTooltips *tt = gtk_tooltips_new();
 157
 158     psel->mode = (SPPaintSelectorMode)-1; // huh?  do you mean 0xff?  --  I think this means "not in the enum"
 159
 160     /* Paint style button box */
 161     psel->style = gtk_hbox_new(FALSE, 0);
 162     gtk_widget_show(psel->style);
 163     gtk_container_set_border_width(GTK_CONTAINER(psel->style), 4);
 164     gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0);
 165
 166     /* Buttons */
 167     psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_NONE,
 168                                                     SP_PAINT_SELECTOR_MODE_NONE, tt, _("No paint"));
 169     psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_SOLID,
 170                                                      SP_PAINT_SELECTOR_MODE_COLOR_RGB, tt, _("Flat color"));
 171     psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_GRADIENT,
 172                                                         SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR, tt, _("Linear gradient"));
 173     psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_RADIAL,
 174                                                       SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL, tt, _("Radial gradient"));
 175     psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_PATTERN,
 176                                                        SP_PAINT_SELECTOR_MODE_PATTERN, tt, _("Pattern"));
 177     psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_UNSET,
 178                                                      SP_PAINT_SELECTOR_MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)"));
 179
 180     /* Fillrule */
 181     {
 182         psel->fillrulebox = gtk_hbox_new(FALSE, 0);
 183         gtk_box_pack_end(GTK_BOX(psel->style), psel->fillrulebox, FALSE, FALSE, 0);
 184
 185         GtkWidget *w;
 186         psel->evenodd = gtk_radio_button_new(NULL);
 187         gtk_button_set_relief(GTK_BUTTON(psel->evenodd), GTK_RELIEF_NONE);
 188         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->evenodd), FALSE);
 189         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
 190         gtk_tooltips_set_tip(tt, psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"), NULL);
 191         gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_EVENODD));
 192         w = sp_icon_new(Inkscape::ICON_SIZE_MENU, "fillrule_evenodd");
 193         gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
 194         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
 195         gtk_signal_connect(GTK_OBJECT(psel->evenodd), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
 196
 197         psel->nonzero = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(psel->evenodd)));
 198         gtk_button_set_relief(GTK_BUTTON(psel->nonzero), GTK_RELIEF_NONE);
 199         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->nonzero), FALSE);
 200         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
 201         gtk_tooltips_set_tip(tt, psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"), NULL);
 202         gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_NONZERO));
 203         w = sp_icon_new(Inkscape::ICON_SIZE_MENU, "fillrule_nonzero");
 204         gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
 205         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
 206         gtk_signal_connect(GTK_OBJECT(psel->nonzero), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
 207     }
 208
 209     /* Frame */
 210     psel->frame = gtk_frame_new("");
 211     gtk_widget_show(psel->frame);
 212     gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0);
 213     gtk_box_pack_start(GTK_BOX(psel), psel->frame, TRUE, TRUE, 0);
 214
 215     /* Last used color */
 216     sp_color_set_rgb_float(&psel->color, 0.0, 0.0, 0.0);
 217     psel->alpha = 1.0;
 218 }
 219
 220 static void
 221 sp_paint_selector_destroy(GtkObject *object)
 222 {
 223     SPPaintSelector *psel = SP_PAINT_SELECTOR(object);
 224
 225     // clean up our long-living pattern menu
 226     g_object_set_data(G_OBJECT(psel),"patternmenu",NULL);
 227
 228     if (((GtkObjectClass *) parent_class)->destroy)
 229         (* ((GtkObjectClass *) parent_class)->destroy)(object);
 230 }
 231
 232 static GtkWidget *
 233 sp_paint_selector_style_button_add(SPPaintSelector *psel,
 234                                    gchar const *pixmap, SPPaintSelectorMode mode,
 235                                    GtkTooltips *tt, gchar const *tip)
 236 {
 237     GtkWidget *b, *w;
 238
 239     b = gtk_toggle_button_new();
 240     gtk_tooltips_set_tip(tt, b, tip, NULL);
 241     gtk_widget_show(b);
 242
 243     gtk_container_set_border_width(GTK_CONTAINER(b), 0);
 244
 245     gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
 246
 247     gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(b), FALSE);
 248     gtk_object_set_data(GTK_OBJECT(b), "mode", GUINT_TO_POINTER(mode));
 249
 250     w = sp_icon_new(Inkscape::ICON_SIZE_BUTTON, pixmap);
 251     gtk_widget_show(w);
 252     gtk_container_add(GTK_CONTAINER(b), w);
 253
 254     gtk_box_pack_start(GTK_BOX(psel->style), b, FALSE, FALSE, 0);
 255     gtk_signal_connect(GTK_OBJECT(b), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_style_button_toggled), psel);
 256
 257     return b;
 258 }
 259
 260 static void
 261 sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 262 {
 263     if (!psel->update && gtk_toggle_button_get_active(tb)) {
 264         sp_paint_selector_set_mode(psel, (SPPaintSelectorMode)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode")));
 265     }
 266 }
 267
 268 static void
 269 sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 270 {
 271     if (!psel->update && gtk_toggle_button_get_active(tb)) {
 272         SPPaintSelectorFillRule fr = (SPPaintSelectorFillRule)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode"));
 273         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[FILLRULE_CHANGED], fr);
 274     }
 275 }
 276
 277 void
 278 sp_paint_selector_show_fillrule(SPPaintSelector *psel, bool is_fill)
 279 {
 280     if (psel->fillrulebox) {
 281         if (is_fill) {
 282             gtk_widget_show_all(psel->fillrulebox);
 283         } else {
 284             gtk_widget_destroy(psel->fillrulebox);
 285             psel->fillrulebox = NULL;
 286         }
 287     }
 288 }
 289
 290
 291 GtkWidget *
 292 sp_paint_selector_new(bool is_fill)
 293 {
 294     SPPaintSelector *psel;
 295
 296     psel = (SPPaintSelector*)gtk_type_new(SP_TYPE_PAINT_SELECTOR);
 297
 298     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
 299
 300     // This silliness is here because I don't know how to pass a parameter to the
 301     // GtkObject "constructor" (sp_paint_selector_init). Remove it when paint_selector
 302     // becomes a normal class.
 303     sp_paint_selector_show_fillrule(psel, is_fill);
 304
 305     return GTK_WIDGET(psel);
 306 }
 307
 308 void
 309 sp_paint_selector_set_mode(SPPaintSelector *psel, SPPaintSelectorMode mode)
 310 {
 311     if (psel->mode != mode) {
 312         psel->update = TRUE;
 313 #ifdef SP_PS_VERBOSE
 314         g_print("Mode change %d -> %d\n", psel->mode, mode);
 315 #endif
 316         switch (mode) {
 317             case SP_PAINT_SELECTOR_MODE_EMPTY:
 318                 sp_paint_selector_set_mode_empty(psel);
 319                 break;
 320             case SP_PAINT_SELECTOR_MODE_MULTIPLE:
 321                 sp_paint_selector_set_mode_multiple(psel);
 322                 break;
 323             case SP_PAINT_SELECTOR_MODE_NONE:
 324                 sp_paint_selector_set_mode_none(psel);
 325                 break;
 326             case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
 327             case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
 328                 sp_paint_selector_set_mode_color(psel, mode);
 329                 break;
 330             case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
 331             case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
 332                 sp_paint_selector_set_mode_gradient(psel, mode);
 333                 break;
 334             case SP_PAINT_SELECTOR_MODE_PATTERN:
 335                 sp_paint_selector_set_mode_pattern(psel, mode);
 336                 break;
 337             case SP_PAINT_SELECTOR_MODE_UNSET:
 338                 sp_paint_selector_set_mode_unset(psel);
 339                 break;
 340             default:
 341                 g_warning("file %s: line %d: Unknown paint mode %d", __FILE__, __LINE__, mode);
 342                 break;
 343         }
 344         psel->mode = mode;
 345         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[MODE_CHANGED], psel->mode);
 346         psel->update = FALSE;
 347     }
 348 }
 349
 350 void
 351 sp_paint_selector_set_fillrule(SPPaintSelector *psel, SPPaintSelectorFillRule fillrule)
 352 {
 353     if (psel->fillrulebox) {
 354         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->evenodd), (fillrule == SP_PAINT_SELECTOR_FILLRULE_EVENODD));
 355         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->nonzero), (fillrule == SP_PAINT_SELECTOR_FILLRULE_NONZERO));
 356     }
 357 }
 358
 359 void
 360 sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, float alpha)
 361 {
 362     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 363     SPColorSelector *csel;
 364     guint32 rgba;
 365
 366     if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
 367     {
 368 #ifdef SP_PS_VERBOSE
 369         g_print("PaintSelector set CMYKA\n");
 370 #endif
 371         sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_CMYK);
 372     }
 373     else
 374     {
 375 #ifdef SP_PS_VERBOSE
 376         g_print("PaintSelector set RGBA\n");
 377 #endif
 378         sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_RGB);
 379     }
 380
 381     csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 382     rgba = sp_color_get_rgba32_falpha( &*color, alpha );
 383     csel->base->setColorAlpha( *color, alpha );
 384 }
 385
 386 void
 387 sp_paint_selector_set_gradient_linear(SPPaintSelector *psel, SPGradient *vector)
 388 {
 389     SPGradientSelector *gsel;
 390 #ifdef SP_PS_VERBOSE
 391     g_print("PaintSelector set GRADIENT LINEAR\n");
 392 #endif
 393     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR);
 394
 395     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 396
 397     sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_LINEAR);
 398     sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
 399 }
 400
 401 void
 402 sp_paint_selector_set_gradient_radial(SPPaintSelector *psel, SPGradient *vector)
 403 {
 404     SPGradientSelector *gsel;
 405 #ifdef SP_PS_VERBOSE
 406     g_print("PaintSelector set GRADIENT RADIAL\n");
 407 #endif
 408     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL);
 409
 410     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 411
 412     sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_RADIAL);
 413     sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
 414 }
 415
 416 void
 417 sp_paint_selector_set_gradient_properties(SPPaintSelector *psel, SPGradientUnits units, SPGradientSpread spread)
 418 {
 419     SPGradientSelector *gsel;
 420     g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
 421     g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 422                      (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
 423     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 424     sp_gradient_selector_set_units(gsel, units);
 425     sp_gradient_selector_set_spread(gsel, spread);
 426 }
 427
 428 void
 429 sp_paint_selector_get_gradient_properties(SPPaintSelector *psel, SPGradientUnits *units, SPGradientSpread *spread)
 430 {
 431     SPGradientSelector *gsel;
 432     g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
 433     g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 434                      (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
 435     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 436     if (units) *units = sp_gradient_selector_get_units(gsel);
 437     if (spread) *spread = sp_gradient_selector_get_spread(gsel);
 438 }
 439
 440 /**
 441  * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
 442  */
 443 void
 444 sp_paint_selector_get_color_alpha(SPPaintSelector *psel, SPColor *color, gfloat *alpha)
 445 {
 446     SPColorSelector *csel;
 447
 448     csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 449
 450     csel->base->getColorAlpha( *color, alpha );
 451
 452     g_assert( !alpha
 453               || ( ( 0.0 <= *alpha )
 454                    && ( *alpha <= 1.0 ) ) );
 455 }
 456
 457 SPGradient *
 458 sp_paint_selector_get_gradient_vector(SPPaintSelector *psel)
 459 {
 460     SPGradientSelector *gsel;
 461
 462     g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 463                          (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL), NULL);
 464
 465     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 466
 467     return sp_gradient_selector_get_vector(gsel);
 468 }
 469
 470 void
 471 sp_gradient_selector_attrs_to_gradient(SPGradient *gr, SPPaintSelector *psel)
 472 {
 473     SPGradientUnits units;
 474     SPGradientSpread spread;
 475     sp_paint_selector_get_gradient_properties(psel, &units, &spread);
 476     sp_gradient_set_units(gr, units);
 477     sp_gradient_set_spread(gr, spread);
 478     SP_OBJECT(gr)->updateRepr();
 479 }
 480
 481 static void
 482 sp_paint_selector_clear_frame(SPPaintSelector *psel)
 483 {
 484     g_return_if_fail( psel != NULL);
 485
 486     if (psel->selector) {
 487
 488         /* before we destroy the frame contents, we must detach
 489          * the patternmenu so that Gtk doesn't gtk_widget_destroy
 490          * all the children of the menu.  (We also have a g_object_ref
 491          * count set on it too so that the gtk_container_remove doesn't
 492          * end up destroying it.
 493          */
 494         GtkWidget *patterns = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
 495         if (patterns != NULL) {
 496             GtkWidget * parent = gtk_widget_get_parent( GTK_WIDGET(patterns));
 497             if ( parent != NULL ) {
 498                 g_assert( GTK_IS_CONTAINER(parent) );
 499                 gtk_container_remove( GTK_CONTAINER(parent), patterns );
 500             }
 501         }
 502
 503         gtk_widget_destroy(psel->selector);
 504         psel->selector = NULL;
 505     }
 506 }
 507
 508 static void
 509 sp_paint_selector_set_mode_empty(SPPaintSelector *psel)
 510 {
 511     sp_paint_selector_set_style_buttons(psel, NULL);
 512     gtk_widget_set_sensitive(psel->style, FALSE);
 513
 514     sp_paint_selector_clear_frame(psel);
 515
 516     gtk_frame_set_label(GTK_FRAME(psel->frame), _("No objects"));
 517 }
 518
 519 static void
 520 sp_paint_selector_set_mode_multiple(SPPaintSelector *psel)
 521 {
 522     sp_paint_selector_set_style_buttons(psel, NULL);
 523     gtk_widget_set_sensitive(psel->style, TRUE);
 524
 525     sp_paint_selector_clear_frame(psel);
 526
 527     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Multiple styles"));
 528 }
 529
 530 static void
 531 sp_paint_selector_set_mode_unset(SPPaintSelector *psel)
 532 {
 533     sp_paint_selector_set_style_buttons(psel, psel->unset);
 534     gtk_widget_set_sensitive(psel->style, TRUE);
 535
 536     sp_paint_selector_clear_frame(psel);
 537
 538     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Paint is undefined"));
 539 }
 540
 541 static void
 542 sp_paint_selector_set_mode_none(SPPaintSelector *psel)
 543 {
 544     sp_paint_selector_set_style_buttons(psel, psel->none);
 545     gtk_widget_set_sensitive(psel->style, TRUE);
 546
 547     sp_paint_selector_clear_frame(psel);
 548
 549     gtk_frame_set_label(GTK_FRAME(psel->frame), _("No paint"));
 550 }
 551
 552 /* Color paint */
 553
 554 static void
 555 sp_paint_selector_color_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
 556 {
 557     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 558 }
 559
 560 static void
 561 sp_paint_selector_color_dragged(SPColorSelector *csel, SPPaintSelector *psel)
 562 {
 563     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 564 }
 565
 566 static void
 567 sp_paint_selector_color_released(SPColorSelector *csel, SPPaintSelector *psel)
 568 {
 569     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 570 }
 571
 572 static void
 573 sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
 574 {
 575     csel->base->getColorAlpha( psel->color, &psel->alpha );
 576
 577     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 578 }
 579
 580 static void
 581 sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode)
 582 {
 583     GtkWidget *csel;
 584
 585     sp_paint_selector_set_style_buttons(psel, psel->solid);
 586     gtk_widget_set_sensitive(psel->style, TRUE);
 587
 588     if ((psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_RGB) || (psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_CMYK)) {
 589         /* Already have color selector */
 590         csel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 591     } else {
 592
 593         sp_paint_selector_clear_frame(psel);
 594         /* Create new color selector */
 595         /* Create vbox */
 596         GtkWidget *vb = gtk_vbox_new(FALSE, 4);
 597         gtk_widget_show(vb);
 598
 599         /* Color selector */
 600         csel = sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK, SP_COLORSPACE_TYPE_NONE);
 601         gtk_widget_show(csel);
 602         gtk_object_set_data(GTK_OBJECT(vb), "color-selector", csel);
 603         gtk_box_pack_start(GTK_BOX(vb), csel, TRUE, TRUE, 0);
 604         gtk_signal_connect(GTK_OBJECT(csel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_color_grabbed), psel);
 605         gtk_signal_connect(GTK_OBJECT(csel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_color_dragged), psel);
 606         gtk_signal_connect(GTK_OBJECT(csel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_color_released), psel);
 607         gtk_signal_connect(GTK_OBJECT(csel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_color_changed), psel);
 608         /* Pack everything to frame */
 609         gtk_container_add(GTK_CONTAINER(psel->frame), vb);
 610         psel->selector = vb;
 611
 612         /* Set color */
 613         SP_COLOR_SELECTOR( csel )->base->setColorAlpha( psel->color, psel->alpha );
 614
 615     }
 616
 617     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Flat color"));
 618 #ifdef SP_PS_VERBOSE
 619     g_print("Color req\n");
 620 #endif
 621 }
 622
 623 /* Gradient */
 624
 625 static void
 626 sp_paint_selector_gradient_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
 627 {
 628     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 629 }
 630
 631 static void
 632 sp_paint_selector_gradient_dragged(SPColorSelector *csel, SPPaintSelector *psel)
 633 {
 634     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 635 }
 636
 637 static void
 638 sp_paint_selector_gradient_released(SPColorSelector *csel, SPPaintSelector *psel)
 639 {
 640     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 641 }
 642
 643 static void
 644 sp_paint_selector_gradient_changed(SPColorSelector *csel, SPPaintSelector *psel)
 645 {
 646     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 647 }
 648
 649 static void
 650 sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode)
 651 {
 652     GtkWidget *gsel;
 653
 654     /* fixme: We do not need function-wide gsel at all */
 655
 656     if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
 657         sp_paint_selector_set_style_buttons(psel, psel->gradient);
 658     } else {
 659         sp_paint_selector_set_style_buttons(psel, psel->radial);
 660     }
 661     gtk_widget_set_sensitive(psel->style, TRUE);
 662
 663     if ((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) || (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL)) {
 664         /* Already have gradient selector */
 665         gsel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 666     } else {
 667         sp_paint_selector_clear_frame(psel);
 668         /* Create new gradient selector */
 669         gsel = sp_gradient_selector_new();
 670         gtk_widget_show(gsel);
 671         gtk_signal_connect(GTK_OBJECT(gsel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_grabbed), psel);
 672         gtk_signal_connect(GTK_OBJECT(gsel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_dragged), psel);
 673         gtk_signal_connect(GTK_OBJECT(gsel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_released), psel);
 674         gtk_signal_connect(GTK_OBJECT(gsel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_changed), psel);
 675         /* Pack everything to frame */
 676         gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
 677         psel->selector = gsel;
 678         gtk_object_set_data(GTK_OBJECT(psel->selector), "gradient-selector", gsel);
 679     }
 680
 681     /* Actually we have to set optiomenu history here */
 682     if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
 683         sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
 684         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Linear gradient"));
 685     } else {
 686         sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_RADIAL);
 687         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Radial gradient"));
 688     }
 689 #ifdef SP_PS_VERBOSE
 690     g_print("Gradient req\n");
 691 #endif
 692 }
 693
 694 static void
 695 sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
 696 {
 697     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->none), (active == psel->none));
 698     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->solid), (active == psel->solid));
 699     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->gradient), (active == psel->gradient));
 700     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->radial), (active == psel->radial));
 701     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->pattern), (active == psel->pattern));
 702     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->unset), (active == psel->unset));
 703 }
 704
 705 static void
 706 sp_psel_pattern_destroy(GtkWidget *widget,  SPPaintSelector *psel)
 707 {
 708     // drop our reference to the pattern menu widget
 709     g_object_unref( G_OBJECT(widget) );
 710 }
 711
 712 static void
 713 sp_psel_pattern_change(GtkWidget *widget,  SPPaintSelector *psel)
 714 {
 715     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 716 }
 717
 718 static GtkWidget*
 719 ink_pattern_menu(GtkWidget *mnu)
 720 {
 721     /* Create new menu widget */
 722     GtkWidget *m = gtk_menu_new();
 723     gtk_widget_show(m);
 724
 725     /* Pick up all patterns  */
 726     SPDocument *doc = SP_ACTIVE_DOCUMENT;
 727     GSList *pl = NULL;
 728     GSList const *patterns = sp_document_get_resource_list(doc, "pattern");
 729     for (GSList *l = (GSList *) patterns; l != NULL; l = l->next) {
 730         if (SP_PATTERN(l->data) == pattern_getroot(SP_PATTERN(l->data))) {  // only if this is a root pattern
 731             pl = g_slist_prepend(pl, l->data);
 732         }
 733     }
 734
 735     pl = g_slist_reverse(pl);
 736
 737     if (!doc) {
 738         GtkWidget *i;
 739         i = gtk_menu_item_new_with_label(_("No document selected"));
 740         gtk_widget_show(i);
 741         gtk_menu_append(GTK_MENU(m), i);
 742         gtk_widget_set_sensitive(mnu, FALSE);
 743     } else if (!pl) {
 744         GtkWidget *i;
 745         i = gtk_menu_item_new_with_label(_("No patterns in document"));
 746         gtk_widget_show(i);
 747         gtk_menu_append(GTK_MENU(m), i);
 748         gtk_widget_set_sensitive(mnu, FALSE);
 749     } else {
 750         for (; pl != NULL; pl = pl->next){
 751             if (SP_IS_PATTERN(pl->data)){
 752                 SPPattern *pat = SP_PATTERN(pl->data);
 753                 GtkWidget *i = gtk_menu_item_new();
 754                 gtk_widget_show(i);
 755                 g_object_set_data(G_OBJECT(i), "pattern", pat);
 756                 GtkWidget *hb = gtk_hbox_new(FALSE, 4);
 757                 gtk_widget_show(hb);
 758                 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) pl->data);
 759                 GtkWidget *l = gtk_label_new(repr->attribute("id"));
 760                 gtk_widget_show(l);
 761                 gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
 762                 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
 763                 gtk_widget_show(hb);
 764                 gtk_container_add(GTK_CONTAINER(i), hb);
 765                 gtk_menu_append(GTK_MENU(m), i);
 766             }
 767         }
 768
 769         gtk_widget_set_sensitive(mnu, TRUE);
 770     }
 771     gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
 772
 773     /* Set history */
 774     //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 775
 776     g_slist_free(pl);
 777     return mnu;
 778 }
 779
 780
 781 /*update pattern list*/
 782 void
 783 sp_update_pattern_list( SPPaintSelector *psel,  SPPattern *pattern)
 784 {
 785     if (psel->update) return;
 786     GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
 787     g_assert( mnu != NULL );
 788
 789     /* Clear existing menu if any */
 790     gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
 791
 792     ink_pattern_menu(mnu);
 793
 794     /* Set history */
 795
 796     if (pattern && !gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
 797
 798         gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
 799
 800         gchar *patname = (gchar *) SP_OBJECT_REPR(pattern)->attribute("id");
 801
 802         GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
 803         GList *kids = GTK_MENU_SHELL(m)->children;
 804
 805         int patpos = 0;
 806         int i = 0;
 807
 808         for (; kids != NULL; kids = kids->next) {
 809             gchar *men_pat = (gchar *) SP_OBJECT_REPR(g_object_get_data(G_OBJECT(kids->data), "pattern"))->attribute("id");
 810             if ( strcmp(men_pat, patname) == 0 ) {
 811                 patpos = i;
 812             }
 813             i++;
 814         }
 815
 816         gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), patpos);
 817         gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
 818     }
 819     //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 820 }
 821
 822 static void
 823 sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode)
 824 {
 825     if (mode == SP_PAINT_SELECTOR_MODE_PATTERN)
 826         sp_paint_selector_set_style_buttons(psel, psel->pattern);
 827
 828     gtk_widget_set_sensitive(psel->style, TRUE);
 829
 830     GtkWidget *tbl = NULL;
 831
 832     if (psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN){
 833         /* Already have pattern menu */
 834         tbl = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "pattern-selector");
 835     } else {
 836         sp_paint_selector_clear_frame(psel);
 837
 838         /* Create vbox */
 839         tbl = gtk_vbox_new(FALSE, 4);
 840         gtk_widget_show(tbl);
 841
 842         {
 843             GtkWidget *hb = gtk_hbox_new(FALSE, 1);
 844
 845             GtkWidget *mnu = gtk_option_menu_new();
 846             ink_pattern_menu(mnu);
 847             gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_psel_pattern_change), psel);
 848             gtk_signal_connect(GTK_OBJECT(mnu), "destroy", GTK_SIGNAL_FUNC(sp_psel_pattern_destroy), psel);
 849             gtk_object_set_data(GTK_OBJECT(psel), "patternmenu", mnu);
 850             g_object_ref( G_OBJECT(mnu));
 851
 852             gtk_container_add(GTK_CONTAINER(hb), mnu);
 853             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 854         }
 855
 856         {
 857             GtkWidget *hb = gtk_hbox_new(FALSE, 0);
 858             GtkWidget *l = gtk_label_new(NULL);
 859             gtk_label_set_markup(GTK_LABEL(l), _("Use <b>Edit &gt; Object(s) to Pattern</b> to create a new pattern from selection."));
 860             gtk_label_set_line_wrap(GTK_LABEL(l), true);
 861             gtk_widget_set_size_request(l, 180, -1);
 862             gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
 863             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 864         }
 865
 866         gtk_widget_show_all(tbl);
 867
 868         gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
 869         psel->selector = tbl;
 870         gtk_object_set_data(GTK_OBJECT(psel->selector), "pattern-selector", tbl);
 871
 872         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Pattern fill"));
 873     }
 874 #ifdef SP_PS_VERBOSE
 875     g_print("Pattern req\n");
 876 #endif
 877 }
 878
 879 SPPattern *
 880 sp_paint_selector_get_pattern(SPPaintSelector *psel)
 881 {
 882     SPPattern *pat;
 883
 884     g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN) , NULL);
 885
 886     GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(psel), "patternmenu");
 887     /* no pattern menu if we were just selected */
 888     if ( patmnu == NULL ) return NULL;
 889
 890     GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(patmnu)));
 891
 892     pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
 893
 894     return pat;
 895 }
 896
 897 void
 898 sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property)
 899 {
 900     SPCSSAttr *css = sp_repr_css_attr_new();
 901
 902     SPColor color;
 903     gfloat alpha;
 904     sp_paint_selector_get_color_alpha(psel, &color, &alpha);
 905     guint32 rgba = sp_color_get_rgba32_falpha(&color, alpha);
 906
 907     gchar b[64];
 908     sp_svg_write_color(b, 64, rgba);
 909
 910     sp_repr_css_set_property(css, color_property, b);
 911     Inkscape::CSSOStringStream osalpha;
 912     osalpha << alpha;
 913     sp_repr_css_set_property(css, opacity_property, osalpha.str().c_str());
 914
 915     sp_desktop_set_style(desktop, css);
 916
 917     sp_repr_css_attr_unref(css);
 918 }
 919
 920 SPPaintSelectorMode
 921 sp_style_determine_paint_selector_mode(SPStyle *style, bool isfill)
 922 {
 923     unsigned set = isfill? style->fill.set : style->stroke.set;
 924     if (!set)
 925         return SP_PAINT_SELECTOR_MODE_UNSET;
 926
 927     unsigned type = isfill? style->fill.type : style->stroke.type;
 928     switch (type) {
 929
 930         case SP_PAINT_TYPE_NONE:
 931         {
 932             return SP_PAINT_SELECTOR_MODE_NONE;
 933         }
 934
 935         case SP_PAINT_TYPE_COLOR:
 936         {
 937             return SP_PAINT_SELECTOR_MODE_COLOR_RGB; // so far only rgb can be read from svg
 938         }
 939
 940         case SP_PAINT_TYPE_PAINTSERVER:
 941         {
 942             SPPaintServer *server = isfill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
 943
 944             if (SP_IS_LINEARGRADIENT(server)) {
 945                 return SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR;
 946             } else if (SP_IS_RADIALGRADIENT(server)) {
 947                 return SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL;
 948             } else if (SP_IS_PATTERN(server)) {
 949                 return SP_PAINT_SELECTOR_MODE_PATTERN;
 950             }
 951
 952             g_warning( "file %s: line %d: Unknown paintserver",
 953                        __FILE__, __LINE__ );
 954             return SP_PAINT_SELECTOR_MODE_NONE;
 955         }
 956
 957         default:
 958             g_warning( "file %s: line %d: Unknown paint type %d",
 959                        __FILE__, __LINE__, type );
 960             break;
 961     }
 962
 963     return SP_PAINT_SELECTOR_MODE_NONE;
 964 }
 965
 966 /*
 967   Local Variables:
 968   mode:c++
 969   c-file-style:"stroustrup"
 970   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 971   indent-tabs-mode:nil
 972   fill-column:99
 973   End:
 974 */
 975 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :