updated to latest trunk

(bzr r14876.2.4)

1 files changed, 365 insertions, 72 deletions

diff --git a/src/widgets/paint-selector.cpp b/src/widgets/paint-selector.cpp
index 58a178aec..855371ddd 100644
--- a/src/widgets/paint-selector.cpp
+++ b/src/widgets/paint-selector.cpp
@@ -33,7 +33,7 @@
 
 #include "sp-linear-gradient.h"
 #include "sp-radial-gradient.h"
-#include "sp-mesh.h"
+#include "sp-mesh-gradient.h"
 #include "sp-stop.h"
 /* fixme: Move it from dialogs to here */
 #include "gradient-selector.h"
@@ -41,7 +41,6 @@
 #include <document-private.h>
 #include <desktop-style.h>
 #include <style.h>
-#include "svg/svg-color.h"
 #include "svg/css-ostringstream.h"
 #include "path-prefix.h"
 #include "io/sys.h"
@@ -55,8 +54,6 @@
 #include "svg/svg-icc-color.h"
 #endif // SP_PS_VERBOSE
 
-#include <gtk/gtk.h>
-
 using Inkscape::Widgets::SwatchSelector;
 using Inkscape::UI::SelectedColor;
 
@@ -81,6 +78,9 @@ static void sp_paint_selector_set_mode_multiple(SPPaintSelector *psel);
 static void sp_paint_selector_set_mode_none(SPPaintSelector *psel);
 static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelector::Mode mode);
 static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+#ifdef WITH_MESH
+static void sp_paint_selector_set_mode_mesh(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+#endif
 static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelector::Mode mode);
 static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelector::Mode mode);
 static void sp_paint_selector_set_mode_unset(SPPaintSelector *psel);
@@ -98,12 +98,14 @@ static gchar const* modeStrings[] = {
     "MODE_SOLID_COLOR",
     "MODE_GRADIENT_LINEAR",
     "MODE_GRADIENT_RADIAL",
+#ifdef WITH_MESH
+    "MODE_GRADIENT_MESH",
+#endif
     "MODE_PATTERN",
     "MODE_SWATCH",
     "MODE_UNSET",
     ".",
     ".",
-    ".",
 };
 #endif
 
@@ -112,9 +114,6 @@ static bool isPaintModeGradient(SPPaintSelector::Mode mode)
 {
     bool isGrad = (mode == SPPaintSelector::MODE_GRADIENT_LINEAR) ||
         (mode == SPPaintSelector::MODE_GRADIENT_RADIAL) ||
-#ifdef WITH_MESH
-        (mode == SPPaintSelector::MODE_GRADIENT_MESH) ||
-#endif
         (mode == SPPaintSelector::MODE_SWATCH);
 
     return isGrad;
@@ -134,11 +133,7 @@ static SPGradientSelector *getGradientFromData(SPPaintSelector const *psel)
     return grad;
 }
 
-#if GTK_CHECK_VERSION(3,0,0)
 G_DEFINE_TYPE(SPPaintSelector, sp_paint_selector, GTK_TYPE_BOX);
-#else
-G_DEFINE_TYPE(SPPaintSelector, sp_paint_selector, GTK_TYPE_VBOX);
-#endif
 
 static void
 sp_paint_selector_class_init(SPPaintSelectorClass *klass)
@@ -197,19 +192,13 @@ sp_paint_selector_class_init(SPPaintSelectorClass *klass)
 static void
 sp_paint_selector_init(SPPaintSelector *psel)
 {
-#if GTK_CHECK_VERSION(3,0,0)
     gtk_orientable_set_orientation(GTK_ORIENTABLE(psel), GTK_ORIENTATION_VERTICAL);
-#endif
 
     psel->mode = static_cast<SPPaintSelector::Mode>(-1); // huh?  do you mean 0xff?  --  I think this means "not in the enum"
 
     /* Paint style button box */
-#if GTK_CHECK_VERSION(3,0,0)
     psel->style = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
     gtk_box_set_homogeneous(GTK_BOX(psel->style), FALSE);
-#else
-    psel->style = gtk_hbox_new(FALSE, 0);
-#endif
     gtk_widget_show(psel->style);
     gtk_container_set_border_width(GTK_CONTAINER(psel->style), 4);
     gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0);
@@ -236,12 +225,8 @@ sp_paint_selector_init(SPPaintSelector *psel)
 
     /* Fillrule */
     {
-#if GTK_CHECK_VERSION(3,0,0)
-    psel->fillrulebox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
-    gtk_box_set_homogeneous(GTK_BOX(psel->fillrulebox), FALSE);
-#else
-        psel->fillrulebox = gtk_hbox_new(FALSE, 0);
-#endif
+        psel->fillrulebox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+        gtk_box_set_homogeneous(GTK_BOX(psel->fillrulebox), FALSE);
         gtk_box_pack_end(GTK_BOX(psel->style), psel->fillrulebox, FALSE, FALSE, 0);
 
         GtkWidget *w;
@@ -270,22 +255,14 @@ sp_paint_selector_init(SPPaintSelector *psel)
 
     /* Frame */
     psel->label = gtk_label_new("");
-#if GTK_CHECK_VERSION(3,0,0)
-    GtkWidget *lbbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
+    auto lbbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
     gtk_box_set_homogeneous(GTK_BOX(lbbox), FALSE);
-#else
-    GtkWidget *lbbox = gtk_hbox_new(FALSE, 4);
-#endif
     gtk_widget_show(psel->label);
     gtk_box_pack_start(GTK_BOX(lbbox), psel->label, false, false, 4);
     gtk_box_pack_start(GTK_BOX(psel), lbbox, false, false, 4);
 
-#if GTK_CHECK_VERSION(3,0,0)
     psel->frame = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
     gtk_box_set_homogeneous(GTK_BOX(psel->frame), FALSE);
-#else
-    psel->frame = gtk_vbox_new(FALSE, 4);
-#endif
     gtk_widget_show(psel->frame);
     //gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0);
     gtk_box_pack_start(GTK_BOX(psel), psel->frame, TRUE, TRUE, 0);
@@ -308,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;
@@ -411,11 +393,13 @@ void SPPaintSelector::setMode(Mode mode)
                 break;
             case MODE_GRADIENT_LINEAR:
             case MODE_GRADIENT_RADIAL:
+                sp_paint_selector_set_mode_gradient(this, mode);
+                break;
 #ifdef WITH_MESH
             case MODE_GRADIENT_MESH:
-#endif
-                sp_paint_selector_set_mode_gradient(this, mode);
+                sp_paint_selector_set_mode_mesh(this, mode);
                 break;
+#endif
             case MODE_PATTERN:
                 sp_paint_selector_set_mode_pattern(this, mode);
                 break;
@@ -513,17 +497,17 @@ void SPPaintSelector::setGradientRadial(SPGradient *vector)
 }
 
 #ifdef WITH_MESH
-void SPPaintSelector::setGradientMesh(SPGradient *vector)
+void SPPaintSelector::setGradientMesh(SPMeshGradient *array)
 {
 #ifdef SP_PS_VERBOSE
     g_print("PaintSelector set GRADIENT MESH\n");
 #endif
-    setMode(MODE_GRADIENT_RADIAL);
+    setMode(MODE_GRADIENT_MESH);
 
-    SPGradientSelector *gsel = getGradientFromData(this);
+    // SPGradientSelector *gsel = getGradientFromData(this);
 
-    gsel->setMode(SPGradientSelector::MODE_MESH);
-    gsel->setVector((vector) ? vector->document : 0, vector);
+    // gsel->setMode(SPGradientSelector::MODE_GRADIENT_MESH);
+    // gsel->setVector((mesh) ? mesh->document : 0, mesh);
 }
 #endif
 
@@ -545,6 +529,7 @@ void SPPaintSelector::getGradientProperties( SPGradientUnits &units, SPGradientS
     spread = gsel->getSpread();
 }
 
+
 /**
  * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
  */
@@ -700,12 +685,8 @@ static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelec
         sp_paint_selector_clear_frame(psel);
         /* Create new color selector */
         /* Create vbox */
-#if GTK_CHECK_VERSION(3,0,0)
-    GtkWidget *vb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
-    gtk_box_set_homogeneous(GTK_BOX(vb), FALSE);
-#else
-        GtkWidget *vb = gtk_vbox_new(FALSE, 4);
-#endif
+        auto vb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
+        gtk_box_set_homogeneous(GTK_BOX(vb), FALSE);
         gtk_widget_show(vb);
 
         /* Color selector */
