src/widgets/gradient-vector.cpp

   1 /*
   2  * Gradient vector selection widget
   3  *
   4  * Authors:
   5  *   Lauris Kaplinski <lauris@kaplinski.com>
   6  *   bulia byak <buliabyak@users.sf.net>
   7  *   MenTaLguY <mental@rydia.net>
   8  *   Jon A. Cruz <jon@joncruz.org>
   9  *
  10  * Copyright (C) 2001-2002 Lauris Kaplinski
  11  * Copyright (C) 2001 Ximian, Inc.
  12  * Copyright (C) 2004 Monash University
  13  * Copyright (C) 2004 David Turner
  14  * Copyright (C) 2006 MenTaLguY
  15  * Copyright (C) 2010 Jon A. Cruz
  16  *
  17  * Released under GNU GPL, read the file 'COPYING' for more information
  18  *
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24 #ifdef HAVE_STRING_H
  25 #endif
  26 #include <gtk/gtk.h>
  27 #include "macros.h"
  28 #include <glibmm/i18n.h>
  29 #include "../widgets/gradient-image.h"
  30 #include "../inkscape.h"
  31 #include "../document-private.h"
  32 #include "../gradient-chemistry.h"
  33 #include "gradient-vector.h"
  34 #include "../helper/window.h"
  35
  36 #include "xml/repr.h"
  37
  38 #include "../dialogs/dialog-events.h"
  39 #include "../preferences.h"
  40 #include "svg/css-ostringstream.h"
  41 #include "sp-stop.h"
  42
  43 #include <sigc++/functors/ptr_fun.h>
  44 #include <sigc++/adaptors/bind.h>
  45
  46 enum {
  47     VECTOR_SET,
  48     LAST_SIGNAL
  49 };
  50
  51 static void sp_gradient_vector_selector_class_init(SPGradientVectorSelectorClass *klass);
  52 static void sp_gradient_vector_selector_init(SPGradientVectorSelector *gvs);
  53 static void sp_gradient_vector_selector_destroy(GtkObject *object);
  54
  55 static void sp_gvs_gradient_release(SPObject *obj, SPGradientVectorSelector *gvs);
  56 static void sp_gvs_defs_release(SPObject *defs, SPGradientVectorSelector *gvs);
  57 static void sp_gvs_defs_modified(SPObject *defs, guint flags, SPGradientVectorSelector *gvs);
  58
  59 static void sp_gvs_rebuild_gui_full(SPGradientVectorSelector *gvs);
  60 static void sp_gvs_gradient_activate(GtkMenuItem *mi, SPGradientVectorSelector *gvs);
  61
  62 static GtkVBoxClass *parent_class;
  63 static guint signals[LAST_SIGNAL] = {0};
  64
  65 // TODO FIXME kill these globals!!!
  66 static GtkWidget *dlg = NULL;
  67 static win_data wd;
  68 static gint x = -1000, y = -1000, w = 0, h = 0; // impossible original values to make sure they are read from prefs
  69 static Glib::ustring const prefs_path = "/dialogs/gradienteditor/";
  70
  71 GType sp_gradient_vector_selector_get_type(void)
  72 {
  73     static GType type = 0;
  74     if (!type) {
  75         static const GTypeInfo info = {
  76             sizeof(SPGradientVectorSelectorClass),
  77             NULL, /* base_init */
  78             NULL, /* base_finalize */
  79             reinterpret_cast<GClassInitFunc>(sp_gradient_vector_selector_class_init),
  80             NULL, /* class_finalize */
  81             NULL, /* class_data */
  82             sizeof(SPGradientVectorSelector),
  83             0,    /* n_preallocs */
  84             reinterpret_cast<GInstanceInitFunc>(sp_gradient_vector_selector_init),
  85             0,    /* value_table */
  86         };
  87
  88         type = g_type_register_static( GTK_TYPE_VBOX,
  89                                        "SPGradientVectorSelector",
  90                                        &info,
  91                                        static_cast< GTypeFlags >(0) );
  92     }
  93     return type;
  94 }
  95
  96 static void sp_gradient_vector_selector_class_init(SPGradientVectorSelectorClass *klass)
  97 {
  98     GtkObjectClass *object_class;
  99
 100     object_class = GTK_OBJECT_CLASS(klass);
 101
 102     parent_class = static_cast<GtkVBoxClass*>(gtk_type_class(GTK_TYPE_VBOX));
 103
 104     signals[VECTOR_SET] = gtk_signal_new( "vector_set",
 105                                           GTK_RUN_LAST,
 106                                           GTK_CLASS_TYPE(object_class),
 107                                           GTK_SIGNAL_OFFSET(SPGradientVectorSelectorClass, vector_set),
 108                                           gtk_marshal_NONE__POINTER,
 109                                           GTK_TYPE_NONE, 1,
 110                                           GTK_TYPE_POINTER);
 111
 112     object_class->destroy = sp_gradient_vector_selector_destroy;
 113 }
 114
 115 static void sp_gradient_vector_selector_init(SPGradientVectorSelector *gvs)
 116 {
 117     gvs->idlabel = TRUE;
 118
 119     gvs->doc = NULL;
 120     gvs->gr = NULL;
 121
 122     new (&gvs->gradient_release_connection) sigc::connection();
 123     new (&gvs->defs_release_connection) sigc::connection();
 124     new (&gvs->defs_modified_connection) sigc::connection();
 125
 126     gvs->menu = gtk_option_menu_new();
 127     gtk_widget_show(gvs->menu);
 128     gtk_box_pack_start(GTK_BOX(gvs), gvs->menu, TRUE, TRUE, 0);
 129 }
 130
 131 static void sp_gradient_vector_selector_destroy(GtkObject *object)
 132 {
 133     SPGradientVectorSelector *gvs = SP_GRADIENT_VECTOR_SELECTOR(object);
 134
 135     if (gvs->gr) {
 136         gvs->gradient_release_connection.disconnect();
 137         gvs->gr = NULL;
 138     }
 139
 140     if (gvs->doc) {
 141         gvs->defs_release_connection.disconnect();
 142         gvs->defs_modified_connection.disconnect();
 143         gvs->doc = NULL;
 144     }
 145
 146     gvs->gradient_release_connection.~connection();
 147     gvs->defs_release_connection.~connection();
 148     gvs->defs_modified_connection.~connection();
 149
 150     if ((reinterpret_cast<GtkObjectClass *>(parent_class))->destroy) {
 151         (* (reinterpret_cast<GtkObjectClass *>(parent_class))->destroy) (object);
 152     }
 153 }
 154
 155 GtkWidget *sp_gradient_vector_selector_new(SPDocument *doc, SPGradient *gr)
 156 {
 157     GtkWidget *gvs;
 158
 159     g_return_val_if_fail(!gr || SP_IS_GRADIENT(gr), NULL);
 160     g_return_val_if_fail(!gr || (SP_OBJECT_DOCUMENT(gr) == doc), NULL);
 161
 162     gvs = static_cast<GtkWidget*>(gtk_type_new(SP_TYPE_GRADIENT_VECTOR_SELECTOR));
 163
 164     if (doc) {
 165         sp_gradient_vector_selector_set_gradient(SP_GRADIENT_VECTOR_SELECTOR(gvs), doc, gr);
 166     } else {
 167         sp_gvs_rebuild_gui_full(SP_GRADIENT_VECTOR_SELECTOR(gvs));
 168     }
 169
 170     return gvs;
 171 }
 172
 173 void sp_gradient_vector_selector_set_gradient(SPGradientVectorSelector *gvs, SPDocument *doc, SPGradient *gr)
 174 {
 175     static gboolean suppress = FALSE;
 176
 177     g_return_if_fail(gvs != NULL);
 178     g_return_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs));
 179     g_return_if_fail(!gr || (doc != NULL));
 180     g_return_if_fail(!gr || SP_IS_GRADIENT(gr));
 181     g_return_if_fail(!gr || (SP_OBJECT_DOCUMENT(gr) == doc));
 182     g_return_if_fail(!gr || SP_GRADIENT_HAS_STOPS(gr));
 183
 184     if (doc != gvs->doc) {
 185         /* Disconnect signals */
 186         if (gvs->gr) {
 187             gvs->gradient_release_connection.disconnect();
 188             gvs->gr = NULL;
 189         }
 190         if (gvs->doc) {
 191             gvs->defs_release_connection.disconnect();
 192             gvs->defs_modified_connection.disconnect();
 193             gvs->doc = NULL;
 194         }
 195
 196         // Connect signals
 197         if (doc) {
 198             gvs->defs_release_connection = SP_DOCUMENT_DEFS(doc)->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_defs_release), gvs));
 199             gvs->defs_modified_connection = SP_DOCUMENT_DEFS(doc)->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gvs_defs_modified), gvs));
 200         }
 201         if (gr) {
 202             gvs->gradient_release_connection = gr->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_gradient_release), gvs));
 203         }
 204         gvs->doc = doc;
 205         gvs->gr = gr;
 206         sp_gvs_rebuild_gui_full(gvs);
 207         if (!suppress) g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, gr);
 208     } else if (gr != gvs->gr) {
 209         // Harder case - keep document, rebuild menus and stuff
 210         // fixme: (Lauris)
 211         suppress = TRUE;
 212         sp_gradient_vector_selector_set_gradient(gvs, NULL, NULL);
 213         sp_gradient_vector_selector_set_gradient(gvs, doc, gr);
 214         suppress = FALSE;
 215         g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, gr);
 216     }
 217     /* The case of setting NULL -> NULL is not very interesting */
 218 }
 219
 220 SPDocument *sp_gradient_vector_selector_get_document(SPGradientVectorSelector *gvs)
 221 {
 222     g_return_val_if_fail(gvs != NULL, NULL);
 223     g_return_val_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs), NULL);
 224
 225     return gvs->doc;
 226 }
 227
 228 SPGradient *sp_gradient_vector_selector_get_gradient(SPGradientVectorSelector *gvs)
 229 {
 230     g_return_val_if_fail(gvs != NULL, NULL);
 231     g_return_val_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs), NULL);
 232
 233     return gvs->gr;
 234 }
 235
 236 static void sp_gvs_rebuild_gui_full(SPGradientVectorSelector *gvs)
 237 {
 238     /* Clear old menu, if there is any */
 239     if (gtk_option_menu_get_menu(GTK_OPTION_MENU(gvs->menu))) {
 240         gtk_option_menu_remove_menu(GTK_OPTION_MENU(gvs->menu));
 241     }
 242
 243     /* Create new menu widget */
 244     GtkWidget *m = gtk_menu_new();
 245     gtk_widget_show(m);
 246
 247     /* Pick up all gradients with vectors */
 248     GSList *gl = NULL;
 249     if (gvs->gr) {
 250         const GSList *gradients = sp_document_get_resource_list(SP_OBJECT_DOCUMENT(gvs->gr), "gradient");
 251         for (const GSList *curr = gradients; curr; curr = curr->next) {
 252             SPGradient* grad = SP_GRADIENT(curr->data);
 253             if (SP_GRADIENT_HAS_STOPS(grad) && !grad->isSwatch()) {
 254                 gl = g_slist_prepend(gl, curr->data);
 255             }
 256         }
 257     }
 258     gl = g_slist_reverse(gl);
 259
 260     gint pos = 0;
 261     gint idx = 0;
 262
 263     if (!gvs->doc) {
 264         GtkWidget *i;
 265         i = gtk_menu_item_new_with_label(_("No document selected"));
 266         gtk_widget_show(i);
 267         gtk_menu_append(GTK_MENU(m), i);
 268         gtk_widget_set_sensitive(gvs->menu, FALSE);
 269     } else if (!gl) {
 270         GtkWidget *i;
 271         i = gtk_menu_item_new_with_label(_("No gradients in document"));
 272         gtk_widget_show(i);
 273         gtk_menu_append(GTK_MENU(m), i);
 274         gtk_widget_set_sensitive(gvs->menu, FALSE);
 275     } else if (!gvs->gr) {
 276         GtkWidget *i;
 277         i = gtk_menu_item_new_with_label(_("No gradient selected"));
 278         gtk_widget_show(i);
 279         gtk_menu_append(GTK_MENU(m), i);
 280         gtk_widget_set_sensitive(gvs->menu, FALSE);
 281     } else {
 282         while (gl) {
 283             SPGradient *gr;
 284             GtkWidget *i, *w;
 285             gr = SP_GRADIENT(gl->data);
 286             gl = g_slist_remove(gl, gr);
 287
 288             /* We have to know: */
 289             /* Gradient destroy */
 290             /* Gradient name change */
 291             i = gtk_menu_item_new();
 292             gtk_widget_show(i);
 293             g_object_set_data(G_OBJECT(i), "gradient", gr);
 294             g_signal_connect(G_OBJECT(i), "activate", G_CALLBACK(sp_gvs_gradient_activate), gvs);
 295
 296             w = sp_gradient_image_new(gr);
 297             gtk_widget_show(w);
 298
 299             if (gvs->idlabel) {
 300                 GtkWidget *hb, *l;
 301                 hb = gtk_hbox_new(FALSE, 4);
 302                 gtk_widget_show(hb);
 303                 l = gtk_label_new(gr->getId());
 304                 gtk_widget_show(l);
 305                 gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
 306                 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
 307                 gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 0);
 308                 w = hb;
 309             }
 310
 311             gtk_container_add(GTK_CONTAINER(i), w);
 312
 313             gtk_menu_append(GTK_MENU(m), i);
 314
 315             if (gr == gvs->gr) {
 316                 pos = idx;
 317             }
 318             idx += 1;
 319         }
 320         gtk_widget_set_sensitive(gvs->menu, TRUE);
 321     }
 322
 323     gtk_option_menu_set_menu(GTK_OPTION_MENU(gvs->menu), m);
 324     /* Set history */
 325     gtk_option_menu_set_history(GTK_OPTION_MENU(gvs->menu), pos);
 326 }
 327
 328 static void sp_gvs_gradient_activate(GtkMenuItem *mi, SPGradientVectorSelector *gvs)
 329 {
 330     SPGradient *gr, *norm;
 331
 332     gr = (SPGradient*)g_object_get_data(G_OBJECT(mi), "gradient");
 333     /* Hmmm... bad things may happen here, if actual gradient is something new */
 334     /* Namely - menuitems etc. will be fucked up */
 335     /* Hmmm - probably we can just re-set it as menuitem data (Lauris) */
 336
 337     //g_print("SPGradientVectorSelector: gradient %s activated\n", SP_OBJECT_ID(gr));
 338
 339     norm = sp_gradient_ensure_vector_normalized(gr);
 340     if (norm != gr) {
 341         //g_print("SPGradientVectorSelector: become %s after normalization\n", SP_OBJECT_ID(norm));
 342         /* But be careful that we do not have gradient saved anywhere else */
 343         g_object_set_data(G_OBJECT(mi), "gradient", norm);
 344     }
 345
 346     /* fixme: Really we would want to use _set_vector */
 347     /* Detach old */
 348     if (gvs->gr) {
 349         gvs->gradient_release_connection.disconnect();
 350         gvs->gr = NULL;
 351     }
 352     /* Attach new */
 353     if (norm) {
 354         gvs->gradient_release_connection = norm->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_gradient_release), gvs));
 355         gvs->gr = norm;
 356     }
 357
 358     g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, norm);
 359
 360     if (norm != gr) {
 361         /* We do extra undo push here */
 362         /* If handler has already done it, it is just NOP */
 363         // FIXME: looks like this is never a valid undo step, consider removing this
 364         sp_document_done(SP_OBJECT_DOCUMENT(norm), SP_VERB_CONTEXT_GRADIENT,
 365                           /* TODO: annotate */ "gradient-vector.cpp:350");
 366     }
 367 }
 368
 369 static void sp_gvs_gradient_release(SPObject */*obj*/, SPGradientVectorSelector *gvs)
 370 {
 371     /* Disconnect gradient */
 372     if (gvs->gr) {
 373         gvs->gradient_release_connection.disconnect();
 374         gvs->gr = NULL;
 375     }
 376
 377     /* Rebuild GUI */
 378     sp_gvs_rebuild_gui_full(gvs);
 379 }
 380
 381 static void sp_gvs_defs_release(SPObject */*defs*/, SPGradientVectorSelector *gvs)
 382 {
 383     gvs->doc = NULL;
 384
 385     gvs->defs_release_connection.disconnect();
 386     gvs->defs_modified_connection.disconnect();
 387
 388     /* Disconnect gradient as well */
 389     if (gvs->gr) {
 390         gvs->gradient_release_connection.disconnect();
 391         gvs->gr = NULL;
 392     }
 393
 394     /* Rebuild GUI */
 395     sp_gvs_rebuild_gui_full(gvs);
 396 }
 397
 398 static void sp_gvs_defs_modified(SPObject */*defs*/, guint /*flags*/, SPGradientVectorSelector *gvs)
 399 {
 400     /* fixme: We probably have to check some flags here (Lauris) */
 401
 402     sp_gvs_rebuild_gui_full(gvs);
 403 }
 404
 405 /*##################################################################
 406   ###                 Vector Editing Widget
 407   ##################################################################*/
 408
 409 #include "../widgets/sp-color-notebook.h"
 410 #include "../widgets/sp-color-preview.h"
 411 #include "../widgets/widget-sizes.h"
 412 #include "../xml/node-event-vector.h"
 413 #include "../svg/svg-color.h"
 414
 415
 416 #define PAD 4
 417
 418 static GtkWidget *sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *stop);
 419
 420 static void sp_gradient_vector_widget_load_gradient(GtkWidget *widget, SPGradient *gradient);
 421 static gint sp_gradient_vector_dialog_delete(GtkWidget *widget, GdkEvent *event, GtkWidget *dialog);
 422 static void sp_gradient_vector_dialog_destroy(GtkObject *object, gpointer data);
 423
 424 static void sp_gradient_vector_widget_destroy(GtkObject *object, gpointer data);
 425 static void sp_gradient_vector_gradient_release(SPObject *obj, GtkWidget *widget);
 426 static void sp_gradient_vector_gradient_modified(SPObject *obj, guint flags, GtkWidget *widget);
 427 static void sp_gradient_vector_color_dragged(SPColorSelector *csel, GtkObject *object);
 428 static void sp_gradient_vector_color_changed(SPColorSelector *csel, GtkObject *object);
 429 static void update_stop_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop);
 430
 431 static gboolean blocked = FALSE;
 432
 433 static void grad_edit_dia_stop_added_or_removed(Inkscape::XML::Node */*repr*/, Inkscape::XML::Node */*child*/, Inkscape::XML::Node */*ref*/, gpointer data)
 434 {
 435     GtkWidget *vb = GTK_WIDGET(data);
 436     GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(vb), "stopmenu");
 437     SPGradient *gradient = (SPGradient *)g_object_get_data(G_OBJECT(vb), "gradient");
 438     update_stop_list(mnu, gradient, NULL);
 439 }
 440
 441 //FIXME!!! We must also listen to attr changes on all children (i.e. stops) too,
 442 //otherwise the dialog does not reflect undoing color or offset change. This is a major
 443 //hassle, unless we have a "one of the descendants changed in some way" signal.
 444 static Inkscape::XML::NodeEventVector grad_edit_dia_repr_events =
 445 {
 446     grad_edit_dia_stop_added_or_removed, /* child_added */
 447     grad_edit_dia_stop_added_or_removed, /* child_removed */
 448     NULL, /* attr_changed*/
 449     NULL, /* content_changed */
 450     NULL  /* order_changed */
 451 };
 452
 453 static void verify_grad(SPGradient *gradient)
 454 {
 455     int i = 0;
 456     SPStop *stop = NULL;
 457     /* count stops */
 458     for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(gradient)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
 459         if (SP_IS_STOP(ochild)) {
 460             i++;
 461             stop = SP_STOP(ochild);
 462         }
 463     }
 464
 465     Inkscape::XML::Document *xml_doc;
 466     xml_doc = SP_OBJECT_REPR(gradient)->document();
 467
 468     if (i < 1) {
 469         gchar c[64];
 470         sp_svg_write_color(c, sizeof(c), 0x00000000);
 471
 472         Inkscape::CSSOStringStream os;
 473         os << "stop-color:" << c << ";stop-opacity:" << 1.0 << ";";
 474
 475         Inkscape::XML::Node *child;
 476
 477         child = xml_doc->createElement("svg:stop");
 478         sp_repr_set_css_double(child, "offset", 0.0);
 479         child->setAttribute("style", os.str().c_str());
 480         SP_OBJECT_REPR(gradient)->addChild(child, NULL);
 481         Inkscape::GC::release(child);
 482
 483         child = xml_doc->createElement("svg:stop");
 484         sp_repr_set_css_double(child, "offset", 1.0);
 485         child->setAttribute("style", os.str().c_str());
 486         SP_OBJECT_REPR(gradient)->addChild(child, NULL);
 487         Inkscape::GC::release(child);
 488     }
 489     if (i < 2) {
 490         sp_repr_set_css_double(SP_OBJECT_REPR(stop), "offset", 0.0);
 491         Inkscape::XML::Node *child = SP_OBJECT_REPR(stop)->duplicate(SP_OBJECT_REPR(gradient)->document());
 492         sp_repr_set_css_double(child, "offset", 1.0);
 493         SP_OBJECT_REPR(gradient)->addChild(child, SP_OBJECT_REPR(stop));
 494         Inkscape::GC::release(child);
 495     }
 496 }
 497
 498 static void select_stop_in_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop)
 499 {
 500     int i = 0;
 501     for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(gradient)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
 502         if (SP_IS_STOP(ochild)) {
 503             if (SP_OBJECT(ochild) == SP_OBJECT(new_stop)) {
 504                 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), i);
 505                 break;
 506             }
 507             i++;
 508         }
 509     }
 510 }
 511
 512 static void update_stop_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop)
 513 {
 514
 515     if (!SP_IS_GRADIENT(gradient)) {
 516         return;
 517     }
 518
 519     blocked = TRUE;
 520
 521     /* Clear old menu, if there is any */
 522     if (gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu))) {
 523         gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
 524     }
 525
 526     /* Create new menu widget */
 527     GtkWidget *m = gtk_menu_new();
 528     gtk_widget_show(m);
 529     GSList *sl = NULL;
 530     if (gradient->has_stops) {
 531         for ( SPObject *ochild = sp_object_first_child(SP_OBJECT(gradient)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
 532             if (SP_IS_STOP(ochild)) {
 533                 sl = g_slist_append(sl, ochild);
 534             }
 535         }
 536     }
 537     if (!sl) {
 538         GtkWidget *i = gtk_menu_item_new_with_label(_("No stops in gradient"));
 539         gtk_widget_show(i);
 540         gtk_menu_append(GTK_MENU(m), i);
 541         gtk_widget_set_sensitive(mnu, FALSE);
 542     } else {
 543
 544         for (; sl != NULL; sl = sl->next){
 545             SPStop *stop;
 546             GtkWidget *i;
 547             if (SP_IS_STOP(sl->data)){
 548                 stop = SP_STOP(sl->data);
 549                 i = gtk_menu_item_new();
 550                 gtk_widget_show(i);
 551                 g_object_set_data(G_OBJECT(i), "stop", stop);
 552                 GtkWidget *hb = gtk_hbox_new(FALSE, 4);
 553                 GtkWidget *cpv = sp_color_preview_new(sp_stop_get_rgba32(stop));
 554                 gtk_widget_show(cpv);
 555                 gtk_container_add( GTK_CONTAINER(hb), cpv );
 556                 g_object_set_data( G_OBJECT(i), "preview", cpv );
 557                 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) sl->data);
 558                 GtkWidget *l = gtk_label_new(repr->attribute("id"));
 559                 gtk_widget_show(l);
 560                 gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
 561                 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
 562                 gtk_widget_show(hb);
 563                 gtk_container_add(GTK_CONTAINER(i), hb);
 564                 gtk_menu_append(GTK_MENU(m), i);
 565             }
 566         }
 567
 568         gtk_widget_set_sensitive(mnu, TRUE);
 569     }
 570     gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
 571
 572     /* Set history */
 573     if (new_stop == NULL) {
 574         gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 575     } else {
 576         select_stop_in_list(mnu, gradient, new_stop);
 577     }
 578
 579     blocked = FALSE;
 580 }
 581
 582
 583 // user selected existing stop from list
 584 static void sp_grad_edit_select(GtkOptionMenu *mnu, GtkWidget *tbl)
 585 {
 586     GObject *item = G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu))));
 587     SPStop *stop = SP_STOP(g_object_get_data(item, "stop"));
 588     if (!stop) {
 589         return;
 590     }
 591
 592     blocked = TRUE;
 593
 594     SPColorSelector *csel = (SPColorSelector*)g_object_get_data(G_OBJECT(tbl), "cselector");
 595     guint32 const c = sp_stop_get_rgba32(stop);
 596     csel->base->setAlpha(SP_RGBA32_A_F(c));
 597     SPColor color( SP_RGBA32_R_F(c), SP_RGBA32_G_F(c), SP_RGBA32_B_F(c) );
 598     // set its color, from the stored array
 599     csel->base->setColor( color );
 600     GtkWidget *offspin = GTK_WIDGET(g_object_get_data(G_OBJECT(tbl), "offspn"));
 601     GtkWidget *offslide =GTK_WIDGET(g_object_get_data(G_OBJECT(tbl), "offslide"));
 602
 603     GtkAdjustment *adj = static_cast<GtkAdjustment*>(gtk_object_get_data(GTK_OBJECT(tbl), "offset"));
 604
 605     bool isEndStop = false;
 606
 607     SPStop *prev = NULL;
 608     prev = stop->getPrevStop();
 609     if (prev != NULL )  {
 610         adj->lower = prev->offset;
 611     } else {
 612         isEndStop = true;
 613         adj->lower = 0;
 614     }
 615
 616     SPStop *next = NULL;
 617     next = stop->getNextStop();
 618     if (next != NULL ) {
 619         adj->upper = next->offset;
 620     } else {
 621         isEndStop = true;
 622         adj->upper = 1.0;
 623     }
 624
 625     //fixme: does this work on all possible input gradients?
 626     if (!isEndStop) {
 627         gtk_widget_set_sensitive(offslide, TRUE);
 628         gtk_widget_set_sensitive(GTK_WIDGET(offspin), TRUE);
 629     } else {
 630         gtk_widget_set_sensitive(offslide, FALSE);
 631         gtk_widget_set_sensitive(GTK_WIDGET(offspin), FALSE);
 632     }
 633
 634     gtk_adjustment_set_value(adj, stop->offset);
 635
 636     gtk_adjustment_changed(adj);
 637
 638     blocked = FALSE;
 639 }
 640
 641
 642
 643
 644 static void offadjustmentChanged( GtkAdjustment *adjustment, GtkWidget *vb)
 645 {
 646     if (blocked) {
 647         return;
 648     }
 649
 650     blocked = TRUE;
 651
 652     GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(vb), "stopmenu"));
 653     if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop")) {
 654         return;
 655     }
 656     SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
 657
 658     stop->offset = adjustment->value;
 659     sp_repr_set_css_double(SP_OBJECT_REPR(stop), "offset", stop->offset);
 660
 661     sp_document_done(SP_OBJECT_DOCUMENT(stop), SP_VERB_CONTEXT_GRADIENT,
 662                       _("Change gradient stop offset"));
 663
 664     blocked = FALSE;
 665 }
 666
 667 guint32 sp_average_color(guint32 c1, guint32 c2, gdouble p = 0.5)
 668 {
 669     guint32 r = (guint32) (SP_RGBA32_R_U(c1) * p + SP_RGBA32_R_U(c2) * (1 - p));
 670     guint32 g = (guint32) (SP_RGBA32_G_U(c1) * p + SP_RGBA32_G_U(c2) * (1 - p));
 671     guint32 b = (guint32) (SP_RGBA32_B_U(c1) * p + SP_RGBA32_B_U(c2) * (1 - p));
 672     guint32 a = (guint32) (SP_RGBA32_A_U(c1) * p + SP_RGBA32_A_U(c2) * (1 - p));
 673
 674     return SP_RGBA32_U_COMPOSE(r, g, b, a);
 675 }
 676
 677
 678 static void sp_grd_ed_add_stop(GtkWidget */*widget*/,  GtkWidget *vb)
 679 {
 680     SPGradient *gradient = static_cast<SPGradient *>(g_object_get_data(G_OBJECT(vb), "gradient"));
 681     verify_grad(gradient);
 682     GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(vb), "stopmenu"));
 683
 684     SPStop *stop = static_cast<SPStop *>(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
 685
 686     if (stop == NULL) {
 687         return;
 688     }
 689
 690     Inkscape::XML::Node *new_stop_repr = NULL;
 691
 692     SPStop *next = stop->getNextStop();
 693
 694     if (next == NULL) {
 695         SPStop *prev = stop->getPrevStop();
 696         if (prev != NULL) {
 697             next = stop;
 698             stop = prev;
 699         }
 700     }
 701
 702     if (next != NULL) {
 703         new_stop_repr = SP_OBJECT_REPR(stop)->duplicate(SP_OBJECT_REPR(gradient)->document());
 704         SP_OBJECT_REPR(gradient)->addChild(new_stop_repr, SP_OBJECT_REPR(stop));
 705     } else {
 706         next = stop;
 707         new_stop_repr = SP_OBJECT_REPR(stop->getPrevStop())->duplicate(SP_OBJECT_REPR(gradient)->document());
 708         SP_OBJECT_REPR(gradient)->addChild(new_stop_repr, SP_OBJECT_REPR(stop->getPrevStop()));
 709     }
 710
 711     SPStop *newstop = (SPStop *) SP_OBJECT_DOCUMENT(gradient)->getObjectByRepr(new_stop_repr);
 712
 713     newstop->offset = (stop->offset + next->offset) * 0.5 ;
 714
 715     guint32 const c1 = sp_stop_get_rgba32(stop);
 716     guint32 const c2 = sp_stop_get_rgba32(next);
 717     guint32 cnew = sp_average_color(c1, c2);
 718
 719     Inkscape::CSSOStringStream os;
 720     gchar c[64];
 721     sp_svg_write_color(c, sizeof(c), cnew);
 722     gdouble opacity = static_cast<gdouble>(SP_RGBA32_A_F(cnew));
 723     os << "stop-color:" << c << ";stop-opacity:" << opacity <<";";
 724     SP_OBJECT_REPR (newstop)->setAttribute("style", os.str().c_str());
 725     sp_repr_set_css_double( SP_OBJECT_REPR(newstop), "offset", (double)newstop->offset);
 726
 727     sp_gradient_vector_widget_load_gradient(vb, gradient);
 728     Inkscape::GC::release(new_stop_repr);
 729     update_stop_list(GTK_WIDGET(mnu), gradient, newstop);
 730     GtkWidget *offspin = GTK_WIDGET(g_object_get_data(G_OBJECT(vb), "offspn"));
 731     GtkWidget *offslide =GTK_WIDGET(g_object_get_data(G_OBJECT(vb), "offslide"));
 732     gtk_widget_set_sensitive(offslide, TRUE);
 733     gtk_widget_set_sensitive(GTK_WIDGET(offspin), TRUE);
 734     sp_document_done(SP_OBJECT_DOCUMENT(gradient), SP_VERB_CONTEXT_GRADIENT,
 735                       _("Add gradient stop"));
 736 }
 737
 738 static void sp_grd_ed_del_stop(GtkWidget */*widget*/,  GtkWidget *vb)
 739 {
 740     SPGradient *gradient = static_cast<SPGradient *>(g_object_get_data(G_OBJECT(vb), "gradient"));
 741
 742     GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(vb), "stopmenu"));
 743     if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop")) return;
 744     SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
 745     if (gradient->vector.stops.size() > 2) { // 2 is the minimum
 746
 747         // if we delete first or last stop, move the next/previous to the edge
 748         if (stop->offset == 0) {
 749             SPStop *next = stop->getNextStop();
 750             if (next) {
 751                 next->offset = 0;
 752                 sp_repr_set_css_double(SP_OBJECT_REPR(next), "offset", 0);
 753             }
 754         } else if (stop->offset == 1) {
 755             SPStop *prev = stop->getPrevStop();
 756             if (prev) {
 757                 prev->offset = 1;
 758                 sp_repr_set_css_double(SP_OBJECT_REPR(prev), "offset", 1);
 759             }
 760         }
 761
 762         SP_OBJECT_REPR(gradient)->removeChild(SP_OBJECT_REPR(stop));
 763         sp_gradient_vector_widget_load_gradient(vb, gradient);
 764         update_stop_list(GTK_WIDGET(mnu), gradient, NULL);
 765         sp_document_done(SP_OBJECT_DOCUMENT(gradient), SP_VERB_CONTEXT_GRADIENT,
 766                           _("Delete gradient stop"));
 767     }
 768
 769 }
 770
 771 static GtkWidget * sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *select_stop)
 772 {
 773     GtkWidget *vb, *w, *f, *csel;
 774
 775     g_return_val_if_fail(!gradient || SP_IS_GRADIENT(gradient), NULL);
 776
 777     vb = gtk_vbox_new(FALSE, PAD);
 778     g_signal_connect(G_OBJECT(vb), "destroy", G_CALLBACK(sp_gradient_vector_widget_destroy), NULL);
 779
 780     w = sp_gradient_image_new(gradient);
 781     g_object_set_data(G_OBJECT(vb), "preview", w);
 782     gtk_widget_show(w);
 783     gtk_box_pack_start(GTK_BOX(vb), w, TRUE, TRUE, PAD);
 784
 785     sp_repr_add_listener(SP_OBJECT_REPR(gradient), &grad_edit_dia_repr_events, vb);
 786     GtkTooltips *tt = gtk_tooltips_new();
 787
 788     /* Stop list */
 789     GtkWidget *mnu = gtk_option_menu_new();
 790     /* Create new menu widget */
 791     update_stop_list(GTK_WIDGET(mnu), gradient, NULL);
 792     gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_grad_edit_select), vb);
 793     gtk_widget_show(mnu);
 794     gtk_object_set_data(GTK_OBJECT(vb), "stopmenu", mnu);
 795     gtk_box_pack_start(GTK_BOX(vb), mnu, FALSE, FALSE, 0);
 796
 797     /* Add and Remove buttons */
 798     GtkWidget *hb = gtk_hbox_new(FALSE, 1);
 799     // TRANSLATORS: "Stop" means: a "phase" of a gradient
 800     GtkWidget *b = gtk_button_new_with_label(_("Add stop"));
 801     gtk_widget_show(b);
 802     gtk_container_add(GTK_CONTAINER(hb), b);
 803     gtk_tooltips_set_tip(tt, b, _("Add another control stop to gradient"), NULL);
 804     gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_grd_ed_add_stop), vb);
 805     b = gtk_button_new_with_label(_("Delete stop"));
 806     gtk_widget_show(b);
 807     gtk_container_add(GTK_CONTAINER(hb), b);
 808     gtk_tooltips_set_tip(tt, b, _("Delete current control stop from gradient"), NULL);
 809     gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_grd_ed_del_stop), vb);
 810
 811     gtk_widget_show(hb);
 812     gtk_box_pack_start(GTK_BOX(vb),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 813
 814
 815     /*  Offset Slider and stuff   */
 816     hb = gtk_hbox_new(FALSE, 0);
 817
 818     /* Label */
 819     GtkWidget *l = gtk_label_new(_("Offset:"));
 820     gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
 821     gtk_box_pack_start(GTK_BOX(hb),l, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 822     gtk_widget_show(l);
 823
 824     /* Adjustment */
 825     GtkAdjustment *Offset_adj = NULL;
 826     Offset_adj= (GtkAdjustment *) gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
 827     gtk_object_set_data(GTK_OBJECT(vb), "offset", Offset_adj);
 828     GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
 829     SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "stop"));
 830     gtk_adjustment_set_value(Offset_adj, stop->offset);
 831
 832     /* Slider */
 833     GtkWidget *slider = gtk_hscale_new(Offset_adj);
 834     gtk_scale_set_draw_value( GTK_SCALE(slider), FALSE );
 835     gtk_widget_show(slider);
 836     gtk_box_pack_start(GTK_BOX(hb),slider, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
 837     gtk_object_set_data(GTK_OBJECT(vb), "offslide", slider);
 838
 839     /* Spinbutton */
 840     GtkWidget *sbtn = gtk_spin_button_new(GTK_ADJUSTMENT(Offset_adj), 0.01, 2);
 841     sp_dialog_defocus_on_enter(sbtn);
 842     gtk_widget_show(sbtn);
 843     gtk_box_pack_start(GTK_BOX(hb),sbtn, FALSE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
 844     gtk_object_set_data(GTK_OBJECT(vb), "offspn", sbtn);
 845
 846     if (stop->offset>0 && stop->offset<1) {
 847         gtk_widget_set_sensitive(slider, TRUE);
 848         gtk_widget_set_sensitive(GTK_WIDGET(sbtn), TRUE);
 849     } else {
 850         gtk_widget_set_sensitive(slider, FALSE);
 851         gtk_widget_set_sensitive(GTK_WIDGET(sbtn), FALSE);
 852     }
 853
 854
 855     /* Signals */
 856     gtk_signal_connect(GTK_OBJECT(Offset_adj), "value_changed",
 857                         GTK_SIGNAL_FUNC(offadjustmentChanged), vb);
 858
 859     // gtk_signal_connect(GTK_OBJECT(slider), "changed",  GTK_SIGNAL_FUNC(offsliderChanged), vb);
 860     gtk_widget_show(hb);
 861     gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, PAD);
 862
 863     // TRANSLATORS: "Stop" means: a "phase" of a gradient
 864     f = gtk_frame_new(_("Stop Color"));
 865     gtk_widget_show(f);
 866     gtk_box_pack_start(GTK_BOX(vb), f, TRUE, TRUE, PAD);
 867     csel = static_cast<GtkWidget*>(sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK));
 868     g_object_set_data(G_OBJECT(vb), "cselector", csel);
 869     gtk_widget_show(csel);
 870     gtk_container_add(GTK_CONTAINER(f), csel);
 871     g_signal_connect(G_OBJECT(csel), "dragged", G_CALLBACK(sp_gradient_vector_color_dragged), vb);
 872     g_signal_connect(G_OBJECT(csel), "changed", G_CALLBACK(sp_gradient_vector_color_changed), vb);
 873
 874     gtk_widget_show(vb);
 875
 876     sp_gradient_vector_widget_load_gradient(vb, gradient);
 877
 878     if (select_stop) {
 879         select_stop_in_list(GTK_WIDGET(mnu), gradient, select_stop);
 880     }
 881
 882     return vb;
 883 }
 884
 885
 886
 887 GtkWidget * sp_gradient_vector_editor_new(SPGradient *gradient, SPStop *stop)
 888 {
 889     GtkWidget *wid;
 890
 891     if (dlg == NULL) {
 892         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 893
 894         dlg = sp_window_new(_("Gradient editor"), TRUE);
 895         if (x == -1000 || y == -1000) {
 896             x = prefs->getInt(prefs_path + "x", -1000);
 897             y = prefs->getInt(prefs_path + "y", -1000);
 898         }
 899         if (w ==0 || h == 0) {
 900             w = prefs->getInt(prefs_path + "w", 0);
 901             h = prefs->getInt(prefs_path + "h", 0);
 902         }
 903
 904         if (x<0) {
 905             x=0;
 906         }
 907         if (y<0) {
 908             y=0;
 909         }
 910
 911         if (x != 0 || y != 0) {
 912             gtk_window_move(reinterpret_cast<GtkWindow *>(dlg), x, y);
 913         } else {
 914             gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
 915         }
 916         if (w && h) {
 917             gtk_window_resize(reinterpret_cast<GtkWindow *>(dlg), w, h);
 918         }
 919         sp_transientize(dlg);
 920         wd.win = dlg;
 921         wd.stop = 0;
 922         g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK(sp_transientize_callback), &wd);
 923         gtk_signal_connect(GTK_OBJECT(dlg), "event", GTK_SIGNAL_FUNC(sp_dialog_event_handler), dlg);
 924         gtk_signal_connect(GTK_OBJECT(dlg), "destroy", G_CALLBACK(sp_gradient_vector_dialog_destroy), dlg);
 925         gtk_signal_connect(GTK_OBJECT(dlg), "delete_event", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
 926         g_signal_connect(G_OBJECT(INKSCAPE), "shut_down", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
 927         g_signal_connect( G_OBJECT(INKSCAPE), "dialogs_hide", G_CALLBACK(sp_dialog_hide), dlg );
 928         g_signal_connect( G_OBJECT(INKSCAPE), "dialogs_unhide", G_CALLBACK(sp_dialog_unhide), dlg );
 929
 930         gtk_container_set_border_width(GTK_CONTAINER(dlg), PAD);
 931
 932         wid = static_cast<GtkWidget*>(sp_gradient_vector_widget_new(gradient, stop));
 933         g_object_set_data(G_OBJECT(dlg), "gradient-vector-widget", wid);
 934         /* Connect signals */
 935         gtk_widget_show(wid);
 936         gtk_container_add(GTK_CONTAINER(dlg), wid);
 937     } else {
 938         // FIXME: temp fix for 0.38
 939         // Simply load_gradient into the editor does not work for multi-stop gradients,
 940         // as the stop list and other widgets are in a wrong state and crash readily.
 941         // Instead we just delete the window (by sending the delete signal)
 942         // and call sp_gradient_vector_editor_new again, so it creates the window anew.
 943
 944         GdkEventAny event;
 945         GtkWidget *widget = static_cast<GtkWidget *>(dlg);
 946         event.type = GDK_DELETE;
 947         event.window = widget->window;
 948         event.send_event = TRUE;
 949         g_object_ref(G_OBJECT(event.window));
 950         gtk_main_do_event(reinterpret_cast<GdkEvent*>(&event));
 951         g_object_unref(G_OBJECT(event.window));
 952
 953         g_assert(dlg == NULL);
 954         sp_gradient_vector_editor_new(gradient, stop);
 955     }
 956
 957     return dlg;
 958 }
 959
 960 static void sp_gradient_vector_widget_load_gradient(GtkWidget *widget, SPGradient *gradient)
 961 {
 962     blocked = TRUE;
 963
 964     SPGradient *old;
 965
 966     old = (SPGradient*)g_object_get_data(G_OBJECT(widget), "gradient");
 967
 968     if (old != gradient) {
 969         sigc::connection *release_connection;
 970         sigc::connection *modified_connection;
 971
 972         release_connection = (sigc::connection *)g_object_get_data(G_OBJECT(widget), "gradient_release_connection");
 973         modified_connection = (sigc::connection *)g_object_get_data(G_OBJECT(widget), "gradient_modified_connection");
 974
 975         if (old) {
 976             g_assert( release_connection != NULL );
 977             g_assert( modified_connection != NULL );
 978             release_connection->disconnect();
 979             modified_connection->disconnect();
 980             sp_signal_disconnect_by_data(old, widget);
 981         }
 982
 983         if (gradient) {
 984             if (!release_connection) {
 985                 release_connection = new sigc::connection();
 986             }
 987             if (!modified_connection) {
 988                 modified_connection = new sigc::connection();
 989             }
 990             *release_connection = gradient->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gradient_vector_gradient_release), widget));
 991             *modified_connection = gradient->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gradient_vector_gradient_modified), widget));
 992         } else {
 993             if (release_connection) {
 994                 delete release_connection;
 995                 release_connection = NULL;
 996             }
 997             if (modified_connection) {
 998                 delete modified_connection;
 999                 modified_connection = NULL;
1000             }
1001         }
1002
1003         g_object_set_data(G_OBJECT(widget), "gradient_release_connection", release_connection);
1004         g_object_set_data(G_OBJECT(widget), "gradient_modified_connection", modified_connection);
1005     }
1006
1007     g_object_set_data(G_OBJECT(widget), "gradient", gradient);
1008
1009     if (gradient) {
1010         gtk_widget_set_sensitive(widget, TRUE);
1011
1012         sp_gradient_ensure_vector(gradient);
1013
1014         GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(widget), "stopmenu"));
1015         SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
1016         guint32 const c = sp_stop_get_rgba32(stop);
1017
1018         /// get the color selector
1019         SPColorSelector *csel = SP_COLOR_SELECTOR(g_object_get_data(G_OBJECT(widget), "cselector"));
1020         // set alpha
1021         csel->base->setAlpha(SP_RGBA32_A_F(c));
1022         SPColor color( SP_RGBA32_R_F(c), SP_RGBA32_G_F(c), SP_RGBA32_B_F(c) );
1023         // set color
1024         csel->base->setColor( color );
1025
1026         /* Fill preview */
1027         GtkWidget *w = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(widget), "preview"));
1028         sp_gradient_image_set_gradient(SP_GRADIENT_IMAGE(w), gradient);
1029
1030         update_stop_list(GTK_WIDGET(mnu), gradient, NULL);
1031
1032         // Once the user edits a gradient, it stops being auto-collectable
1033         if (SP_OBJECT_REPR(gradient)->attribute("inkscape:collect")) {
1034             SPDocument *document = SP_OBJECT_DOCUMENT(gradient);
1035             bool saved = sp_document_get_undo_sensitive(document);
1036             sp_document_set_undo_sensitive(document, false);
1037             SP_OBJECT_REPR(gradient)->setAttribute("inkscape:collect", NULL);
1038             sp_document_set_undo_sensitive(document, saved);
1039         }
1040     } else { // no gradient, disable everything
1041         gtk_widget_set_sensitive(widget, FALSE);
1042     }
1043
1044     blocked = FALSE;
1045 }
1046
1047 static void sp_gradient_vector_dialog_destroy(GtkObject */*object*/, gpointer /*data*/)
1048 {
1049     sp_signal_disconnect_by_data(INKSCAPE, dlg);
1050     wd.win = dlg = NULL;
1051     wd.stop = 0;
1052 }
1053
1054 static gboolean sp_gradient_vector_dialog_delete(GtkWidget */*widget*/, GdkEvent */*event*/, GtkWidget */*dialog*/)
1055 {
1056     gtk_window_get_position(GTK_WINDOW(dlg), &x, &y);
1057     gtk_window_get_size(GTK_WINDOW(dlg), &w, &h);
1058
1059     if (x<0) {
1060         x=0;
1061     }
1062     if (y<0) {
1063         y=0;
1064     }
1065
1066     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1067     prefs->setInt(prefs_path + "x", x);
1068     prefs->setInt(prefs_path + "y", y);
1069     prefs->setInt(prefs_path + "w", w);
1070     prefs->setInt(prefs_path + "h", h);
1071
1072     return FALSE; // which means, go ahead and destroy it
1073 }
1074
1075 /* Widget destroy handler */
1076
1077 static void sp_gradient_vector_widget_destroy(GtkObject *object, gpointer /*data*/)
1078 {
1079     GObject *gradient;
1080
1081     gradient = (GObject*)g_object_get_data(G_OBJECT(object), "gradient");
1082
1083     sigc::connection *release_connection = (sigc::connection *)g_object_get_data(G_OBJECT(object), "gradient_release_connection");
1084     sigc::connection *modified_connection = (sigc::connection *)g_object_get_data(G_OBJECT(object), "gradient_modified_connection");
1085
1086     if (gradient) {
1087         g_assert( release_connection != NULL );
1088         g_assert( modified_connection != NULL );
1089         release_connection->disconnect();
1090         modified_connection->disconnect();
1091         sp_signal_disconnect_by_data(gradient, object);
1092     }
1093
1094     if (gradient && SP_OBJECT_REPR(gradient)) {
1095         sp_repr_remove_listener_by_data(SP_OBJECT_REPR(gradient), object);
1096     }
1097 }
1098
1099 static void sp_gradient_vector_gradient_release(SPObject */*object*/, GtkWidget *widget)
1100 {
1101     sp_gradient_vector_widget_load_gradient(widget, NULL);
1102 }
1103
1104 static void sp_gradient_vector_gradient_modified(SPObject *object, guint /*flags*/, GtkWidget *widget)
1105 {
1106     SPGradient *gradient=SP_GRADIENT(object);
1107     if (!blocked) {
1108         blocked = TRUE;
1109         sp_gradient_vector_widget_load_gradient(widget, gradient);
1110         blocked = FALSE;
1111     }
1112 }
1113
1114 static void sp_gradient_vector_color_dragged(SPColorSelector *csel, GtkObject *object)
1115 {
1116     SPGradient *gradient, *ngr;
1117
1118     if (blocked) {
1119         return;
1120     }
1121
1122     gradient = static_cast<SPGradient*>(g_object_get_data(G_OBJECT(object), "gradient"));
1123     if (!gradient) {
1124         return;
1125     }
1126
1127     blocked = TRUE;
1128
1129     ngr = sp_gradient_ensure_vector_normalized(gradient);
1130     if (ngr != gradient) {
1131         /* Our master gradient has changed */
1132         sp_gradient_vector_widget_load_gradient(GTK_WIDGET(object), ngr);
1133     }
1134
1135     sp_gradient_ensure_vector(ngr);
1136
1137     GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(object), "stopmenu"));
1138     SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
1139
1140
1141     csel->base->getColorAlpha(stop->specified_color, &stop->opacity);
1142     stop->currentColor = false;
1143
1144     blocked = FALSE;
1145 }
1146
1147 static void sp_gradient_vector_color_changed(SPColorSelector *csel, GtkObject *object)
1148 {
1149     SPColor color;
1150     float alpha;
1151     guint32 rgb;
1152
1153     if (blocked) {
1154         return;
1155     }
1156
1157     SPGradient *gradient = static_cast<SPGradient*>(g_object_get_data(G_OBJECT(object), "gradient"));
1158     if (!gradient) {
1159         return;
1160     }
1161
1162     blocked = TRUE;
1163
1164     SPGradient *ngr = sp_gradient_ensure_vector_normalized(gradient);
1165     if (ngr != gradient) {
1166         /* Our master gradient has changed */
1167         sp_gradient_vector_widget_load_gradient(GTK_WIDGET(object), ngr);
1168     }
1169
1170     sp_gradient_ensure_vector(ngr);
1171
1172     /* Set start parameters */
1173     /* We rely on normalized vector, i.e. stops HAVE to exist */
1174     g_return_if_fail(ngr->getFirstStop() != NULL);
1175
1176     GtkOptionMenu *mnu = static_cast<GtkOptionMenu *>(g_object_get_data(G_OBJECT(object), "stopmenu"));
1177     SPStop *stop = SP_STOP(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "stop"));
1178
1179     csel = static_cast<SPColorSelector*>(g_object_get_data(G_OBJECT(object), "cselector"));
1180     csel->base->getColorAlpha( color, &alpha );
1181     rgb = color.toRGBA32( 0x00 );
1182
1183     sp_repr_set_css_double(SP_OBJECT_REPR(stop), "offset", stop->offset);
1184     Inkscape::CSSOStringStream os;
1185     gchar c[64];
1186     sp_svg_write_color(c, sizeof(c), rgb);
1187     os << "stop-color:" << c << ";stop-opacity:" << static_cast<gdouble>(alpha) <<";";
1188     SP_OBJECT_REPR(stop)->setAttribute("style", os.str().c_str());
1189     // g_snprintf(c, 256, "stop-color:#%06x;stop-opacity:%g;", rgb >> 8, static_cast<gdouble>(alpha));
1190     //SP_OBJECT_REPR(stop)->setAttribute("style", c);
1191
1192     sp_document_done(SP_OBJECT_DOCUMENT(ngr), SP_VERB_CONTEXT_GRADIENT,
1193                       _("Change gradient stop color"));
1194
1195     blocked = FALSE;
1196
1197     SPColorPreview *cpv = static_cast<SPColorPreview *>(g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(mnu)))), "preview"));
1198     sp_color_preview_set_rgba32(cpv, sp_stop_get_rgba32(stop));
1199 }
1200
1201 /*
1202   Local Variables:
1203   mode:c++
1204   c-file-style:"stroustrup"
1205   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1206   indent-tabs-mode:nil
1207   fill-column:99
1208   End:
1209 */
1210 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :