src/gradient-context.cpp

   1 #define __SP_GRADIENT_CONTEXT_C__
   2
   3 /*
   4  * Gradient drawing and editing tool
   5  *
   6  * Authors:
   7  *   bulia byak <buliabyak@users.sf.net>
   8  *
   9  * Copyright (C) 2005 Authors
  10  *
  11  * Released under GNU GPL, read the file 'COPYING' for more information
  12  */
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include "config.h"
  16 #endif
  17
  18
  19 #include <gdk/gdkkeysyms.h>
  20
  21 #include "macros.h"
  22 #include "document.h"
  23 #include "selection.h"
  24 #include "desktop.h"
  25 #include "desktop-handles.h"
  26 #include "message-context.h"
  27 #include "message-stack.h"
  28 #include "pixmaps/cursor-gradient.xpm"
  29 #include "pixmaps/cursor-gradient-add.xpm"
  30 #include "pixmaps/cursor-gradient-delete.xpm"
  31 #include "gradient-context.h"
  32 #include "gradient-chemistry.h"
  33 #include <glibmm/i18n.h>
  34 #include "prefs-utils.h"
  35 #include "gradient-drag.h"
  36 #include "gradient-chemistry.h"
  37 #include "xml/repr.h"
  38 #include "sp-item.h"
  39 #include "display/sp-ctrlline.h"
  40 #include "sp-linear-gradient.h"
  41 #include "sp-radial-gradient.h"
  42 #include "sp-stop.h"
  43 #include "svg/css-ostringstream.h"
  44 #include "svg/svg-color.h"
  45
  46
  47
  48
  49 static void sp_gradient_context_class_init(SPGradientContextClass *klass);
  50 static void sp_gradient_context_init(SPGradientContext *gr_context);
  51 static void sp_gradient_context_dispose(GObject *object);
  52
  53 static void sp_gradient_context_setup(SPEventContext *ec);
  54
  55 static gint sp_gradient_context_root_handler(SPEventContext *event_context, GdkEvent *event);
  56
  57 static void sp_gradient_drag(SPGradientContext &rc, NR::Point const pt, guint state, guint32 etime);
  58
  59 static SPEventContextClass *parent_class;
  60
  61
  62 GtkType sp_gradient_context_get_type()
  63 {
  64     static GType type = 0;
  65     if (!type) {
  66         GTypeInfo info = {
  67             sizeof(SPGradientContextClass),
  68             NULL, NULL,
  69             (GClassInitFunc) sp_gradient_context_class_init,
  70             NULL, NULL,
  71             sizeof(SPGradientContext),
  72             4,
  73             (GInstanceInitFunc) sp_gradient_context_init,
  74             NULL,    /* value_table */
  75         };
  76         type = g_type_register_static(SP_TYPE_EVENT_CONTEXT, "SPGradientContext", &info, (GTypeFlags) 0);
  77     }
  78     return type;
  79 }
  80
  81 static void sp_gradient_context_class_init(SPGradientContextClass *klass)
  82 {
  83     GObjectClass *object_class = (GObjectClass *) klass;
  84     SPEventContextClass *event_context_class = (SPEventContextClass *) klass;
  85
  86     parent_class = (SPEventContextClass *) g_type_class_peek_parent(klass);
  87
  88     object_class->dispose = sp_gradient_context_dispose;
  89
  90     event_context_class->setup = sp_gradient_context_setup;
  91     event_context_class->root_handler  = sp_gradient_context_root_handler;
  92 }
  93
  94 static void sp_gradient_context_init(SPGradientContext *gr_context)
  95 {
  96     SPEventContext *event_context = SP_EVENT_CONTEXT(gr_context);
  97
  98     gr_context->cursor_addnode = false;
  99     event_context->cursor_shape = cursor_gradient_xpm;
 100     event_context->hot_x = 4;
 101     event_context->hot_y = 4;
 102     event_context->xp = 0;
 103     event_context->yp = 0;
 104     event_context->tolerance = 4;
 105     event_context->within_tolerance = false;
 106     event_context->item_to_select = NULL;
 107 }
 108
 109 static void sp_gradient_context_dispose(GObject *object)
 110 {
 111     SPGradientContext *rc = SP_GRADIENT_CONTEXT(object);
 112     SPEventContext *ec = SP_EVENT_CONTEXT(object);
 113
 114     ec->enableGrDrag(false);
 115
 116     if (rc->_message_context) {
 117         delete rc->_message_context;
 118     }
 119
 120     G_OBJECT_CLASS(parent_class)->dispose(object);
 121 }
 122
 123 static void sp_gradient_context_setup(SPEventContext *ec)
 124 {
 125     SPGradientContext *rc = SP_GRADIENT_CONTEXT(ec);
 126
 127     if (((SPEventContextClass *) parent_class)->setup) {
 128         ((SPEventContextClass *) parent_class)->setup(ec);
 129     }
 130
 131     if (prefs_get_int_attribute("tools.gradient", "selcue", 1) != 0) {
 132         ec->enableSelectionCue();
 133     }
 134
 135     ec->enableGrDrag();
 136
 137     rc->_message_context = new Inkscape::MessageContext(sp_desktop_message_stack(ec->desktop));
 138 }
 139
 140 void
 141 sp_gradient_context_select_next (SPEventContext *event_context)
 142 {
 143     GrDrag *drag = event_context->_grdrag;
 144     g_assert (drag);
 145
 146     drag->select_next();
 147 }
 148
 149 void
 150 sp_gradient_context_select_prev (SPEventContext *event_context)
 151 {
 152     GrDrag *drag = event_context->_grdrag;
 153     g_assert (drag);
 154
 155     drag->select_prev();
 156 }
 157
 158 // FIXME: make global function in libnr or somewhere.
 159 static NR::Point
 160 snap_vector_midpoint (NR::Point p, NR::Point begin, NR::Point end)
 161 {
 162     double length = NR::L2(end - begin);
 163     NR::Point be = (end - begin) / length;
 164     double r = NR::dot(p - begin, be);
 165
 166     if (r < 0.0) return begin;
 167     if (r > length) return end;
 168
 169     return (begin + r * be);
 170 }
 171
 172 static bool
 173 sp_gradient_context_is_over_line (SPGradientContext *rc, SPItem *item, NR::Point event_p)
 174 {
 175     SPDesktop *desktop = SP_EVENT_CONTEXT (rc)->desktop;
 176
 177     //Translate mouse point into proper coord system
 178     rc->mousepoint_doc = desktop->w2d(event_p);
 179
 180     SPCtrlLine* line = SP_CTRLLINE(item);
 181
 182     NR::Point nearest = snap_vector_midpoint (rc->mousepoint_doc, line->s, line->e);
 183     NR::Point delta = rc->mousepoint_doc - nearest;
 184
 185     double tolerance = (double) SP_EVENT_CONTEXT(rc)->tolerance;
 186
 187     bool close = (NR::L2 (delta) < tolerance);
 188
 189     return close;
 190 }
 191
 192 // Fixme : must be able to put this in a general file.
 193 static guint32
 194 average_color (guint32 c1, guint32 c2, gdouble p = 0.5)
 195 {
 196         guint32 r = (guint32) (SP_RGBA32_R_U (c1) * (1 - p) + SP_RGBA32_R_U (c2) * p);
 197         guint32 g = (guint32) (SP_RGBA32_G_U (c1) * (1 - p) + SP_RGBA32_G_U (c2) * p);
 198         guint32 b = (guint32) (SP_RGBA32_B_U (c1) * (1 - p) + SP_RGBA32_B_U (c2) * p);
 199         guint32 a = (guint32) (SP_RGBA32_A_U (c1) * (1 - p) + SP_RGBA32_A_U (c2) * p);
 200
 201         return SP_RGBA32_U_COMPOSE (r, g, b, a);
 202 }
 203
 204 static double
 205 get_offset_between_points (NR::Point p, NR::Point begin, NR::Point end)
 206 {
 207     double length = NR::L2(end - begin);
 208     NR::Point be = (end - begin) / length;
 209     double r = NR::dot(p - begin, be);
 210
 211     if (r < 0.0) return 0.0;
 212     if (r > length) return 1.0;
 213
 214     return (r / length);
 215 }
 216
 217 static void
 218 sp_gradient_context_add_stop_near_point (SPGradientContext *rc, SPItem *item,  NR::Point mouse_p, guint32 etime)
 219 {
 220     // item is the selected item. mouse_p the location in doc coordinates of where to add the stop
 221
 222     SPEventContext *ec = SP_EVENT_CONTEXT(rc);
 223     double tolerance = (double) ec->tolerance;
 224
 225     gfloat offset; // type of SPStop.offset = gfloat
 226     SPGradient *gradient;
 227     bool fill_or_stroke = true;
 228     bool r1_knot = false;
 229
 230     bool addknot = false;
 231     do {
 232         gradient = sp_item_gradient (item, fill_or_stroke);
 233         if (SP_IS_LINEARGRADIENT(gradient)) {
 234             NR::Point begin   = sp_item_gradient_get_coords(item, POINT_LG_BEGIN, 0, fill_or_stroke);
 235             NR::Point end     = sp_item_gradient_get_coords(item, POINT_LG_END, 0, fill_or_stroke);
 236
 237             NR::Point nearest = snap_vector_midpoint (mouse_p, begin, end);
 238             NR::Point delta = mouse_p - nearest;
 239             if ( NR::L2 (delta) < tolerance ) {
 240                 // add the knot
 241                 offset = get_offset_between_points(nearest, begin, end);
 242                 addknot = true;
 243                 break; // break out of the while loop: add only one knot
 244             }
 245         } else if (SP_IS_RADIALGRADIENT(gradient)) {
 246             NR::Point begin = sp_item_gradient_get_coords(item, POINT_RG_CENTER, 0, fill_or_stroke);
 247             NR::Point end   = sp_item_gradient_get_coords(item, POINT_RG_R1, 0, fill_or_stroke);
 248             NR::Point nearest = snap_vector_midpoint (mouse_p, begin, end);
 249             NR::Point delta = mouse_p - nearest;
 250             if ( NR::L2 (delta) < tolerance ) {
 251                 offset = get_offset_between_points(nearest, begin, end);
 252                 addknot = true;
 253                 r1_knot = true;
 254                 break; // break out of the while loop: add only one knot
 255             }
 256
 257             end    = sp_item_gradient_get_coords(item, POINT_RG_R2, 0, fill_or_stroke);
 258             nearest = snap_vector_midpoint (mouse_p, begin, end);
 259             delta = mouse_p - nearest;
 260             if ( NR::L2 (delta) < tolerance ) {
 261                 offset = get_offset_between_points(nearest, begin, end);
 262                 addknot = true;
 263                 r1_knot = false;
 264                 break; // break out of the while loop: add only one knot
 265             }
 266         }
 267         fill_or_stroke = !fill_or_stroke;
 268     } while (!fill_or_stroke && !addknot) ;
 269
 270     if (addknot) {
 271         SPGradient *vector = sp_gradient_get_vector (gradient, false);
 272         SPStop* prev_stop = sp_first_stop(vector);
 273         SPStop* next_stop = sp_next_stop(prev_stop);
 274         while ( (next_stop) && (next_stop->offset < offset) ) {
 275             prev_stop = next_stop;
 276             next_stop = sp_next_stop(next_stop);
 277         }
 278         if (!next_stop) {
 279             // logical error: the endstop should have offset 1 and should always be more than this offset here
 280             return;
 281         }
 282
 283         Inkscape::XML::Node *new_stop_repr = NULL;
 284         new_stop_repr = SP_OBJECT_REPR(prev_stop)->duplicate();
 285         SP_OBJECT_REPR(vector)->addChild(new_stop_repr, SP_OBJECT_REPR(prev_stop));
 286
 287         SPStop *newstop = (SPStop *) SP_OBJECT_DOCUMENT(vector)->getObjectByRepr(new_stop_repr);
 288         newstop->offset = offset;
 289         sp_repr_set_css_double( SP_OBJECT_REPR(newstop), "offset", (double)offset);
 290         guint32 const c1 = sp_stop_get_rgba32(prev_stop);
 291         guint32 const c2 = sp_stop_get_rgba32(next_stop);
 292         guint32 cnew = average_color (c1, c2, (offset - prev_stop->offset) / (next_stop->offset - prev_stop->offset));
 293         Inkscape::CSSOStringStream os;
 294         gchar c[64];
 295         sp_svg_write_color (c, 64, cnew);
 296         gdouble opacity = (gdouble) SP_RGBA32_A_F (cnew);
 297         os << "stop-color:" << c << ";stop-opacity:" << opacity <<";";
 298         SP_OBJECT_REPR (newstop)->setAttribute("style", os.str().c_str());
 299
 300
 301         Inkscape::GC::release(new_stop_repr);
 302         sp_document_done (SP_OBJECT_DOCUMENT (vector), SP_VERB_CONTEXT_GRADIENT,
 303                   _("Add gradient stop"));
 304
 305         ec->_grdrag->updateDraggers();
 306                 sp_gradient_ensure_vector (gradient);
 307
 308         if (vector->has_stops) {
 309             int i = 0;
 310             for ( SPObject *ochild = sp_object_first_child (SP_OBJECT(vector)) ; ochild != NULL ; ochild = SP_OBJECT_NEXT(ochild) ) {
 311                 if (SP_IS_STOP (ochild)) {
 312                     if ( SP_STOP(ochild) == newstop ) {
 313                         break;
 314                     } else {
 315                         i++;
 316                     }
 317                 }
 318             }
 319             GrDragger *dragger = NULL;
 320             gradient = sp_item_gradient (item, fill_or_stroke);
 321             GrPointType pointtype;
 322             if (SP_IS_LINEARGRADIENT(gradient)) {
 323                 dragger = SP_EVENT_CONTEXT(rc)->_grdrag->getDraggerFor (item, POINT_LG_MID, i, fill_or_stroke);
 324                 pointtype = POINT_LG_MID;
 325             } else if (SP_IS_RADIALGRADIENT(gradient)) {
 326                 dragger = SP_EVENT_CONTEXT(rc)->_grdrag->getDraggerFor (item, r1_knot ? POINT_RG_MID1 : POINT_RG_MID2, i, fill_or_stroke);
 327                 pointtype = r1_knot ? POINT_RG_MID1 : POINT_RG_MID2;
 328             }
 329                 if (dragger && (etime == 0) ) {
 330                     ec->_grdrag->setSelected (dragger);
 331                 } else {
 332                     ec->_grdrag->grabKnot (item,
 333                                        pointtype,
 334                                        i,
 335                                        fill_or_stroke, 99999, 99999, etime);
 336                 }
 337                 ec->_grdrag->local_change = true;
 338
 339         }
 340     }
 341 }
 342
 343 static void
 344 sp_gradient_context_delete_stops (SPGradientContext *rc, SPItem *item, GrDrag *drag, bool just_one) {
 345     GrDragger *draggertemp = (GrDragger*) drag->selected->data;
 346     GrDraggable *draggabletemp = (GrDraggable*) draggertemp->draggables->data;
 347     SPGradient *gradient = sp_item_gradient (item, draggabletemp->fill_or_stroke);
 348     SPGradient *vector   = sp_gradient_get_vector (gradient, false);
 349
 350     // 2 is the minimum, cannot delete more than that without deleting the whole vector
 351     guint num_delete = just_one ? 1 : g_list_length(drag->selected);
 352     if (vector->vector.stops.size() >= (2+num_delete) ) {
 353         GSList *stoplist = NULL;
 354         while (drag->selected) {
 355             GrDragger *dragger = (GrDragger*) drag->selected->data;
 356             GrDraggable *draggable = (GrDraggable*) dragger->draggables->data;
 357             SPStop *selstop = NULL;
 358             switch (draggable->point_type) {
 359                 case POINT_LG_END:
 360                 case POINT_RG_R1:
 361                 case POINT_RG_R2:
 362                     selstop = sp_last_stop(vector);
 363                     break;
 364                 default:
 365                     selstop = sp_get_stop_i(vector, draggable->point_i);
 366                     break;
 367             }
 368             if ( !g_slist_find(stoplist, selstop) ) {
 369                 stoplist = g_slist_append(stoplist, selstop);
 370             }
 371             drag->selected = g_list_remove(drag->selected, dragger);
 372             if ( just_one ) break; // iterate once if just_one is set.
 373         }
 374         while (stoplist) {
 375             SPStop *stop = (SPStop*) stoplist->data;
 376             SP_OBJECT_REPR(vector)->removeChild(SP_OBJECT_REPR(stop));
 377             stoplist = g_slist_remove(stoplist, stop);
 378         }
 379         // if we delete first or last stop, move the next/previous to the edge
 380         SPStop *first = sp_first_stop (vector);
 381         if (first) {
 382             if (first->offset != 0) {
 383                 first->offset = 0;
 384                 sp_repr_set_css_double (SP_OBJECT_REPR (first), "offset", 0);
 385             }
 386         }
 387         SPStop *last = sp_last_stop (vector);
 388         if (last) {
 389             if (last->offset != 1) {
 390                 last->offset = 1;
 391                 sp_repr_set_css_double (SP_OBJECT_REPR (last), "offset", 1);
 392             }
 393         }
 394         if ( just_one || (num_delete == 1) ) {
 395             sp_document_done (SP_OBJECT_DOCUMENT (vector), SP_VERB_CONTEXT_GRADIENT,
 396                               _("Delete gradient stop"));
 397         } else {
 398             sp_document_done (SP_OBJECT_DOCUMENT (vector), SP_VERB_CONTEXT_GRADIENT,
 399                               _("Delete gradient stops"));
 400         }
 401     } else { // delete the gradient from the object. set fill to unset
 402         SPCSSAttr *css = sp_repr_css_attr_new ();
 403         if (draggabletemp->fill_or_stroke) {
 404             sp_repr_css_unset_property (css, "fill");
 405         } else {
 406             sp_repr_css_unset_property (css, "stroke");
 407         }
 408         sp_repr_css_change (SP_OBJECT_REPR (item), css, "style");
 409         sp_repr_css_attr_unref (css);
 410         sp_document_done (SP_OBJECT_DOCUMENT (vector), SP_VERB_CONTEXT_GRADIENT,
 411                           _("Remove gradient"));
 412     }
 413 }
 414
 415
 416
 417 static gint
 418 sp_gradient_context_root_handler(SPEventContext *event_context, GdkEvent *event)
 419 {
 420     static bool dragging;
 421
 422     SPDesktop *desktop = event_context->desktop;
 423     Inkscape::Selection *selection = sp_desktop_selection (desktop);
 424
 425     SPGradientContext *rc = SP_GRADIENT_CONTEXT(event_context);
 426
 427     event_context->tolerance = prefs_get_int_attribute_limited("options.dragtolerance", "value", 0, 0, 100);
 428     double const nudge = prefs_get_double_attribute_limited("options.nudgedistance", "value", 2, 0, 1000); // in px
 429
 430     GrDrag *drag = event_context->_grdrag;
 431     g_assert (drag);
 432
 433     gint ret = FALSE;
 434     switch (event->type) {
 435     case GDK_2BUTTON_PRESS:
 436         if ( event->button.button == 1 ) {
 437             bool over_line = false;
 438             SPCtrlLine *line = NULL;
 439             if (drag->lines) {
 440                 for (GSList *l = drag->lines; (l != NULL) && (!over_line); l = l->next) {
 441                     line = (SPCtrlLine*) l->data;
 442                     over_line |= sp_gradient_context_is_over_line (rc, (SPItem*) line, NR::Point(event->motion.x, event->motion.y));
 443                 }
 444             }
 445             if (over_line) {
 446                 sp_gradient_context_add_stop_near_point(rc, SP_ITEM(selection->itemList()->data), rc->mousepoint_doc, event->button.time);
 447             } else {
 448                 for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
 449                     SPItem *item = SP_ITEM(i->data);
 450                     SPGradientType new_type = (SPGradientType) prefs_get_int_attribute ("tools.gradient", "newgradient", SP_GRADIENT_TYPE_LINEAR);
 451                     guint new_fill = prefs_get_int_attribute ("tools.gradient", "newfillorstroke", 1);
 452
 453                     SPGradient *vector = sp_gradient_vector_for_object(sp_desktop_document(desktop), desktop,                                                                                   SP_OBJECT (item), new_fill);
 454
 455                     SPGradient *priv = sp_item_set_gradient(item, vector, new_type, new_fill);
 456                     sp_gradient_reset_to_userspace(priv, item);
 457                 }
 458
 459                 sp_document_done (sp_desktop_document (desktop), SP_VERB_CONTEXT_GRADIENT,
 460                                   _("Create default gradient"));
 461             }
 462             ret = TRUE;
 463         }
 464         break;
 465     case GDK_BUTTON_PRESS:
 466         if ( event->button.button == 1 ) {
 467             NR::Point const button_w(event->button.x, event->button.y);
 468
 469             // save drag origin
 470             event_context->xp = (gint) button_w[NR::X];
 471             event_context->yp = (gint) button_w[NR::Y];
 472             event_context->within_tolerance = true;
 473
 474             // remember clicked item, disregarding groups, honoring Alt; do nothing with Crtl to
 475             // enable Ctrl+doubleclick of exactly the selected item(s)
 476             if (!(event->button.state & GDK_CONTROL_MASK))
 477                 event_context->item_to_select = sp_event_context_find_item (desktop, button_w, event->button.state & GDK_MOD1_MASK, TRUE);
 478
 479             dragging = true;
 480             /* Position center */
 481             NR::Point const button_dt = desktop->w2d(button_w);
 482             /* Snap center to nearest magnetic point */
 483
 484             rc->origin = button_dt;
 485
 486             ret = TRUE;
 487         }
 488         break;
 489     case GDK_MOTION_NOTIFY:
 490         if ( dragging
 491              && ( event->motion.state & GDK_BUTTON1_MASK ) )
 492         {
 493             if ( event_context->within_tolerance
 494                  && ( abs( (gint) event->motion.x - event_context->xp ) < event_context->tolerance )
 495                  && ( abs( (gint) event->motion.y - event_context->yp ) < event_context->tolerance ) ) {
 496                 break; // do not drag if we're within tolerance from origin
 497             }
 498             // Once the user has moved farther than tolerance from the original location
 499             // (indicating they intend to draw, not click), then always process the
 500             // motion notify coordinates as given (no snapping back to origin)
 501             event_context->within_tolerance = false;
 502
 503             NR::Point const motion_w(event->motion.x,
 504                                      event->motion.y);
 505             NR::Point const motion_dt = event_context->desktop->w2d(motion_w);
 506
 507             sp_gradient_drag(*rc, motion_dt, event->motion.state, event->motion.time);
 508
 509             ret = TRUE;
 510         } else {
 511             bool over_line = false;
 512             if (drag->lines) {
 513                 for (GSList *l = drag->lines; l != NULL; l = l->next) {
 514                     over_line |= sp_gradient_context_is_over_line (rc, (SPItem*) l->data, NR::Point(event->motion.x, event->motion.y));
 515                 }
 516             }
 517
 518             if (rc->cursor_addnode && !over_line) {
 519                 event_context->cursor_shape = cursor_gradient_xpm;
 520                 sp_event_context_update_cursor(event_context);
 521                 rc->cursor_addnode = false;
 522             } else if (!rc->cursor_addnode && over_line) {
 523                 event_context->cursor_shape = cursor_gradient_add_xpm;
 524                 sp_event_context_update_cursor(event_context);
 525                 rc->cursor_addnode = true;
 526             }
 527         }
 528         break;
 529     case GDK_BUTTON_RELEASE:
 530         event_context->xp = event_context->yp = 0;
 531         if ( event->button.button == 1 ) {
 532             if ( (event->button.state & GDK_CONTROL_MASK) && (event->button.state & GDK_MOD1_MASK ) ) {
 533                 bool over_line = false;
 534                 SPCtrlLine *line = NULL;
 535                 if (drag->lines) {
 536                     for (GSList *l = drag->lines; (l != NULL) && (!over_line); l = l->next) {
 537                         line = (SPCtrlLine*) l->data;
 538                         over_line |= sp_gradient_context_is_over_line (rc, (SPItem*) line, NR::Point(event->motion.x, event->motion.y));
 539                     }
 540                 }
 541                 if (over_line) {
 542                     sp_gradient_context_add_stop_near_point(rc, SP_ITEM(selection->itemList()->data), rc->mousepoint_doc, 0);
 543                     ret = TRUE;
 544                 }
 545             } else {
 546                 dragging = false;
 547
 548                 // unless clicked with Ctrl (to enable Ctrl+doubleclick).  (don't what this is for (johan))
 549                 if (event->button.state & GDK_CONTROL_MASK) {
 550                     ret = TRUE;
 551                     break;
 552                 }
 553
 554                 if (!event_context->within_tolerance) {
 555                     // we've been dragging, do nothing (grdrag handles that)
 556                 } else if (event_context->item_to_select) {
 557                     // no dragging, select clicked item if any
 558                     if (event->button.state & GDK_SHIFT_MASK) {
 559                         selection->toggle(event_context->item_to_select);
 560                     } else {
 561                         selection->set(event_context->item_to_select);
 562                     }
 563                 } else {
 564                     // click in an empty space; do the same as Esc
 565                     if (drag->selected) {
 566                         drag->deselect_all();
 567                     } else {
 568                         selection->clear();
 569                     }
 570                 }
 571
 572                 event_context->item_to_select = NULL;
 573                 ret = TRUE;
 574             }
 575         }
 576         break;
 577     case GDK_KEY_PRESS:
 578         switch (get_group0_keyval (&event->key)) {
 579         case GDK_Alt_L:
 580         case GDK_Alt_R:
 581         case GDK_Control_L:
 582         case GDK_Control_R:
 583         case GDK_Shift_L:
 584         case GDK_Shift_R:
 585         case GDK_Meta_L:  // Meta is when you press Shift+Alt (at least on my machine)
 586         case GDK_Meta_R:
 587             sp_event_show_modifier_tip (event_context->defaultMessageContext(), event,
 588                                         _("<b>Ctrl</b>: snap gradient angle"),
 589                                         _("<b>Shift</b>: draw gradient around the starting point"),
 590                                         NULL);
 591             break;
 592
 593         case GDK_x:
 594         case GDK_X:
 595             if (MOD__ALT_ONLY) {
 596                 desktop->setToolboxFocusTo ("altx-grad");
 597                 ret = TRUE;
 598             }
 599             break;
 600
 601         case GDK_Escape:
 602             if (drag->selected) {
 603                 drag->deselect_all();
 604             } else {
 605                 selection->clear();
 606             }
 607             ret = TRUE;
 608             //TODO: make dragging escapable by Esc
 609             break;
 610
 611         case GDK_Left: // move handle left
 612         case GDK_KP_Left:
 613         case GDK_KP_4:
 614             if (!MOD__CTRL) { // not ctrl
 615                 if (MOD__ALT) { // alt
 616                     if (MOD__SHIFT) drag->selected_move_screen(-10, 0); // shift
 617                     else drag->selected_move_screen(-1, 0); // no shift
 618                 }
 619                 else { // no alt
 620                     if (MOD__SHIFT) drag->selected_move(-10*nudge, 0); // shift
 621                     else drag->selected_move(-nudge, 0); // no shift
 622                 }
 623                 ret = TRUE;
 624             }
 625             break;
 626         case GDK_Up: // move handle up
 627         case GDK_KP_Up:
 628         case GDK_KP_8:
 629             if (!MOD__CTRL) { // not ctrl
 630                 if (MOD__ALT) { // alt
 631                     if (MOD__SHIFT) drag->selected_move_screen(0, 10); // shift
 632                     else drag->selected_move_screen(0, 1); // no shift
 633                 }
 634                 else { // no alt
 635                     if (MOD__SHIFT) drag->selected_move(0, 10*nudge); // shift
 636                     else drag->selected_move(0, nudge); // no shift
 637                 }
 638                 ret = TRUE;
 639             }
 640             break;
 641         case GDK_Right: // move handle right
 642         case GDK_KP_Right:
 643         case GDK_KP_6:
 644             if (!MOD__CTRL) { // not ctrl
 645                 if (MOD__ALT) { // alt
 646                     if (MOD__SHIFT) drag->selected_move_screen(10, 0); // shift
 647                     else drag->selected_move_screen(1, 0); // no shift
 648                 }
 649                 else { // no alt
 650                     if (MOD__SHIFT) drag->selected_move(10*nudge, 0); // shift
 651                     else drag->selected_move(nudge, 0); // no shift
 652                 }
 653                 ret = TRUE;
 654             }
 655             break;
 656         case GDK_Down: // move handle down
 657         case GDK_KP_Down:
 658         case GDK_KP_2:
 659             if (!MOD__CTRL) { // not ctrl
 660                 if (MOD__ALT) { // alt
 661                     if (MOD__SHIFT) drag->selected_move_screen(0, -10); // shift
 662                     else drag->selected_move_screen(0, -1); // no shift
 663                 }
 664                 else { // no alt
 665                     if (MOD__SHIFT) drag->selected_move(0, -10*nudge); // shift
 666                     else drag->selected_move(0, -nudge); // no shift
 667                 }
 668                 ret = TRUE;
 669             }
 670             break;
 671         case GDK_r:
 672         case GDK_R:
 673             if (MOD__SHIFT_ONLY) {
 674                 // First try selected dragger
 675                 if (drag && drag->selected) {
 676                     drag->selected_reverse_vector();
 677                 } else { // If no drag or no dragger selected, act on selection (both fill and stroke gradients)
 678                     for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
 679                         sp_item_gradient_reverse_vector (SP_ITEM(i->data), true);
 680                         sp_item_gradient_reverse_vector (SP_ITEM(i->data), false);
 681                     }
 682                 }
 683                 // we did an undoable action
 684                 sp_document_done (sp_desktop_document (desktop), SP_VERB_CONTEXT_GRADIENT,
 685                                   _("Invert gradient"));
 686                 ret = TRUE;
 687             }
 688             break;
 689 /*
 690         case GDK_Insert:
 691         case GDK_KP_Insert:
 692             // with any modifiers
 693             sp_node_selected_add_node();
 694             ret = TRUE;
 695             break;
 696 */
 697         case GDK_Delete:
 698         case GDK_KP_Delete:
 699         case GDK_BackSpace:
 700             if ( drag->selected ) {
 701                 sp_gradient_context_delete_stops ( rc, SP_ITEM(selection->itemList()->data), drag, MOD__CTRL_ONLY ) ;
 702                 ret = TRUE;
 703             }
 704             break;
 705         default:
 706             break;
 707         }
 708         break;
 709     case GDK_KEY_RELEASE:
 710         switch (get_group0_keyval (&event->key)) {
 711         case GDK_Alt_L:
 712         case GDK_Alt_R:
 713         case GDK_Control_L:
 714         case GDK_Control_R:
 715         case GDK_Shift_L:
 716         case GDK_Shift_R:
 717         case GDK_Meta_L:  // Meta is when you press Shift+Alt
 718         case GDK_Meta_R:
 719             event_context->defaultMessageContext()->clear();
 720             break;
 721         default:
 722             break;
 723         }
 724         break;
 725     default:
 726         break;
 727     }
 728
 729     if (!ret) {
 730         if (((SPEventContextClass *) parent_class)->root_handler) {
 731             ret = ((SPEventContextClass *) parent_class)->root_handler(event_context, event);
 732         }
 733     }
 734
 735     return ret;
 736 }
 737
 738 static void sp_gradient_drag(SPGradientContext &rc, NR::Point const pt, guint state, guint32 etime)
 739 {
 740     SPDesktop *desktop = SP_EVENT_CONTEXT(&rc)->desktop;
 741     Inkscape::Selection *selection = sp_desktop_selection(desktop);
 742     SPDocument *document = sp_desktop_document(desktop);
 743     SPEventContext *ec = SP_EVENT_CONTEXT(&rc);
 744
 745     if (!selection->isEmpty()) {
 746         int type = prefs_get_int_attribute ("tools.gradient", "newgradient", 1);
 747         int fill_or_stroke = prefs_get_int_attribute ("tools.gradient", "newfillorstroke", 1);
 748
 749         SPGradient *vector;
 750         if (ec->item_to_select) {
 751             vector = sp_gradient_vector_for_object(document, desktop, ec->item_to_select, fill_or_stroke);
 752         } else {
 753             vector = sp_gradient_vector_for_object(document, desktop, SP_ITEM(selection->itemList()->data), fill_or_stroke);
 754         }
 755
 756         // HACK: reset fill-opacity - that 0.75 is annoying; BUT remove this when we have an opacity slider for all tabs
 757         SPCSSAttr *css = sp_repr_css_attr_new();
 758         sp_repr_css_set_property(css, "fill-opacity", "1.0");
 759
 760         for (GSList const *i = selection->itemList(); i != NULL; i = i->next) {
 761
 762             //FIXME: see above
 763             sp_repr_css_change_recursive(SP_OBJECT_REPR(i->data), css, "style");
 764
 765             sp_item_set_gradient(SP_ITEM(i->data), vector, (SPGradientType) type, fill_or_stroke);
 766
 767             if (type == SP_GRADIENT_TYPE_LINEAR) {
 768                 sp_item_gradient_set_coords (SP_ITEM(i->data), POINT_LG_BEGIN, 0, rc.origin, fill_or_stroke, true, false);
 769                 sp_item_gradient_set_coords (SP_ITEM(i->data), POINT_LG_END, 0, pt, fill_or_stroke, true, false);
 770             } else if (type == SP_GRADIENT_TYPE_RADIAL) {
 771                 sp_item_gradient_set_coords (SP_ITEM(i->data), POINT_RG_CENTER, 0, rc.origin, fill_or_stroke, true, false);
 772                 sp_item_gradient_set_coords (SP_ITEM(i->data), POINT_RG_R1, 0, pt, fill_or_stroke, true, false);
 773             }
 774             SP_OBJECT (i->data)->requestModified(SP_OBJECT_MODIFIED_FLAG);
 775         }
 776         if (ec->_grdrag) {
 777             ec->_grdrag->updateDraggers();
 778             // prevent regenerating draggers by selection modified signal, which sometimes
 779             // comes too late and thus destroys the knot which we will now grab:
 780             ec->_grdrag->local_change = true;
 781             // give the grab out-of-bounds values of xp/yp because we're already dragging
 782             // and therefore are already out of tolerance
 783             ec->_grdrag->grabKnot (SP_ITEM(selection->itemList()->data),
 784                                    type == SP_GRADIENT_TYPE_LINEAR? POINT_LG_END : POINT_RG_R1,
 785                                    0, //point_i
 786                                    fill_or_stroke, 99999, 99999, etime);
 787         }
 788         // We did an undoable action, but sp_document_done will be called by the knot when released
 789
 790         // status text; we do not track coords because this branch is run once, not all the time
 791         // during drag
 792         int n_objects = g_slist_length((GSList *) selection->itemList());
 793         rc._message_context->setF(Inkscape::NORMAL_MESSAGE,
 794                                   ngettext("<b>Gradient</b> for %d object; with <b>Ctrl</b> to snap angle",
 795                                            "<b>Gradient</b> for %d objects; with <b>Ctrl</b> to snap angle", n_objects),
 796                                   n_objects);
 797     } else {
 798         sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>objects</b> on which to create gradient."));
 799     }
 800 }
 801
 802
 803 /*
 804   Local Variables:
 805   mode:c++
 806   c-file-style:"stroustrup"
 807   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 808   indent-tabs-mode:nil
 809   fill-column:99
 810   End:
 811 */
 812 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :