Improve mesh handling in Fill and Stroke dialog.

Create new meshes with alternating color/white pattern
(makes it more obvious a mesh has been created).

(bzr r15229)

9 files changed, 551 insertions, 118 deletions

diff --git a/src/sp-mesh-array.cpp b/src/sp-mesh-array.cpp
index 208dac2bc..107359c6c 100644
--- a/src/sp-mesh-array.cpp
+++ b/src/sp-mesh-array.cpp
@@ -1057,10 +1057,10 @@ void SPMeshNodeArray::write( SPMeshGradient *mg ) {
                         break;
                     case 'z':
                     case 'Z':
-                        std::cout << "SPMeshNodeArray::write(): bad path type" << path_type << std::endl;
+                        std::cerr << "SPMeshNodeArray::write(): bad path type" << path_type << std::endl;
                         break;
                     default:
-                        std::cout << "SPMeshNodeArray::write(): unhandled path type" << path_type << std::endl;
+                        std::cerr << "SPMeshNodeArray::write(): unhandled path type" << path_type << std::endl;
                 }
                 stop->setAttribute("path", is.str().c_str());
                 // std::cout << "SPMeshNodeArray::write: path:  " << is.str().c_str() << std::endl;
@@ -1120,11 +1120,11 @@ void SPMeshNodeArray::create( SPMeshGradient *mg, SPItem *item, Geom::OptRect bb
 
     if( !bbox ) {
         // Set default size to bounding box if size not given.
-        std::cout << "SPMeshNodeArray::create(): bbox empty" << std::endl;
+        std::cerr << "SPMeshNodeArray::create(): bbox empty" << std::endl;
         bbox = item->geometricBounds();
 
         if( !bbox ) {
-            std::cout << "SPMeshNodeArray::create: ERROR: No bounding box!" << std::endl;
+            std::cerr << "SPMeshNodeArray::create: ERROR: No bounding box!" << std::endl;
             return;
         }
     }
@@ -1151,7 +1151,14 @@ void SPMeshNodeArray::create( SPMeshGradient *mg, SPItem *item, Geom::OptRect bb
 
     // Get default color
     SPColor color = default_color( item );
- 
+
+    // Set some corners to white so we can see the mesh.
+    SPColor white( 1.0, 1.0, 1.0 );
+    if (color == white) {
+        // If default color is white, set other color to black.
+        white = SPColor( 0.0, 0.0, 0.0 );
+    }
+
     // Get preferences
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     guint prows = prefs->getInt("/tools/mesh/mesh_rows", 1);
@@ -1190,6 +1197,9 @@ void SPMeshNodeArray::create( SPMeshGradient *mg, SPItem *item, Geom::OptRect bb
             ry = arc->ry.computed;
             start = arc->start;
             end   = arc->end;
+            if( end == start ) {
+                end += 2.0 * M_PI;
+            }
         }
 
         // std::cout << " start: " << start << "  end: " << end << std::endl;
@@ -1236,7 +1246,7 @@ void SPMeshNodeArray::create( SPMeshGradient *mg, SPItem *item, Geom::OptRect bb
 
             for( guint k = 0; k < 4; ++k ) {
                 patch.setPathType( k, 'l' );
-                patch.setColor( k, color );
+                patch.setColor( k, (i+k)%2 ? color : white );
                 patch.setOpacity( k, 1.0 );
             }
             patch.setPathType( 0, 'c' );
@@ -1293,7 +1303,7 @@ void SPMeshNodeArray::create( SPMeshGradient *mg, SPItem *item, Geom::OptRect bb
 
                 patch.setPathType( i, 'c' );
 
-                patch.setColor( i, color );
+                patch.setColor( i, i%2 ? color : white );
                 patch.setOpacity( i, 1.0 );
             }
 
@@ -1334,7 +1344,7 @@ void SPMeshNodeArray::create( SPMeshGradient *mg, SPItem *item, Geom::OptRect bb
 
                     for( guint s = 0; s < 4; ++s ) {
                         patch.setPathType( s, 'l' );
-                        patch.setColor( s, color );
+                        patch.setColor( s, (i+s)%2 ? color : white );
                         patch.setOpacity( s, 1.0 );
                     }
 
@@ -1362,10 +1372,10 @@ void SPMeshNodeArray::create( SPMeshGradient *mg, SPItem *item, Geom::OptRect bb
 
                     for( guint s = 0; s < 4; ++s ) {
                         patch0.setPathType( s, 'l' );
-                        patch0.setColor( s, color );
+                        patch0.setColor( s, s%2 ? color : white );
                         patch0.setOpacity( s, 1.0 );
                         patch1.setPathType( s, 'l' );
-                        patch1.setColor( s, color );
+                        patch1.setColor( s, s%2 ? white : color );
                         patch1.setOpacity( s, 1.0 );
                     }
 
@@ -1415,7 +1425,7 @@ void SPMeshNodeArray::create( SPMeshGradient *mg, SPItem *item, Geom::OptRect bb
                             // Corner
                             node->node_type = MG_NODE_TYPE_CORNER;
                             node->set = true;
-                            node->color = color;
+                            node->color = (i+j)%2 ? color : white;
                             node->opacity = 1.0;
 
                         } else {
@@ -2704,6 +2714,11 @@ SPCurve * SPMeshNodeArray::outline_path() {
 
     SPCurve *outline = new SPCurve();
 
+    if (nodes.empty() ) {
+        std::cerr << "SPMeshNodeArray::outline_path: empty array!" << std::endl;
+        return outline;
+    }
+
     outline->moveto( nodes[0][0]->p );
 
     int ncol = nodes[0].size();
@@ -2743,6 +2758,34 @@ void SPMeshNodeArray::transform(Geom::Affine const &m) {
     }
 }
 
+// Transform mesh to fill box. Return true if mesh transformed.
+bool SPMeshNodeArray::fill_box(Geom::OptRect &box) {
+
+    SPCurve *outline = outline_path();
+    Geom::OptRect mesh_bbox = outline->get_pathvector().boundsExact();
+    outline->unref();
+
+    if ((*mesh_bbox).width() == 0 || (*mesh_bbox).height() == 0) {
+        return false;
+    }            
+
+    double scale_x = (*box).width() /(*mesh_bbox).width() ;
+    double scale_y = (*box).height()/(*mesh_bbox).height();
+
+    Geom::Translate t1(-(*mesh_bbox).min());
+    Geom::Scale scale(scale_x,scale_y);
+    Geom::Translate t2((*box).min());
+    Geom::Affine trans = t1 * scale * t2;
+    if (!trans.isIdentity() ) {
+        transform(trans);
+        write( mg );
+        mg->requestModified(SP_OBJECT_MODIFIED_FLAG);
+        return true;
+    }
+
+    return false;
+}
+
 // Defined in gradient-chemistry.cpp
 guint32 average_color(guint32 c1, guint32 c2, gdouble p);
 
diff --git a/src/sp-mesh-array.h b/src/sp-mesh-array.h
index 2ba1bfd5d..ee9243753 100644
--- a/src/sp-mesh-array.h
+++ b/src/sp-mesh-array.h
@@ -202,6 +202,9 @@ public:
   // Transform array
   void transform(Geom::Affine const &m);
 
+  // Transform mesh to fill box. Return true if not identity transform.
+  bool fill_box(Geom::OptRect &box);
+
   // Find bounding box
   // Geom::OptRect findBoundingBox();
 
diff --git a/src/ui/tools/mesh-tool.cpp b/src/ui/tools/mesh-tool.cpp
index c6983b94a..87cbeef16 100644
--- a/src/ui/tools/mesh-tool.cpp
+++ b/src/ui/tools/mesh-tool.cpp
@@ -456,38 +456,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,
@@ -540,25 +535,8 @@ bool MeshTool::root_handler(GdkEvent* event) {
                 // 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"));
+                sp_mesh_new_default(*this);
             }
 
             ret = TRUE;
diff --git a/src/widgets/fill-style.cpp b/src/widgets/fill-style.cpp
index 636d892f8..8946eb4b3 100644
--- a/src/widgets/fill-style.cpp
+++ b/src/widgets/fill-style.cpp
@@ -40,6 +40,7 @@
 #include "sp-mesh-gradient.h"
 #include "sp-pattern.h"
 #include "sp-radial-gradient.h"
+#include "sp-text.h"
 #include "style.h"
 #include "widgets/paint-selector.h"
 
@@ -279,34 +280,35 @@ void FillNStroke::performUpdate()
 
                 SPPaintServer *server = (kind == FILL) ? query.getFillPaintServer() : query.getStrokePaintServer();
 
-                if (server && SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()) {
-                    SPGradient *vector = SP_GRADIENT(server)->getVector();
-                    psel->setSwatch( vector );
-                } else if (SP_IS_LINEARGRADIENT(server)) {
-                    SPGradient *vector = SP_GRADIENT(server)->getVector();
-                    psel->setGradientLinear( vector );
-
-                    SPLinearGradient *lg = SP_LINEARGRADIENT(server);
-                    psel->setGradientProperties( lg->getUnits(),
-                                                 lg->getSpread() );
-                } else if (SP_IS_RADIALGRADIENT(server)) {
-                    SPGradient *vector = SP_GRADIENT(server)->getVector();
-                    psel->setGradientRadial( vector );
-
-                    SPRadialGradient *rg = SP_RADIALGRADIENT(server);
-                    psel->setGradientProperties( rg->getUnits(),
-                                                 rg->getSpread() );
+                if (server) {
+                    if (SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()) {
+                        SPGradient *vector = SP_GRADIENT(server)->getVector();
+                        psel->setSwatch( vector );
+                    } else if (SP_IS_LINEARGRADIENT(server)) {
+                        SPGradient *vector = SP_GRADIENT(server)->getVector();
+                        psel->setGradientLinear( vector );
+
+                        SPLinearGradient *lg = SP_LINEARGRADIENT(server);
+                        psel->setGradientProperties( lg->getUnits(),
+                                                     lg->getSpread() );
+                    } else if (SP_IS_RADIALGRADIENT(server)) {
+                        SPGradient *vector = SP_GRADIENT(server)->getVector();
+                        psel->setGradientRadial( vector );
+
+                        SPRadialGradient *rg = SP_RADIALGRADIENT(server);
+                        psel->setGradientProperties( rg->getUnits(),
+                                                     rg->getSpread() );
 #ifdef WITH_MESH
-                } else if (SP_IS_MESHGRADIENT(server)) {
-                    SPGradient *array = SP_MESHGRADIENT(server)->getArray();
-                    psel->setGradientMesh( array );
-
-                    SPMeshGradient *mg = SP_MESHGRADIENT(server);
-                    psel->setMeshProperties( mg->getUnits() );
+                    } else if (SP_IS_MESHGRADIENT(server)) {
+                        SPGradient *array = SP_GRADIENT(server)->getArray();
+                        psel->setGradientMesh( SP_MESHGRADIENT(array) );
+                        SPMeshGradient *mg = SP_MESHGRADIENT(server);
+                        psel->updateMeshList( SP_MESHGRADIENT( array ));
 #endif
-                } else if (SP_IS_PATTERN(server)) {
-                    SPPattern *pat = SP_PATTERN(server)->rootPattern();
-                    psel->updatePatternList( pat );
+                    } else if (SP_IS_PATTERN(server)) {
+                        SPPattern *pat = SP_PATTERN(server)->rootPattern();
+                        psel->updatePatternList( pat );
+                    }
                 }
             }
             break;
@@ -622,6 +624,107 @@ void FillNStroke::updateFromPaint()
             }
             break;
 
+#ifdef WITH_MESH
+        case SPPaintSelector::MODE_GRADIENT_MESH:
+
+            if (!items.empty()) {
+                SPGradientType const gradient_type = SP_GRADIENT_TYPE_MESH;
+
+                SPCSSAttr *css = 0;
+                if (kind == FILL) {
+                    // HACK: reset fill-opacity - that 0.75 is annoying; BUT remove this when we have an opacity slider for all tabs
+                    css = sp_repr_css_attr_new();
+                    sp_repr_css_set_property(css, "fill-opacity", "1.0");
+                }
+                
+                Inkscape::XML::Document *xml_doc = document->getReprDoc();
+                SPDefs *defs = document->getDefs();
+
+                SPMeshGradient * mesh = psel->getMeshGradient();
+
+                for(std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end(); ++i){
+
+                    //FIXME: see above
+                    if (kind == FILL) {
+                        sp_repr_css_change_recursive((*i)->getRepr(), css, "style");
+                    }
+
+                    // Check if object already has mesh.
+                    bool has_mesh = false;
+                    SPStyle *style = (*i)->style;
+                    if (style) {
+                        SPPaintServer *server =
+                            (kind==FILL) ? style->getFillPaintServer():style->getStrokePaintServer();
+                        if (server && SP_IS_MESHGRADIENT(server)) 
+                            has_mesh = true;
+                    }
+
+                    if (!mesh || !has_mesh) {
+                        // No mesh in document or object does not already have mesh ->
+                        // Create new mesh.
+
+                        // Create mesh element
+                        Inkscape::XML::Node *repr = xml_doc->createElement("svg:meshgradient");
+
+                        // privates are garbage-collectable
+                        repr->setAttribute("inkscape:collect", "always");
+
+                        // Attach to document
+                        defs->getRepr()->appendChild(repr);
+                        Inkscape::GC::release(repr);
+
+                        // Get corresponding object
+                        SPMeshGradient *mg = static_cast<SPMeshGradient *>(document->getObjectByRepr(repr));
+                        mg->array.create(mg, *i, (kind==FILL) ?
+                                         (*i)->geometricBounds() : (*i)->visualBounds());
+
+                        bool isText = SP_IS_TEXT(*i);
+                        sp_style_set_property_url (*i, ((kind == FILL) ? "fill":"stroke"),
+                                                   mg, isText);
+
+                        // (*i)->requestModified(SP_OBJECT_MODIFIED_FLAG|SP_OBJECT_STYLE_MODIFIED_FLAG);
+
+                    } else {
+                        // Using found mesh
+
+                        // Duplicate
+                        Inkscape::XML::Node *mesh_repr = mesh->getRepr();
+                        Inkscape::XML::Node *copy_repr = mesh_repr->duplicate(xml_doc);
+
+                        // privates are garbage-collectable
+                        copy_repr->setAttribute("inkscape:collect", "always");
+
+                        // Attach to document
+                        defs->getRepr()->appendChild(copy_repr);
+                        Inkscape::GC::release(copy_repr);
+
+                        // Get corresponding object
+                        SPMeshGradient *mg =
+                            static_cast<SPMeshGradient *>(document->getObjectByRepr(copy_repr));
+                        // std::cout << "  " << (mg->getId()?mg->getId():"null") << std::endl;
+                        mg->array.read(mg);
+
+                        Geom::OptRect item_bbox = (kind==FILL) ?
+                            (*i)->geometricBounds() : (*i)->visualBounds();
+                        mg->array.fill_box( item_bbox );
+
+                        bool isText = SP_IS_TEXT(*i);
+                        sp_style_set_property_url (*i, ((kind == FILL) ? "fill":"stroke"),
+                                                   mg, isText);
+                    }
+                }
+
+                if (css) {
+                    sp_repr_css_attr_unref(css);
+                    css = 0;
+                }
+
+                DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE,
+                                   (kind == FILL) ? _("Set mesh on fill") : _("Set mesh on stroke"));
+            }
+            break;
+#endif
+
         case SPPaintSelector::MODE_PATTERN:
 
             if (!items.empty()) {
diff --git a/src/widgets/gradient-selector.h b/src/widgets/gradient-selector.h
index 6b5d4ca60..e058c5112 100644
--- a/src/widgets/gradient-selector.h
+++ b/src/widgets/gradient-selector.h
@@ -50,9 +50,6 @@ struct SPGradientSelector {
     enum SelectorMode {
         MODE_LINEAR,
         MODE_RADIAL,
-#ifdef WITH_MESH
-        MODE_MESH,
-#endif
         MODE_SWATCH
     };
 
diff --git a/src/widgets/mesh-toolbar.cpp b/src/widgets/mesh-toolbar.cpp
index 898104ad3..a960782cb 100644
--- a/src/widgets/mesh-toolbar.cpp
+++ b/src/widgets/mesh-toolbar.cpp
@@ -36,6 +36,7 @@
 #include "document-undo.h"
 #include "desktop.h"
 
+#include <gtkmm.h>
 #include <glibmm/i18n.h>
 
 #include "ui/tools/gradient-tool.h"
@@ -356,6 +357,20 @@ static void ms_fit_mesh(void)
     }
 }
 
+static void ms_warning_popup(void)
+{
+    char *msg = _("Mesh gradients are part of SVG 2:\n"
+                  "* Syntax may change.\n"
+                  "* Web browser implementation is not guaranteed.\n"
+                  "\n"
+                  "For web: convert to bitmap (Edit->Make bitmap copy).\n"
+                  "For print: export to PDF.");
+    Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_WARNING,
+                              Gtk::BUTTONS_OK, true);
+    dialog.run();
+
+}
+
 static void mesh_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder);
 
 /**
@@ -504,9 +519,14 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj
 
     /* Warning */
     {
-        GtkAction* act = gtk_action_new( "MeshWarningAction",
-          _("WARNING: Mesh SVG Syntax Subject to Change"), NULL, NULL );
+        InkAction* act = ink_action_new( "MeshWarningAction",
+                                         _("WARNING: Mesh SVG Syntax Subject to Change"),
+                                         _("WARNING: Mesh SVG Syntax Subject to Change"),
+                                         INKSCAPE_ICON("dialog-warning"),
+                                         secondarySize );
         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
+        g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_warning_popup), holder );
+        gtk_action_set_sensitive( GTK_ACTION(act), TRUE );
     }
 
     /* Type */
diff --git a/src/widgets/paint-selector.cpp b/src/widgets/paint-selector.cpp
index 3e9f0687d..855371ddd 100644
--- a/src/widgets/paint-selector.cpp
+++ b/src/widgets/paint-selector.cpp
@@ -285,6 +285,11 @@ static void sp_paint_selector_dispose(GObject *object)
     // clean up our long-living pattern menu
     g_object_set_data(G_OBJECT(psel),"patternmenu",NULL);
 
+#ifdef WITH_MESH
+    // clean up our long-living mesh menu
+    g_object_set_data(G_OBJECT(psel),"meshmenu",NULL);
+#endif
+
     if (psel->selected_color) {
         delete psel->selected_color;
         psel->selected_color = NULL;
@@ -492,7 +497,7 @@ void SPPaintSelector::setGradientRadial(SPGradient *vector)
 }
 
 #ifdef WITH_MESH
-void SPPaintSelector::setGradientMesh(SPGradient *array)
+void SPPaintSelector::setGradientMesh(SPMeshGradient *array)
 {
 #ifdef SP_PS_VERBOSE
     g_print("PaintSelector set GRADIENT MESH\n");
@@ -524,24 +529,6 @@ void SPPaintSelector::getGradientProperties( SPGradientUnits &units, SPGradientS
     spread = gsel->getSpread();
 }
 
-#ifdef WITH_MESH
-void SPPaintSelector::setMeshProperties( SPGradientUnits units )
-{
-    g_return_if_fail(mode == MODE_GRADIENT_MESH);
-
-    // SPGradientSelector *gsel = getGradientFromData(this);
-    // gsel->setUnits(units);
-}
-
-void SPPaintSelector::getMeshProperties( SPGradientUnits &units) const
-{
-    g_return_if_fail(mode == MODE_GRADIENT_MESH);
-
-    // SPGradientSelector *gsel = getGradientFromData(this);
-    // units = gsel->getUnits();
-}
-#endif
-
 
 /**
  * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
@@ -788,7 +775,214 @@ static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSe
 #endif
 }
 
+// ************************* MESH ************************
 #ifdef WITH_MESH
+static void sp_psel_mesh_destroy(GtkWidget *widget, SPPaintSelector * /*psel*/)
+{
+    // drop our reference to the mesh menu widget
+    g_object_unref( G_OBJECT(widget) );
+}
+
+static void sp_psel_mesh_change(GtkWidget * /*widget*/, SPPaintSelector *psel)
+{
+    g_signal_emit(G_OBJECT(psel), psel_signals[CHANGED], 0);
+}
+
+
+/**
+ *  Returns a list of meshes in the defs of the given source document as a GSList object
+ *  Returns NULL if there are no meshes in the document.
+ */
+static GSList *
+ink_mesh_list_get (SPDocument *source)
+{
+    if (source == NULL)
+        return NULL;
+
+    GSList *pl = NULL;
+    std::vector<SPObject *> meshes = source->getResourceList("gradient");
+    for (std::vector<SPObject *>::const_iterator it = meshes.begin(); it != meshes.end(); ++it) {
+        if (SP_IS_MESHGRADIENT(*it) &&
+            SP_GRADIENT(*it) == SP_GRADIENT(*it)->getArray()) {  // only if this is a root mesh
+            pl = g_slist_prepend(pl, *it);
+        }
+    }
+
+    pl = g_slist_reverse(pl);
+    return pl;
+}
+
+/**
+ * Adds menu items for mesh list.
+ */
+static void
+sp_mesh_menu_build (GtkWidget *combo, GSList *mesh_list, SPDocument */*source*/)
+{
+    GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
+    GtkTreeIter iter;
+
+    for (; mesh_list != NULL; mesh_list = mesh_list->next) {
+
+        Inkscape::XML::Node *repr = reinterpret_cast<SPItem *>(mesh_list->data)->getRepr();
+
+        gchar const *meshid = repr->attribute("id");
+        gchar const *label  = meshid;
+
+        // Only relevant if we supply a set of canned meshes.
+        gboolean stockid = false;
+        if (repr->attribute("inkscape:stockid")) {
+            label = _(repr->attribute("inkscape:stockid"));
+            stockid = true;
+        }
+
+        gtk_list_store_append(store, &iter);
+        gtk_list_store_set(store, &iter,
+                COMBO_COL_LABEL, label, COMBO_COL_STOCK, stockid, COMBO_COL_MESH, meshid, COMBO_COL_SEP, FALSE, -1);
+
+    }
+}
+
+/**
+ * Pick up all meshes from source, except those that are in
+ * current_doc (if non-NULL), and add items to the mesh menu.
+ */
+static void sp_mesh_list_from_doc(GtkWidget *combo, SPDocument * /*current_doc*/, SPDocument *source, SPDocument * /*mesh_doc*/)
+{
+    GSList *pl = ink_mesh_list_get(source);
+    GSList *clean_pl = NULL;
+
+    for (; pl != NULL; pl = pl->next) {
+        if (!SP_IS_MESHGRADIENT(pl->data)) {
+            continue;
+        }
+        // Add to the list of meshes we really do wish to show
+        clean_pl = g_slist_prepend (clean_pl, pl->data);
+    }
+
+    sp_mesh_menu_build (combo, clean_pl, source);
+
+    g_slist_free (pl);
+    g_slist_free (clean_pl);
+}
+
+
+static void
+ink_mesh_menu_populate_menu(GtkWidget *combo, SPDocument *doc)
+{
+    static SPDocument *meshes_doc = NULL;
+
+    // If we ever add a list of canned mesh gradients, uncomment following:
+
+    // find and load meshes.svg
+    // if (meshes_doc == NULL) {
+    //     char *meshes_source = g_build_filename(INKSCAPE_MESHESDIR, "meshes.svg", NULL);
+    //     if (Inkscape::IO::file_test(meshes_source, G_FILE_TEST_IS_REGULAR)) {
+    //         meshes_doc = SPDocument::createNewDoc(meshes_source, FALSE);
+    //     }
+    //     g_free(meshes_source);
+    // }
+
+    // suck in from current doc
+    sp_mesh_list_from_doc ( combo, NULL, doc, meshes_doc );
+
+    // add separator
+    // {
+    //     GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
+    //     GtkTreeIter iter;
+    //     gtk_list_store_append (store, &iter);
+    //     gtk_list_store_set(store, &iter,
+    //             COMBO_COL_LABEL, "", COMBO_COL_STOCK, false, COMBO_COL_MESH, "", COMBO_COL_SEP, true, -1);
+    // }
+
+    // suck in from meshes.svg
+    // if (meshes_doc) {
+    //     doc->ensureUpToDate();
+    //     sp_mesh_list_from_doc ( combo, doc, meshes_doc, NULL );
+    // }
+
+}
+
+
+static GtkWidget*
+ink_mesh_menu(GtkWidget *combo)
+{
+    SPDocument *doc = SP_ACTIVE_DOCUMENT;
+
+    GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
+    GtkTreeIter iter;
+
+    if (!doc) {
+
+        gtk_list_store_append (store, &iter);
+        gtk_list_store_set (store, &iter,
+                COMBO_COL_LABEL, _("No document selected"), COMBO_COL_STOCK, false, COMBO_COL_MESH, "", COMBO_COL_SEP, false, -1);
+        gtk_widget_set_sensitive(combo, FALSE);
+
+    } else {
+
+        ink_mesh_menu_populate_menu(combo, doc);
+        gtk_widget_set_sensitive(combo, TRUE);
+
+    }
+
+    // Select the first item that is not a separator
+    if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL(store), &iter)) {
+        gboolean sep = false;
+        gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, COMBO_COL_SEP, &sep, -1);
+        if (sep) {
+            gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
+        }
+        gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+    }
+
+    return combo;
+}
+
+
+/*update mesh list*/
+void SPPaintSelector::updateMeshList( SPMeshGradient *mesh )
+{
+    if (update) {
+        return;
+    }
+
+    GtkWidget *combo = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "meshmenu"));
+    g_assert( combo != NULL );
+
+    /* Clear existing menu if any */
+    GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+    gtk_list_store_clear(GTK_LIST_STORE(store));
+
+    ink_mesh_menu(combo);
+
+    /* Set history */
+
+    if (mesh && !g_object_get_data(G_OBJECT(combo), "update")) {
+
+        g_object_set_data(G_OBJECT(combo), "update", GINT_TO_POINTER(TRUE));
+        gchar const *meshname = mesh->getRepr()->attribute("id");
+
+        // Find this mesh and set it active in the combo_box
+        GtkTreeIter iter ;
+        gchar *meshid = NULL;
+        bool valid = gtk_tree_model_get_iter_first (store, &iter);
+        if (!valid) {
+            return;
+        }
+        gtk_tree_model_get (store, &iter, COMBO_COL_MESH, &meshid, -1);
+        while (valid && strcmp(meshid, meshname)  != 0) {
+            valid = gtk_tree_model_iter_next (store, &iter);
+            gtk_tree_model_get (store, &iter, COMBO_COL_MESH, &meshid, -1);
+        }
+
+        if (valid) {
+            gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+        }
+
+        g_object_set_data(G_OBJECT(combo), "update", GINT_TO_POINTER(FALSE));
+    }
+}
+
 static void sp_paint_selector_set_mode_mesh(SPPaintSelector *psel, SPPaintSelector::Mode mode)
 {
     if (mode == SPPaintSelector::MODE_GRADIENT_MESH) {
@@ -799,23 +993,50 @@ static void sp_paint_selector_set_mode_mesh(SPPaintSelector *psel, SPPaintSelect
     GtkWidget *tbl = NULL;
 
     if (psel->mode == SPPaintSelector::MODE_GRADIENT_MESH) {
-        /* Already have mesh selector */
+        /* Already have mesh menu */
         tbl = GTK_WIDGET(g_object_get_data(G_OBJECT(psel->selector), "mesh-selector"));
     } else {
         sp_paint_selector_clear_frame(psel);
 
-        /* We could create a new gradient selector once adapted for meshes.
-           But for the moment we just create an empty widget. */
         /* Create vbox */
         tbl = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
         gtk_box_set_homogeneous(GTK_BOX(tbl), FALSE);
         gtk_widget_show(tbl);
 
         {
+            auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1);
+            gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
+
+            /**
+             * Create a combo_box and store with 4 columns,
+             * The label, a pointer to the mesh, is stockid or not, is a separator or not.
+             */
+            GtkListStore *store = gtk_list_store_new (COMBO_N_COLS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN);
+            GtkWidget *combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
+            gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo), SPPaintSelector::isSeparator, NULL, NULL);
+
+            GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
+            gtk_cell_renderer_set_padding (renderer, 2, 0);
+            gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
+            gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", COMBO_COL_LABEL, NULL);
+
+            ink_mesh_menu(combo);
+            g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(sp_psel_mesh_change), psel);
+            g_signal_connect(G_OBJECT(combo), "destroy", G_CALLBACK(sp_psel_mesh_destroy), psel);
+            g_object_set_data(G_OBJECT(psel), "meshmenu", combo);
+            g_object_ref( G_OBJECT(combo));
+
+            gtk_container_add(GTK_CONTAINER(hb), combo);
+            gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+
+            g_object_unref( G_OBJECT(store));
+        }
+
+        {
             auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
             gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
             auto l = gtk_label_new(NULL);
-            gtk_label_set_markup(GTK_LABEL(l), _("Use the <b>Mesh tool</b> to create new and edit existing meshes. Mesh selection and copying not yet implemented."));
+            gtk_label_set_markup(GTK_LABEL(l), _("Use the <b>Mesh tool</b> to modify the mesh."));
             gtk_label_set_line_wrap(GTK_LABEL(l), true);
             gtk_widget_set_size_request(l, 180, -1);
             gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
@@ -828,11 +1049,66 @@ static void sp_paint_selector_set_mode_mesh(SPPaintSelector *psel, SPPaintSelect
         psel->selector = tbl;
         g_object_set_data(G_OBJECT(psel->selector), "mesh-selector", tbl);
 
-        gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Mesh gradient</b>"));
+        gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Mesh fill</b>"));
     }
+#ifdef SP_PS_VERBOSE
+    g_print("Mesh req\n");
+#endif
+}
+
+SPMeshGradient *SPPaintSelector::getMeshGradient()
+{
+    g_return_val_if_fail((mode == MODE_GRADIENT_MESH) , NULL);
+
+    GtkWidget *combo = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "meshmenu"));
 
+    /* no mesh menu if we were just selected */
+    if ( combo == NULL ) {
+        return NULL;
+    }
+    GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+
+    /* Get the selected mesh */
+    GtkTreeIter  iter;
+    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX(combo), &iter) ||
+            !gtk_list_store_iter_is_valid(GTK_LIST_STORE(store), &iter)) {
+        return NULL;
+    }
+
+    gchar *meshid = NULL;
+    gboolean stockid = FALSE;
+    gchar *label = NULL;
+    gtk_tree_model_get (store, &iter, COMBO_COL_LABEL, &label, COMBO_COL_STOCK, &stockid, COMBO_COL_MESH, &meshid,  -1);
+    // std::cout << "  .. meshid: " << (meshid?meshid:"null") << "   label: " << (label?label:"null") << std::endl;
+    if (meshid == NULL) {
+        return NULL;
+    }
+
+    SPMeshGradient *mesh = 0;
+    if (strcmp(meshid, "none")){
+
+        gchar *mesh_name;
+        if (stockid) {
+            mesh_name = g_strconcat("urn:inkscape:mesh:", meshid, NULL);
+        } else {
+            mesh_name = g_strdup(meshid);
+        }
+
+        SPObject *mesh_obj = get_stock_item(mesh_name);
+        if (mesh_obj && SP_IS_MESHGRADIENT(mesh_obj)) {
+            mesh = SP_MESHGRADIENT(mesh_obj);
+        }
+        g_free(mesh_name);
+
+    } else {
+        std::cerr << "SPPaintSelector::getMeshGradient: Unexpected meshid value." << std::endl;
+    }
+
+    return mesh;
 }
+
 #endif
+// ************************ End Mesh ************************
 
 static void
 sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
diff --git a/src/widgets/paint-selector.h b/src/widgets/paint-selector.h
index 815a6da0b..3302632b8 100644
--- a/src/widgets/paint-selector.h
+++ b/src/widgets/paint-selector.h
@@ -26,6 +26,9 @@
 #include "ui/selected-color.h"
 
 class SPGradient;
+#ifdef WITH_MESH
+class SPMeshGradient;
+#endif
 class SPDesktop;
 class SPPattern;
 class SPStyle;
@@ -98,18 +101,21 @@ struct SPPaintSelector {
     void setGradientLinear( SPGradient *vector );
     void setGradientRadial( SPGradient *vector );
 #ifdef WITH_MESH
-    void setGradientMesh(SPGradient *array);
+    void setGradientMesh(SPMeshGradient *array);
 #endif
     void setSwatch( SPGradient *vector );
 
     void setGradientProperties( SPGradientUnits units, SPGradientSpread spread );
     void getGradientProperties( SPGradientUnits &units, SPGradientSpread &spread ) const;
 
-    void setMeshProperties( SPGradientUnits units );
-    void getMeshProperties( SPGradientUnits &units ) const;
-
     void pushAttrsToGradient( SPGradient *gr ) const;
     SPGradient *getGradientVector();
+
+#ifdef WITH_MESH
+    SPMeshGradient * getMeshGradient();
+    void updateMeshList( SPMeshGradient *pat );
+#endif
+
     SPPattern * getPattern();
     void updatePatternList( SPPattern *pat );
 
@@ -124,8 +130,14 @@ struct SPPaintSelector {
     void onSelectedColorChanged();
 };
 
-enum {COMBO_COL_LABEL=0, COMBO_COL_STOCK=1, COMBO_COL_PATTERN=2, COMBO_COL_SEP=3, COMBO_N_COLS=4};
-
+enum {
+    COMBO_COL_LABEL   = 0,
+    COMBO_COL_STOCK   = 1,
+    COMBO_COL_PATTERN = 2,
+    COMBO_COL_MESH    = COMBO_COL_PATTERN,
+    COMBO_COL_SEP     = 3,
+    COMBO_N_COLS      = 4
+};
 
 /// The SPPaintSelector vtable
 struct SPPaintSelectorClass {
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index d3715cf4e..ea9af71c8 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -575,6 +575,7 @@ static gchar const * ui_descr =
         "    <toolitem action='MeshFitInBoundingBoxAction' />"
         "    <separator />"
         "    <toolitem action='MeshWarningAction' />"
+        "    <separator />"
         "    <toolitem action='MeshSmoothAction' />"
         "  </toolbar>"