fixing to new trunk

(bzr r15142.1.38)

1 files changed, 273 insertions, 139 deletions

diff --git a/src/ui/tools/mesh-tool.cpp b/src/ui/tools/mesh-tool.cpp
index c6983b94a..e628094d9 100644
--- a/src/ui/tools/mesh-tool.cpp
+++ b/src/ui/tools/mesh-tool.cpp
@@ -41,6 +41,7 @@
 #include "sp-text.h"
 #include "sp-defs.h"
 #include "style.h"
+#include "ui/control-manager.h"
 
 // Gradient specific
 #include "gradient-drag.h"
@@ -74,6 +75,9 @@ MeshTool::MeshTool()
     : ToolBase(cursor_gradient_xpm, 4, 4)
     , cursor_addnode(false)
     , node_added(false)
+    , show_handles(true)
+    , edit_fill(true)
+    , edit_stroke(true)
 // TODO: Why are these connections stored as pointers?
     , selcon(NULL)
     , subselcon(NULL)
@@ -92,7 +96,19 @@ MeshTool::~MeshTool() {
     delete this->subselcon;
 }
 
+// This must match GrPointType enum sp-gradient.h
+// We should move this to a shared header (can't simply move to gradient.h since that would require
+// including <glibmm/i18n.h> which messes up "N_" in extensions... argh!).
 const gchar *ms_handle_descr [] = {
+    N_("Linear gradient <b>start</b>"), //POINT_LG_BEGIN
+    N_("Linear gradient <b>end</b>"),
+    N_("Linear gradient <b>mid stop</b>"),
+    N_("Radial gradient <b>center</b>"),
+    N_("Radial gradient <b>radius</b>"),
+    N_("Radial gradient <b>radius</b>"),
+    N_("Radial gradient <b>focus</b>"), // POINT_RG_FOCUS
+    N_("Radial gradient <b>mid stop</b>"),
+    N_("Radial gradient <b>mid stop</b>"),
     N_("Mesh gradient <b>corner</b>"),
     N_("Mesh gradient <b>handle</b>"),
     N_("Mesh gradient <b>tensor</b>")
@@ -240,7 +256,25 @@ void MeshTool::setup() {
     	)
     ));
 
+    sp_event_context_read(this, "show_handles");
+    sp_event_context_read(this, "edit_fill");
+    sp_event_context_read(this, "edit_stroke");
+
     this->selection_changed(selection);
+
+}
+
+void MeshTool::set(const Inkscape::Preferences::Entry& value) {
+    Glib::ustring entry_name = value.getEntryName();
+    if (entry_name == "show_handles") {
+        this->show_handles = value.getBool(true);
+    } else if (entry_name == "edit_fill") {
+        this->edit_fill = value.getBool(true);
+    } else if (entry_name == "edit_stroke") {
+        this->edit_stroke = value.getBool(true);
+    } else {
+        ToolBase::set(value);
+    }
 }
 
 void
@@ -266,32 +300,39 @@ sp_mesh_context_select_prev (ToolBase *event_context)
 }
 
 /**
-Returns true if mouse cursor over mesh edge.
+Returns vector of control lines mouse is over. Returns only first if 'first' is true.
 */
-static bool
-sp_mesh_context_is_over_line (MeshTool *rc, SPCtrlLine *line, Geom::Point event_p)
+static std::vector<SPCtrlCurve *>
+sp_mesh_context_over_line (MeshTool *rc, Geom::Point event_p, bool first = true)
 {
-    if (!SP_IS_CTRLCURVE(line) ) {
-        return false;
-    }
-
     SPDesktop *desktop = SP_EVENT_CONTEXT (rc)->desktop;
 
     //Translate mouse point into proper coord system
     rc->mousepoint_doc = desktop->w2d(event_p);
 
-    SPCtrlCurve *curve = SP_CTRLCURVE(line);
-    Geom::BezierCurveN<3> b( curve->p0, curve->p1, curve->p2, curve->p3 );
-    Geom::Coord coord = b.nearestTime( rc->mousepoint_doc ); // Coord == double
-    Geom::Point nearest = b( coord );
+    double tolerance = (double) SP_EVENT_CONTEXT(rc)->tolerance;
+
+    GrDrag *drag = rc->_grdrag;
 
-    double dist_screen = Geom::L2 (rc->mousepoint_doc - nearest) * desktop->current_zoom();
+    std::vector<SPCtrlCurve *> selected;
 
-    double tolerance = (double) SP_EVENT_CONTEXT(rc)->tolerance;
+    for (std::vector<SPCtrlLine *>::const_iterator l = drag->lines.begin(); l != drag->lines.end(); ++l) {
+        if (!SP_IS_CTRLCURVE(*l)) continue;
 
-    bool close = (dist_screen < tolerance);
+        SPCtrlCurve *curve = SP_CTRLCURVE(*l);
+        Geom::BezierCurveN<3> b( curve->p0, curve->p1, curve->p2, curve->p3 );
+        Geom::Coord coord = b.nearestTime( rc->mousepoint_doc ); // Coord == double
+        Geom::Point nearest = b( coord );
 
-    return close;
+        double dist_screen = Geom::L2 (rc->mousepoint_doc - nearest) * desktop->current_zoom();
+        if (dist_screen < tolerance) {
+            selected.push_back(curve);
+            if (first) {
+                break;
+            }
+        }
+    }
+    return selected;
 }
 
 
@@ -336,12 +377,13 @@ sp_mesh_context_corner_operation (MeshTool *rc, MeshCornerOperation operation )
 
     std::map<SPMeshGradient*, std::vector<guint> > points;
     std::map<SPMeshGradient*, SPItem*> items;
- 
+    std::map<SPMeshGradient*, Inkscape::PaintTarget> fill_or_stroke;
+
     // Get list of selected draggers for each mesh.
-    // For all selected draggers
+    // For all selected draggers (a dragger may include draggerables from different meshes).
     for (std::set<GrDragger *>::const_iterator i = drag->selected.begin(); i != drag->selected.end(); ++i) {
         GrDragger *dragger = *i;
-        // For all draggables of dragger
+        // For all draggables of dragger (a draggable corresponds to a unique mesh).
         for (std::vector<GrDraggable *>::const_iterator j = dragger->draggables.begin(); j != dragger->draggables.end() ; ++j) { 
             GrDraggable *d = *j;
 
@@ -354,6 +396,7 @@ sp_mesh_context_corner_operation (MeshTool *rc, MeshCornerOperation operation )
             // Collect points together for same gradient
             points[gradient].push_back( d->point_i );
             items[gradient] = d->item;
+            fill_or_stroke[gradient] = d->fill_or_stroke ? Inkscape::FOR_FILL: Inkscape::FOR_STROKE;
         }
     }
 
@@ -389,6 +432,11 @@ sp_mesh_context_corner_operation (MeshTool *rc, MeshCornerOperation operation )
                     noperation += mg->array.color_pick( iter->second, items[iter->first] );
                     break;
 
+                case MG_CORNER_INSERT:
+                    // std::cout << "INSERT" << std::endl;
+                    noperation += mg->array.insert( iter->second );
+                    break;
+
                 default:
                     std::cout << "sp_mesh_corner_operation: unknown operation" << std::endl;
             }                    
@@ -402,22 +450,31 @@ sp_mesh_context_corner_operation (MeshTool *rc, MeshCornerOperation operation )
 
                     case MG_CORNER_SIDE_TOGGLE:
                         DocumentUndo::done(doc, SP_VERB_CONTEXT_MESH, _("Toggled mesh path type."));
+                        drag->local_change = true; // Don't create new draggers.
                         break;
 
                     case MG_CORNER_SIDE_ARC:
                         DocumentUndo::done(doc, SP_VERB_CONTEXT_MESH, _("Approximated arc for mesh side."));
+                        drag->local_change = true; // Don't create new draggers.
                         break;
 
                     case MG_CORNER_TENSOR_TOGGLE:
                         DocumentUndo::done(doc, SP_VERB_CONTEXT_MESH, _("Toggled mesh tensors."));
