update to trunk

(bzr r14422.3.4)

4 files changed, 541 insertions, 178 deletions

diff --git a/src/ui/tools/spray-tool.cpp b/src/ui/tools/spray-tool.cpp
index 17b82fe1d..0d3405dbd 100644
--- a/src/ui/tools/spray-tool.cpp
+++ b/src/ui/tools/spray-tool.cpp
@@ -173,13 +173,25 @@ SprayTool::SprayTool()
     , is_dilating(false)
     , has_dilated(false)
     , dilate_area(NULL)
-    , nooverlap(false)
+    , no_overlap(false)
     , picker(false)
-    , pickinversevalue(false)
-    , pickfill(false)
-    , pickstroke(false)
-    , visible(false)
+    , pick_center(true)
+    , pick_inverse_value(false)
+    , pick_fill(false)
+    , pick_stroke(false)
+    , pick_no_overlap(false)
+    , over_transparent(true)
+    , over_no_transparent(true)
     , offset(0)
+    , pick(0)
+    , do_trace(false)
+    , pick_to_size(false)
+    , pick_to_presence(false)
+    , pick_to_color(false)
+    , pick_to_opacity(false)
+    , invert_picked(false)
+    , gamma_picked(0)
+    , rand_picked(0)
 {
 }
 
@@ -240,6 +252,15 @@ void SprayTool::setup() {
 
     this->is_drawing = false;
 
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool("/dialogs/clonetiler/dotrace", false);
+    if (prefs->getBool("/tools/spray/selcue")) {
+        this->enableSelectionCue();
+    }
+    if (prefs->getBool("/tools/spray/gradientdrag")) {
+        this->enableGrDrag();
+    }
+
     sp_event_context_read(this, "distrib");
     sp_event_context_read(this, "width");
     sp_event_context_read(this, "ratio");
@@ -256,19 +277,27 @@ void SprayTool::setup() {
     sp_event_context_read(this, "Scale");
     sp_event_context_read(this, "offset");
     sp_event_context_read(this, "picker");
-    sp_event_context_read(this, "pickinversevalue");
-    sp_event_context_read(this, "pickfill");
-    sp_event_context_read(this, "pickstroke");
-    sp_event_context_read(this, "visible");
-    sp_event_context_read(this, "nooverlap");
+    sp_event_context_read(this, "pick_center");
+    sp_event_context_read(this, "pick_inverse_value");
+    sp_event_context_read(this, "pick_fill");
+    sp_event_context_read(this, "pick_stroke");
+    sp_event_context_read(this, "pick_no_overlap");
+    sp_event_context_read(this, "over_no_transparent");
+    sp_event_context_read(this, "over_transparent");
+    sp_event_context_read(this, "no_overlap");
+}
 
+void SprayTool::setCloneTilerPrefs() {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    if (prefs->getBool("/tools/spray/selcue")) {
-        this->enableSelectionCue();
-    }
-    if (prefs->getBool("/tools/spray/gradientdrag")) {
-        this->enableGrDrag();
-    }
+    this->do_trace = prefs->getBool("/dialogs/clonetiler/dotrace", false);
+    this->pick = prefs->getInt("/dialogs/clonetiler/pick");
+    this->pick_to_size = prefs->getBool("/dialogs/clonetiler/pick_to_size", false);
+    this->pick_to_presence = prefs->getBool("/dialogs/clonetiler/pick_to_presence", false);
+    this->pick_to_color = prefs->getBool("/dialogs/clonetiler/pick_to_color", false);
+    this->pick_to_opacity = prefs->getBool("/dialogs/clonetiler/pick_to_opacity", false);
+    this->rand_picked = 0.01 * prefs->getDoubleLimited("/dialogs/clonetiler/rand_picked", 0, 0, 100);
+    this->invert_picked = prefs->getBool("/dialogs/clonetiler/invert_picked", false);
+    this->gamma_picked = prefs->getDoubleLimited("/dialogs/clonetiler/gamma_picked", 0, -10, 10);
 }
 
 void SprayTool::set(const Inkscape::Preferences::Entry& val) {
@@ -303,19 +332,25 @@ void SprayTool::set(const Inkscape::Preferences::Entry& val) {
     } else if (path == "ratio") {
         this->ratio = CLAMP(val.getDouble(), 0.0, 0.9);
     } else if (path == "offset") {
-        this->offset = CLAMP(val.getDouble(), -1000.0, 1000.0);
+        this->offset = val.getDoubleLimited(100.0, 0, 1000.0);
+    } else if (path == "pick_center") {
+        this->pick_center =  val.getBool(true);
+    } else if (path == "pick_inverse_value") {
+        this->pick_inverse_value =  val.getBool(false);
+    } else if (path == "pick_fill") {
+        this->pick_fill =  val.getBool(false);
+    } else if (path == "pick_stroke") {
+        this->pick_stroke =  val.getBool(false);
+    } else if (path == "pick_no_overlap") {
+        this->pick_no_overlap =  val.getBool(false);
+    } else if (path == "over_no_transparent") {
+        this->over_no_transparent =  val.getBool(true);
+    } else if (path == "over_transparent") {
+        this->over_transparent =  val.getBool(true);
+    } else if (path == "no_overlap") {
+        this->no_overlap = val.getBool(false);
     } else if (path == "picker") {
-        this->picker =  val.getBool();
-    } else if (path == "pickinversevalue") {
-        this->pickinversevalue =  val.getBool();
-    } else if (path == "pickfill") {
-        this->pickfill =  val.getBool();
-    } else if (path == "pickstroke") {
-        this->pickstroke =  val.getBool();
-    } else if (path == "visible") {
-        this->visible =  val.getBool();
-    } else if (path == "nooverlap") {
-        this->nooverlap = val.getBool();
+        this->picker =  val.getBool(false);
     }
 }
 
@@ -428,39 +463,76 @@ double randomize01(double val, double rand)
     return CLAMP(val, 0, 1); // this should be unnecessary with the above provisions, but just in case...
 }
 
+guint32 getPickerData(Geom::IntRect area){
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    double R = 0, G = 0, B = 0, A = 0;
+    cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, area.width(), area.height());
+    sp_canvas_arena_render_surface(SP_CANVAS_ARENA(desktop->getDrawing()), s, area);
+    ink_cairo_surface_average_color(s, R, G, B, A);
+    cairo_surface_destroy(s);
+    //this can fix the bug #1511998 if confirmed 
+    if( A == 0 || A < 1e-6){
+        R = 1;
+        G = 1;
+        B = 1;
+    }
+    return SP_RGBA32_F_COMPOSE(R, G, B, A);
+}
+
+static void showHidden(std::vector<SPItem *> items_down){
+    for (std::vector<SPItem *>::const_iterator k=items_down.begin(); k!=items_down.end(); ++k) {
+        SPItem *item_hidden = *k;
+        item_hidden->setHidden(false);
+        item_hidden->updateRepr();
+    }
+}
+//todo: maybe move same parameter to preferences
 static bool fit_item(SPDesktop *desktop,
                      SPItem *item,
                      Geom::OptRect bbox,
                      Geom::Point &move,
                      Geom::Point center,
+                     gint mode,
                      double angle,
                      double &_scale,
                      double scale,
                      bool picker,
-                     bool pickinversevalue,
-                     bool pickfill,
-                     bool pickstroke,
-                     bool visible,
-                     bool nooverlap,
+                     bool pick_center,
+                     bool pick_inverse_value,
+                     bool pick_fill,
+                     bool pick_stroke,
+                     bool pick_no_overlap,
+                     bool over_no_transparent,
+                     bool over_transparent,
+                     bool no_overlap,
                      double offset,
                      SPCSSAttr *css,
-                     bool trace_scale)
+                     bool trace_scale,
+                     int pick,
+                     bool do_trace,
+                     bool pick_to_size,
+                     bool pick_to_presence,
+                     bool pick_to_color,
+                     bool pick_to_opacity,
+                     bool invert_picked,
+                     double gamma_picked ,
+                     double rand_picked)
 {
     SPDocument *doc = item->document;
     double width = bbox->width();
     double height = bbox->height();
-    double size = std::min(width,height);
-    double offset_min = (offset * size)/100.0 - (size);
-    if(offset_min < 0 ){
-        offset_min = 0;
+    double offset_width = (offset * width)/100.0 - (width);
+    if(offset_width < 0 ){
+        offset_width = 0;
     }
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    bool pick_to_size = prefs->getBool("/dialogs/clonetiler/pick_to_size");
-    bool trace = prefs->getBool("/dialogs/clonetiler/dotrace");
-    if(picker && pick_to_size && !trace_scale && trace){
+    double offset_height = (offset * height)/100.0 - (height);
+    if(offset_height < 0 ){
+        offset_height = 0;
+    }
+    if(picker && pick_to_size && !trace_scale && do_trace){
         _scale = 0.1;
     }
-    Geom::OptRect bbox_procesed = Geom::Rect(Geom::Point(bbox->left() - offset_min, bbox->top() - offset_min),Geom::Point(bbox->right() + offset_min, bbox->bottom() + offset_min));
+    Geom::OptRect bbox_procesed = Geom::Rect(Geom::Point(bbox->left() - offset_width, bbox->top() - offset_height),Geom::Point(bbox->right() + offset_width, bbox->bottom() + offset_height));
     Geom::Path path;
     path.start(Geom::Point(bbox_procesed->left(), bbox_procesed->top()));
     path.appendNew<Geom::LineSegment>(Geom::Point(bbox_procesed->right(), bbox_procesed->top()));
@@ -474,25 +546,39 @@ static bool fit_item(SPDesktop *desktop,
     path *= desktop->doc2dt();
     bbox_procesed = path.boundsFast();
     double bbox_left_main = bbox_procesed->left();
+    double bbox_right_main = bbox_procesed->right();
     double bbox_top_main = bbox_procesed->top();
+    double bbox_bottom_main = bbox_procesed->bottom();
     double width_transformed = bbox_procesed->width();
     double height_transformed = bbox_procesed->height();
     Geom::Point mid_point = desktop->d2w(bbox_procesed->midpoint());
     Geom::IntRect area = Geom::IntRect::from_xywh(floor(mid_point[Geom::X]), floor(mid_point[Geom::Y]), 1, 1);
-    double R = 0, G = 0, B = 0, A = 0;
-    cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
-    sp_canvas_arena_render_surface(SP_CANVAS_ARENA(desktop->getDrawing()), s, area);
-    ink_cairo_surface_average_color(s, R, G, B, A);
-    cairo_surface_destroy(s);
-    guint32 rgba = SP_RGBA32_F_COMPOSE(R, G, B, A);
-    if(nooverlap && visible && (A==0 || A < 1e-6)){
+    guint32 rgba = getPickerData(area);
+    guint32 rgba2 = 0xffffff00;
+    Geom::Rect rect_sprayed(desktop->d2w(Geom::Point(bbox_left_main,bbox_top_main)), desktop->d2w(Geom::Point(bbox_right_main,bbox_bottom_main)));
+    if (!rect_sprayed.hasZeroArea()) {
+        rgba2 = getPickerData(rect_sprayed.roundOutwards());
+    }
+    if(pick_no_overlap){
+        if(rgba != rgba2){
+            return false;
+        }
+    }
+    if(!pick_center){
+        rgba = rgba2;
+    }
+    if(!over_transparent && (SP_RGBA32_A_F(rgba) == 0 || SP_RGBA32_A_F(rgba) < 1e-6)){
+        return false;
+    }
+    if(!over_no_transparent && SP_RGBA32_A_F(rgba) > 0){
         return false;
     }
-    size = std::min(width_transformed,height_transformed);
     if(offset < 100 ){
-        offset_min = ((99.0 - offset) * size)/100.0 - size;
+        offset_width = ((99.0 - offset) * width_transformed)/100.0 - width_transformed;
+        offset_height = ((99.0 - offset) * height_transformed)/100.0 - height_transformed;
     } else {
-        offset_min = 0;
+        offset_width = 0;
+        offset_height = 0;
     }
     std::vector<SPItem*> items_down = desktop->getDocument()->getItemsPartiallyInBox(desktop->dkey, *bbox_procesed);
     Inkscape::Selection *selection = desktop->getSelection();
@@ -500,6 +586,7 @@ static bool fit_item(SPDesktop *desktop,
         return false;
     }
     std::vector<SPItem*> const items_selected(selection->itemList());
+    std::vector<SPItem*> items_down_erased;
     for (std::vector<SPItem*>::const_iterator i=items_down.begin(); i!=items_down.end(); i++) {
         SPItem *item_down = *i;
         Geom::OptRect bbox_down = item_down->documentVisualBounds();
@@ -508,6 +595,7 @@ static bool fit_item(SPDesktop *desktop,
         double bbox_left = bbox_down->left();
         double bbox_top = bbox_down->top();
         gchar const * item_down_sharp = g_strdup_printf("#%s", item_down->getId());
+        items_down_erased.push_back(item_down);
         for (std::vector<SPItem*>::const_iterator j=items_selected.begin(); j!=items_selected.end(); j++) {
             SPItem *item_selected = *j;
             gchar const * spray_origin;
@@ -520,46 +608,72 @@ static bool fit_item(SPDesktop *desktop,
                 (item_down->getAttribute("inkscape:spray-origin") && 
                 strcmp(item_down->getAttribute("inkscape:spray-origin"),spray_origin) == 0 ))
             {
-                if(nooverlap){
-                    if(!(offset_min < 0 && std::abs(bbox_left - bbox_left_main) > std::abs(offset_min) && 
-                std::abs(bbox_top - bbox_top_main) > std::abs(offset_min))){
+                if(mode == SPRAY_MODE_ERASER){
+                    if(strcmp(item_down_sharp, spray_origin) != 0 && !selection->includes(item_down) ){
+                        item_down->deleteObject();
+                        items_down_erased.pop_back();
+                        break;
+                    }
+                }else if(no_overlap){
+                    if(!(offset_width < 0 && offset_height < 0 && std::abs(bbox_left - bbox_left_main) > std::abs(offset_width) && 
+                std::abs(bbox_top - bbox_top_main) > std::abs(offset_height))){
+                        if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+                            showHidden(items_down);
+                        }
                         return false;
                     }
-                } else if(picker || visible){
+                } else if(picker || over_transparent || over_no_transparent){
                     item_down->setHidden(true);
                     item_down->updateRepr();
                 }
             }
         }
     }
-    if(picker || visible){
-        if(!nooverlap){
+    if(mode == SPRAY_MODE_ERASER){
+        if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+            showHidden(items_down_erased);
+        }
+        return false;
+    }
+    if(picker || over_transparent || over_no_transparent){
+        if(!no_overlap){
             doc->ensureUpToDate();
+            rgba = getPickerData(area);
+            if (!rect_sprayed.hasZeroArea()) {
+                rgba2 = getPickerData(rect_sprayed.roundOutwards());
+            }
+        }
+        if(pick_no_overlap){
+            if(rgba != rgba2){
+                if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+                    showHidden(items_down);
+                }
+                return false;
+            }
+        }
+        if(!pick_center){
+            rgba = rgba2;
         }
-        int    pick = prefs->getInt("/dialogs/clonetiler/pick");
-        bool   pick_to_presence = prefs->getBool("/dialogs/clonetiler/pick_to_presence", false);
-        bool   pick_to_color = prefs->getBool("/dialogs/clonetiler/pick_to_color");
-        bool   pick_to_opacity = prefs->getBool("/dialogs/clonetiler/pick_to_opacity");
-        double rand_picked = 0.01 * prefs->getDoubleLimited("/dialogs/clonetiler/rand_picked", 0, 0, 100);
-        bool   invert_picked = prefs->getBool("/dialogs/clonetiler/invert_picked");
-        double gamma_picked = prefs->getDoubleLimited("/dialogs/clonetiler/gamma_picked", 0, -10, 10);
         double opacity = 1.0;
         gchar color_string[32]; *color_string = 0;
         float r = SP_RGBA32_R_F(rgba);
         float g = SP_RGBA32_G_F(rgba);
         float b = SP_RGBA32_B_F(rgba);
         float a = SP_RGBA32_A_F(rgba);
-        //this can fix the bug #1511998 if confirmed 
-        if( a == 0 || a < 1e-6){
-            r = 1;
-            g = 1;
-            b = 1;
+        if(!over_transparent && (a == 0 || a < 1e-6)){
+            if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+                showHidden(items_down);
+            }
+            return false;
         }
-        if(visible && (a == 0 || a < 1e-6)){
+        if(!over_no_transparent && a > 0){
+            if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+                showHidden(items_down);
+            }
             return false;
         }
 
-        if(picker && trace){
+        if(picker && do_trace){
             float hsl[3];
             sp_color_rgb_to_hsl_floatv (hsl, r, g, b);
 
@@ -629,38 +743,59 @@ static bool fit_item(SPDesktop *desktop,
             rgba = SP_RGBA32_F_COMPOSE(r, g, b, a);
             if (pick_to_size) {
                 if(!trace_scale){
-                    if(pickinversevalue) {
+                    if(pick_inverse_value) {
                         _scale = 1.0 - val;
                     } else {
                         _scale = val;
                     }
                     if(_scale == 0.0) {
+                        if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+                            showHidden(items_down);
+                        }
+                        return false;
+                    }
+                    if(!fit_item(desktop
+                                 , item
+                                 , bbox
+                                 , move
+                                 , center
+                                 , mode
+                                 , angle
+                                 , _scale
+                                 , scale
+                                 , picker
+                                 , pick_center
+                                 , pick_inverse_value
+                                 , pick_fill
+                                 , pick_stroke
+                                 , pick_no_overlap
+                                 , over_no_transparent
+                                 , over_transparent
+                                 , no_overlap
+                                 , offset
+                                 , css
+                                 , true
+                                 , pick
+                                 , do_trace
+                                 , pick_to_size
+                                 , pick_to_presence
+                                 , pick_to_color
+                                 , pick_to_opacity
+                                 , invert_picked
+                                 , gamma_picked
+                                 , rand_picked)
+                        )
+                    {
+                        if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+                            showHidden(items_down);
+                        }
                         return false;
                     }
-                    if(!fit_item(desktop,
-                         item,
-                         bbox,
-                         move,
-                         center,
-                         angle,
-                         _scale,
-                         scale,
-                         picker,
-                         pickinversevalue,
-                         pickfill,
-                         pickstroke,
-                         visible,
-                         nooverlap,
-                         offset,
-                         css,
-                         true)){
-                            return false;
-                         }
                 }
             }
 
             if (pick_to_opacity) {
-                if(pickinversevalue) {
+                if(pick_inverse_value) {
                     opacity *= 1.0 - val;
                 } else {
                     opacity *= val;
@@ -679,32 +814,44 @@ static bool fit_item(SPDesktop *desktop,
             }
             if (pick_to_color) {
                 sp_svg_write_color(color_string, sizeof(color_string), rgba);
-                if(pickfill){
+                if(pick_fill){
                     sp_repr_css_set_property(css, "fill", color_string);
                 }
-                if(pickstroke){
+                if(pick_stroke){
                     sp_repr_css_set_property(css, "stroke", color_string);
                 }
             }
             if (opacity < 1e-6) { // invisibly transparent, skip
+                if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+                    showHidden(items_down);
+                }
                 return false;
             }
         }
-        if(!trace){
+        if(!do_trace){
+            if(!pick_center){
+                rgba = rgba2;
+            }
+            if (pick_inverse_value) {
+                r = 1 - SP_RGBA32_R_F(rgba);
+                g = 1 - SP_RGBA32_G_F(rgba);
+                b = 1 - SP_RGBA32_B_F(rgba);
+            } else {
+                r = SP_RGBA32_R_F(rgba);
+                g = SP_RGBA32_G_F(rgba);
+                b = SP_RGBA32_B_F(rgba);
+            }
+            rgba = SP_RGBA32_F_COMPOSE(r, g, b, a);
             sp_svg_write_color(color_string, sizeof(color_string), rgba);
-            if(pickfill){
+            if(pick_fill){
                 sp_repr_css_set_property(css, "fill", color_string);
             }
-            if(pickstroke){
+            if(pick_stroke){
                 sp_repr_css_set_property(css, "stroke", color_string);
             }
         }
-        if(!nooverlap && (picker || visible)){
-            for (std::vector<SPItem *>::const_iterator k=items_down.begin(); k!=items_down.end(); k++) {
-                SPItem *item_hidden = *k;
-                item_hidden->setHidden(false);
-                item_hidden->updateRepr();
-            }
+        if(!no_overlap && (picker || over_transparent || over_no_transparent)){
+            showHidden(items_down);
         }
     }
     return true;
@@ -727,15 +874,27 @@ static bool sp_spray_recursive(SPDesktop *desktop,
                                double tilt,
                                double rotation_variation,
                                gint _distrib,
-                               bool nooverlap,
+                               bool no_overlap,
                                bool picker,
-                               bool pickinversevalue,
-                               bool pickfill,
-                               bool pickstroke,
-                               bool visible,
+                               bool pick_center,
+                               bool pick_inverse_value,
+                               bool pick_fill,
+                               bool pick_stroke,
+                               bool pick_no_overlap,
+                               bool over_no_transparent,
+                               bool over_transparent,
                                double offset,
                                bool usepressurescale,
-                               double pressure)
+                               double pressure,
+                               int pick,
+                               bool do_trace,
+                               bool pick_to_size,
+                               bool pick_to_presence,
+                               bool pick_to_color,
+                               bool pick_to_opacity,
+                               bool invert_picked,
+                               double gamma_picked ,
+                               double rand_picked)
 {
     bool did = false;
 
@@ -758,7 +917,7 @@ static bool sp_spray_recursive(SPDesktop *desktop,
     random_position( dr, dp, mean, standard_deviation, _distrib );
     dr=dr*radius;
 
-    if (mode == SPRAY_MODE_COPY) {
+    if (mode == SPRAY_MODE_COPY || mode == SPRAY_MODE_ERASER) {
         Geom::OptRect a = item->documentVisualBounds();
         if (a) {
             if(_fid <= population)
@@ -773,8 +932,37 @@ static bool sp_spray_recursive(SPDesktop *desktop,
                 Geom::Point center = item->getCenter();
                 Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio), -sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());
                 SPCSSAttr *css = sp_repr_css_attr_new();
-                if(nooverlap || picker || visible){
-                    if(!fit_item(desktop, item, a, move, center, angle, _scale, scale, picker, pickinversevalue, pickfill, pickstroke, visible, nooverlap, offset, css, false)){
+                if(no_overlap || picker || !over_transparent || !over_no_transparent){
+                    if(!fit_item(desktop
+                                 , item
+                                 , a
+                                 , move
+                                 , center
+                                 , mode
+                                 , angle
+                                 , _scale
+                                 , scale
+                                 , picker
+                                 , pick_center
+                                 , pick_inverse_value
+                                 , pick_fill
+                                 , pick_stroke
+                                 , pick_no_overlap
+                                 , over_no_transparent
+                                 , over_transparent
+                                 , no_overlap
+                                 , offset
+                                 , css
+                                 , false
+                                 , pick
+                                 , do_trace
+                                 , pick_to_size
+                                 , pick_to_presence
+                                 , pick_to_color
+                                 , pick_to_opacity
+                                 , invert_picked
+                                 , gamma_picked
+                                 , rand_picked)){
                         return false;
                     }
                 }
@@ -880,8 +1068,38 @@ static bool sp_spray_recursive(SPDesktop *desktop,
                 Geom::Point center=item->getCenter();
                 Geom::Point move = (Geom::Point(cos(tilt)*cos(dp)*dr/(1-ratio)+sin(tilt)*sin(dp)*dr/(1+ratio), -sin(tilt)*cos(dp)*dr/(1-ratio)+cos(tilt)*sin(dp)*dr/(1+ratio)))+(p-a->midpoint());
                 SPCSSAttr *css = sp_repr_css_attr_new();
-                if(nooverlap || picker || visible){
-                    if(!fit_item(desktop, item, a, move, center, angle, _scale, scale, picker, pickinversevalue, pickfill, pickstroke, visible, nooverlap, offset, css, false)){
+                if(no_overlap || picker || !over_transparent || !over_no_transparent){
+                    if(!fit_item(desktop
+                                 , item
+                                 , a
+                                 , move
+                                 , center
+                                 , mode
+                                 , angle
+                                 , _scale
+                                 , scale
+                                 , picker
+                                 , pick_center
+                                 , pick_inverse_value
+                                 , pick_fill
+                                 , pick_stroke
+                                 , pick_no_overlap
+                                 , over_no_transparent
+                                 , over_transparent
+                                 , no_overlap
+                                 , offset
+                                 , css
+                                 , true
+                                 , pick
+                                 , do_trace
+                                 , pick_to_size
+                                 , pick_to_presence
+                                 , pick_to_color
+                                 , pick_to_opacity
+                                 , invert_picked
+                                 , gamma_picked
+                                 , rand_picked))
+                    {
                         return false;
                     }
                 }
@@ -959,7 +1177,43 @@ static bool sp_spray_dilate(SprayTool *tc, Geom::Point /*event_p*/, Geom::Point
         for(std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
             SPItem *item = *i;
             g_assert(item != NULL);
-            if (sp_spray_recursive(desktop, selection, item, p, vector, tc->mode, radius, population, tc->scale, tc->scale_variation, reverse, move_mean, move_standard_deviation, tc->ratio, tc->tilt, tc->rotation_variation, tc->distrib, tc->nooverlap, tc->picker, tc->pickinversevalue, tc->pickfill, tc->pickstroke, tc->visible, tc->offset, tc->usepressurescale, get_pressure(tc))) {
+            if (sp_spray_recursive(desktop
+                                , selection
+                                , item
+                                , p, vector
+                                , tc->mode
+                                , radius
+                                , population
+                                , tc->scale
+                                , tc->scale_variation
+                                , reverse
+                                , move_mean
+                                , move_standard_deviation
+                                , tc->ratio
+                                , tc->tilt
+                                , tc->rotation_variation
+                                , tc->distrib
+                                , tc->no_overlap
+                                , tc->picker
+                                , tc->pick_center
+                                , tc->pick_inverse_value
+                                , tc->pick_fill
+                                , tc->pick_stroke
+                                , tc->pick_no_overlap
+                                , tc->over_no_transparent
+                                , tc->over_transparent
+                                , tc->offset
+                                , tc->usepressurescale
+                                , get_pressure(tc)
+                                , tc->pick
+                                , tc->do_trace
+                                , tc->pick_to_size
+                                , tc->pick_to_presence
+                                , tc->pick_to_color
+                                , tc->pick_to_opacity
+                                , tc->invert_picked
+                                , tc->gamma_picked
+                                , tc->rand_picked)) {
                 did = true;
             }
         }
@@ -1006,7 +1260,7 @@ bool SprayTool::root_handler(GdkEvent* event) {
                 if (Inkscape::have_viable_layer(desktop, this->message_context) == false) {
                     return TRUE;
                 }
-
+                this->setCloneTilerPrefs();
                 Geom::Point const motion_w(event->button.x, event->button.y);
                 Geom::Point const motion_dt(desktop->w2d(motion_w));
                 this->last_push = desktop->dt2doc(motion_dt);
diff --git a/src/ui/tools/spray-tool.h b/src/ui/tools/spray-tool.h
index ca0c20375..c81110b37 100644
--- a/src/ui/tools/spray-tool.h
+++ b/src/ui/tools/spray-tool.h
@@ -47,7 +47,8 @@ namespace Tools {
 enum {
     SPRAY_MODE_COPY,
     SPRAY_MODE_CLONE,
-    SPRAY_MODE_SINGLE_PATH,    
+    SPRAY_MODE_SINGLE_PATH,
+    SPRAY_MODE_ERASER,
     SPRAY_OPTION,
 };
 
@@ -89,19 +90,32 @@ public:
     bool has_dilated;
     Geom::Point last_push;
     SPCanvasItem *dilate_area;
-    bool nooverlap;
+    bool no_overlap;
     bool picker;
-    bool pickinversevalue;
-    bool pickfill;
-    bool pickstroke;
-    bool visible;
+    bool pick_center;
+    bool pick_inverse_value;
+    bool pick_fill;
+    bool pick_stroke;
+    bool pick_no_overlap;
+    bool over_transparent;
+    bool over_no_transparent;
     double offset;
+    int pick;
+    bool do_trace;
+    bool pick_to_size;
+    bool pick_to_presence;
+    bool pick_to_color;
+    bool pick_to_opacity;
+    bool invert_picked;
+    double gamma_picked;
+    double rand_picked;
     sigc::connection style_set_connection;
 
     static const std::string prefsPath;
 
     virtual void setup();
     virtual void set(const Inkscape::Preferences::Entry& val);
+    virtual void setCloneTilerPrefs();
     virtual bool root_handler(GdkEvent* event);
 
     virtual const std::string& getPrefsPath();
diff --git a/src/widgets/spray-toolbar.cpp b/src/widgets/spray-toolbar.cpp
index 5e0d81964..db1f9526a 100644
--- a/src/widgets/spray-toolbar.cpp
+++ b/src/widgets/spray-toolbar.cpp
@@ -66,14 +66,16 @@ static void sp_stb_sensitivize( GObject *tbl )
     GtkAction* spray_scale = GTK_ACTION( g_object_get_data(tbl, "spray_scale") );
     GtkAdjustment *adj_offset = ege_adjustment_action_get_adjustment( EGE_ADJUSTMENT_ACTION(offset) );
     GtkAdjustment *adj_scale = ege_adjustment_action_get_adjustment( EGE_ADJUSTMENT_ACTION(spray_scale) );
-    GtkToggleAction *nooverlap = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "nooverlap") );
+    GtkToggleAction *no_overlap = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "no_overlap") );
     GtkToggleAction *picker = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "picker") );
+    GtkAction* picker_action = GTK_ACTION( g_object_get_data(tbl, "picker") );
     GtkToggleAction *usepressurescale = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "usepressurescale") );
-    GtkAction *pickfill = GTK_ACTION( g_object_get_data(tbl, "pickfill") );
-    GtkAction *pickstroke = GTK_ACTION( g_object_get_data(tbl, "pickstroke") );
-    GtkAction *pickinversevalue = GTK_ACTION( g_object_get_data(tbl, "pickinversevalue") );
+    GtkAction *pick_fill = GTK_ACTION( g_object_get_data(tbl, "pick_fill") );
+    GtkAction *pick_stroke = GTK_ACTION( g_object_get_data(tbl, "pick_stroke") );
+    GtkAction *pick_inverse_value = GTK_ACTION( g_object_get_data(tbl, "pick_inverse_value") );
+    GtkAction *pick_center = GTK_ACTION( g_object_get_data(tbl, "pick_center") );
     gtk_adjustment_set_value( adj_offset, 100.0 );
-    if (gtk_toggle_action_get_active(nooverlap)) {
+    if (gtk_toggle_action_get_active(no_overlap) && gtk_action_get_sensitive(picker_action)) {
         gtk_action_set_sensitive( offset, TRUE );
     } else {
         gtk_action_set_sensitive( offset, FALSE );
@@ -84,17 +86,34 @@ static void sp_stb_sensitivize( GObject *tbl )
     } else {
         gtk_action_set_sensitive( spray_scale, TRUE );
     }
-    if(gtk_toggle_action_get_active(picker)){
-        gtk_action_set_sensitive( pickfill, TRUE );
-        gtk_action_set_sensitive( pickstroke, TRUE );
-        gtk_action_set_sensitive( pickinversevalue, TRUE );
+    if(gtk_toggle_action_get_active(picker) && gtk_action_get_sensitive(picker_action)){
+        gtk_action_set_sensitive( pick_fill, TRUE );
+        gtk_action_set_sensitive( pick_stroke, TRUE );
+        gtk_action_set_sensitive( pick_inverse_value, TRUE );
+        gtk_action_set_sensitive( pick_center, TRUE );
     } else {
-        gtk_action_set_sensitive( pickfill, FALSE );
-        gtk_action_set_sensitive( pickstroke, FALSE );
-        gtk_action_set_sensitive( pickinversevalue, FALSE );
+        gtk_action_set_sensitive( pick_fill, FALSE );
+        gtk_action_set_sensitive( pick_stroke, FALSE );
+        gtk_action_set_sensitive( pick_inverse_value, FALSE );
+        gtk_action_set_sensitive( pick_center, FALSE );
     }
 }
 
+static void sp_spray_erase_sensitivize( GObject *tbl, bool sensitive){
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "no_overlap") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "over_no_transparent") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "over_transparent") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "pick_no_overlap") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "pick_stroke") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "pick_fill") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "pick_inverse_value") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "pick_center") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "picker") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "offset") ), sensitive );
+    gtk_action_set_sensitive( GTK_ACTION( g_object_get_data(tbl, "spray_rotation") ), sensitive );
+    sp_stb_sensitivize( tbl );
+}
+
 Inkscape::UI::Dialog::CloneTiler *get_clone_tiler_panel(SPDesktop *desktop)
 {
     if (Inkscape::UI::Dialog::PanelDialogBase *panel_dialog =
@@ -130,11 +149,16 @@ static void sp_spray_standard_deviation_value_changed( GtkAdjustment *adj, GObje
             gtk_adjustment_get_value(adj));
 }
 
-static void sp_spray_mode_changed( EgeSelectOneAction *act, GObject * /*tbl*/ )
+static void sp_spray_mode_changed( EgeSelectOneAction *act, GObject * tbl )
 {
     int mode = ege_select_one_action_get_active( act );
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setInt("/tools/spray/mode", mode);
+    if(mode != 3){
+        sp_spray_erase_sensitivize(tbl, true);
+    } else {
+        sp_spray_erase_sensitivize(tbl, false);
+    }
 }
 
 static void sp_spray_population_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
@@ -165,11 +189,11 @@ static void sp_spray_offset_value_changed( GtkAdjustment *adj, GObject * /*tbl*/
             gtk_adjustment_get_value(adj));
 }
 
-static void sp_toggle_nooverlap( GtkToggleAction* act, gpointer data)
+static void sp_toggle_no_overlap( GtkToggleAction* act, gpointer data)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/nooverlap", active);
+    prefs->setBool("/tools/spray/no_overlap", active);
     GObject *tbl = G_OBJECT(data);
     sp_stb_sensitivize(tbl);
 }
@@ -186,20 +210,28 @@ static void sp_toggle_pressure_scale( GtkToggleAction* act, gpointer data)
     sp_stb_sensitivize( tbl );
 }
 
-static void sp_toggle_visible( GtkToggleAction* act, gpointer data)
+static void sp_toggle_over_no_transparent( GtkToggleAction* act, gpointer data)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(act);
+    prefs->setBool("/tools/spray/over_no_transparent", active);
+}
+
+static void sp_toggle_over_transparent( GtkToggleAction* act, gpointer data)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/visible", active);
+    prefs->setBool("/tools/spray/over_transparent", active);
 }
 
+
 static void sp_toggle_picker( GtkToggleAction* act, gpointer data )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gboolean active = gtk_toggle_action_get_active(act);
     prefs->setBool("/tools/spray/picker", active);
     if(active == true){
-        prefs->setBool("/dialogs/clonetiler/dotrace", true);
+        prefs->setBool("/dialogs/clonetiler/dotrace", false);
         SPDesktop *dt = SP_ACTIVE_DESKTOP;
         if (Inkscape::UI::Dialog::CloneTiler *ct = get_clone_tiler_panel(dt)){
             dt->_dlg_mgr->showDialog("CloneTiler");
@@ -210,25 +242,39 @@ static void sp_toggle_picker( GtkToggleAction* act, gpointer data )
     sp_stb_sensitivize(tbl);
 }
 
-static void sp_toggle_pick_fill( GtkToggleAction* act, gpointer data )
+static void sp_toggle_pick_center( GtkToggleAction* act, gpointer data )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/pickfill", active);
+    prefs->setBool("/tools/spray/pick_center", active);
 }
 
-static void sp_toggle_pick_inverse_value( GtkToggleAction* act, gpointer data )
+static void sp_toggle_pick_fill( GtkToggleAction* act, gpointer data )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/pickinversevalue", active);
+    prefs->setBool("/tools/spray/pick_fill", active);
 }
 
 static void sp_toggle_pick_stroke( GtkToggleAction* act, gpointer data )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gboolean active = gtk_toggle_action_get_active(act);
-    prefs->setBool("/tools/spray/pickstroke", active);
+    prefs->setBool("/tools/spray/pick_stroke", active);
+}
+
+static void sp_toggle_pick_no_overlap( GtkToggleAction* act, gpointer data )
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(act);
+    prefs->setBool("/tools/spray/pick_no_overlap", active);
+}
+
+static void sp_toggle_pick_inverse_value( GtkToggleAction* act, gpointer data )
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gboolean active = gtk_toggle_action_get_active(act);
+    prefs->setBool("/tools/spray/pick_inverse_value", active);
 }
 
 void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
@@ -298,7 +344,7 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
 
     /* Mode */
     {
-        GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
+        GtkListStore* model = gtk_list_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
 
         GtkTreeIter iter;
         gtk_list_store_append( model, &iter );
@@ -314,6 +360,7 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
                             1, _("Spray clones of the initial selection"),
                             2, INKSCAPE_ICON("spray-mode-clone"),
                             -1 );
+        
 #ifdef ENABLE_SPRAY_MODE_SINGLE_PATH
         gtk_list_store_append( model, &iter );
         gtk_list_store_set( model, &iter,
@@ -322,6 +369,14 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
                             2, INKSCAPE_ICON("spray-mode-union"),
                             -1 );
 #endif
+        
+        gtk_list_store_append( model, &iter );
+        gtk_list_store_set( model, &iter,
+                            0, _("Delete sprayed items"),
+                            1, _("Delete sprayed items from selection"),
+                            2, INKSCAPE_ICON("draw-eraser"),
+                            -1 );
+        
         EgeSelectOneAction* act = ege_select_one_action_new( "SprayModeAction", _("Mode"), (""), NULL, GTK_TREE_MODEL(model) );
         g_object_set( act, "short_label", _("Mode:"), NULL );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
@@ -420,7 +475,6 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
 
-
     /* Picker */
     {
         InkToggleAction* act = ink_toggle_action_new( "SprayPickColorAction",
@@ -433,56 +487,95 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_picker), holder) ;
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
+    
+    /* Pick from center */
+    {
+        InkToggleAction* act = ink_toggle_action_new( "SprayPickCenterAction",
+                                                      _("Pick from center instead average area."),
+                                                      _("Pick from center instead average area."),
+                                                      INKSCAPE_ICON("snap-bounding-box-center"),
+                                                      secondarySize );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_center", true) );
+        g_object_set_data( holder, "pick_center", act );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_center), holder) ;
+        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+    }
 
     /* Inverse Value Size */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayOverPickInverseValueAction",
-                                                      _("Inversed pick value retaining color"),
-                                                      _("Inversed pick value retaining color"),
+        InkToggleAction* act = ink_toggle_action_new( "SprayPickInverseValueAction",
+                                                      _("Inversed pick value, retaining color in advanced trace mode"),
+                                                      _("Inversed pick value, retaining color in advanced trace mode"),
                                                       INKSCAPE_ICON("object-tweak-shrink"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pickinversevalue", false) );
-        g_object_set_data( holder, "pickinversevalue", act );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_inverse_value", false) );
+        g_object_set_data( holder, "pick_inverse_value", act );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_inverse_value), holder) ;
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
 
     /* Pick Fill */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayOverPickFillAction",
+        InkToggleAction* act = ink_toggle_action_new( "SprayPickFillAction",
                                                       _("Apply picked color to fill"),
                                                       _("Apply picked color to fill"),
                                                       INKSCAPE_ICON("paint-solid"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pickfill", false) );
-        g_object_set_data( holder, "pickfill", act );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_fill", false) );
+        g_object_set_data( holder, "pick_fill", act );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_fill), holder) ;
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
 
     /* Pick Stroke */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayOverPickStrokeAction",
+        InkToggleAction* act = ink_toggle_action_new( "SprayPickStrokeAction",
                                                       _("Apply picked color to stroke"),
                                                       _("Apply picked color to stroke"),
                                                       INKSCAPE_ICON("no-marker"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pickstroke", false) );
-        g_object_set_data( holder, "pickstroke", act );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_stroke", false) );
+        g_object_set_data( holder, "pick_stroke", act );
         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_stroke), holder) ;
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
-    
-    /* Visible */
+
+    /* Pick No Overlap */
+    {
+        InkToggleAction* act = ink_toggle_action_new( "SprayPickNoOverlapAction",
+                                                      _("No overlap between colors"),
+                                                      _("No overlap between colors"),
+                                                      INKSCAPE_ICON("symbol-bigger"),
+                                                      secondarySize );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_no_overlap", false) );
+        g_object_set_data( holder, "pick_no_overlap", act );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_no_overlap), holder) ;
+        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+    }
+
+    /* Over Transparent */
+    {
+        InkToggleAction* act = ink_toggle_action_new( "SprayOverTransparentAction",
+                                                      _("Apply over transparent areas"),
+                                                      _("Apply over transparent areas"),
+                                                      INKSCAPE_ICON("object-hidden"),
+                                                      secondarySize );
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/over_transparent", true) );
+        g_object_set_data( holder, "over_transparent", act );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_over_transparent), holder) ;
+        gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+    }
+
+    /* Over No Transparent */
     {
-        InkToggleAction* act = ink_toggle_action_new( "SprayOverVisibleAction",
-                                                      _("Apply only over non transparent areas"),
-                                                      _("Apply only over non transparent areas"),
+        InkToggleAction* act = ink_toggle_action_new( "SprayOverNoTransparentAction",
+                                                      _("Apply over no transparent areas"),
+                                                      _("Apply over no transparent areas"),
                                                       INKSCAPE_ICON("object-visible"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/visible", false) );
-        g_object_set_data( holder, "visible", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_visible), holder) ;
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/over_no_transparent", true) );
+        g_object_set_data( holder, "over_no_transparent", act );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_over_no_transparent), holder) ;
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
 
@@ -493,9 +586,9 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
                                                       _("Prevent overlapping objects"),
                                                       INKSCAPE_ICON("distribute-randomize"),
                                                       secondarySize );
-        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/nooverlap", false) );
-        g_object_set_data( holder, "nooverlap", act );
-        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_nooverlap), holder) ;
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/no_overlap", false) );
+        g_object_set_data( holder, "no_overlap", act );
+        g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_no_overlap), holder) ;
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
     }
     
@@ -512,7 +605,7 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj
         g_object_set_data( holder, "offset", eact );
         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
     }
-    sp_stb_sensitivize(holder);
+    sp_spray_erase_sensitivize(holder, prefs->getInt("/tools/spray/mode") != 3);
 }
 
 
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index cdb9e0d20..3e79e038a 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -321,15 +321,17 @@ static gchar const * ui_descr =
         "    <toolitem action='SprayStandard_deviationAction' />"
         "    <toolitem action='SprayMeanAction' />"
         "    <separator />"
-        "    <toolitem action='SprayOverVisibleAction' />"
+        "    <toolitem action='SprayOverNoTransparentAction' />"
+        "    <toolitem action='SprayOverTransparentAction' />"
+        "    <toolitem action='SprayPickNoOverlapAction' />"
         "    <toolitem action='SprayNoOverlapAction' />"
         "    <toolitem action='SprayToolOffsetAction' />"
         "    <separator />"
         "    <toolitem action='SprayPickColorAction' />"
-        "    <toolitem action='SprayOverPickInverseValueAction' />"
-        "    <toolitem action='SprayOverPickFillAction' />"
-        "    <toolitem action='SprayOverPickStrokeAction' />"
-        
+        "    <toolitem action='SprayPickFillAction' />"
+        "    <toolitem action='SprayPickStrokeAction' />"
+        "    <toolitem action='SprayPickInverseValueAction' />"
+        "    <toolitem action='SprayPickCenterAction' />"
         "  </toolbar>"
 
         "  <toolbar name='ZoomToolbar'>"
@@ -368,7 +370,7 @@ static gchar const * ui_descr =
         "    <toolitem action='MeasureToGuides' />"
         "    <toolitem action='MeasureMarkDimension' />"
         "    <toolitem action='MeasureToItem' />"
-        "  </toolbar>"
+        "  </toolbar>" 
 
         "  <toolbar name='StarToolbar'>"
         "    <separator />"