@@ -759,11 +740,6 @@ static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSe
     } else if (mode == SPPaintSelector::MODE_GRADIENT_RADIAL) {
         sp_paint_selector_set_style_buttons(psel, psel->radial);
     }
-#ifdef WITH_MESH
-    else {
-        sp_paint_selector_set_style_buttons(psel, psel->mesh);
-    }
-#endif
     gtk_widget_set_sensitive(psel->style, TRUE);
 
     if ((psel->mode == SPPaintSelector::MODE_GRADIENT_LINEAR) || (psel->mode == SPPaintSelector::MODE_GRADIENT_RADIAL)) {
@@ -793,18 +769,347 @@ static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSe
         SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_RADIAL);
         gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Radial gradient</b>"));
     }
+
+#ifdef SP_PS_VERBOSE
+    g_print("Gradient req\n");
+#endif
+}
+
+// ************************* MESH ************************
 #ifdef WITH_MESH
-    else {
-        SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_MESH);
-        gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Mesh gradient</b>"));
+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);
+        }
     }
-#endif
 
+    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) {
+        sp_paint_selector_set_style_buttons(psel, psel->mesh);
+    }
+    gtk_widget_set_sensitive(psel->style, TRUE);
+
+    GtkWidget *tbl = NULL;
+
+    if (psel->mode == SPPaintSelector::MODE_GRADIENT_MESH) {
+        /* Already have mesh menu */
+        tbl = GTK_WIDGET(g_object_get_data(G_OBJECT(psel->selector), "mesh-selector"));
+    } else {
+        sp_paint_selector_clear_frame(psel);
+
+        /* 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 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);
+            gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+        }
+
+        gtk_widget_show_all(tbl);
+
+        gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
+        psel->selector = tbl;
+        g_object_set_data(G_OBJECT(psel->selector), "mesh-selector", tbl);
+
+        gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Mesh fill</b>"));
+    }
 #ifdef SP_PS_VERBOSE
-    g_print("Gradient req\n");
+    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)
 {
@@ -1046,21 +1351,13 @@ static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSel
         sp_paint_selector_clear_frame(psel);
 
         /* Create vbox */
-#if GTK_CHECK_VERSION(3,0,0)
         tbl = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
         gtk_box_set_homogeneous(GTK_BOX(tbl), FALSE);
-#else
-        tbl = gtk_vbox_new(FALSE, 4);
-#endif
         gtk_widget_show(tbl);
 
         {
-#if GTK_CHECK_VERSION(3,0,0)
-            GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1);
+            auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1);
             gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
-#else
-            GtkWidget *hb = gtk_hbox_new(FALSE, 1);
-#endif
 
             /**
              * Create a combo_box and store with 4 columns,
@@ -1088,13 +1385,9 @@ static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSel
         }
 
         {
-#if GTK_CHECK_VERSION(3,0,0)
-            GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+            auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
             gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
-#else
-            GtkWidget *hb = gtk_hbox_new(FALSE, 0);
-#endif
-            GtkWidget *l = gtk_label_new(NULL);
+            auto l = gtk_label_new(NULL);
             gtk_label_set_markup(GTK_LABEL(l), _("Use the <b>Node tool</b> to adjust position, scale, and rotation of the pattern on canvas. Use <b>Object &gt; Pattern &gt; Objects to Pattern</b> to create a new pattern from selection."));
             gtk_label_set_line_wrap(GTK_LABEL(l), true);
             gtk_widget_set_size_request(l, 180, -1);
@@ -1262,7 +1555,7 @@ SPPaintSelector::Mode SPPaintSelector::getModeForStyle(SPStyle const & style, Fi
         } else if (SP_IS_RADIALGRADIENT(server)) {
             mode = MODE_GRADIENT_RADIAL;
 #ifdef WITH_MESH
-        } else if (SP_IS_MESH(server)) {
+        } else if (SP_IS_MESHGRADIENT(server)) {
             mode = MODE_GRADIENT_MESH;
 #endif
         } else if (SP_IS_PATTERN(server)) {