+                        drag->local_change = true; // Don't create new draggers.
                         break;
 
                     case MG_CORNER_COLOR_SMOOTH:
                         DocumentUndo::done(doc, SP_VERB_CONTEXT_MESH, _("Smoothed mesh corner color."));
+                        drag->local_change = true; // Don't create new draggers.
                         break;
 
                     case MG_CORNER_COLOR_PICK:
                         DocumentUndo::done(doc, SP_VERB_CONTEXT_MESH, _("Picked mesh corner color."));
+                        drag->local_change = true; // Don't create new draggers.
+                        break;
+
+                    case MG_CORNER_INSERT:
+                        DocumentUndo::done(doc, SP_VERB_CONTEXT_MESH, _("Inserted new row or column."));
                         break;
 
                     default:
@@ -426,7 +483,9 @@ sp_mesh_context_corner_operation (MeshTool *rc, MeshCornerOperation operation )
             }
         }
     }
-    drag->updateDraggers();
+
+    // Not needed. Update is done via gr_drag_sel_modified().
+    // drag->updateDraggers();
 
 }
 
@@ -456,38 +515,33 @@ sp_mesh_context_fit_mesh_in_bbox (MeshTool *rc)
         SPItem *item = *i;
         SPStyle *style = item->style;
 
-        if (style && (style->fill.isPaintserver())) {
-            SPPaintServer *server = item->style->getFillPaintServer();
-            if ( SP_IS_MESHGRADIENT(server) ) {
-
-                SPMeshGradient *gradient = SP_MESHGRADIENT(server);
-                SPCurve * outline = gradient->array.outline_path();
-                Geom::OptRect mesh_bbox = outline->get_pathvector().boundsExact();
-                outline->unref();
-                Geom::OptRect item_bbox = item->geometricBounds();
-
-                if ((*mesh_bbox).width() == 0) {
-                    continue;
-                }            
-                if ((*mesh_bbox).height() == 0) {
-                    continue;
+        if (style) {
+
+            if (style->fill.isPaintserver()) {
+                SPPaintServer *server = item->style->getFillPaintServer();
+                if ( SP_IS_MESHGRADIENT(server) ) {
+
+                    Geom::OptRect item_bbox = item->geometricBounds();
+                    SPMeshGradient *gradient = SP_MESHGRADIENT(server);
+                    if (gradient->array.fill_box( item_bbox )) {
+                        changed = true;
+                    }
                 }
-                double scale_x = (*item_bbox).width() /(*mesh_bbox).width() ;
-                double scale_y = (*item_bbox).height()/(*mesh_bbox).height();
-
-                Geom::Translate t1(-(*mesh_bbox).min());
-                Geom::Scale scale(scale_x,scale_y);
-                Geom::Translate t2((*item_bbox).min());
-                Geom::Affine transform = t1 * scale * t2;
-                if (!transform.isIdentity() ) {
-                    gradient->array.transform(transform);
-                    gradient->array.write( gradient );
-                    gradient->requestModified(SP_OBJECT_MODIFIED_FLAG);
-                    changed = true;
+            }
+
+            if (style->stroke.isPaintserver()) {
+                SPPaintServer *server = item->style->getStrokePaintServer();
+                if ( SP_IS_MESHGRADIENT(server) ) {
+
+                    Geom::OptRect item_bbox = item->visualBounds();
+                    SPMeshGradient *gradient = SP_MESHGRADIENT(server);
+                    if (gradient->array.fill_box( item_bbox )) {
+                        changed = true;
+                    }
                 }
             }
+
         }
-   
     }
     if (changed) {
         DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_MESH,
@@ -523,42 +577,42 @@ bool MeshTool::root_handler(GdkEvent* event) {
 
         // Double click:
         //  If over a mesh line, divide mesh row/column
-        //  If not over a line, create new gradients for selected objects.
+        //  If not over a line and no mesh, create new mesh for top selected object.
 
         if ( event->button.button == 1 ) {
-            // Are we over a mesh line?
-            bool over_line = false;
 
-            if (! drag->lines.empty()) {
-                for (std::vector<SPCtrlLine *>::const_iterator l = drag->lines.begin(); l != drag->lines.end() && (!over_line); ++l) {
-                    over_line |= sp_mesh_context_is_over_line (this, *l, Geom::Point(event->motion.x, event->motion.y));
-                }
-            }
+            // Are we over a mesh line?
+            std::vector<SPCtrlCurve *> over_line =
+                sp_mesh_context_over_line(this, Geom::Point(event->motion.x, event->motion.y));
 
-            if (over_line) {
+            if (!over_line.empty()) {
                 // We take the first item in selection, because with doubleclick, the first click
                 // always resets selection to the single object under cursor
                 sp_mesh_context_split_near_point(this, selection->items().front(), this->mousepoint_doc, event->button.time);
             } else {
-                sp_mesh_new_default(*this);
                 // Create a new gradient with default coordinates.
-//             	auto items= selection->items();
-//                 for(auto i=items.begin();i!=items.end();++i){
-//                     SPItem *item = *i;
-//                     SPGradientType new_type = SP_GRADIENT_TYPE_MESH;
-//                     Inkscape::PaintTarget fsmode = (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
-
-// #ifdef DEBUG_MESH
-//                     std::cout << "sp_mesh_context_root_handler: creating new mesh on: " << (fsmode == Inkscape::FOR_FILL ? "Fill" : "Stroke") << std::endl;
-// #endif
-//                     SPGradient *vector = sp_gradient_vector_for_object(desktop->getDocument(), desktop, item, fsmode);
-
-//                     SPGradient *priv = sp_item_set_gradient(item, vector, new_type, fsmode);
-//                     sp_gradient_reset_to_userspace(priv, item);
-//                 }
-
-//                 DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_MESH,
-//                                    _("Create default mesh"));
+
+                // Check if object already has mesh... if it does,
+                // don't create new mesh with click-drag.
+                bool has_mesh = false;
+                if (!selection->isEmpty()) {
+                    SPStyle *style = selection->items().front()->style;
+                    if (style) {
+                        Inkscape::PaintTarget fill_or_stroke =
+                            (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ?
+                            Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
+                        SPPaintServer *server =
+                            (fill_or_stroke == Inkscape::FOR_FILL) ?
+                            style->getFillPaintServer():
+                            style->getStrokePaintServer();
+                        if (server && SP_IS_MESHGRADIENT(server)) 
+                            has_mesh = true;
+                    }
+                }
+
+                if (!has_mesh) {
+                    sp_mesh_new_default(*this);
+                }
             }
 
             ret = TRUE;
@@ -570,10 +624,36 @@ bool MeshTool::root_handler(GdkEvent* event) {
 #ifdef DEBUG_MESH
         std::cout << "sp_mesh_context_root_handler: GDK_BUTTON_PRESS" << std::endl;
 #endif
+
         // Button down
-        //  If Shift key down: do rubber band selection
-        //  Else set origin for drag. A drag creates a new gradient if one does not exist
+        //  If mesh already exists, do rubber band selection.
+        //  Else set origin for drag which will create a new gradient.
          if ( event->button.button == 1 && !this->space_panning ) {
+
+            // Are we over a mesh line?
+            std::vector<SPCtrlCurve *> over_line =
+                sp_mesh_context_over_line(this, Geom::Point(event->motion.x, event->motion.y), false);
+
+            if (!over_line.empty()) {
+                for (std::vector<SPCtrlCurve *>::const_iterator it = over_line.begin();
+                     it != over_line.end(); ++it ) {
+                    SPItem *item = (*it)->item;
+                    Inkscape::PaintTarget fill_or_stroke =
+                        (*it)->is_fill ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
+                    GrDragger* dragger0 = drag->getDraggerFor(item, POINT_MG_CORNER, (*it)->corner0, fill_or_stroke);
+                    GrDragger* dragger1 = drag->getDraggerFor(item, POINT_MG_CORNER, (*it)->corner1, fill_or_stroke);
+                    bool add    = (event->button.state & GDK_SHIFT_MASK);
+                    bool toggle = (event->button.state & GDK_CONTROL_MASK);
+                    if ( !add && !toggle ) {
+                        drag->deselectAll();
+                    }
+                    drag->setSelected( dragger0, true, !toggle );
+                    drag->setSelected( dragger1, true, !toggle );
+                }
+                ret = true;
+                break; // To avoid putting the following code in an else block.
+            }
+
             Geom::Point button_w(event->button.x, event->button.y);
 
             // save drag origin
@@ -584,25 +664,43 @@ bool MeshTool::root_handler(GdkEvent* event) {
             dragging = true;
 
             Geom::Point button_dt = desktop->w2d(button_w);
-            if (event->button.state & GDK_SHIFT_MASK) {
-                Inkscape::Rubberband::get(desktop)->start(desktop, button_dt);
-            } else {
-                // remember clicked item, disregarding groups, honoring Alt; do nothing with Crtl to
-                // enable Ctrl+doubleclick of exactly the selected item(s)
-                if (!(event->button.state & GDK_CONTROL_MASK)) {
-                    this->item_to_select = sp_event_context_find_item (desktop, button_w, event->button.state & GDK_MOD1_MASK, TRUE);
+            // Check if object already has mesh... if it does,
+            // don't create new mesh with click-drag.
+            bool has_mesh = false;
+            if (!selection->isEmpty()) {
+                SPStyle *style = selection->items().front()->style;
+                if (style) {
+                    Inkscape::PaintTarget fill_or_stroke =
+                        (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ?
+                        Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
+                    SPPaintServer *server =
+                        (fill_or_stroke == Inkscape::FOR_FILL) ?
+                        style->getFillPaintServer():
+                        style->getStrokePaintServer();
+                    if (server && SP_IS_MESHGRADIENT(server)) 
+                        has_mesh = true;
                 }
+            }
 
-                if (!selection->isEmpty()) {
-                    SnapManager &m = desktop->namedview->snap_manager;
-                    m.setup(desktop);
-                    m.freeSnapReturnByRef(button_dt, Inkscape::SNAPSOURCE_NODE_HANDLE);
-                    m.unSetup();
-                }
+            if (has_mesh) {
+                Inkscape::Rubberband::get(desktop)->start(desktop, button_dt);
+            }
 
-                this->origin = button_dt;
+            // remember clicked item, disregarding groups, honoring Alt; do nothing with Crtl to
+            // enable Ctrl+doubleclick of exactly the selected item(s)
+            if (!(event->button.state & GDK_CONTROL_MASK)) {
+                this->item_to_select = sp_event_context_find_item (desktop, button_w, event->button.state & GDK_MOD1_MASK, TRUE);
             }
 
+            if (!selection->isEmpty()) {
+                SnapManager &m = desktop->namedview->snap_manager;
+                m.setup(desktop);
+                m.freeSnapReturnByRef(button_dt, Inkscape::SNAPSOURCE_NODE_HANDLE);
+                m.unSetup();
+            }
+
+            this->origin = button_dt;
+
             ret = TRUE;
         }
         break;
@@ -663,19 +761,14 @@ bool MeshTool::root_handler(GdkEvent* event) {
             }
 
             // Change cursor shape if over line
-            bool over_line = false;
+            std::vector<SPCtrlCurve *> over_line =
+                sp_mesh_context_over_line(this, Geom::Point(event->motion.x, event->motion.y));
 
-            if (!drag->lines.empty()) {
-                for (std::vector<SPCtrlLine *>::const_iterator l = drag->lines.begin(); l != drag->lines.end() ; ++l) {
-                    over_line |= sp_mesh_context_is_over_line (this, *l, Geom::Point(event->motion.x, event->motion.y));
-                }
-            }
-
-            if (this->cursor_addnode && !over_line) {
+            if (this->cursor_addnode && over_line.empty()) {
                 this->cursor_shape = cursor_gradient_xpm;
                 this->sp_event_context_update_cursor();
                 this->cursor_addnode = false;
-            } else if (!this->cursor_addnode && over_line) {
+            } else if (!this->cursor_addnode && !over_line.empty()) {
                 this->cursor_shape = cursor_gradient_add_xpm;
                 this->sp_event_context_update_cursor();
                 this->cursor_addnode = true;
@@ -692,23 +785,15 @@ bool MeshTool::root_handler(GdkEvent* event) {
         this->xp = this->yp = 0;
 
         if ( event->button.button == 1 && !this->space_panning ) {
-            // Check if over line
-            bool over_line = false;
-            SPCtrlLine *line = NULL;
-
-            if (!drag->lines.empty()) {
-                for (std::vector<SPCtrlLine *>::const_iterator l = drag->lines.begin(); l != drag->lines.end() && (!over_line); ++l) {
-                    over_line = sp_mesh_context_is_over_line (this, *l, Geom::Point(event->motion.x, event->motion.y));
 
-                    if (over_line) {
-                        break;
-                    }
-                }
-            }
+            // Check if over line
+            std::vector<SPCtrlCurve *> over_line =
+                sp_mesh_context_over_line(this, Geom::Point(event->motion.x, event->motion.y));
 
             if ( (event->button.state & GDK_CONTROL_MASK) && (event->button.state & GDK_MOD1_MASK ) ) {
-                if (over_line && line) {
-                    sp_mesh_context_split_near_point(this, line->item, this->mousepoint_doc, 0);
+                if (!over_line.empty()) {
+                    sp_mesh_context_split_near_point(this, over_line[0]->item,
+                                                     this->mousepoint_doc, 0);
                     ret = TRUE;
                 }
             } else {
@@ -721,22 +806,47 @@ bool MeshTool::root_handler(GdkEvent* event) {
                 }
 
                 if (!this->within_tolerance) {
-                    // we've been dragging, either create a new gradient
-                    // or rubberband-select if we have rubberband
-                    Inkscape::Rubberband *r = Inkscape::Rubberband::get(desktop);
-
-                    if (r->is_started() && !this->within_tolerance) {
-                        // this was a rubberband drag
-                        if (r->getMode() == RUBBERBAND_MODE_RECT) {
-                            Geom::OptRect const b = r->getRectangle();
-                            drag->selectRect(*b);
+
+                    // Check if object already has mesh... if it does,
+                    // don't create new mesh with click-drag.
+                    bool has_mesh = false;
+                    if (!selection->isEmpty()) {
+                        SPStyle *style = selection->items().front()->style;
+                        if (style) {
+                            Inkscape::PaintTarget fill_or_stroke =
+                                (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ?
+                                Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
+                            SPPaintServer *server =
+                                (fill_or_stroke == Inkscape::FOR_FILL) ?
+                                style->getFillPaintServer():
+                                style->getStrokePaintServer();
+                            if (server && SP_IS_MESHGRADIENT(server)) 
+                                has_mesh = true;
                         }
-                    } else {
-                        // Create a new mesh gradient
+                    }
+
+                    if (!has_mesh) {
                         sp_mesh_new_default(*this);
+                    } else {
+
+                        // we've been dragging, either create a new gradient
+                        // or rubberband-select if we have rubberband
+                        Inkscape::Rubberband *r = Inkscape::Rubberband::get(desktop);
+
+                        if (r->is_started() && !this->within_tolerance) {
+                            // this was a rubberband drag
+                            if (r->getMode() == RUBBERBAND_MODE_RECT) {
+                                Geom::OptRect const b = r->getRectangle();
+                                if (!(event->button.state & GDK_SHIFT_MASK)) {
+                                    drag->deselectAll();
+                                }
+                                drag->selectRect(*b);
+                            }
+                        }
                     }
+
                 } else if (this->item_to_select) {
-                    if (over_line && line) {
+                    if (!over_line.empty()) {
                         // Clicked on an existing mesh line, don't change selection. This stops
                         // possible change in selection during a double click with overlapping objects
                     } else {
@@ -744,15 +854,21 @@ bool MeshTool::root_handler(GdkEvent* event) {
                         if (event->button.state & GDK_SHIFT_MASK) {
                             selection->toggle(this->item_to_select);
                         } else {
+                            drag->deselectAll();
                             selection->set(this->item_to_select);
                         }
                     }
                 } else {
-                    // click in an empty space; do the same as Esc
-                    if (!drag->selected.empty()) {
-                        drag->deselectAll();
+                    if (!over_line.empty()) {
+                        // Clicked on an existing mesh line, don't change selection. This stops
+                        // possible change in selection during a double click with overlapping objects
                     } else {
-                        selection->clear();
+                        // click in an empty space; do the same as Esc
+                        if (!drag->selected.empty()) {
+                            drag->deselectAll();
+                        } else {
+                            selection->clear();
+                        }
                     }
                 }
 
@@ -780,10 +896,11 @@ bool MeshTool::root_handler(GdkEvent* event) {
         case GDK_KEY_Shift_R:
         case GDK_KEY_Meta_L:  // Meta is when you press Shift+Alt (at least on my machine)
         case GDK_KEY_Meta_R:
-            sp_event_show_modifier_tip (this->defaultMessageContext(), event,
-                                        _("FIXME<b>Ctrl</b>: snap mesh angle"),
-                                        _("FIXME<b>Shift</b>: draw mesh around the starting point"),
-                                        NULL);
+
+            // sp_event_show_modifier_tip (this->defaultMessageContext(), event,
+            //                             _("FIXME<b>Ctrl</b>: snap mesh angle"),
+            //                             _("FIXME<b>Shift</b>: draw mesh around the starting point"),
+            //                             NULL);
             break;
 
         case GDK_KEY_A:
@@ -901,25 +1018,33 @@ bool MeshTool::root_handler(GdkEvent* event) {
             }
             break;
 
+        // Mesh Operations --------------------------------------------
+
         case GDK_KEY_Insert:
         case GDK_KEY_KP_Insert:
             // with any modifiers:
-            //sp_gradient_context_add_stops_between_selected_stops (rc);
-            std::cout << "Inserting stops between selected stops not implemented yet" << std::endl;
+            sp_mesh_context_corner_operation ( this, MG_CORNER_INSERT );
             ret = TRUE;
             break;
 
+        case GDK_KEY_i:
+        case GDK_KEY_I:
+            if (MOD__SHIFT_ONLY(event)) {
+                // Shift+I - insert corners (alternate keybinding for keyboards
+                //           that don't have the Insert key)
+                sp_mesh_context_corner_operation ( this, MG_CORNER_INSERT );
+                ret = TRUE;
+            }
+            break;
+
         case GDK_KEY_Delete:
         case GDK_KEY_KP_Delete:
         case GDK_KEY_BackSpace:
             if ( !drag->selected.empty() ) {
-                std::cout << "Deleting mesh stops not implemented yet" << std::endl;
                 ret = TRUE;
             }
             break;
 
-        // Mesh Operations --------------------------------------------
-
         case GDK_KEY_b:  // Toggle mesh side between lineto and curveto.
         case GDK_KEY_B: 
             if (MOD__ALT(event) && drag->isNonEmpty() && drag->hasSelection()) {
@@ -1011,6 +1136,16 @@ static void sp_mesh_new_default(MeshTool &rc) {
             (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ?
             Inkscape::FOR_FILL : Inkscape::FOR_STROKE;
 
+        // Ensure mesh is immediately editable.
+        // Editting both fill and stroke at same time doesn't work well so avoid.
+        if (fill_or_stroke == Inkscape::FOR_FILL) {
+            prefs->setBool("/tools/mesh/edit_fill",   true );
+            prefs->setBool("/tools/mesh/edit_stroke", false);
+        } else {
+            prefs->setBool("/tools/mesh/edit_fill",   false);
+            prefs->setBool("/tools/mesh/edit_stroke", true );
+        }
+
 // HACK: reset fill-opacity - that 0.75 is annoying; BUT remove this when we have an opacity slider for all tabs
         SPCSSAttr *css = sp_repr_css_attr_new();
         sp_repr_css_set_property(css, "fill-opacity", "1.0");
@@ -1065,7 +1200,6 @@ static void sp_mesh_new_default(MeshTool &rc) {
     }
 
 }
-
 }
 }
 }