src/tweak-context.cpp

   1 #define __SP_TWEAK_CONTEXT_C__
   2
   3 /*
   4  * tweaking paths without node editing
   5  *
   6  * Authors:
   7  *   bulia byak
   8  *
   9  * Copyright (C) 2007 authors
  10  *
  11  * Released under GNU GPL, read the file 'COPYING' for more information
  12  */
  13
  14 #include "config.h"
  15
  16 #include <gtk/gtk.h>
  17 #include <gdk/gdkkeysyms.h>
  18 #include <glibmm/i18n.h>
  19
  20 #include <numeric>
  21
  22 #include "svg/svg.h"
  23 #include "display/canvas-bpath.h"
  24
  25 #include <glib/gmem.h>
  26 #include "macros.h"
  27 #include "document.h"
  28 #include "selection.h"
  29 #include "desktop.h"
  30 #include "desktop-events.h"
  31 #include "desktop-handles.h"
  32 #include "desktop-style.h"
  33 #include "message-context.h"
  34 #include "pixmaps/cursor-tweak-move.xpm"
  35 #include "pixmaps/cursor-thin.xpm"
  36 #include "pixmaps/cursor-thicken.xpm"
  37 #include "pixmaps/cursor-attract.xpm"
  38 #include "pixmaps/cursor-repel.xpm"
  39 #include "pixmaps/cursor-push.xpm"
  40 #include "pixmaps/cursor-roughen.xpm"
  41 #include "pixmaps/cursor-color.xpm"
  42 #include <boost/optional.hpp>
  43 #include "libnr/nr-matrix-ops.h"
  44 #include "libnr/nr-scale-translate-ops.h"
  45 #include "xml/repr.h"
  46 #include "context-fns.h"
  47 #include "sp-item.h"
  48 #include "inkscape.h"
  49 #include "color.h"
  50 #include "svg/svg-color.h"
  51 #include "splivarot.h"
  52 #include "sp-item-group.h"
  53 #include "sp-shape.h"
  54 #include "sp-path.h"
  55 #include "path-chemistry.h"
  56 #include "sp-gradient.h"
  57 #include "sp-stop.h"
  58 #include "sp-stop-fns.h"
  59 #include "sp-gradient-reference.h"
  60 #include "sp-linear-gradient.h"
  61 #include "sp-radial-gradient.h"
  62 #include "gradient-chemistry.h"
  63 #include "sp-text.h"
  64 #include "sp-flowtext.h"
  65 #include "display/canvas-bpath.h"
  66 #include "display/canvas-arena.h"
  67 #include "display/curve.h"
  68 #include "livarot/Shape.h"
  69 #include <2geom/isnan.h>
  70 #include <2geom/transforms.h>
  71 #include "preferences.h"
  72 #include "style.h"
  73 #include "box3d.h"
  74 #include "sp-item-transform.h"
  75 #include "filter-chemistry.h"
  76 #include "sp-gaussian-blur-fns.h"
  77 #include "sp-gaussian-blur.h"
  78
  79 #include "tweak-context.h"
  80
  81 #define DDC_RED_RGBA 0xff0000ff
  82
  83 #define DYNA_MIN_WIDTH 1.0e-6
  84
  85 static void sp_tweak_context_class_init(SPTweakContextClass *klass);
  86 static void sp_tweak_context_init(SPTweakContext *ddc);
  87 static void sp_tweak_context_dispose(GObject *object);
  88
  89 static void sp_tweak_context_setup(SPEventContext *ec);
  90 static void sp_tweak_context_set(SPEventContext *ec, Inkscape::Preferences::Entry *val);
  91 static gint sp_tweak_context_root_handler(SPEventContext *ec, GdkEvent *event);
  92
  93 static SPEventContextClass *parent_class;
  94
  95 GtkType
  96 sp_tweak_context_get_type(void)
  97 {
  98     static GType type = 0;
  99     if (!type) {
 100         GTypeInfo info = {
 101             sizeof(SPTweakContextClass),
 102             NULL, NULL,
 103             (GClassInitFunc) sp_tweak_context_class_init,
 104             NULL, NULL,
 105             sizeof(SPTweakContext),
 106             4,
 107             (GInstanceInitFunc) sp_tweak_context_init,
 108             NULL,   /* value_table */
 109         };
 110         type = g_type_register_static(SP_TYPE_EVENT_CONTEXT, "SPTweakContext", &info, (GTypeFlags)0);
 111     }
 112     return type;
 113 }
 114
 115 static void
 116 sp_tweak_context_class_init(SPTweakContextClass *klass)
 117 {
 118     GObjectClass *object_class = (GObjectClass *) klass;
 119     SPEventContextClass *event_context_class = (SPEventContextClass *) klass;
 120
 121     parent_class = (SPEventContextClass*)g_type_class_peek_parent(klass);
 122
 123     object_class->dispose = sp_tweak_context_dispose;
 124
 125     event_context_class->setup = sp_tweak_context_setup;
 126     event_context_class->set = sp_tweak_context_set;
 127     event_context_class->root_handler = sp_tweak_context_root_handler;
 128 }
 129
 130 static void
 131 sp_tweak_context_init(SPTweakContext *tc)
 132 {
 133     SPEventContext *event_context = SP_EVENT_CONTEXT(tc);
 134
 135     event_context->cursor_shape = cursor_push_xpm;
 136     event_context->hot_x = 4;
 137     event_context->hot_y = 4;
 138
 139     /* attributes */
 140     tc->dragging = FALSE;
 141
 142     tc->width = 0.2;
 143     tc->force = 0.2;
 144     tc->pressure = TC_DEFAULT_PRESSURE;
 145
 146     tc->is_dilating = false;
 147     tc->has_dilated = false;
 148
 149     tc->do_h = true;
 150     tc->do_s = true;
 151     tc->do_l = true;
 152     tc->do_o = false;
 153
 154     new (&tc->style_set_connection) sigc::connection();
 155 }
 156
 157 static void
 158 sp_tweak_context_dispose(GObject *object)
 159 {
 160     SPTweakContext *tc = SP_TWEAK_CONTEXT(object);
 161
 162     tc->style_set_connection.disconnect();
 163     tc->style_set_connection.~connection();
 164
 165     if (tc->dilate_area) {
 166         gtk_object_destroy(GTK_OBJECT(tc->dilate_area));
 167         tc->dilate_area = NULL;
 168     }
 169
 170     if (tc->_message_context) {
 171         delete tc->_message_context;
 172     }
 173
 174     G_OBJECT_CLASS(parent_class)->dispose(object);
 175 }
 176
 177 bool is_transform_mode (gint mode)
 178 {
 179     return (mode == TWEAK_MODE_MOVE ||
 180             mode == TWEAK_MODE_MOVE_IN_OUT ||
 181             mode == TWEAK_MODE_MOVE_JITTER ||
 182             mode == TWEAK_MODE_SCALE ||
 183             mode == TWEAK_MODE_ROTATE ||
 184             mode == TWEAK_MODE_MORELESS);
 185 }
 186
 187 bool is_color_mode (gint mode)
 188 {
 189     return (mode == TWEAK_MODE_COLORPAINT || mode == TWEAK_MODE_COLORJITTER || mode == TWEAK_MODE_BLUR);
 190 }
 191
 192 void
 193 sp_tweak_update_cursor (SPTweakContext *tc, bool with_shift)
 194 {
 195    SPEventContext *event_context = SP_EVENT_CONTEXT(tc);
 196    SPDesktop *desktop = event_context->desktop;
 197
 198                 guint num = 0;
 199                 gchar *sel_message = NULL;
 200                 if (!desktop->selection->isEmpty()) {
 201                     num = g_slist_length((GSList *) desktop->selection->itemList());
 202                     sel_message = g_strdup_printf(ngettext("<b>%i</b> object selected","<b>%i</b> objects selected",num), num);
 203                 } else {
 204                     sel_message = g_strdup_printf(_("<b>Nothing</b> selected"));
 205                 }
 206
 207
 208    switch (tc->mode) {
 209        case TWEAK_MODE_MOVE:
 210            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag to <b>move</b>."), sel_message);
 211            event_context->cursor_shape = cursor_tweak_move_xpm;
 212            break;
 213        case TWEAK_MODE_MOVE_IN_OUT:
 214            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>move in</b>; with Shift to <b>move out</b>."), sel_message);
 215            event_context->cursor_shape = cursor_tweak_move_xpm;
 216            break;
 217        case TWEAK_MODE_MOVE_JITTER:
 218            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>move randomly</b>."), sel_message);
 219            event_context->cursor_shape = cursor_tweak_move_xpm;
 220            break;
 221        case TWEAK_MODE_SCALE:
 222            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>scale down</b>; with Shift to <b>scale up</b>."), sel_message);
 223            event_context->cursor_shape = cursor_tweak_move_xpm;
 224            break;
 225        case TWEAK_MODE_ROTATE:
 226            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>rotate clockwise</b>; with Shift, <b>counterclockwise</b>."), sel_message);
 227            event_context->cursor_shape = cursor_tweak_move_xpm;
 228            break;
 229        case TWEAK_MODE_MORELESS:
 230            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>duplicate</b>; with Shift, <b>delete</b>."), sel_message);
 231            event_context->cursor_shape = cursor_tweak_move_xpm;
 232            break;
 233        case TWEAK_MODE_PUSH:
 234            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag to <b>push paths</b>."), sel_message);
 235            event_context->cursor_shape = cursor_push_xpm;
 236            break;
 237        case TWEAK_MODE_SHRINK_GROW:
 238            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>inset paths</b>; with Shift to <b>outset</b>."), sel_message);
 239            if (with_shift) {
 240                event_context->cursor_shape = cursor_thicken_xpm;
 241            } else {
 242                event_context->cursor_shape = cursor_thin_xpm;
 243            }
 244            break;
 245        case TWEAK_MODE_ATTRACT_REPEL:
 246            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>attract paths</b>; with Shift to <b>repel</b>."), sel_message);
 247            if (with_shift) {
 248                event_context->cursor_shape = cursor_repel_xpm;
 249            } else {
 250                event_context->cursor_shape = cursor_attract_xpm;
 251            }
 252            break;
 253        case TWEAK_MODE_ROUGHEN:
 254            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>roughen paths</b>."), sel_message);
 255            event_context->cursor_shape = cursor_roughen_xpm;
 256            break;
 257        case TWEAK_MODE_COLORPAINT:
 258            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>paint objects</b> with color."), sel_message);
 259            event_context->cursor_shape = cursor_color_xpm;
 260            break;
 261        case TWEAK_MODE_COLORJITTER:
 262            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>randomize colors</b>."), sel_message);
 263            event_context->cursor_shape = cursor_color_xpm;
 264            break;
 265        case TWEAK_MODE_BLUR:
 266            tc->_message_context->setF(Inkscape::NORMAL_MESSAGE, _("%s. Drag or click to <b>increase blur</b>; with Shift to <b>decrease</b>."), sel_message);
 267            event_context->cursor_shape = cursor_color_xpm;
 268            break;
 269    }
 270    sp_event_context_update_cursor(event_context);
 271    g_free(sel_message);
 272 }
 273
 274 static bool
 275 sp_tweak_context_style_set(SPCSSAttr const *css, SPTweakContext *tc)
 276 {
 277     if (tc->mode == TWEAK_MODE_COLORPAINT) { // intercept color setting only in this mode
 278         // we cannot store properties with uris
 279         css = sp_css_attr_unset_uris ((SPCSSAttr *) css);
 280         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 281         prefs->setStyle("/tools/tweak/style", const_cast<SPCSSAttr*>(css));
 282         return true;
 283     }
 284     return false;
 285 }
 286
 287
 288 static void
 289 sp_tweak_context_setup(SPEventContext *ec)
 290 {
 291     SPTweakContext *tc = SP_TWEAK_CONTEXT(ec);
 292
 293     if (((SPEventContextClass *) parent_class)->setup)
 294         ((SPEventContextClass *) parent_class)->setup(ec);
 295
 296     {
 297         /* TODO: have a look at sp_dyna_draw_context_setup where the same is done.. generalize? at least make it an arcto! */
 298         SPCurve *c = new SPCurve();
 299         const double C1 = 0.552;
 300         c->moveto(-1,0);
 301         c->curveto(-1, C1, -C1, 1, 0, 1 );
 302         c->curveto(C1, 1, 1, C1, 1, 0 );
 303         c->curveto(1, -C1, C1, -1, 0, -1 );
 304         c->curveto(-C1, -1, -1, -C1, -1, 0 );
 305         c->closepath();
 306         tc->dilate_area = sp_canvas_bpath_new(sp_desktop_controls(ec->desktop), c);
 307         c->unref();
 308         sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(tc->dilate_area), 0x00000000,(SPWindRule)0);
 309         sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(tc->dilate_area), 0xff9900ff, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
 310         sp_canvas_item_hide(tc->dilate_area);
 311     }
 312
 313     tc->is_drawing = false;
 314
 315     tc->_message_context = new Inkscape::MessageContext((ec->desktop)->messageStack());
 316
 317     sp_event_context_read(ec, "width");
 318     sp_event_context_read(ec, "mode");
 319     sp_event_context_read(ec, "fidelity");
 320     sp_event_context_read(ec, "force");
 321     sp_event_context_read(ec, "usepressure");
 322     sp_event_context_read(ec, "doh");
 323     sp_event_context_read(ec, "dol");
 324     sp_event_context_read(ec, "dos");
 325     sp_event_context_read(ec, "doo");
 326
 327     tc->style_set_connection = ec->desktop->connectSetStyle( // catch style-setting signal in this tool
 328         sigc::bind(sigc::ptr_fun(&sp_tweak_context_style_set), tc)
 329     );
 330
 331     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 332     if (prefs->getBool("/tools/tweak/selcue")) {
 333         ec->enableSelectionCue();
 334     }
 335
 336     if (prefs->getBool("/tools/tweak/gradientdrag")) {
 337         ec->enableGrDrag();
 338     }
 339 }
 340
 341 static void
 342 sp_tweak_context_set(SPEventContext *ec, Inkscape::Preferences::Entry *val)
 343 {
 344     SPTweakContext *tc = SP_TWEAK_CONTEXT(ec);
 345     Glib::ustring path = val->getEntryName();
 346
 347     if (path == "width") {
 348         tc->width = CLAMP(val->getDouble(0.1), -1000.0, 1000.0);
 349     } else if (path == "mode") {
 350         tc->mode = val->getInt();
 351         sp_tweak_update_cursor(tc, false);
 352     } else if (path == "fidelity") {
 353         tc->fidelity = CLAMP(val->getDouble(), 0.0, 1.0);
 354     } else if (path == "force") {
 355         tc->force = CLAMP(val->getDouble(1.0), 0, 1.0);
 356     } else if (path == "usepressure") {
 357         tc->usepressure = val->getBool();
 358     } else if (path == "doh") {
 359         tc->do_h = val->getBool();
 360     } else if (path == "dos") {
 361         tc->do_s = val->getBool();
 362     } else if (path == "dol") {
 363         tc->do_l = val->getBool();
 364     } else if (path == "doo") {
 365         tc->do_o = val->getBool();
 366     }
 367 }
 368
 369 static void
 370 sp_tweak_extinput(SPTweakContext *tc, GdkEvent *event)
 371 {
 372     if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &tc->pressure))
 373         tc->pressure = CLAMP (tc->pressure, TC_MIN_PRESSURE, TC_MAX_PRESSURE);
 374     else
 375         tc->pressure = TC_DEFAULT_PRESSURE;
 376 }
 377
 378 double
 379 get_dilate_radius (SPTweakContext *tc)
 380 {
 381     // 10 times the pen width:
 382     return 500 * tc->width/SP_EVENT_CONTEXT(tc)->desktop->current_zoom();
 383 }
 384
 385 double
 386 get_path_force (SPTweakContext *tc)
 387 {
 388     double force = 8 * (tc->usepressure? tc->pressure : TC_DEFAULT_PRESSURE)
 389         /sqrt(SP_EVENT_CONTEXT(tc)->desktop->current_zoom());
 390     if (force > 3) {
 391         force += 4 * (force - 3);
 392     }
 393     return force * tc->force;
 394 }
 395
 396 double
 397 get_move_force (SPTweakContext *tc)
 398 {
 399     double force = (tc->usepressure? tc->pressure : TC_DEFAULT_PRESSURE);
 400     return force * tc->force;
 401 }
 402
 403 bool
 404 sp_tweak_dilate_recursive (Inkscape::Selection *selection, SPItem *item, Geom::Point p, Geom::Point vector, gint mode, double radius, double force, double fidelity, bool reverse)
 405 {
 406     bool did = false;
 407
 408     if (SP_IS_BOX3D(item) && !is_transform_mode(mode) && !is_color_mode(mode)) {
 409         // convert 3D boxes to ordinary groups before tweaking their shapes
 410         item = SP_ITEM(box3d_convert_to_group(SP_BOX3D(item)));
 411         selection->add(item);
 412     }
 413
 414     if (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item)) {
 415         GSList *items = g_slist_prepend (NULL, item);
 416         GSList *selected = NULL;
 417         GSList *to_select = NULL;
 418         Document *doc = SP_OBJECT_DOCUMENT(item);
 419         sp_item_list_to_curves (items, &selected, &to_select);
 420         g_slist_free (items);
 421         SPObject* newObj = doc->getObjectByRepr((Inkscape::XML::Node *) to_select->data);
 422         g_slist_free (to_select);
 423         item = (SPItem *) newObj;
 424         selection->add(item);
 425     }
 426
 427     if (SP_IS_GROUP(item) && !SP_IS_BOX3D(item)) {
 428         GSList *children = NULL;
 429         for (SPObject *child = sp_object_first_child(SP_OBJECT(item)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
 430             if (SP_IS_ITEM(child)) {
 431                 children = g_slist_prepend(children, child);
 432             }
 433         }
 434
 435         for (GSList *i = children; i; i = i->next) {
 436             SPItem *child = SP_ITEM(i->data);
 437             if (sp_tweak_dilate_recursive (selection, SP_ITEM(child), p, vector, mode, radius, force, fidelity, reverse))
 438                 did = true;
 439         }
 440
 441         g_slist_free(children);
 442
 443     } else {
 444         if (mode == TWEAK_MODE_MOVE) {
 445
 446             Geom::OptRect a = item->getBounds(sp_item_i2doc_affine(item));
 447             if (a) {
 448                 double x = Geom::L2(a->midpoint() - p)/radius;
 449                 if (a->contains(p)) x = 0;
 450                 if (x < 1) {
 451                     Geom::Point move = force * 0.5 * (cos(M_PI * x) + 1) * vector;
 452                     sp_item_move_rel(item, Geom::Translate(move[Geom::X], -move[Geom::Y]));
 453                     did = true;
 454                 }
 455             }
 456
 457         } else if (mode == TWEAK_MODE_MOVE_IN_OUT) {
 458
 459             Geom::OptRect a = item->getBounds(sp_item_i2doc_affine(item));
 460             if (a) {
 461                 double x = Geom::L2(a->midpoint() - p)/radius;
 462                 if (a->contains(p)) x = 0;
 463                 if (x < 1) {
 464                     Geom::Point move = force * 0.5 * (cos(M_PI * x) + 1) *
 465                         (reverse? (a->midpoint() - p) : (p - a->midpoint()));
 466                     sp_item_move_rel(item, Geom::Translate(move[Geom::X], -move[Geom::Y]));
 467                     did = true;
 468                 }
 469             }
 470
 471         } else if (mode == TWEAK_MODE_MOVE_JITTER) {
 472
 473             Geom::OptRect a = item->getBounds(sp_item_i2doc_affine(item));
 474             if (a) {
 475                 double dp = g_random_double_range(0, M_PI*2);
 476                 double dr = g_random_double_range(0, radius);
 477                 double x = Geom::L2(a->midpoint() - p)/radius;
 478                 if (a->contains(p)) x = 0;
 479                 if (x < 1) {
 480                     Geom::Point move = force * 0.5 * (cos(M_PI * x) + 1) * Geom::Point(cos(dp)*dr, sin(dp)*dr);
 481                     sp_item_move_rel(item, Geom::Translate(move[Geom::X], -move[Geom::Y]));
 482                     did = true;
 483                 }
 484             }
 485
 486         } else if (mode == TWEAK_MODE_SCALE) {
 487
 488             Geom::OptRect a = item->getBounds(sp_item_i2doc_affine(item));
 489             if (a) {
 490                 double x = Geom::L2(a->midpoint() - p)/radius;
 491                 if (a->contains(p)) x = 0;
 492                 if (x < 1) {
 493                     double scale = 1 + (reverse? force : -force) * 0.05 * (cos(M_PI * x) + 1);
 494                     sp_item_scale_rel(item, Geom::Scale(scale, scale));
 495                     did = true;
 496                 }
 497             }
 498
 499         } else if (mode == TWEAK_MODE_ROTATE) {
 500
 501             Geom::OptRect a = item->getBounds(sp_item_i2doc_affine(item));
 502             if (a) {
 503                 double x = Geom::L2(a->midpoint() - p)/radius;
 504                 if (a->contains(p)) x = 0;
 505                 if (x < 1) {
 506                     double angle = (reverse? force : -force) * 0.05 * (cos(M_PI * x) + 1) * M_PI;
 507                     sp_item_rotate_rel(item, Geom::Rotate(angle));
 508                     did = true;
 509                 }
 510             }
 511
 512         } else if (mode == TWEAK_MODE_MORELESS) {
 513
 514             Geom::OptRect a = item->getBounds(sp_item_i2doc_affine(item));
 515             if (a) {
 516                 double x = Geom::L2(a->midpoint() - p)/radius;
 517                 if (a->contains(p)) x = 0;
 518                 if (x < 1) {
 519                     double prob = force * 0.5 * (cos(M_PI * x) + 1);
 520                     double chance = g_random_double_range(0, 1);
 521                     if (chance <= prob) {
 522                         if (reverse) { // delete
 523                             sp_object_ref(SP_OBJECT(item), NULL);
 524                             SP_OBJECT(item)->deleteObject(true, true);
 525                             sp_object_unref(SP_OBJECT(item), NULL);
 526                         } else { // duplicate
 527                             Document *doc = SP_OBJECT_DOCUMENT(item);
 528                             Inkscape::XML::Document* xml_doc = sp_document_repr_doc(doc);
 529                             Inkscape::XML::Node *old_repr = SP_OBJECT_REPR(item);
 530                             SPObject *old_obj = doc->getObjectByRepr(old_repr);
 531                             Inkscape::XML::Node *parent = old_repr->parent();
 532                             Inkscape::XML::Node *copy = old_repr->duplicate(xml_doc);
 533                             parent->appendChild(copy);
 534                             SPObject *new_obj = doc->getObjectByRepr(copy);
 535                             if (selection->includes(old_obj)) {
 536                                 selection->add(new_obj);
 537                             }
 538                             Inkscape::GC::release(copy);
 539                         }
 540                         did = true;
 541                     }
 542                 }
 543             }
 544
 545         } else if (SP_IS_PATH(item) || SP_IS_SHAPE(item)) {
 546
 547         Inkscape::XML::Node *newrepr = NULL;
 548         gint pos = 0;
 549         Inkscape::XML::Node *parent = NULL;
 550         char const *id = NULL;
 551         if (!SP_IS_PATH(item)) {
 552             newrepr = sp_selected_item_to_curved_repr(item, 0);
 553             if (!newrepr)
 554                 return false;
 555
 556             // remember the position of the item
 557             pos = SP_OBJECT_REPR(item)->position();
 558             // remember parent
 559             parent = SP_OBJECT_REPR(item)->parent();
 560             // remember id
 561             id = SP_OBJECT_REPR(item)->attribute("id");
 562         }
 563
 564
 565         // skip those paths whose bboxes are entirely out of reach with our radius
 566         Geom::OptRect bbox = item->getBounds(sp_item_i2doc_affine(item));
 567         if (bbox) {
 568             bbox->expandBy(radius);
 569             if (!bbox->contains(p)) {
 570                 return false;
 571             }
 572         }
 573
 574         Path *orig = Path_for_item(item, false);
 575         if (orig == NULL) {
 576             return false;
 577         }
 578
 579         Path *res = new Path;
 580         res->SetBackData(false);
 581
 582         Shape *theShape = new Shape;
 583         Shape *theRes = new Shape;
 584         Geom::Matrix i2doc(sp_item_i2doc_affine(item));
 585
 586         orig->ConvertWithBackData((0.08 - (0.07 * fidelity)) / i2doc.descrim()); // default 0.059
 587         orig->Fill(theShape, 0);
 588
 589         SPCSSAttr *css = sp_repr_css_attr(SP_OBJECT_REPR(item), "style");
 590         gchar const *val = sp_repr_css_property(css, "fill-rule", NULL);
 591         if (val && strcmp(val, "nonzero") == 0)
 592         {
 593             theRes->ConvertToShape(theShape, fill_nonZero);
 594         }
 595         else if (val && strcmp(val, "evenodd") == 0)
 596         {
 597             theRes->ConvertToShape(theShape, fill_oddEven);
 598         }
 599         else
 600         {
 601             theRes->ConvertToShape(theShape, fill_nonZero);
 602         }
 603
 604         if (Geom::L2(vector) != 0)
 605             vector = 1/Geom::L2(vector) * vector;
 606
 607         bool did_this = false;
 608         if (mode == TWEAK_MODE_SHRINK_GROW) {
 609             if (theShape->MakeTweak(tweak_mode_grow, theRes,
 610                                  reverse? force : -force,
 611                                  join_straight, 4.0,
 612                                  true, p, Geom::Point(0,0), radius, &i2doc) == 0) // 0 means the shape was actually changed
 613               did_this = true;
 614         } else if (mode == TWEAK_MODE_ATTRACT_REPEL) {
 615             if (theShape->MakeTweak(tweak_mode_repel, theRes,
 616                                  reverse? force : -force,
 617                                  join_straight, 4.0,
 618                                  true, p, Geom::Point(0,0), radius, &i2doc) == 0)
 619               did_this = true;
 620         } else if (mode == TWEAK_MODE_PUSH) {
 621             if (theShape->MakeTweak(tweak_mode_push, theRes,
 622                                  1.0,
 623                                  join_straight, 4.0,
 624                                  true, p, force*2*vector, radius, &i2doc) == 0)
 625               did_this = true;
 626         } else if (mode == TWEAK_MODE_ROUGHEN) {
 627             if (theShape->MakeTweak(tweak_mode_roughen, theRes,
 628                                  force,
 629                                  join_straight, 4.0,
 630                                  true, p, Geom::Point(0,0), radius, &i2doc) == 0)
 631               did_this = true;
 632         }
 633
 634         // the rest only makes sense if we actually changed the path
 635         if (did_this) {
 636             theRes->ConvertToShape(theShape, fill_positive);
 637
 638             res->Reset();
 639             theRes->ConvertToForme(res);
 640
 641             double th_max = (0.6 - 0.59*sqrt(fidelity)) / i2doc.descrim();
 642             double threshold = MAX(th_max, th_max*force);
 643             res->ConvertEvenLines(threshold);
 644             res->Simplify(threshold / (selection->desktop()->current_zoom()));
 645
 646             if (newrepr) { // converting to path, need to replace the repr
 647                 bool is_selected = selection->includes(item);
 648                 if (is_selected)
 649                     selection->remove(item);
 650
 651                 // It's going to resurrect, so we delete without notifying listeners.
 652                 SP_OBJECT(item)->deleteObject(false);
 653
 654                 // restore id
 655                 newrepr->setAttribute("id", id);
 656                 // add the new repr to the parent
 657                 parent->appendChild(newrepr);
 658                 // move to the saved position
 659                 newrepr->setPosition(pos > 0 ? pos : 0);
 660
 661                 if (is_selected)
 662                     selection->add(newrepr);
 663             }
 664
 665             if (res->descr_cmd.size() > 1) {
 666                 gchar *str = res->svg_dump_path();
 667                 if (newrepr) {
 668                     newrepr->setAttribute("d", str);
 669                 } else {
 670                     if (SP_IS_LPE_ITEM(item) && sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(item))) {
 671                         SP_OBJECT_REPR(item)->setAttribute("inkscape:original-d", str);
 672                     } else {
 673                         SP_OBJECT_REPR(item)->setAttribute("d", str);
 674                     }
 675                 }
 676                 g_free(str);
 677             } else {
 678                 // TODO: if there's 0 or 1 node left, delete this path altogether
 679             }
 680
 681             if (newrepr) {
 682                 Inkscape::GC::release(newrepr);
 683                 newrepr = NULL;
 684             }
 685         }
 686
 687         delete theShape;
 688         delete theRes;
 689         delete orig;
 690         delete res;
 691
 692         if (did_this)
 693             did = true;
 694     }
 695
 696     }
 697
 698     return did;
 699 }
 700
 701 void
 702 tweak_colorpaint (float *color, guint32 goal, double force, bool do_h, bool do_s, bool do_l)
 703 {
 704     float rgb_g[3];
 705
 706     if (!do_h || !do_s || !do_l) {
 707         float hsl_g[3];
 708         sp_color_rgb_to_hsl_floatv (hsl_g, SP_RGBA32_R_F(goal), SP_RGBA32_G_F(goal), SP_RGBA32_B_F(goal));
 709         float hsl_c[3];
 710         sp_color_rgb_to_hsl_floatv (hsl_c, color[0], color[1], color[2]);
 711         if (!do_h)
 712             hsl_g[0] = hsl_c[0];
 713         if (!do_s)
 714             hsl_g[1] = hsl_c[1];
 715         if (!do_l)
 716             hsl_g[2] = hsl_c[2];
 717         sp_color_hsl_to_rgb_floatv (rgb_g, hsl_g[0], hsl_g[1], hsl_g[2]);
 718     } else {
 719         rgb_g[0] = SP_RGBA32_R_F(goal);
 720         rgb_g[1] = SP_RGBA32_G_F(goal);
 721         rgb_g[2] = SP_RGBA32_B_F(goal);
 722     }
 723
 724     for (int i = 0; i < 3; i++) {
 725         double d = rgb_g[i] - color[i];
 726         color[i] += d * force;
 727     }
 728 }
 729
 730 void
 731 tweak_colorjitter (float *color, double force, bool do_h, bool do_s, bool do_l)
 732 {
 733     float hsl_c[3];
 734     sp_color_rgb_to_hsl_floatv (hsl_c, color[0], color[1], color[2]);
 735
 736     if (do_h) {
 737         hsl_c[0] += g_random_double_range(-0.5, 0.5) * force;
 738         if (hsl_c[0] > 1)
 739             hsl_c[0] -= 1;
 740         if (hsl_c[0] < 0)
 741             hsl_c[0] += 1;
 742     }
 743     if (do_s) {
 744         hsl_c[1] += g_random_double_range(-hsl_c[1], 1 - hsl_c[1]) * force;
 745     }
 746     if (do_l) {
 747         hsl_c[2] += g_random_double_range(-hsl_c[2], 1 - hsl_c[2]) * force;
 748     }
 749
 750     sp_color_hsl_to_rgb_floatv (color, hsl_c[0], hsl_c[1], hsl_c[2]);
 751 }
 752
 753 void
 754 tweak_color (guint mode, float *color, guint32 goal, double force, bool do_h, bool do_s, bool do_l)
 755 {
 756     if (mode == TWEAK_MODE_COLORPAINT) {
 757         tweak_colorpaint (color, goal, force, do_h, do_s, do_l);
 758     } else if (mode == TWEAK_MODE_COLORJITTER) {
 759         tweak_colorjitter (color, force, do_h, do_s, do_l);
 760     }
 761 }
 762
 763 void
 764 tweak_opacity (guint mode, SPIScale24 *style_opacity, double opacity_goal, double force)
 765 {
 766     double opacity = SP_SCALE24_TO_FLOAT (style_opacity->value);
 767
 768     if (mode == TWEAK_MODE_COLORPAINT) {
 769         double d = opacity_goal - opacity;
 770         opacity += d * force;
 771     } else if (mode == TWEAK_MODE_COLORJITTER) {
 772         opacity += g_random_double_range(-opacity, 1 - opacity) * force;
 773     }
 774
 775     style_opacity->value = SP_SCALE24_FROM_FLOAT(opacity);
 776 }
 777
 778
 779 double
 780 tweak_profile (double dist, double radius)
 781 {
 782     if (radius == 0)
 783         return 0;
 784     double x = dist / radius;
 785     double alpha = 1;
 786     if (x >= 1) {
 787         return 0;
 788     } else if (x <= 0) {
 789         return 1;
 790     } else {
 791         return (0.5 * cos (M_PI * (pow(x, alpha))) + 0.5);
 792     }
 793 }
 794
 795 void
 796 tweak_colors_in_gradient (SPItem *item, bool fill_or_stroke,
 797                           guint32 const rgb_goal, Geom::Point p_w, double radius, double force, guint mode,
 798                           bool do_h, bool do_s, bool do_l, bool /*do_o*/)
 799 {
 800     SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);
 801
 802     if (!gradient || !SP_IS_GRADIENT(gradient))
 803         return;
 804
 805     Geom::Matrix i2d (sp_item_i2doc_affine (item));
 806     Geom::Point p = p_w * i2d.inverse();
 807     p *= (gradient->gradientTransform).inverse();
 808     // now p is in gradient's original coordinates
 809
 810     double pos = 0;
 811     double r = 0;
 812     if (SP_IS_LINEARGRADIENT(gradient)) {
 813         SPLinearGradient *lg = SP_LINEARGRADIENT(gradient);
 814
 815         Geom::Point p1(lg->x1.computed, lg->y1.computed);
 816         Geom::Point p2(lg->x2.computed, lg->y2.computed);
 817         Geom::Point pdiff(p2 - p1);
 818         double vl = Geom::L2(pdiff);
 819
 820         // This is the matrix which moves and rotates the gradient line
 821         // so it's oriented along the X axis:
 822         Geom::Matrix norm = Geom::Matrix(Geom::Translate(-p1)) * Geom::Matrix(Geom::Rotate(-atan2(pdiff[Geom::Y], pdiff[Geom::X])));
 823
 824         // Transform the mouse point by it to find out its projection onto the gradient line:
 825         Geom::Point pnorm = p * norm;
 826
 827         // Scale its X coordinate to match the length of the gradient line:
 828         pos = pnorm[Geom::X] / vl;
 829         // Calculate radius in lenfth-of-gradient-line units
 830         r = radius / vl;
 831
 832     } else if (SP_IS_RADIALGRADIENT(gradient)) {
 833         SPRadialGradient *rg = SP_RADIALGRADIENT(gradient);
 834         Geom::Point c (rg->cx.computed, rg->cy.computed);
 835         pos = Geom::L2(p - c) / rg->r.computed;
 836         r = radius / rg->r.computed;
 837     }
 838
 839     // Normalize pos to 0..1, taking into accound gradient spread:
 840     double pos_e = pos;
 841     if (gradient->spread == SP_GRADIENT_SPREAD_PAD) {
 842         if (pos > 1)
 843             pos_e = 1;
 844         if (pos < 0)
 845             pos_e = 0;
 846     } else if (gradient->spread == SP_GRADIENT_SPREAD_REPEAT) {
 847         if (pos > 1 || pos < 0)
 848             pos_e = pos - floor(pos);
 849     } else if (gradient->spread == SP_GRADIENT_SPREAD_REFLECT) {
 850         if (pos > 1 || pos < 0) {
 851             bool odd = ((int)(floor(pos)) % 2 == 1);
 852             pos_e = pos - floor(pos);
 853             if (odd)
 854                 pos_e = 1 - pos_e;
 855         }
 856     }
 857
 858     SPGradient *vector = sp_gradient_get_forked_vector_if_necessary(gradient, false);
 859
 860     double offset_l = 0;
 861     double offset_h = 0;
 862     SPObject *child_prev = NULL;
 863     for (SPObject *child = sp_object_first_child(vector);
 864          child != NULL; child = SP_OBJECT_NEXT(child)) {
 865         if (!SP_IS_STOP(child))
 866             continue;
 867         SPStop *stop = SP_STOP (child);
 868
 869         offset_h = stop->offset;
 870
 871         if (child_prev) {
 872
 873             if (offset_h - offset_l > r && pos_e >= offset_l && pos_e <= offset_h) {
 874                 // the summit falls in this interstop, and the radius is small,
 875                 // so it only affects the ends of this interstop;
 876                 // distribute the force between the two endstops so that they
 877                 // get all the painting even if they are not touched by the brush
 878                 tweak_color (mode, stop->specified_color.v.c, rgb_goal,
 879                                   force * (pos_e - offset_l) / (offset_h - offset_l),
 880                                   do_h, do_s, do_l);
 881                 tweak_color (mode, SP_STOP(child_prev)->specified_color.v.c, rgb_goal,
 882                                   force * (offset_h - pos_e) / (offset_h - offset_l),
 883                                   do_h, do_s, do_l);
 884                 SP_OBJECT(stop)->updateRepr();
 885                 child_prev->updateRepr();
 886                 break;
 887             } else {
 888                 // wide brush, may affect more than 2 stops,
 889                 // paint each stop by the force from the profile curve
 890                 if (offset_l <= pos_e && offset_l > pos_e - r) {
 891                     tweak_color (mode, SP_STOP(child_prev)->specified_color.v.c, rgb_goal,
 892                                  force * tweak_profile (fabs (pos_e - offset_l), r),
 893                                  do_h, do_s, do_l);
 894                     child_prev->updateRepr();
 895                 }
 896
 897                 if (offset_h >= pos_e && offset_h < pos_e + r) {
 898                     tweak_color (mode, stop->specified_color.v.c, rgb_goal,
 899                                  force * tweak_profile (fabs (pos_e - offset_h), r),
 900                                  do_h, do_s, do_l);
 901                     SP_OBJECT(stop)->updateRepr();
 902                 }
 903             }
 904         }
 905
 906         offset_l = offset_h;
 907         child_prev = child;
 908     }
 909 }
 910
 911 bool
 912 sp_tweak_color_recursive (guint mode, SPItem *item, SPItem *item_at_point,
 913                           guint32 fill_goal, bool do_fill,
 914                           guint32 stroke_goal, bool do_stroke,
 915                           float opacity_goal, bool do_opacity,
 916                           bool do_blur, bool reverse,
 917                           Geom::Point p, double radius, double force,
 918                           bool do_h, bool do_s, bool do_l, bool do_o)
 919 {
 920     bool did = false;
 921
 922     if (SP_IS_GROUP(item)) {
 923         for (SPObject *child = sp_object_first_child(SP_OBJECT(item)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
 924             if (SP_IS_ITEM(child)) {
 925                 if (sp_tweak_color_recursive (mode, SP_ITEM(child), item_at_point,
 926                                           fill_goal, do_fill,
 927                                           stroke_goal, do_stroke,
 928                                           opacity_goal, do_opacity,
 929                                           do_blur, reverse,
 930                                           p, radius, force, do_h, do_s, do_l, do_o))
 931                     did = true;
 932             }
 933         }
 934
 935     } else {
 936         SPStyle *style = SP_OBJECT_STYLE(item);
 937         if (!style) {
 938             return false;
 939         }
 940         Geom::OptRect bbox = item->getBounds(sp_item_i2doc_affine(item),
 941                                                         SPItem::GEOMETRIC_BBOX);
 942         if (!bbox) {
 943             return false;
 944         }
 945
 946         Geom::Rect brush(p - Geom::Point(radius, radius), p + Geom::Point(radius, radius));
 947
 948         Geom::Point center = bbox->midpoint();
 949         double this_force;
 950
 951 // if item == item_at_point, use max force
 952         if (item == item_at_point) {
 953             this_force = force;
 954 // else if no overlap of bbox and brush box, skip:
 955         } else if (!bbox->intersects(brush)) {
 956             return false;
 957 //TODO:
 958 // else if object > 1.5 brush: test 4/8/16 points in the brush on hitting the object, choose max
 959         //} else if (bbox->maxExtent() > 3 * radius) {
 960         //}
 961 // else if object > 0.5 brush: test 4 corners of bbox and center on being in the brush, choose max
 962 // else if still smaller, then check only the object center:
 963         } else {
 964             this_force = force * tweak_profile (Geom::L2 (p - center), radius);
 965         }
 966
 967         if (this_force > 0.002) {
 968
 969             if (do_blur) {
 970                 Geom::OptRect bbox = item->getBounds(sp_item_i2doc_affine(item),
 971                                                         SPItem::GEOMETRIC_BBOX);
 972                 if (!bbox) {
 973                     return did;
 974                 }
 975
 976                 double blur_now = 0;
 977                 Geom::Matrix i2d = sp_item_i2d_affine (item);
 978                 if (style->filter.set && style->getFilter()) {
 979                     //cycle through filter primitives
 980                     SPObject *primitive_obj = style->getFilter()->children;
 981                     while (primitive_obj) {
 982                         if (SP_IS_FILTER_PRIMITIVE(primitive_obj)) {
 983                             SPFilterPrimitive *primitive = SP_FILTER_PRIMITIVE(primitive_obj);
 984                             //if primitive is gaussianblur
 985                             if(SP_IS_GAUSSIANBLUR(primitive)) {
 986                                 SPGaussianBlur * spblur = SP_GAUSSIANBLUR(primitive);
 987                                 float num = spblur->stdDeviation.getNumber();
 988                                 blur_now += num * i2d.descrim(); // sum all blurs in the filter
 989                             }
 990                         }
 991                         primitive_obj = primitive_obj->next;
 992                     }
 993                 }
 994                 double perimeter = bbox->dimensions()[Geom::X] + bbox->dimensions()[Geom::Y];
 995                 blur_now = blur_now / perimeter;
 996
 997                 double blur_new;
 998                 if (reverse)
 999                     blur_new = blur_now - 0.06 * force;
1000                 else
1001                     blur_new = blur_now + 0.06 * force;
1002                 if (blur_new < 0.0005 && blur_new < blur_now) {
1003                     blur_new = 0;
1004                 }
1005
1006                 if (blur_new == 0) {
1007                     remove_filter(item, false);
1008                 } else {
1009                     double radius = blur_new * perimeter;
1010                     SPFilter *filter = modify_filter_gaussian_blur_from_item(SP_OBJECT_DOCUMENT(item), item, radius);
1011
1012                     sp_style_set_property_url(item, "filter", filter, false);
1013                 }
1014                 return true; // do not do colors, blur is a separate mode
1015             }
1016
1017             if (do_fill) {
1018                 if (style->fill.isPaintserver()) {
1019                     tweak_colors_in_gradient (item, true, fill_goal, p, radius, this_force, mode, do_h, do_s, do_l, do_o);
1020                     did = true;
1021                 } else if (style->fill.isColor()) {
1022                     tweak_color (mode, style->fill.value.color.v.c, fill_goal, this_force, do_h, do_s, do_l);
1023                     item->updateRepr();
1024                     did = true;
1025                 }
1026             }
1027             if (do_stroke) {
1028                 if (style->stroke.isPaintserver()) {
1029                     tweak_colors_in_gradient (item, false, stroke_goal, p, radius, this_force, mode, do_h, do_s, do_l, do_o);
1030                     did = true;
1031                 } else if (style->stroke.isColor()) {
1032                     tweak_color (mode, style->stroke.value.color.v.c, stroke_goal, this_force, do_h, do_s, do_l);
1033                     item->updateRepr();
1034                     did = true;
1035                 }
1036             }
1037             if (do_opacity && do_o) {
1038                 tweak_opacity (mode, &style->opacity, opacity_goal, this_force);
1039             }
1040         }
1041     }
1042
1043     return did;
1044 }
1045
1046
1047 bool
1048 sp_tweak_dilate (SPTweakContext *tc, Geom::Point event_p, Geom::Point p, Geom::Point vector, bool reverse)
1049 {
1050     Inkscape::Selection *selection = sp_desktop_selection(SP_EVENT_CONTEXT(tc)->desktop);
1051     SPDesktop *desktop = SP_EVENT_CONTEXT(tc)->desktop;
1052
1053     if (selection->isEmpty()) {
1054         return false;
1055     }
1056
1057     bool did = false;
1058     double radius = get_dilate_radius(tc);
1059
1060     SPItem *item_at_point = SP_EVENT_CONTEXT(tc)->desktop->item_at_point(event_p, TRUE);
1061
1062     bool do_fill = false, do_stroke = false, do_opacity = false;
1063     guint32 fill_goal = sp_desktop_get_color_tool(desktop, "/tools/tweak", true, &do_fill);
1064     guint32 stroke_goal = sp_desktop_get_color_tool(desktop, "/tools/tweak", false, &do_stroke);
1065     double opacity_goal = sp_desktop_get_master_opacity_tool(desktop, "/tools/tweak", &do_opacity);
1066     if (reverse) {
1067 #if 0
1068         // HSL inversion
1069         float hsv[3];
1070         float rgb[3];
1071         sp_color_rgb_to_hsv_floatv (hsv,
1072                                     SP_RGBA32_R_F(fill_goal),
1073                                     SP_RGBA32_G_F(fill_goal),
1074                                     SP_RGBA32_B_F(fill_goal));
1075         sp_color_hsv_to_rgb_floatv (rgb, hsv[0]<.5? hsv[0]+.5 : hsv[0]-.5, 1 - hsv[1], 1 - hsv[2]);
1076         fill_goal = SP_RGBA32_F_COMPOSE(rgb[0], rgb[1], rgb[2], 1);
1077         sp_color_rgb_to_hsv_floatv (hsv,
1078                                     SP_RGBA32_R_F(stroke_goal),
1079                                     SP_RGBA32_G_F(stroke_goal),
1080                                     SP_RGBA32_B_F(stroke_goal));
1081         sp_color_hsv_to_rgb_floatv (rgb, hsv[0]<.5? hsv[0]+.5 : hsv[0]-.5, 1 - hsv[1], 1 - hsv[2]);
1082         stroke_goal = SP_RGBA32_F_COMPOSE(rgb[0], rgb[1], rgb[2], 1);
1083 #else
1084         // RGB inversion
1085         fill_goal = SP_RGBA32_U_COMPOSE(
1086             (255 - SP_RGBA32_R_U(fill_goal)),
1087             (255 - SP_RGBA32_G_U(fill_goal)),
1088             (255 - SP_RGBA32_B_U(fill_goal)),
1089             (255 - SP_RGBA32_A_U(fill_goal)));
1090         stroke_goal = SP_RGBA32_U_COMPOSE(
1091             (255 - SP_RGBA32_R_U(stroke_goal)),
1092             (255 - SP_RGBA32_G_U(stroke_goal)),
1093             (255 - SP_RGBA32_B_U(stroke_goal)),
1094             (255 - SP_RGBA32_A_U(stroke_goal)));
1095 #endif
1096         opacity_goal = 1 - opacity_goal;
1097     }
1098
1099     double path_force = get_path_force(tc);
1100     if (radius == 0 || path_force == 0) {
1101         return false;
1102     }
1103     double move_force = get_move_force(tc);
1104     double color_force = MIN(sqrt(path_force)/20.0, 1);
1105
1106     for (GSList *items = g_slist_copy((GSList *) selection->itemList());
1107          items != NULL;
1108          items = items->next) {
1109
1110         SPItem *item = (SPItem *) items->data;
1111
1112         if (is_color_mode (tc->mode)) {
1113             if (do_fill || do_stroke || do_opacity) {
1114                 if (sp_tweak_color_recursive (tc->mode, item, item_at_point,
1115                                           fill_goal, do_fill,
1116                                           stroke_goal, do_stroke,
1117                                           opacity_goal, do_opacity,
1118                                           tc->mode == TWEAK_MODE_BLUR, reverse,
1119                                           p, radius, color_force, tc->do_h, tc->do_s, tc->do_l, tc->do_o))
1120                 did = true;
1121             }
1122         } else if (is_transform_mode(tc->mode)) {
1123             if (sp_tweak_dilate_recursive (selection, item, p, vector, tc->mode, radius, move_force, tc->fidelity, reverse))
1124                 did = true;
1125         } else {
1126             if (sp_tweak_dilate_recursive (selection, item, p, vector, tc->mode, radius, path_force, tc->fidelity, reverse))
1127                 did = true;
1128         }
1129     }
1130
1131     return did;
1132 }
1133
1134 void
1135 sp_tweak_update_area (SPTweakContext *tc)
1136 {
1137         double radius = get_dilate_radius(tc);
1138         Geom::Matrix const sm (Geom::Scale(radius, radius) * Geom::Translate(SP_EVENT_CONTEXT(tc)->desktop->point()));
1139         sp_canvas_item_affine_absolute(tc->dilate_area, sm);
1140         sp_canvas_item_show(tc->dilate_area);
1141 }
1142
1143 void
1144 sp_tweak_switch_mode (SPTweakContext *tc, gint mode, bool with_shift)
1145 {
1146     SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue ("tweak_tool_mode", mode);
1147     // need to set explicitly, because the prefs may not have changed by the previous
1148     tc->mode = mode;
1149     sp_tweak_update_cursor (tc, with_shift);
1150 }
1151
1152 void
1153 sp_tweak_switch_mode_temporarily (SPTweakContext *tc, gint mode, bool with_shift)
1154 {
1155     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1156    // Juggling about so that prefs have the old value but tc->mode and the button show new mode:
1157    gint now_mode = prefs->getInt("/tools/tweak/mode", 0);
1158    SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue ("tweak_tool_mode", mode);
1159    // button has changed prefs, restore
1160    prefs->setInt("/tools/tweak/mode", now_mode);
1161    // changing prefs changed tc->mode, restore back :)
1162    tc->mode = mode;
1163    sp_tweak_update_cursor (tc, with_shift);
1164 }
1165
1166 gint
1167 sp_tweak_context_root_handler(SPEventContext *event_context,
1168                                   GdkEvent *event)
1169 {
1170     SPTweakContext *tc = SP_TWEAK_CONTEXT(event_context);
1171     SPDesktop *desktop = event_context->desktop;
1172
1173     gint ret = FALSE;
1174
1175     switch (event->type) {
1176         case GDK_ENTER_NOTIFY:
1177             sp_canvas_item_show(tc->dilate_area);
1178             break;
1179         case GDK_LEAVE_NOTIFY:
1180             sp_canvas_item_hide(tc->dilate_area);
1181             break;
1182         case GDK_BUTTON_PRESS:
1183             if (event->button.button == 1 && !event_context->space_panning) {
1184
1185                 if (Inkscape::have_viable_layer(desktop, tc->_message_context) == false) {
1186                     return TRUE;
1187                 }
1188
1189                 Geom::Point const button_w(event->button.x,
1190                                          event->button.y);
1191                 Geom::Point const button_dt(desktop->w2d(button_w));
1192                 tc->last_push = desktop->dt2doc(button_dt);
1193
1194                 sp_tweak_extinput(tc, event);
1195
1196                 sp_canvas_force_full_redraw_after_interruptions(desktop->canvas, 3);
1197                 tc->is_drawing = true;
1198                 tc->is_dilating = true;
1199                 tc->has_dilated = false;
1200
1201                 ret = TRUE;
1202             }
1203             break;
1204         case GDK_MOTION_NOTIFY:
1205         {
1206             Geom::Point const motion_w(event->motion.x,
1207                                      event->motion.y);
1208             Geom::Point motion_dt(desktop->w2d(motion_w));
1209             Geom::Point motion_doc(desktop->dt2doc(motion_dt));
1210             sp_tweak_extinput(tc, event);
1211
1212             // draw the dilating cursor
1213                 double radius = get_dilate_radius(tc);
1214                 Geom::Matrix const sm (Geom::Scale(radius, radius) * Geom::Translate(desktop->w2d(motion_w)));
1215                 sp_canvas_item_affine_absolute(tc->dilate_area, sm);
1216                 sp_canvas_item_show(tc->dilate_area);
1217
1218                 guint num = 0;
1219                 if (!desktop->selection->isEmpty()) {
1220                     num = g_slist_length((GSList *) desktop->selection->itemList());
1221                 }
1222                 if (num == 0) {
1223                     tc->_message_context->flash(Inkscape::ERROR_MESSAGE, _("<b>Nothing selected!</b> Select objects to tweak."));
1224                 }
1225
1226             // dilating:
1227             if (tc->is_drawing && ( event->motion.state & GDK_BUTTON1_MASK )) {
1228                 sp_tweak_dilate (tc, motion_w, motion_doc, motion_doc - tc->last_push, event->button.state & GDK_SHIFT_MASK? true : false);
1229                 //tc->last_push = motion_doc;
1230                 tc->has_dilated = true;
1231                 // it's slow, so prevent clogging up with events
1232                 gobble_motion_events(GDK_BUTTON1_MASK);
1233                 return TRUE;
1234             }
1235
1236         }
1237         break;
1238
1239
1240     case GDK_BUTTON_RELEASE:
1241     {
1242         Geom::Point const motion_w(event->button.x, event->button.y);
1243         Geom::Point const motion_dt(desktop->w2d(motion_w));
1244
1245         sp_canvas_end_forced_full_redraws(desktop->canvas);
1246         tc->is_drawing = false;
1247
1248         if (tc->is_dilating && event->button.button == 1 && !event_context->space_panning) {
1249             if (!tc->has_dilated) {
1250                 // if we did not rub, do a light tap
1251                 tc->pressure = 0.03;
1252                 sp_tweak_dilate (tc, motion_w, desktop->dt2doc(motion_dt), Geom::Point(0,0), MOD__SHIFT);
1253             }
1254             tc->is_dilating = false;
1255             tc->has_dilated = false;
1256             switch (tc->mode) {
1257                 case TWEAK_MODE_MOVE:
1258                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1259                                      SP_VERB_CONTEXT_TWEAK, _("Move tweak"));
1260                     break;
1261                 case TWEAK_MODE_MOVE_IN_OUT:
1262                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1263                                      SP_VERB_CONTEXT_TWEAK, _("Move in/out tweak"));
1264                     break;
1265                 case TWEAK_MODE_MOVE_JITTER:
1266                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1267                                      SP_VERB_CONTEXT_TWEAK, _("Move jitter tweak"));
1268                     break;
1269                 case TWEAK_MODE_SCALE:
1270                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1271                                      SP_VERB_CONTEXT_TWEAK, _("Scale tweak"));
1272                     break;
1273                 case TWEAK_MODE_ROTATE:
1274                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1275                                      SP_VERB_CONTEXT_TWEAK, _("Rotate tweak"));
1276                     break;
1277                 case TWEAK_MODE_MORELESS:
1278                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1279                                      SP_VERB_CONTEXT_TWEAK, _("Duplicate/delete tweak"));
1280                     break;
1281                 case TWEAK_MODE_PUSH:
1282                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1283                                      SP_VERB_CONTEXT_TWEAK, _("Push path tweak"));
1284                     break;
1285                 case TWEAK_MODE_SHRINK_GROW:
1286                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1287                                      SP_VERB_CONTEXT_TWEAK, _("Shrink/grow path tweak"));
1288                     break;
1289                 case TWEAK_MODE_ATTRACT_REPEL:
1290                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1291                                      SP_VERB_CONTEXT_TWEAK, _("Attract/repel path tweak"));
1292                     break;
1293                 case TWEAK_MODE_ROUGHEN:
1294                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1295                                      SP_VERB_CONTEXT_TWEAK, _("Roughen path tweak"));
1296                     break;
1297                 case TWEAK_MODE_COLORPAINT:
1298                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1299                                      SP_VERB_CONTEXT_TWEAK, _("Color paint tweak"));
1300                     break;
1301                 case TWEAK_MODE_COLORJITTER:
1302                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1303                                      SP_VERB_CONTEXT_TWEAK, _("Color jitter tweak"));
1304                     break;
1305                 case TWEAK_MODE_BLUR:
1306                     sp_document_done(sp_desktop_document(SP_EVENT_CONTEXT(tc)->desktop),
1307                                      SP_VERB_CONTEXT_TWEAK, _("Blur tweak"));
1308                     break;
1309             }
1310         }
1311         break;
1312     }
1313
1314     case GDK_KEY_PRESS:
1315         switch (get_group0_keyval (&event->key)) {
1316         case GDK_m:
1317         case GDK_M:
1318         case GDK_0:
1319             if (MOD__SHIFT_ONLY) {
1320                 sp_tweak_switch_mode(tc, TWEAK_MODE_MOVE, MOD__SHIFT);
1321                 ret = TRUE;
1322             }
1323             break;
1324         case GDK_i:
1325         case GDK_I:
1326         case GDK_1:
1327             if (MOD__SHIFT_ONLY) {
1328                 sp_tweak_switch_mode(tc, TWEAK_MODE_MOVE_IN_OUT, MOD__SHIFT);
1329                 ret = TRUE;
1330             }
1331             break;
1332         case GDK_z:
1333         case GDK_Z:
1334         case GDK_2:
1335             if (MOD__SHIFT_ONLY) {
1336                 sp_tweak_switch_mode(tc, TWEAK_MODE_MOVE_JITTER, MOD__SHIFT);
1337                 ret = TRUE;
1338             }
1339             break;
1340         case GDK_less:
1341         case GDK_comma:
1342         case GDK_greater:
1343         case GDK_period:
1344         case GDK_3:
1345             if (MOD__SHIFT_ONLY) {
1346                 sp_tweak_switch_mode(tc, TWEAK_MODE_SCALE, MOD__SHIFT);
1347                 ret = TRUE;
1348             }
1349             break;
1350         case GDK_bracketright:
1351         case GDK_bracketleft:
1352         case GDK_4:
1353             if (MOD__SHIFT_ONLY) {
1354                 sp_tweak_switch_mode(tc, TWEAK_MODE_ROTATE, MOD__SHIFT);
1355                 ret = TRUE;
1356             }
1357             break;
1358         case GDK_d:
1359         case GDK_D:
1360         case GDK_5:
1361             if (MOD__SHIFT_ONLY) {
1362                 sp_tweak_switch_mode(tc, TWEAK_MODE_MORELESS, MOD__SHIFT);
1363                 ret = TRUE;
1364             }
1365             break;
1366         case GDK_p:
1367         case GDK_P:
1368         case GDK_6:
1369             if (MOD__SHIFT_ONLY) {
1370                 sp_tweak_switch_mode(tc, TWEAK_MODE_PUSH, MOD__SHIFT);
1371                 ret = TRUE;
1372             }
1373             break;
1374         case GDK_s:
1375         case GDK_S:
1376         case GDK_7:
1377             if (MOD__SHIFT_ONLY) {
1378                 sp_tweak_switch_mode(tc, TWEAK_MODE_SHRINK_GROW, MOD__SHIFT);
1379                 ret = TRUE;
1380             }
1381             break;
1382         case GDK_a:
1383         case GDK_A:
1384         case GDK_8:
1385             if (MOD__SHIFT_ONLY) {
1386                 sp_tweak_switch_mode(tc, TWEAK_MODE_ATTRACT_REPEL, MOD__SHIFT);
1387                 ret = TRUE;
1388             }
1389             break;
1390         case GDK_r:
1391         case GDK_R:
1392         case GDK_9:
1393             if (MOD__SHIFT_ONLY) {
1394                 sp_tweak_switch_mode(tc, TWEAK_MODE_ROUGHEN, MOD__SHIFT);
1395                 ret = TRUE;
1396             }
1397             break;
1398         case GDK_c:
1399         case GDK_C:
1400             if (MOD__SHIFT_ONLY) {
1401                 sp_tweak_switch_mode(tc, TWEAK_MODE_COLORPAINT, MOD__SHIFT);
1402                 ret = TRUE;
1403             }
1404             break;
1405         case GDK_j:
1406         case GDK_J:
1407             if (MOD__SHIFT_ONLY) {
1408                 sp_tweak_switch_mode(tc, TWEAK_MODE_COLORJITTER, MOD__SHIFT);
1409                 ret = TRUE;
1410             }
1411             break;
1412         case GDK_b:
1413         case GDK_B:
1414             if (MOD__SHIFT_ONLY) {
1415                 sp_tweak_switch_mode(tc, TWEAK_MODE_BLUR, MOD__SHIFT);
1416                 ret = TRUE;
1417             }
1418             break;
1419
1420         case GDK_Up:
1421         case GDK_KP_Up:
1422             if (!MOD__CTRL_ONLY) {
1423                 tc->force += 0.05;
1424                 if (tc->force > 1.0)
1425                     tc->force = 1.0;
1426                 desktop->setToolboxAdjustmentValue ("tweak-force", tc->force * 100);
1427                 ret = TRUE;
1428             }
1429             break;
1430         case GDK_Down:
1431         case GDK_KP_Down:
1432             if (!MOD__CTRL_ONLY) {
1433                 tc->force -= 0.05;
1434                 if (tc->force < 0.0)
1435                     tc->force = 0.0;
1436                 desktop->setToolboxAdjustmentValue ("tweak-force", tc->force * 100);
1437                 ret = TRUE;
1438             }
1439             break;
1440         case GDK_Right:
1441         case GDK_KP_Right:
1442             if (!MOD__CTRL_ONLY) {
1443                 tc->width += 0.01;
1444                 if (tc->width > 1.0)
1445                     tc->width = 1.0;
1446                 desktop->setToolboxAdjustmentValue ("altx-tweak", tc->width * 100); // the same spinbutton is for alt+x
1447                 sp_tweak_update_area(tc);
1448                 ret = TRUE;
1449             }
1450             break;
1451         case GDK_Left:
1452         case GDK_KP_Left:
1453             if (!MOD__CTRL_ONLY) {
1454                 tc->width -= 0.01;
1455                 if (tc->width < 0.01)
1456                     tc->width = 0.01;
1457                 desktop->setToolboxAdjustmentValue ("altx-tweak", tc->width * 100);
1458                 sp_tweak_update_area(tc);
1459                 ret = TRUE;
1460             }
1461             break;
1462         case GDK_Home:
1463         case GDK_KP_Home:
1464             tc->width = 0.01;
1465             desktop->setToolboxAdjustmentValue ("altx-tweak", tc->width * 100);
1466             sp_tweak_update_area(tc);
1467             ret = TRUE;
1468             break;
1469         case GDK_End:
1470         case GDK_KP_End:
1471             tc->width = 1.0;
1472             desktop->setToolboxAdjustmentValue ("altx-tweak", tc->width * 100);
1473             sp_tweak_update_area(tc);
1474             ret = TRUE;
1475             break;
1476         case GDK_x:
1477         case GDK_X:
1478             if (MOD__ALT_ONLY) {
1479                 desktop->setToolboxFocusTo ("altx-tweak");
1480                 ret = TRUE;
1481             }
1482             break;
1483
1484         case GDK_Shift_L:
1485         case GDK_Shift_R:
1486             sp_tweak_update_cursor(tc, true);
1487             break;
1488
1489         case GDK_Control_L:
1490         case GDK_Control_R:
1491             sp_tweak_switch_mode_temporarily(tc, TWEAK_MODE_SHRINK_GROW, MOD__SHIFT);
1492             break;
1493         default:
1494             break;
1495         }
1496         break;
1497
1498     case GDK_KEY_RELEASE: {
1499         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1500         switch (get_group0_keyval(&event->key)) {
1501             case GDK_Shift_L:
1502             case GDK_Shift_R:
1503                 sp_tweak_update_cursor(tc, false);
1504                 break;
1505             case GDK_Control_L:
1506             case GDK_Control_R:
1507                 sp_tweak_switch_mode (tc, prefs->getInt("/tools/tweak/mode"), MOD__SHIFT);
1508                 tc->_message_context->clear();
1509                 break;
1510             default:
1511                 sp_tweak_switch_mode (tc, prefs->getInt("/tools/tweak/mode"), MOD__SHIFT);
1512                 break;
1513         }
1514     }
1515
1516     default:
1517         break;
1518     }
1519
1520     if (!ret) {
1521         if (((SPEventContextClass *) parent_class)->root_handler) {
1522             ret = ((SPEventContextClass *) parent_class)->root_handler(event_context, event);
1523         }
1524     }
1525
1526     return ret;
1527 }
1528
1529
1530 /*
1531   Local Variables:
1532   mode:c++
1533   c-file-style:"stroustrup"
1534   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1535   indent-tabs-mode:nil
1536   fill-column:99
1537   End:
1538 */
1539 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :