src/widgets/gradient-selector.cpp

   1 #define __SP_GRADIENT_SELECTOR_C__
   2
   3 /*
   4  * Gradient vector widget
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *
  10  * Copyright (C) 2001-2002 Lauris Kaplinski
  11  * Copyright (C) 2001 Ximian, Inc.
  12  *
  13  * Released under GNU GPL, read the file 'COPYING' for more information
  14  */
  15
  16 #ifdef HAVE_CONFIG_H
  17 # include "config.h"
  18 #endif
  19 #include <gtk/gtkhbox.h>
  20 #include <gtk/gtklabel.h>
  21 #include <gtk/gtkoptionmenu.h>
  22 #include <gtk/gtkmenuitem.h>
  23 #include <gtk/gtktooltips.h>
  24
  25 #include "../document-private.h"
  26 #include "../gradient-chemistry.h"
  27
  28 #include <glibmm/i18n.h>
  29 #include <xml/repr.h>
  30
  31 #include "gradient-vector.h"
  32
  33 #include "gradient-selector.h"
  34
  35 enum {
  36         GRABBED,
  37         DRAGGED,
  38         RELEASED,
  39         CHANGED,
  40         LAST_SIGNAL
  41 };
  42
  43 static void sp_gradient_selector_class_init (SPGradientSelectorClass *klass);
  44 static void sp_gradient_selector_init (SPGradientSelector *selector);
  45 static void sp_gradient_selector_destroy (GtkObject *object);
  46
  47 /* Signal handlers */
  48 static void sp_gradient_selector_vector_set (SPGradientVectorSelector *gvs, SPGradient *gr, SPGradientSelector *sel);
  49 static void sp_gradient_selector_edit_vector_clicked (GtkWidget *w, SPGradientSelector *sel);
  50 static void sp_gradient_selector_add_vector_clicked (GtkWidget *w, SPGradientSelector *sel);
  51
  52 static void sp_gradient_selector_spread_activate (GtkWidget *widget, SPGradientSelector *sel);
  53
  54 static GtkVBoxClass *parent_class;
  55 static guint signals[LAST_SIGNAL] = {0};
  56
  57 GtkType
  58 sp_gradient_selector_get_type (void)
  59 {
  60         static GtkType type = 0;
  61         if (!type) {
  62                 GtkTypeInfo info = {
  63                         "SPGradientSelector",
  64                         sizeof (SPGradientSelector),
  65                         sizeof (SPGradientSelectorClass),
  66                         (GtkClassInitFunc) sp_gradient_selector_class_init,
  67                         (GtkObjectInitFunc) sp_gradient_selector_init,
  68                         NULL, NULL, NULL
  69                 };
  70                 type = gtk_type_unique (GTK_TYPE_VBOX, &info);
  71         }
  72         return type;
  73 }
  74
  75 static void
  76 sp_gradient_selector_class_init (SPGradientSelectorClass *klass)
  77 {
  78         GtkObjectClass *object_class;
  79
  80         object_class = (GtkObjectClass *) klass;
  81
  82         parent_class = (GtkVBoxClass*)gtk_type_class (GTK_TYPE_VBOX);
  83
  84         signals[GRABBED] =  gtk_signal_new ("grabbed",
  85                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
  86                                             GTK_CLASS_TYPE(object_class),
  87                                             GTK_SIGNAL_OFFSET (SPGradientSelectorClass, grabbed),
  88                                             gtk_marshal_NONE__NONE,
  89                                             GTK_TYPE_NONE, 0);
  90         signals[DRAGGED] =  gtk_signal_new ("dragged",
  91                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
  92                                             GTK_CLASS_TYPE(object_class),
  93                                             GTK_SIGNAL_OFFSET (SPGradientSelectorClass, dragged),
  94                                             gtk_marshal_NONE__NONE,
  95                                             GTK_TYPE_NONE, 0);
  96         signals[RELEASED] = gtk_signal_new ("released",
  97                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
  98                                             GTK_CLASS_TYPE(object_class),
  99                                             GTK_SIGNAL_OFFSET (SPGradientSelectorClass, released),
 100                                             gtk_marshal_NONE__NONE,
 101                                             GTK_TYPE_NONE, 0);
 102         signals[CHANGED] =  gtk_signal_new ("changed",
 103                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 104                                             GTK_CLASS_TYPE(object_class),
 105                                             GTK_SIGNAL_OFFSET (SPGradientSelectorClass, changed),
 106                                             gtk_marshal_NONE__NONE,
 107                                             GTK_TYPE_NONE, 0);
 108
 109         object_class->destroy = sp_gradient_selector_destroy;
 110 }
 111
 112 static void
 113 sp_gradient_selector_init (SPGradientSelector *sel)
 114 {
 115         GtkWidget *hb, *l, *m, *mi;
 116
 117         sel->mode = SP_GRADIENT_SELECTOR_MODE_LINEAR;
 118
 119         sel->gradientUnits = SP_GRADIENT_UNITS_USERSPACEONUSE;
 120         sel->gradientSpread = SP_GRADIENT_SPREAD_PAD;
 121
 122         /* Vectors */
 123         sel->vectors = sp_gradient_vector_selector_new (NULL, NULL);
 124         gtk_widget_show (sel->vectors);
 125         gtk_box_pack_start (GTK_BOX (sel), sel->vectors, FALSE, FALSE, 0);
 126         g_signal_connect (G_OBJECT (sel->vectors), "vector_set", G_CALLBACK (sp_gradient_selector_vector_set), sel);
 127
 128         /* Create box for buttons */
 129         hb = gtk_hbox_new (FALSE, 0);
 130         gtk_box_pack_start (GTK_BOX (sel), hb, FALSE, FALSE, 0);
 131         GtkTooltips *ttips = gtk_tooltips_new ();
 132
 133         sel->add = gtk_button_new_with_label (_("Duplicate"));
 134         gtk_box_pack_start (GTK_BOX (hb), sel->add, TRUE, TRUE, 0);
 135         g_signal_connect (G_OBJECT (sel->add), "clicked", G_CALLBACK (sp_gradient_selector_add_vector_clicked), sel);
 136         gtk_widget_set_sensitive (sel->add, FALSE);
 137
 138         sel->edit = gtk_button_new_with_label (_("Edit..."));
 139         gtk_box_pack_start (GTK_BOX (hb), sel->edit, TRUE, TRUE, 0);
 140         g_signal_connect (G_OBJECT (sel->edit), "clicked", G_CALLBACK (sp_gradient_selector_edit_vector_clicked), sel);
 141         gtk_widget_set_sensitive (sel->edit, FALSE);
 142
 143         gtk_widget_show_all (hb);
 144
 145         /* Spread selector */
 146         hb = gtk_hbox_new (FALSE, 0);
 147         gtk_widget_show (hb);
 148         gtk_box_pack_start (GTK_BOX (sel), hb, FALSE, FALSE, 0);
 149
 150         sel->spread = gtk_option_menu_new ();
 151         gtk_widget_show (sel->spread);
 152         gtk_box_pack_end (GTK_BOX (hb), sel->spread, FALSE, FALSE, 0);
 153         gtk_tooltips_set_tip (ttips, sel->spread,
 154         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/pservers.html#LinearGradientSpreadMethodAttribute
 155                                         _("Whether to fill with flat color beyond the ends of the gradient vector "
 156                                         "(spreadMethod=\"pad\"), or repeat the gradient in the same direction "
 157                                         "(spreadMethod=\"repeat\"), or repeat the gradient in alternating opposite "
 158                                         "directions (spreadMethod=\"reflect\")"), NULL);
 159
 160         m = gtk_menu_new ();
 161         mi = gtk_menu_item_new_with_label (_("none"));
 162         gtk_menu_append (GTK_MENU (m), mi);
 163         g_object_set_data (G_OBJECT (mi), "gradientSpread", GUINT_TO_POINTER (SP_GRADIENT_SPREAD_PAD));
 164         g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (sp_gradient_selector_spread_activate), sel);
 165         mi = gtk_menu_item_new_with_label (_("reflected"));
 166         g_object_set_data (G_OBJECT (mi), "gradientSpread", GUINT_TO_POINTER (SP_GRADIENT_SPREAD_REFLECT));
 167         g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (sp_gradient_selector_spread_activate), sel);
 168         gtk_menu_append (GTK_MENU (m), mi);
 169         mi = gtk_menu_item_new_with_label (_("direct"));
 170         g_object_set_data (G_OBJECT (mi), "gradientSpread", GUINT_TO_POINTER (SP_GRADIENT_SPREAD_REPEAT));
 171         g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (sp_gradient_selector_spread_activate), sel);
 172         gtk_menu_append (GTK_MENU (m), mi);
 173         gtk_widget_show_all (m);
 174
 175         gtk_option_menu_set_menu (GTK_OPTION_MENU (sel->spread), m);
 176
 177         l = gtk_label_new (_("Repeat:"));
 178         gtk_widget_show (l);
 179         gtk_box_pack_end (GTK_BOX (hb), l, FALSE, FALSE, 4);
 180 }
 181
 182 static void
 183 sp_gradient_selector_destroy (GtkObject *object)
 184 {
 185         SPGradientSelector *sel;
 186
 187         sel = SP_GRADIENT_SELECTOR (object);
 188
 189         if (((GtkObjectClass *) (parent_class))->destroy)
 190                 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
 191 }
 192
 193 GtkWidget *
 194 sp_gradient_selector_new (void)
 195 {
 196         SPGradientSelector *sel;
 197
 198         sel = (SPGradientSelector*)gtk_type_new (SP_TYPE_GRADIENT_SELECTOR);
 199
 200         return (GtkWidget *) sel;
 201 }
 202
 203 void
 204 sp_gradient_selector_set_mode (SPGradientSelector *sel, guint mode)
 205 {
 206         g_return_if_fail (sel != NULL);
 207         g_return_if_fail (SP_IS_GRADIENT_SELECTOR (sel));
 208
 209         sel->mode = mode;
 210 }
 211
 212 void
 213 sp_gradient_selector_set_units (SPGradientSelector *sel, guint units)
 214 {
 215         g_return_if_fail (sel != NULL);
 216         g_return_if_fail (SP_IS_GRADIENT_SELECTOR (sel));
 217
 218         sel->gradientUnits = (SPGradientUnits)units;
 219 }
 220
 221 void
 222 sp_gradient_selector_set_spread (SPGradientSelector *sel, guint spread)
 223 {
 224         g_return_if_fail (sel != NULL);
 225         g_return_if_fail (SP_IS_GRADIENT_SELECTOR (sel));
 226
 227         sel->gradientSpread = (SPGradientSpread)spread;
 228
 229         gtk_option_menu_set_history (GTK_OPTION_MENU (sel->spread), sel->gradientSpread);
 230 }
 231
 232 SPGradientUnits
 233 sp_gradient_selector_get_units (SPGradientSelector *sel)
 234 {
 235         return (SPGradientUnits) sel->gradientUnits;
 236 }
 237
 238 SPGradientSpread
 239 sp_gradient_selector_get_spread (SPGradientSelector *sel)
 240 {
 241         return (SPGradientSpread) sel->gradientSpread;
 242 }
 243
 244 void
 245 sp_gradient_selector_set_vector (SPGradientSelector *sel, SPDocument *doc, SPGradient *vector)
 246 {
 247         g_return_if_fail (sel != NULL);
 248         g_return_if_fail (SP_IS_GRADIENT_SELECTOR (sel));
 249         g_return_if_fail (!vector || SP_IS_GRADIENT (vector));
 250         g_return_if_fail (!vector || (SP_OBJECT_DOCUMENT (vector) == doc));
 251
 252         if (vector && !SP_GRADIENT_HAS_STOPS (vector))
 253                 return;
 254
 255         sp_gradient_vector_selector_set_gradient (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors), doc, vector);
 256
 257         if (vector) {
 258                 gtk_widget_set_sensitive (sel->edit, TRUE);
 259                 gtk_widget_set_sensitive (sel->add, TRUE);
 260         } else {
 261                 gtk_widget_set_sensitive (sel->edit, FALSE);
 262                 gtk_widget_set_sensitive (sel->add, (doc != NULL));
 263         }
 264 }
 265
 266 SPGradient *
 267 sp_gradient_selector_get_vector (SPGradientSelector *sel)
 268 {
 269         if (sel == NULL || !SP_IS_GRADIENT_SELECTOR (sel))
 270                 return NULL;
 271
 272         /* fixme: */
 273         return SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)->gr;
 274 }
 275
 276 static void
 277 sp_gradient_selector_vector_set (SPGradientVectorSelector *gvs, SPGradient *gr, SPGradientSelector *sel)
 278 {
 279         static gboolean blocked = FALSE;
 280
 281         if (!blocked) {
 282                 blocked = TRUE;
 283                 gr = sp_gradient_ensure_vector_normalized (gr);
 284                 sp_gradient_selector_set_vector (sel, (gr) ? SP_OBJECT_DOCUMENT (gr) : NULL, gr);
 285                 g_signal_emit (G_OBJECT (sel), signals[CHANGED], 0, gr);
 286                 blocked = FALSE;
 287         }
 288 }
 289
 290 static void
 291 sp_gradient_selector_edit_vector_clicked (GtkWidget *w, SPGradientSelector *sel)
 292 {
 293         GtkWidget *dialog;
 294
 295         /* fixme: */
 296         dialog = sp_gradient_vector_editor_new (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)->gr);
 297
 298         gtk_widget_show (dialog);
 299 }
 300
 301 static void
 302 sp_gradient_selector_add_vector_clicked (GtkWidget *w, SPGradientSelector *sel)
 303 {
 304         SPDocument *doc;
 305         SPGradient *gr;
 306         Inkscape::XML::Node *repr;
 307
 308         doc = sp_gradient_vector_selector_get_document (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors));
 309         if (!doc) return;
 310         gr = sp_gradient_vector_selector_get_gradient (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors));
 311
 312         if (gr) {
 313                 repr = SP_OBJECT_REPR (gr)->duplicate();
 314         } else {
 315                 Inkscape::XML::Node *stop;
 316                 repr = sp_repr_new ("svg:linearGradient");
 317                 stop = sp_repr_new ("svg:stop");
 318                 stop->setAttribute("offset", "0");
 319                 stop->setAttribute("style", "stop-color:#000;stop-opacity:1;");
 320                 repr->appendChild(stop);
 321                 Inkscape::GC::release(stop);
 322                 stop = sp_repr_new ("svg:stop");
 323                 stop->setAttribute("offset", "1");
 324                 stop->setAttribute("style", "stop-color:#fff;stop-opacity:1;");
 325                 repr->appendChild(stop);
 326                 Inkscape::GC::release(stop);
 327         }
 328
 329         SP_OBJECT_REPR (SP_DOCUMENT_DEFS (doc))->addChild(repr, NULL);
 330         Inkscape::GC::release(repr);
 331
 332         gr = (SPGradient *) doc->getObjectByRepr(repr);
 333         sp_gradient_vector_selector_set_gradient (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors), doc, gr);
 334 }
 335
 336 static void
 337 sp_gradient_selector_spread_activate (GtkWidget *widget, SPGradientSelector *sel)
 338 {
 339         sel->gradientSpread = (SPGradientSpread)GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (widget), "gradientSpread"));
 340
 341         g_signal_emit (G_OBJECT (sel), signals[CHANGED], 0);
 342 }