Merge lp:~inkscape.dev/inkscape/mesh_improvements into lp:~inkscape.dev/inkscape/trunk

[Jabiertxof]

This branch improve the mesh gradient code:
Update to angled triangle knots the handles of selected corners.
Highlight current line.

[lp:~inkscape.dev/inkscape/mesh_improvements]

14415. By Jabiertxof <jtx@jtx> on 2016-12-02

Force knot previously. End of split mesh_and_knot branch. knot branch requred

14416. By Jabiertxof <jtx@jtx> on 2016-12-03

Add missing knot code

14417. By Jabiertxof <jtx@jtx> on 2016-12-03

Fix indent

14418. By Jabiertxof <jtx@jtx> on 2016-12-03

Update to trunk

14419. By Jabiertxof <jtx@jtx> on 2016-12-03

Fix blank lines

14420. By Jabiertxof <jtx@jtx> on 2016-12-03

Remove knot_improvements data

14421. By Jabiertxof <jtx@jtx> on 2016-12-03

Add knot_improvements data

14422. By Jabiertxof <jtx@jtx> on 2016-12-03

Update to trunk

14423. By Jabiertxof <jtx@jtx> on 2016-12-03

Update to trunk

[Jabiertxof (jabiertxof)]

merged

review: Approve

=== modified file 'src/gradient-drag.cpp'
--- src/gradient-drag.cpp	2016-12-01 13:05:02 +0000
+++ src/gradient-drag.cpp	2016-12-03 19:47:59 +0000
@@ -62,6 +62,7 @@
 guint32 const GR_KNOT_COLOR_NORMAL     = 0xffffff00;
 guint32 const GR_KNOT_COLOR_MOUSEOVER  = 0xff000000;
 guint32 const GR_KNOT_COLOR_SELECTED   = 0x0000ff00;
+guint32 const GR_KNOT_COLOR_HIGHLIGHT  = 0xffffff00;
 guint32 const GR_KNOT_COLOR_MESHCORNER = 0xbfbfbf00;
 
 guint32 const GR_LINE_COLOR_FILL       = 0x0000ff7f;
@@ -733,10 +734,12 @@
 static void gr_knot_moved_handler(SPKnot *knot, Geom::Point const &ppointer, guint state, gpointer data)
 {
     GrDragger *dragger = (GrDragger *) data;
-    GrDrag *drag = dragger->parent;
-
+    GrDraggable *draggable = (GrDraggable *) dragger->draggables[0];
+    if (!draggable) return;
     Geom::Point p = ppointer;
-
+    GrDragger *dragger_corner = dragger->getMgCorner();
+    GrDrag *drag = dragger_corner->parent;
+    dragger_corner->highlightCorner(true);
     SPDesktop *desktop = dragger->parent->desktop;
     SnapManager &m = desktop->namedview->snap_manager;
     double snap_dist = m.snapprefs.getObjectTolerance() / dragger->parent->desktop->current_zoom();
@@ -1058,7 +1061,13 @@
 static void gr_knot_grabbed_handler(SPKnot */*knot*/, unsigned int /*state*/, gpointer data)
 {
     GrDragger *dragger = (GrDragger *) data;
-
+    GrDragger *dragger_corner = dragger->getMgCorner();
+    GrDrag *drag = dragger_corner->parent;
+    for(std::vector<GrDragger *>::const_iterator it = drag->draggers.begin(); it != drag->draggers.end(); ++it) { //for all selected draggers
+        GrDragger *d = *it;
+        d->highlightCorner(false);
+    }
+    dragger_corner->highlightCorner(true);
     dragger->parent->desktop->canvas->forceFullRedrawAfterInterruptions(5);
 }
 
@@ -1068,7 +1077,6 @@
 static void gr_knot_ungrabbed_handler(SPKnot *knot, unsigned int state, gpointer data)
 {
     GrDragger *dragger = (GrDragger *) data;
-
     dragger->parent->desktop->canvas->endForcedFullRedraws();
 
     dragger->point_original = dragger->point = knot->pos;
@@ -1107,7 +1115,6 @@
     GrDragger *dragger = (GrDragger *) data;
     GrDraggable *draggable = dragger->draggables[0];
     if (!draggable) return;
-
     if ( (state & GDK_CONTROL_MASK) && (state & GDK_MOD1_MASK ) ) {
     // delete this knot from vector
         SPGradient *gradient = getGradient(draggable->item, draggable->fill_or_stroke);
@@ -1209,6 +1216,30 @@
     }
 }
 
+void GrDragger::updateControlSizesOverload(SPKnot * knot)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    int sizes[] = {4, 6, 8, 10, 12, 14, 16};
+    std::vector<int> sizeTable = std::vector<int>(sizes, sizes + (sizeof(sizes) / sizeof(sizes[0])));
+    int size = prefs->getIntLimited("/options/grabsize/value", 3, 1, 7);
+    int knot_size = sizeTable[size - 1];
+    if(knot->shape == SP_KNOT_SHAPE_TRIANGLE){
+        knot_size *= 2.2;
+        knot_size = floor(knot_size);
+        if ( knot_size % 2 == 0 ){
+            knot_size += 1;
+        }
+    }
+    knot->setSize(knot_size);
+}
+
+void GrDragger::updateControlSizes()
+{
+    updateControlSizesOverload(this->knot);
+    this->knot->updateCtrl();
+    this->updateKnotShape();
+}
+
 /**
  * Checks if the dragger has a draggable with this point_type.
  */
@@ -1385,6 +1416,7 @@
         for( guint i = 0; i < mg->array.handles.size(); ++i ) {
             GrDragger *handle = drag->getDraggerFor( item, POINT_MG_HANDLE, i, fill_or_stroke ); 
             SPKnot *knot = handle->knot;
+            knot->setFill(GR_KNOT_COLOR_NORMAL, GR_KNOT_COLOR_MOUSEOVER, GR_KNOT_COLOR_MOUSEOVER);
             Geom::Point pk = getGradientCoords( item, POINT_MG_HANDLE, i, fill_or_stroke );
             knot->moveto(pk);
 
@@ -1462,8 +1494,18 @@
 {
     if (draggables.empty())
         return;
-    GrDraggable *last = draggables.back();
+    GrDraggable *last =  draggables.back();
+    bool highlight = false;
+    if(this->knot->shape == SP_KNOT_SHAPE_TRIANGLE){
+        highlight = true;
+    }
     g_object_set (G_OBJECT (this->knot->item), "shape", gr_knot_shapes[last->point_type], NULL);
+    if(highlight){
+        this->knot->setFill(GR_KNOT_COLOR_HIGHLIGHT, GR_KNOT_COLOR_MOUSEOVER, GR_KNOT_COLOR_MOUSEOVER);
+        if(gr_knot_shapes[last->point_type] == SP_KNOT_SHAPE_CIRCLE){
+            g_object_set (G_OBJECT (this->knot->item), "shape", SP_KNOT_SHAPE_TRIANGLE, NULL);
+        }
+    }
 }
 
 /**
@@ -1608,6 +1650,7 @@
     }
     this->knot->setFill(fill_color, GR_KNOT_COLOR_MOUSEOVER, GR_KNOT_COLOR_MOUSEOVER);
     this->knot->setStroke(0x0000007f, 0x0000007f, 0x0000007f);
+    this->updateControlSizesOverload(this->knot);
     this->knot->updateCtrl();
 
     // move knot to the given point
@@ -1626,6 +1669,7 @@
         this->_moved_connection = this->knot->moved_signal.connect(sigc::bind(sigc::ptr_fun(gr_knot_moved_handler), this));
     }
 
+    this->sizeUpdatedConn = ControlManager::getManager().connectCtrlSizeChanged(sigc::mem_fun(*this, &GrDragger::updateControlSizes));
     this->_clicked_connection = this->knot->click_signal.connect(sigc::bind(sigc::ptr_fun(gr_knot_clicked_handler), this));
     this->_doubleclicked_connection = this->knot->doubleclicked_signal.connect(sigc::bind(sigc::ptr_fun(gr_knot_doubleclicked_handler), this));
     this->_grabbed_connection = this->knot->grabbed_signal.connect(sigc::bind(sigc::ptr_fun(gr_knot_grabbed_handler), this));
@@ -1635,7 +1679,7 @@
     if (draggable) {
         this->addDraggable (draggable);
     }
-
+    
     updateKnotShape();
 }
 
@@ -1648,6 +1692,7 @@
     //this->parent->setDeselected(this);
 
     // disconnect signals
+    this->sizeUpdatedConn.disconnect();
     this->_moved_connection.disconnect();
     this->_clicked_connection.disconnect();
     this->_doubleclicked_connection.disconnect();
@@ -1708,6 +1753,180 @@
     }
 }
 
+GrDragger * 
+GrDragger::getMgCorner(){
+    GrDraggable *draggable = (GrDraggable *) this->draggables[0];
+    if (draggable){
+        if(draggable->point_type == POINT_MG_CORNER){
+            return this;
+        }
+        SPGradient *gradient = getGradient(draggable->item, draggable->fill_or_stroke);
+        if (SP_IS_MESHGRADIENT( gradient ) ){
+            SPMeshGradient *mg = SP_MESHGRADIENT( gradient );
+            std::vector< std::vector< SPMeshNode* > > nodes = mg->array.nodes;
+            for( guint i = 0; i < nodes.size(); ++i ) {
+                for( guint j = 0; j < nodes[i].size(); ++j ) {
+                    if( nodes[i][j]->set ) {
+                        if( nodes[i][j]->node_type == MG_NODE_TYPE_HANDLE){
+                            if(draggable->point_i == (gint)nodes[i][j]->draggable){
+                                if(nodes.size() > i+1 && nodes[i+1].size() > j && nodes[i+1][j]->node_type == MG_NODE_TYPE_CORNER){
+                                    return this->parent->getDraggerFor(draggable->item, POINT_MG_CORNER,  nodes[i+1][j]->draggable, draggable->fill_or_stroke);
+                                }
+                                if(j != 0 && nodes.size() > i && nodes[i].size() > j-1 && nodes[i][j-1]->node_type == MG_NODE_TYPE_CORNER){
+                                    return this->parent->getDraggerFor(draggable->item, POINT_MG_CORNER,  nodes[i][j-1]->draggable, draggable->fill_or_stroke);
+                                }
+                                if(i != 0 && nodes.size() > i-1 && nodes[i-1].size() > j && nodes[i-1][j]->node_type == MG_NODE_TYPE_CORNER){
+                                    return this->parent->getDraggerFor(draggable->item, POINT_MG_CORNER,  nodes[i-1][j]->draggable, draggable->fill_or_stroke);
+                                }
+                                if(nodes.size() > i && nodes[i].size() > j+1 && nodes[i][j+1]->node_type == MG_NODE_TYPE_CORNER){
+                                    return this->parent->getDraggerFor(draggable->item, POINT_MG_CORNER,  nodes[i][j+1]->draggable, draggable->fill_or_stroke);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return NULL;
+}
+
+mgDraggerPosition
+GrDragger::getMgDraggerPosition(){
+    GrDraggable *draggable = (GrDraggable *) this->draggables[0];
+    if (draggable && draggable->point_i < G_MAXINT){
+        NodeType type = MG_NODE_TYPE_TENSOR;
+        if(draggable->point_type == POINT_MG_HANDLE){
+            type = MG_NODE_TYPE_HANDLE;
+        } else if (draggable->point_type == POINT_MG_CORNER){
+            type = MG_NODE_TYPE_CORNER;
+        }
+        SPGradient *gradient = getGradient(draggable->item, draggable->fill_or_stroke);
+        if (SP_IS_MESHGRADIENT( gradient ) ){
+            SPMeshGradient *mg = SP_MESHGRADIENT( gradient );
+            SPMeshNodeArray mg_arr = mg->array;
+            std::vector< std::vector< SPMeshNode* > > nodes = mg_arr.nodes;
+            for( guint i = 0; i < nodes.size(); ++i ) {
+                for( guint j = 0; j < nodes[i].size(); ++j ) {
+                    if( nodes[i][j]->set) {
+                        if(draggable->point_i == (gint)nodes[i][j]->draggable && type == nodes[i][j]->node_type){
+                            if( nodes[i][j]->node_type == MG_NODE_TYPE_HANDLE){
+                                if(nodes.size() > i+1 && nodes[i+1].size() > j && nodes[i+1][j]->node_type == MG_NODE_TYPE_CORNER){
+                                    return std::make_pair(MG_D_BOTTOM,std::make_pair(i,j));
+                                }
+                                if(j != 0 && nodes.size() > i && nodes[i].size() > j-1 && nodes[i][j-1]->node_type == MG_NODE_TYPE_CORNER){
+                                    return std::make_pair(MG_D_LEFT,std::make_pair(i,j));
+                                }
+                                if(i != 0 && nodes.size() > i-1 && nodes[i-1].size() > j && nodes[i-1][j]->node_type == MG_NODE_TYPE_CORNER){
+                                    return std::make_pair(MG_D_TOP,std::make_pair(i,j));
+                                }
+                                if(nodes.size() > i && nodes[i].size() > j+1 && nodes[i][j+1]->node_type == MG_NODE_TYPE_CORNER){
+                                    return std::make_pair(MG_D_RIGHT,std::make_pair(i,j));
+                                }
+                            }
+                            if(nodes[i][j]->node_type == MG_NODE_TYPE_CORNER){
+                                 return std::make_pair(MG_D_CENTER,std::make_pair(i,j));
+                            }
+                        }
+                        
+                    }
+                }
+            }
+        }
+    }
+    return std::make_pair(MG_D_NONE, std::make_pair(0,0));
+}
+
+void GrDragger::highlightNode(SPMeshNode* node, bool highlight, Geom::Point corner_pos)
+{
+    GrPointType type = POINT_MG_TENSOR;
+    if(node->node_type == MG_NODE_TYPE_HANDLE){
+        type = POINT_MG_HANDLE;
+    }
+    GrDraggable *draggable = (GrDraggable *) this->draggables[0];
+    GrDragger *d = this->parent->getDraggerFor(draggable->item, type, node->draggable, draggable->fill_or_stroke);
+    if (d && node->draggable < G_MAXUINT) {
+        Geom::Point end = d->knot->pos;
+        double angl = Geom::Ray(corner_pos, end).angle();
+        if(highlight && knot->fill[SP_KNOT_VISIBLE] == GR_KNOT_COLOR_HIGHLIGHT && abs(angl - knot->angle) > Geom::rad_from_deg(10.0)){
+            return;
+        }
+        SPKnot *knot = d->knot;
+        if(highlight){
+            knot->setFill(GR_KNOT_COLOR_HIGHLIGHT, GR_KNOT_COLOR_MOUSEOVER, GR_KNOT_COLOR_MOUSEOVER);
+        } else {
+            knot->setFill(GR_KNOT_COLOR_NORMAL, GR_KNOT_COLOR_MOUSEOVER, GR_KNOT_COLOR_MOUSEOVER);
+        }
+        if(type == POINT_MG_HANDLE){
+            if(highlight){
+                knot->setShape(SP_KNOT_SHAPE_TRIANGLE);
+            } else {
+                knot->setShape(SP_KNOT_SHAPE_CIRCLE);
+                
+            }
+        } else {
+            //Code for tensors
+            return;
+        }
+        this->updateControlSizesOverload(knot);
+        knot->setAngle(angl);
+        knot->updateCtrl();
+        d->updateKnotShape();
+    }
+}
+
+void  GrDragger::highlightCorner(bool highlight)
+{
+    // Must be a mesh gradient
+    GrDraggable *draggable = (GrDraggable *) this->draggables[0];
+    if (draggable &&  draggable->point_type == POINT_MG_CORNER){
+        SPGradient *gradient = getGradient(draggable->item, draggable->fill_or_stroke);
+        if (SP_IS_MESHGRADIENT( gradient ) ){
+            Geom::Point corner_point = this->point;
+            gint corner = draggable->point_i;
+            SPMeshGradient *mg = SP_MESHGRADIENT( gradient );
+            SPMeshNodeArray mg_arr = mg->array;
+            std::vector< std::vector< SPMeshNode* > > nodes = mg_arr.nodes;
+            // Find number of patch rows and columns
+            guint mrow = mg_arr.patch_rows();
+            guint mcol = mg_arr.patch_columns();
+            // Number of corners in a row of patches.
+            guint ncorners = mcol + 1;
+            // Find corner row/column
+            guint crow = corner / ncorners;
+            guint ccol = corner % ncorners;
+            // Find node row/column
+            guint nrow  = crow * 3;
+            guint ncol  = ccol * 3;
+
+            bool patch[4];
+            patch[0] = patch[1] = patch[2] = patch[3] = false;
+            if( ccol > 0    && crow > 0) patch[0] = true;
+            if( ccol < mcol && crow > 0    ) patch[1] = true;
+            if( ccol < mcol && crow < mrow ) patch[2] = true;
+            if( ccol > 0    && crow < mrow ) patch[3] = true;
+            if( patch[0] || patch[1] ) {
+                highlightNode(nodes[nrow-1][ncol  ], highlight, corner_point);
+            }
+            if( patch[1] || patch[2] )  {
+                highlightNode(nodes[nrow  ][ncol+1], highlight, corner_point);
+            }
+            if( patch[2] || patch[3] ) {
+                highlightNode(nodes[nrow+1][ncol  ], highlight, corner_point);
+            }
+            if( patch[3] || patch[0] ) {
+                highlightNode(nodes[nrow  ][ncol-1], highlight, corner_point);
+            }
+            // Highlight tensors
+            /*
+            if( patch[0] ) highlightNode(nodes[nrow-1][ncol-1], highlight, corner_point, point_i);
+            if( patch[1] ) highlightNode(nodes[nrow-1][ncol+1], highlight, corner_point, point_i);
+            if( patch[2] ) highlightNode(nodes[nrow+1][ncol+1], highlight, corner_point, point_i);
+            if( patch[3] ) highlightNode(nodes[nrow+1][ncol-1], highlight, corner_point, point_i);
+            */
+        }
+    }
+}
 
 /**
  * Draw this dragger as selected.
@@ -1716,6 +1935,7 @@
 {
     this->knot->fill [SP_KNOT_STATE_NORMAL] = GR_KNOT_COLOR_SELECTED;
     g_object_set (G_OBJECT (this->knot->item), "fill_color", GR_KNOT_COLOR_SELECTED, NULL);
+    highlightCorner(true);
     //if( isA(POINT_MG_CORNER) ) {
     //    for (GSList * drgble = this->draggables; drgble != NULL; drgble = drgble->next) {
     //        GrDraggable *draggable = (GrDraggable*) drgble->data;
@@ -1733,6 +1953,7 @@
     guint32 fill_color = isA(POINT_MG_CORNER) ? GR_KNOT_COLOR_MESHCORNER : GR_KNOT_COLOR_NORMAL;
     this->knot->fill [SP_KNOT_STATE_NORMAL] = fill_color;
     g_object_set (G_OBJECT (this->knot->item), "fill_color", fill_color, NULL);
+    highlightCorner(false);
     // MESH FIXME: TURN OFF CORRESPONDING SIDE/TENSOR NODE VISIBILITY
 }
 
@@ -1903,10 +2124,14 @@
  * Create a curve from p0 to p3 and add it to the lines list. Used for mesh sides.
  */
 void GrDrag::addCurve(SPItem *item, Geom::Point p0, Geom::Point p1, Geom::Point p2, Geom::Point p3,
-                      int corner0, int corner1, Inkscape::PaintTarget fill_or_stroke)
+                      int corner0, int corner1, Inkscape::PaintTarget fill_or_stroke, bool highlight)
+
 {
     // CtrlLineType only sets color
     CtrlLineType type = (fill_or_stroke == Inkscape::FOR_FILL) ? CTLINE_PRIMARY : CTLINE_SECONDARY;
+    if(highlight){
+        type = (fill_or_stroke == Inkscape::FOR_FILL) ?  CTLINE_SECONDARY : CTLINE_PRIMARY;
+    }
     SPCtrlCurve *line = ControlManager::getManager().createControlCurve(this->desktop->getControls(), p0, p1, p2, p3, type); 
     line->corner0 = corner0;
     line->corner1 = corner1;
@@ -2265,12 +2490,20 @@
  */
 bool GrDrag::mouseOver()
 {
+    static bool mouse_out = false;
+    // added knot mouse out for future use
     for (std::vector<GrDragger *>::const_iterator l = this->draggers.begin(); l != this->draggers.end(); ++l) {
         GrDragger *d = *l; 
         if (d->knot && (d->knot->flags & SP_KNOT_MOUSEOVER)) {
+            mouse_out = true;
+            updateLines();
             return true;
         }
     }
+    if(mouse_out == true){
+        updateLines();
+        mouse_out = false;
+    }
     return false;
 }
 
@@ -2284,16 +2517,22 @@
     for (std::vector<SPCtrlLine *>::const_iterator i = this->lines.begin(); i != this->lines.end(); ++i) {
         sp_canvas_item_destroy(SP_CANVAS_ITEM(*i));
     }
+    bool highlight = false;
     this->lines.clear();
-
     g_return_if_fail(this->selection != NULL);
 
+    mgDraggerPosition mg_dragger_position = std::make_pair(MG_D_NONE, std::make_pair(0,0));
+    for (std::vector<GrDragger *>::const_iterator it = this->draggers.begin(); it != this->draggers.end() ; ++it ) {
+        GrDragger *d = *it;
+        if (d->knot && (d->knot->flags & SP_KNOT_MOUSEOVER)) {
+            mg_dragger_position = d->getMgDraggerPosition();
+            break;
+        }
+    }
     auto list = this->selection->items();
     for (auto i = list.begin(); i != list.end(); ++i) {
         SPItem *item = *i;
-
         SPStyle *style = item->style;
-
         if (style && (style->fill.isPaintserver())) {
             SPPaintServer *server = item->style->getFillPaintServer();
             if ( server && SP_IS_GRADIENT( server ) ) {
@@ -2307,62 +2546,90 @@
                     addLine(item, center, getGradientCoords(item, POINT_RG_R1, 0, Inkscape::FOR_FILL), Inkscape::FOR_FILL);
                     addLine(item, center, getGradientCoords(item, POINT_RG_R2, 0, Inkscape::FOR_FILL), Inkscape::FOR_FILL);
                 } else if ( SP_IS_MESHGRADIENT(server) ) {
-
                     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
                     bool edit_fill    = abs(prefs->getBool("/tools/mesh/edit_fill",    true));
-
                     SPMeshGradient *mg = SP_MESHGRADIENT(server);
-
                     if (edit_fill) {
-                    guint rows    = mg->array.patch_rows();
-                    guint columns = mg->array.patch_columns();
-                    for ( guint i = 0; i < rows; ++i ) {
-                        for ( guint j = 0; j < columns; ++j ) {
-
-                            std::vector<Geom::Point> h;
-
-                            SPMeshPatchI patch( &(mg->array.nodes), i, j );
-
-                            // clockwise around patch, used to find corner dragger
-                            int corner0 = i * (columns + 1) + j;
-                            int corner1 = corner0 + 1;
-                            int corner2 = corner1 + columns + 1;
-                            int corner3 = corner2 - 1;
-
-                            // Top line
-                            h = patch.getPointsForSide( 0 );
-                            for( guint p = 0; p < 4; ++p ) {
-                                h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
-                            }
-                            addCurve (item, h[0], h[1], h[2], h[3], corner0, corner1, Inkscape::FOR_FILL );
-
-                            // Right line
-                            if( j == columns - 1 ) {
-                                h = patch.getPointsForSide( 1 );
-                                for( guint p = 0; p < 4; ++p ) {
-                                    h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
-                                }
-                                addCurve (item, h[0], h[1], h[2], h[3], corner1, corner2, Inkscape::FOR_FILL );
-                            }
-
-                            // Bottom line
-                            if( i == rows    - 1 ) {
-                                h = patch.getPointsForSide( 2 );
-                                for( guint p = 0; p < 4; ++p ) {
-                                    h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
-                                }
-                                addCurve (item, h[0], h[1], h[2], h[3], corner2, corner3, Inkscape::FOR_FILL );
-                            }
-
-                            // Left line
-                            h = patch.getPointsForSide( 3 );
-                            for( guint p = 0; p < 4; ++p ) {
-                                h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
-                            }
-                            addCurve (item, h[0], h[1], h[2], h[3], corner3, corner0, Inkscape::FOR_FILL );
+                        guint rows    = mg->array.patch_rows();
+                        guint columns = mg->array.patch_columns();
+                        for ( guint i = 0; i < rows; ++i ) {
+                            for ( guint j = 0; j < columns; ++j ) {
+                                std::vector<Geom::Point> h;
+                                SPMeshPatchI patch( &(mg->array.nodes), i, j );
+                                // clockwise around patch, used to find corner dragger
+                                int corner0 = i * (columns + 1) + j;
+                                int corner1 = corner0 + 1;
+                                int corner2 = corner1 + columns + 1;
+                                int corner3 = corner2 - 1;
+                                // Top line
+                                h = patch.getPointsForSide( 0 );
+                                for( guint p = 0; p < 4; ++p ) {
+                                    h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
+                                }
+                                highlight = false;
+                                if(mg_dragger_position.first != MG_D_NONE && 
+                                    ((mg_dragger_position.first == MG_D_CENTER  && mg_dragger_position.second.first/3 == i && mg_dragger_position.second.second/3 == j) ||
+                                    (mg_dragger_position.first == MG_D_CENTER  && mg_dragger_position.second.first/3 == i && (mg_dragger_position.second.second/3)-1 == j) ||
+                                    (mg_dragger_position.first == MG_D_RIGHT && mg_dragger_position.second.first/3  == i && mg_dragger_position.second.second/3 == j) ||
+                                    (mg_dragger_position.first == MG_D_LEFT && mg_dragger_position.second.first/3 == i && mg_dragger_position.second.second/3 == j)))
+                                {
+                                    highlight = true;
+                                }
+                                addCurve (item, h[0], h[1], h[2], h[3], corner0, corner1, Inkscape::FOR_FILL, highlight);
+                                // Right line
+                                if( j == columns - 1 ) {
+                                    h = patch.getPointsForSide( 1 );
+                                    for( guint p = 0; p < 4; ++p ) {
+                                        h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
+                                    }
+                                    highlight = false;
+                                    if(mg_dragger_position.first != MG_D_NONE && 
+                                        ((mg_dragger_position.first == MG_D_CENTER  && mg_dragger_position.second.first/3 == i && (mg_dragger_position.second.second/3) >j) ||
+                                        (mg_dragger_position.first == MG_D_CENTER  && (mg_dragger_position.second.first/3)-1 == i && (mg_dragger_position.second.second/3)  > j) ||
+                                        (mg_dragger_position.first == MG_D_TOP && mg_dragger_position.second.first/3  == i && (mg_dragger_position.second.second/3) > j) ||
+                                        (mg_dragger_position.first == MG_D_BOTTOM && mg_dragger_position.second.first/3 == i && (mg_dragger_position.second.second/3) > j)))
+                                    {
+                                        highlight = true;
+                                    }
+                                    addCurve (item, h[0], h[1], h[2], h[3], corner1, corner2, Inkscape::FOR_FILL, highlight);
+                                }
+
+                                // Bottom line
+                                if( i == rows    - 1 ) {
+                                    h = patch.getPointsForSide( 2 );
+                                    for( guint p = 0; p < 4; ++p ) {
+                                        h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
+                                    }
+                                    highlight = false;
+                                    if(mg_dragger_position.first != MG_D_NONE && 
+                                        ((mg_dragger_position.first == MG_D_CENTER  && (mg_dragger_position.second.first/3) > i && mg_dragger_position.second.second/3 == j) ||
+                                        (mg_dragger_position.first == MG_D_CENTER  && (mg_dragger_position.second.first/3) > i && (mg_dragger_position.second.second/3)-1 == j) ||
+                                        (mg_dragger_position.first == MG_D_RIGHT && (mg_dragger_position.second.first/3) > i && mg_dragger_position.second.second/3 == j) ||
+                                        (mg_dragger_position.first == MG_D_LEFT && (mg_dragger_position.second.first/3) > i && mg_dragger_position.second.second/3 == j)))
+                                    {
+                                        highlight = true;
+                                    }
+                                    addCurve (item, h[0], h[1], h[2], h[3], corner2, corner3, Inkscape::FOR_FILL, highlight );
+                                }
+
+                                // Left line
+                                h = patch.getPointsForSide( 3 );
+                                for( guint p = 0; p < 4; ++p ) {
+                                    h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
+                                }          
+                                highlight = false;
+                                if(mg_dragger_position.first != MG_D_NONE && 
+                                    ((mg_dragger_position.first == MG_D_CENTER  && mg_dragger_position.second.first/3 == i && mg_dragger_position.second.second/3 == j) ||
+                                    (mg_dragger_position.first == MG_D_CENTER  && (mg_dragger_position.second.first/3)-1 == i && mg_dragger_position.second.second/3 == j) ||
+                                    (mg_dragger_position.first == MG_D_TOP && mg_dragger_position.second.first/3  == i && mg_dragger_position.second.second/3 == j) ||
+                                    (mg_dragger_position.first == MG_D_BOTTOM && mg_dragger_position.second.first/3 == i && mg_dragger_position.second.second/3 == j)))
+                                {
+                                    highlight = true;
+                                }
+                                addCurve (item, h[0], h[1], h[2], h[3], corner3, corner0, Inkscape::FOR_FILL, highlight );
+                            }
                         }
                     }
-                    }
                 }                        
             }
         }
@@ -2388,14 +2655,12 @@
 
                     // MESH FIXME: TURN ROUTINE INTO FUNCTION AND CALL FOR BOTH FILL AND STROKE.
                     SPMeshGradient *mg = SP_MESHGRADIENT(server);
-
                     guint rows    = mg->array.patch_rows();
                     guint columns = mg->array.patch_columns();
                     for ( guint i = 0; i < rows; ++i ) {
                         for ( guint j = 0; j < columns; ++j ) {
-
+                            
                             std::vector<Geom::Point> h;
-
                             SPMeshPatchI patch( &(mg->array.nodes), i, j );
 
                             // clockwise around patch, used to find corner dragger
@@ -2409,7 +2674,17 @@
                             for( guint p = 0; p < 4; ++p ) {
                                 h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
                             }
-                            addCurve (item, h[0], h[1], h[2], h[3], corner0, corner1, Inkscape::FOR_STROKE );
+
+                            highlight = false;
+                            if(mg_dragger_position.first != MG_D_NONE && 
+                                ((mg_dragger_position.first == MG_D_CENTER  && mg_dragger_position.second.first/3 == i && mg_dragger_position.second.second/3 == j) ||
+                                (mg_dragger_position.first == MG_D_CENTER  && mg_dragger_position.second.first/3 == i && (mg_dragger_position.second.second/3)-1 == j) ||
+                                (mg_dragger_position.first == MG_D_RIGHT && mg_dragger_position.second.first/3  == i && mg_dragger_position.second.second/3 == j) ||
+                                (mg_dragger_position.first == MG_D_LEFT && mg_dragger_position.second.first/3 == i && mg_dragger_position.second.second/3 == j)))
+                            {
+                                highlight = true;
+                            }
+                            addCurve (item, h[0], h[1], h[2], h[3], corner0, corner1, Inkscape::FOR_STROKE, highlight);
 
                             // Right line
                             if( j == columns - 1 ) {
@@ -2417,7 +2692,16 @@
                                 for( guint p = 0; p < 4; ++p ) {
                                     h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
                                 }
-                                addCurve (item, h[0], h[1], h[2], h[3], corner1, corner2, Inkscape::FOR_STROKE );
+                                highlight = false;
+                                if(mg_dragger_position.first != MG_D_NONE && 
+                                    ((mg_dragger_position.first == MG_D_CENTER  && mg_dragger_position.second.first/3 == i && (mg_dragger_position.second.second/3) >j) ||
+                                    (mg_dragger_position.first == MG_D_CENTER  && (mg_dragger_position.second.first/3)-1 == i && (mg_dragger_position.second.second/3)  > j) ||
+                                    (mg_dragger_position.first == MG_D_TOP && mg_dragger_position.second.first/3  == i && (mg_dragger_position.second.second/3) > j) ||
+                                    (mg_dragger_position.first == MG_D_BOTTOM && mg_dragger_position.second.first/3 == i && (mg_dragger_position.second.second/3) > j)))
+                                {
+                                    highlight = true;
+                                }
+                                addCurve (item, h[0], h[1], h[2], h[3], corner1, corner2, Inkscape::FOR_STROKE, highlight );
                             }
 
                             // Bottom line
@@ -2426,7 +2710,16 @@
                                 for( guint p = 0; p < 4; ++p ) {
                                     h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
                                 }
-                                addCurve (item, h[0], h[1], h[2], h[3], corner2, corner3, Inkscape::FOR_STROKE );
+                                highlight = false;
+                                if(mg_dragger_position.first != MG_D_NONE && 
+                                    ((mg_dragger_position.first == MG_D_CENTER  && (mg_dragger_position.second.first/3) > i && mg_dragger_position.second.second/3 == j) ||
+                                    (mg_dragger_position.first == MG_D_CENTER  && (mg_dragger_position.second.first/3) > i && (mg_dragger_position.second.second/3)-1 == j) ||
+                                    (mg_dragger_position.first == MG_D_RIGHT && (mg_dragger_position.second.first/3) > i && mg_dragger_position.second.second/3 == j) ||
+                                    (mg_dragger_position.first == MG_D_LEFT && (mg_dragger_position.second.first/3) > i && mg_dragger_position.second.second/3 == j)))
+                                {
+                                    highlight = true;
+                                }
+                                addCurve (item, h[0], h[1], h[2], h[3], corner2, corner3, Inkscape::FOR_STROKE, highlight );
                             }
 
                             // Left line
@@ -2434,7 +2727,17 @@
                             for( guint p = 0; p < 4; ++p ) {
                                 h[p] *= Geom::Affine(mg->gradientTransform) * (Geom::Affine)item->i2dt_affine();
                             }
-                            addCurve (item, h[0], h[1], h[2], h[3], corner3, corner0, Inkscape::FOR_STROKE );
+                            highlight = false;
+                            if(mg_dragger_position.first != MG_D_NONE && 
+                                ((mg_dragger_position.first == MG_D_CENTER  && mg_dragger_position.second.first/3 == i && mg_dragger_position.second.second/3 == j) ||
+                                (mg_dragger_position.first == MG_D_CENTER  && (mg_dragger_position.second.first/3)-1 == i && mg_dragger_position.second.second/3 == j) ||
+                                (mg_dragger_position.first == MG_D_TOP && mg_dragger_position.second.first/3  == i && mg_dragger_position.second.second/3 == j) ||
+                                (mg_dragger_position.first == MG_D_BOTTOM && mg_dragger_position.second.first/3 == i && mg_dragger_position.second.second/3 == j)))
+                            {
+                                highlight = true;
+                            }
+                            addCurve (item, h[0], h[1], h[2], h[3], corner3, corner0, Inkscape::FOR_STROKE, highlight  );
+
                         }
                     }
                     }

=== modified file 'src/gradient-drag.h'
--- src/gradient-drag.h	2016-11-23 09:23:22 +0000
+++ src/gradient-drag.h	2016-12-03 19:47:59 +0000
@@ -25,7 +25,6 @@
 #include <glibmm/ustring.h>
 
 #include <2geom/point.h>
-
 #include "sp-gradient.h" // TODO refactor enums to external .h file
 #include "sp-mesh-array.h"
 
@@ -44,6 +43,16 @@
 class Selection;
 } // namespace Inkscape
 
+enum GrDraggerPositions {
+    MG_D_CENTER = 0, //Corner
+    MG_D_TOP,    //Top dragger
+    MG_D_RIGHT,     //Right dragger
+    MG_D_BOTTOM,    //Bottom dragger
+    MG_D_LEFT,     // Left dragger
+    MG_D_NONE    // Invalid dragger
+};
+typedef std::pair<GrDraggerPositions,std::pair<guint,guint> > mgDraggerPosition;
+
 /**
 This class represents a single draggable point of a gradient. It remembers the item
 which has the gradient, whether it's fill or stroke, the point type (from the
@@ -94,6 +103,10 @@
     void updateKnotShape();
     void updateTip();
 
+    mgDraggerPosition getMgDraggerPosition();
+    GrDragger *getMgCorner();
+    void highlightNode(SPMeshNode* node, bool highlight, Geom::Point corner_pos);
+    void highlightCorner(bool highlight);
     void select();
     void deselect();
     bool isSelected();
@@ -116,6 +129,11 @@
 
     void fireDraggables(bool write_repr, bool scale_radial = false, bool merging_focus = false);
 
+protected:
+    void updateControlSizesOverload(SPKnot * knot);
+    void updateControlSizes();
+    sigc::connection sizeUpdatedConn;
+
 private:
     sigc::connection _moved_connection;
     sigc::connection _clicked_connection;
@@ -205,7 +223,7 @@
     void deselect_all();
 
     void addLine( SPItem *item, Geom::Point p1, Geom::Point p2, Inkscape::PaintTarget fill_or_stroke);
-    void addCurve(SPItem *item, Geom::Point p0, Geom::Point p1, Geom::Point p2, Geom::Point p3, int corner0, int corner1, Inkscape::PaintTarget fill_or_stroke);
+    void addCurve(SPItem *item, Geom::Point p0, Geom::Point p1, Geom::Point p2, Geom::Point p3, int corner0, int corner1, Inkscape::PaintTarget fill_or_stroke, bool highlight = false);
 
     GrDragger *addDragger(GrDraggable *draggable);
 

=== modified file 'src/knot.h'
--- src/knot.h	2016-12-03 16:11:45 +0000
+++ src/knot.h	2016-12-03 19:47:59 +0000
@@ -59,6 +59,7 @@
 
     SPKnotShapeType shape;   /**< Shape type. */
     SPKnotModeType mode;
+    double angle;
 
     guint32 fill[SP_KNOT_VISIBLE_STATES];
     guint32 stroke[SP_KNOT_VISIBLE_STATES];

=== modified file 'src/ui/tools/mesh-tool.cpp'
--- src/ui/tools/mesh-tool.cpp	2016-12-02 09:15:24 +0000
+++ src/ui/tools/mesh-tool.cpp	2016-12-03 19:47:59 +0000
@@ -754,11 +754,11 @@
             }
 
             // Highlight corner node corresponding to side or tensor node
-            if( drag->mouseOver() ) {
+            //if( drag->mouseOver() ) {
                 // MESH FIXME: Light up corresponding corner node corresponding to node we are over.
                 // See "pathflash" in ui/tools/node-tool.cpp for ideas.
                 // Use desktop->add_temporary_canvasitem( SPCanvasItem, milliseconds );
-            }
+            //}
 
             // Change cursor shape if over line
             std::vector<SPCtrlCurve *> over_line =