Trunk merge

(bzr r11073.1.20)

16 files changed, 548 insertions, 218 deletions

diff --git a/src/widgets/button.cpp b/src/widgets/button.cpp
index 676cb9b59..0071fc56e 100644
--- a/src/widgets/button.cpp
+++ b/src/widgets/button.cpp
@@ -30,6 +30,17 @@ static void sp_button_init (SPButton *button);
 static void sp_button_destroy (GtkObject *object);
 
 static void sp_button_size_request (GtkWidget *widget, GtkRequisition *requisition);
+
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_button_get_preferred_width(GtkWidget *widget, 
+                                          gint *minimal_width,
+					  gint *natural_width);
+
+static void sp_button_get_preferred_height(GtkWidget *widget, 
+                                           gint *minimal_height,
+					   gint *natural_height);
+#endif
+
 static void sp_button_clicked (GtkButton *button);
 static void sp_button_perform_action (SPButton *button, gpointer data);
 static gint sp_button_process_event (SPButton *button, GdkEvent *event);
@@ -72,7 +83,12 @@ sp_button_class_init (SPButtonClass *klass)
 	parent_class = (GtkToggleButtonClass *)g_type_class_peek_parent (klass);
 
 	object_class->destroy = sp_button_destroy;
+#if GTK_CHECK_VERSION(3,0,0)
+	widget_class->get_preferred_width = sp_button_get_preferred_width;
+	widget_class->get_preferred_height = sp_button_get_preferred_height;
+#else
 	widget_class->size_request = sp_button_size_request;
+#endif
 	button_class->clicked = sp_button_clicked;
 }
 
@@ -129,6 +145,22 @@ sp_button_size_request (GtkWidget *widget, GtkRequisition *requisition)
 	requisition->height += 2 + 2 * MAX (2, style->ythickness);
 }
 
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_button_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+	sp_button_size_request(widget, &requisition);
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void sp_button_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+	sp_button_size_request(widget, &requisition);
+	*minimal_height = *natural_height = requisition.height;
+}
+#endif
+
 static void
 sp_button_clicked (GtkButton *button)
 {
diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index 44d3c2f9a..996f116e2 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -1741,7 +1741,7 @@ sp_dtw_zoom_value_changed (GtkSpinButton *spin, gpointer data)
     desktop->zoom_absolute (d.midpoint()[Geom::X], d.midpoint()[Geom::Y], zoom_factor);
     g_signal_handler_unblock (spin, dtw->zoom_update);
 
-    spinbutton_defocus (GTK_OBJECT (spin));
+    spinbutton_defocus (GTK_WIDGET(spin));
 }
 
 static void
diff --git a/src/widgets/eek-preview.cpp b/src/widgets/eek-preview.cpp
index 134cf9342..db9cb96bd 100644
--- a/src/widgets/eek-preview.cpp
+++ b/src/widgets/eek-preview.cpp
@@ -177,6 +177,22 @@ static void eek_preview_size_request( GtkWidget* widget, GtkRequisition* req )
     req->height = height;
 }
 
+#if GTK_CHECK_VERSION(3,0,0)
+static void eek_preview_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+	eek_preview_size_request(widget, &requisition);
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void eek_preview_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+	eek_preview_size_request(widget, &requisition);
+	*minimal_height = *natural_height = requisition.height;
+}
+#endif
+
 enum {
   CLICKED_SIGNAL,
   ALTCLICKED_SIGNAL,
@@ -578,7 +594,12 @@ static void eek_preview_class_init( EekPreviewClass *klass )
     /*widgetClass->unmap = ;*/
     /*widgetClass->realize = ;*/
     /*widgetClass->unrealize = ;*/
+#if GTK_CHECK_VERSION(3,0,0)
+    widgetClass->get_preferred_width = eek_preview_get_preferred_width;
+    widgetClass->get_preferred_height = eek_preview_get_preferred_height;
+#else
     widgetClass->size_request = eek_preview_size_request;
+#endif
     /*widgetClass->size_allocate = ;*/
     /*widgetClass->state_changed = ;*/
     /*widgetClass->style_set = ;*/
diff --git a/src/widgets/gradient-image.cpp b/src/widgets/gradient-image.cpp
index b835dc36b..114d76293 100644
--- a/src/widgets/gradient-image.cpp
+++ b/src/widgets/gradient-image.cpp
@@ -28,6 +28,17 @@ static void sp_gradient_image_init (SPGradientImage *image);
 static void sp_gradient_image_destroy (GtkObject *object);
 
 static void sp_gradient_image_size_request (GtkWidget *widget, GtkRequisition *requisition);
+
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_gradient_image_get_preferred_width(GtkWidget *widget, 
+                                                   gint *minimal_width,
+						   gint *natural_width);
+
+static void sp_gradient_image_get_preferred_height(GtkWidget *widget, 
+                                                    gint *minimal_height,
+						    gint *natural_height);
+#endif
+
 static gint sp_gradient_image_expose (GtkWidget *widget, GdkEventExpose *event);
 
 static void sp_gradient_image_gradient_release (SPObject *, SPGradientImage *im);
@@ -69,7 +80,12 @@ sp_gradient_image_class_init (SPGradientImageClass *klass)
 
 	object_class->destroy = sp_gradient_image_destroy;
 
+#if GTK_CHECK_VERSION(3,0,0)
+	widget_class->get_preferred_width = sp_gradient_image_get_preferred_width;
+	widget_class->get_preferred_height = sp_gradient_image_get_preferred_height;
+#else
 	widget_class->size_request = sp_gradient_image_size_request;
+#endif
 	widget_class->expose_event = sp_gradient_image_expose;
 }
 
@@ -110,6 +126,22 @@ static void sp_gradient_image_size_request(GtkWidget * /*widget*/, GtkRequisitio
     requisition->height = 12;
 }
 
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_gradient_image_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+	sp_gradient_image_size_request(widget, &requisition);
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void sp_gradient_image_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+	sp_gradient_image_size_request(widget, &requisition);
+	*minimal_height = *natural_height = requisition.height;
+}
+#endif
+
 static gint
 sp_gradient_image_expose (GtkWidget *widget, GdkEventExpose *event)
 {
diff --git a/src/widgets/gradient-toolbar.cpp b/src/widgets/gradient-toolbar.cpp
index e239457fd..a7b97c21a 100644
--- a/src/widgets/gradient-toolbar.cpp
+++ b/src/widgets/gradient-toolbar.cpp
@@ -636,6 +636,20 @@ gr_remove_stop (GtkWidget */*button*/, GtkWidget *vb)
 }
 
 static void
+gr_linked_changed (GtkToggleAction *act, gpointer data)
+{
+    gboolean active = gtk_toggle_action_get_active( act );
+    if ( active ) {
+        g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-locked"), NULL );
+    } else {
+        g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-unlocked"), NULL );
+    }
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool("/options/forkgradientvectors/value", !active);
+}
+
+static void
 gr_reverse (GtkWidget */*button*/, gpointer data)
 {
     SPDesktop *desktop = static_cast<SPDesktop *>(data);
@@ -1264,6 +1278,22 @@ void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions,
 
     }
 
+    // Gradients Linked toggle
+    {
+        InkToggleAction* itact = ink_toggle_action_new( "GradientEditLinkAction",
+                                                        _("Link gradients"),
+                                                        _("Link gradients to change all related gradients"),
+                                                        INKSCAPE_ICON("object-unlocked"),
+                                                        secondarySize );
+        g_object_set( itact, "short_label", "Lock", NULL );
+        g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(gr_linked_changed), desktop) ;
+        gtk_action_group_add_action( mainActions, GTK_ACTION(itact) );
+
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        bool linkedmode = prefs->getBool("/options/forkgradientvectors/value", true);
+        gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), !linkedmode );
+    }
+
     Inkscape::Selection *selection = sp_desktop_selection (desktop);
     SPDocument *document = sp_desktop_document (desktop);
 
diff --git a/src/widgets/icon.cpp b/src/widgets/icon.cpp
index 7f027870d..a58645015 100644
--- a/src/widgets/icon.cpp
+++ b/src/widgets/icon.cpp
@@ -61,6 +61,15 @@ struct IconImpl {
     static void clear(SPIcon *icon);
 
     static void sizeRequest(GtkWidget *widget, GtkRequisition *requisition);
+    
+    static void getPreferredWidth(GtkWidget *widget, 
+		    gint *minimal_width,
+		    gint *natural_width);
+
+    static void getPreferredHeight(GtkWidget *widget, 
+		    gint *minimal_height,
+		    gint *natural_height);
+
     static void sizeAllocate(GtkWidget *widget, GtkAllocation *allocation);
     static int expose(GtkWidget *widget, GdkEventExpose *event);
 
@@ -172,7 +181,12 @@ void IconImpl::classInit(SPIconClass *klass)
 
     object_class->dispose = IconImpl::dispose;
 
+#if GTK_CHECK_VERSION(3,0,0)
+    widget_class->get_preferred_width = IconImpl::getPreferredWidth;
+    widget_class->get_preferred_height = IconImpl::getPreferredHeight;
+#else
     widget_class->size_request = IconImpl::sizeRequest;
+#endif
     widget_class->size_allocate = IconImpl::sizeAllocate;
     widget_class->expose_event = IconImpl::expose;
     widget_class->screen_changed = IconImpl::screenChanged;
@@ -225,6 +239,20 @@ void IconImpl::sizeRequest(GtkWidget *widget, GtkRequisition *requisition)
     requisition->height = size;
 }
 
+void IconImpl::getPreferredWidth(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+	sizeRequest(widget, &requisition);
+	*minimal_width = *natural_width = requisition.width;
+}
+
+void IconImpl::getPreferredHeight(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+	sizeRequest(widget, &requisition);
+	*minimal_height = *natural_height = requisition.height;
+}
+
 void IconImpl::sizeAllocate(GtkWidget *widget, GtkAllocation *allocation)
 {
     gtk_widget_set_allocation(widget, allocation);
diff --git a/src/widgets/paint-selector.cpp b/src/widgets/paint-selector.cpp
index 3f34c8ad1..075308321 100644
--- a/src/widgets/paint-selector.cpp
+++ b/src/widgets/paint-selector.cpp
@@ -445,9 +445,9 @@ void SPPaintSelector::setColorAlpha(SPColor const &color, float alpha)
 {
     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
     SPColorSelector *csel = 0;
+/*
     guint32 rgba = 0;
 
-/*
     if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
     {
 #ifdef SP_PS_VERBOSE
@@ -465,7 +465,7 @@ void SPPaintSelector::setColorAlpha(SPColor const &color, float alpha)
     }
 
     csel = reinterpret_cast<SPColorSelector*>(g_object_get_data(G_OBJECT(selector), "color-selector"));
-    rgba = color.toRGBA32( alpha );
+    //rgba = color.toRGBA32( alpha );
     csel->base->setColorAlpha( color, alpha );
 }
 
@@ -572,21 +572,6 @@ sp_paint_selector_clear_frame(SPPaintSelector *psel)
 
     if (psel->selector) {
 
-        /* before we destroy the frame contents, we must detach
-         * the patternmenu so that Gtk doesn't gtk_widget_destroy
-         * all the children of the menu.  (We also have a g_object_ref
-         * count set on it too so that the gtk_container_remove doesn't
-         * end up destroying it.
-         */
-        GtkWidget *patterns = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
-        if (patterns != NULL) {
-            GtkWidget * parent = gtk_widget_get_parent( GTK_WIDGET(patterns));
-            if ( parent != NULL ) {
-                g_assert( GTK_IS_CONTAINER(parent) );
-                gtk_container_remove( GTK_CONTAINER(parent), patterns );
-            }
-        }
-
         gtk_widget_destroy(psel->selector);
         psel->selector = NULL;
     }
@@ -829,53 +814,42 @@ ink_pattern_list_get (SPDocument *source)
  * Adds menu items for pattern list - derived from marker code, left hb etc in to make addition of previews easier at some point.
  */
 static void
-sp_pattern_menu_build (GtkWidget *m, GSList *pattern_list, SPDocument */*source*/)
+sp_pattern_menu_build (GtkWidget *combo, GSList *pattern_list, SPDocument */*source*/)
 {
+    GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
+    GtkTreeIter iter;
 
     for (; pattern_list != NULL; pattern_list = pattern_list->next) {
+
         Inkscape::XML::Node *repr = reinterpret_cast<SPItem *>(pattern_list->data)->getRepr();
-                GtkWidget *i = gtk_menu_item_new();
-                gtk_widget_show(i);
 
-        if (repr->attribute("inkscape:stockid"))
-            g_object_set_data (G_OBJECT(i), "stockid", (void *) "true");
-        else
-            g_object_set_data (G_OBJECT(i), "stockid", (void *) "false");
+        // label for combobox
+        gchar const *label;
+        if (repr->attribute("inkscape:stockid")) {
+            label = _(repr->attribute("inkscape:stockid"));
+        } else {
+            label = _(repr->attribute("id"));
+        }
 
         gchar const *patid = repr->attribute("id");
-        g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
-
-#if GTK_CHECK_VERSION(3,0,0)
-                GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
-                gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
-#else
-                GtkWidget *hb = gtk_hbox_new(FALSE, 4);
-#endif
-                gtk_widget_show(hb);
-
-        // create label
-                GtkWidget *l;
-                if (repr->attribute("inkscape:stockid"))
-                    l = gtk_label_new(_(repr->attribute("inkscape:stockid")));
-                else
-                    l = gtk_label_new(_(repr->attribute("id")));
-                gtk_widget_show(l);
-                gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
 
-                gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
+        gboolean stockid = false;
+        if (repr->attribute("inkscape:stockid")) {
+            stockid = true;
+        }
 
-                gtk_widget_show(hb);
-                gtk_container_add(GTK_CONTAINER(i), hb);
+        gtk_list_store_append(store, &iter);
+        gtk_list_store_set(store, &iter,
+                COMBO_COL_LABEL, label, COMBO_COL_STOCK, stockid, COMBO_COL_PATTERN, patid, COMBO_COL_SEP, FALSE, -1);
 
-                gtk_menu_shell_append(GTK_MENU_SHELL(m), i);
-            }
-        }
+    }
+}
 
 /**
  * Pick up all patterns from source, except those that are in
  * current_doc (if non-NULL), and add items to the pattern menu.
  */
-static void sp_pattern_list_from_doc(GtkWidget *m, SPDocument * /*current_doc*/, SPDocument *source, SPDocument * /*pattern_doc*/)
+static void sp_pattern_list_from_doc(GtkWidget *combo, SPDocument * /*current_doc*/, SPDocument *source, SPDocument * /*pattern_doc*/)
 {
     GSList *pl = ink_pattern_list_get(source);
     GSList *clean_pl = NULL;
@@ -889,17 +863,15 @@ static void sp_pattern_list_from_doc(GtkWidget *m, SPDocument * /*current_doc*/,
         clean_pl = g_slist_prepend (clean_pl, pl->data);
     }
 
-    sp_pattern_menu_build (m, clean_pl, source);
+    sp_pattern_menu_build (combo, clean_pl, source);
 
     g_slist_free (pl);
     g_slist_free (clean_pl);
 }
 
 
-
-
 static void
-ink_pattern_menu_populate_menu(GtkWidget *m, SPDocument *doc)
+ink_pattern_menu_populate_menu(GtkWidget *combo, SPDocument *doc)
 {
     static SPDocument *patterns_doc = NULL;
 
@@ -913,51 +885,59 @@ ink_pattern_menu_populate_menu(GtkWidget *m, SPDocument *doc)
     }
 
     // suck in from current doc
-    sp_pattern_list_from_doc ( m, NULL, doc, patterns_doc );
+    sp_pattern_list_from_doc ( combo, NULL, doc, patterns_doc );
 
     // add separator
     {
-        GtkWidget *i = gtk_separator_menu_item_new();
-        gchar const *patid = "";
-        g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
-        gtk_widget_show(i);
-        gtk_menu_shell_append(GTK_MENU_SHELL(m), i);
+        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_PATTERN, "", COMBO_COL_SEP, true, -1);
     }
 
     // suck in from patterns.svg
     if (patterns_doc) {
         doc->ensureUpToDate();
-        sp_pattern_list_from_doc ( m, doc, patterns_doc, NULL );
+        sp_pattern_list_from_doc ( combo, doc, patterns_doc, NULL );
     }
 
 }
 
 
 static GtkWidget*
-ink_pattern_menu(GtkWidget *mnu)
+ink_pattern_menu(GtkWidget *combo)
 {
-   /* Create new menu widget */
-    GtkWidget *m = gtk_menu_new();
-    gtk_widget_show(m);
     SPDocument *doc = SP_ACTIVE_DOCUMENT;
 
+    GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
+    GtkTreeIter iter;
+
     if (!doc) {
-        GtkWidget *i;
-        i = gtk_menu_item_new_with_label(_("No document selected"));
-        gtk_widget_show(i);
-        gtk_menu_shell_append(GTK_MENU_SHELL(m), i);
-        gtk_widget_set_sensitive(mnu, FALSE);
+
+        gtk_list_store_append (store, &iter);
+        gtk_list_store_set (store, &iter,
+                COMBO_COL_LABEL, _("No document selected"), COMBO_COL_STOCK, false, COMBO_COL_PATTERN, "", COMBO_COL_SEP, false, -1);
+        gtk_widget_set_sensitive(combo, FALSE);
+
     } else {
 
-       ink_pattern_menu_populate_menu(m, doc);
-        gtk_widget_set_sensitive(mnu, TRUE);
+        ink_pattern_menu_populate_menu(combo, doc);
+        gtk_widget_set_sensitive(combo, TRUE);
 
     }
-    gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
 
-    /* Set history */
-    gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
-    return mnu;
+    // Select the first item that is not a seperator
+    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;
 }
 
 
@@ -967,43 +947,41 @@ void SPPaintSelector::updatePatternList( SPPattern *pattern )
     if (update) {
         return;
     }
-    GtkWidget *mnu = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "patternmenu"));
-    g_assert( mnu != NULL );
+    GtkWidget *combo = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "patternmenu"));
+    g_assert( combo != NULL );
 
     /* Clear existing menu if any */
-    gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
+    GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+    gtk_list_store_clear(GTK_LIST_STORE(store));
 
-    ink_pattern_menu(mnu);
+    ink_pattern_menu(combo);
 
     /* Set history */
 
-    if (pattern && !g_object_get_data(G_OBJECT(mnu), "update")) {
-
-        g_object_set_data(G_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
+    if (pattern && !g_object_get_data(G_OBJECT(combo), "update")) {
 
+        g_object_set_data(G_OBJECT(combo), "update", GINT_TO_POINTER(TRUE));
         gchar const *patname = pattern->getRepr()->attribute("id");
 
-        GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
-
-        GList *kids = gtk_container_get_children(GTK_CONTAINER(m));
-
-        int patpos = 0;
-        int i = 0;
-
-        for (; kids != NULL; kids = kids->next) {
-
-            gchar *men_pat = (gchar *) g_object_get_data(G_OBJECT(kids->data), "pattern");
-            if ( strcmp(men_pat, patname) == 0 ) {
-                patpos = i;
-            }
-            i++;
+        // Find this pattern and set it active in the combo_box
+        GtkTreeIter iter ;
+        gchar *patid = NULL;
+        bool valid = gtk_tree_model_get_iter_first (store, &iter);
+        if (!valid) {
+            return;
+        }
+        gtk_tree_model_get (store, &iter, COMBO_COL_PATTERN, &patid, -1);
+        while (valid && strcmp(patid, patname)  != 0) {
+            valid = gtk_tree_model_iter_next (store, &iter);
+            gtk_tree_model_get (store, &iter, COMBO_COL_PATTERN, &patid, -1);
         }
 
+        if (valid) {
+            gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+        }
 
-        gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), patpos);
-        g_object_set_data(G_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
+        g_object_set_data(G_OBJECT(combo), "update", GINT_TO_POINTER(FALSE));
     }
-    //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 }
 
 static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelector::Mode mode)
@@ -1039,15 +1017,29 @@ static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSel
             GtkWidget *hb = gtk_hbox_new(FALSE, 1);
 #endif
 
-            GtkWidget *mnu = gtk_option_menu_new();
-            ink_pattern_menu(mnu);
-            g_signal_connect(G_OBJECT(mnu), "changed", G_CALLBACK(sp_psel_pattern_change), psel);
-            g_signal_connect(G_OBJECT(mnu), "destroy", G_CALLBACK(sp_psel_pattern_destroy), psel);
-            g_object_set_data(G_OBJECT(psel), "patternmenu", mnu);
-            g_object_ref( G_OBJECT(mnu));
-
-            gtk_container_add(GTK_CONTAINER(hb), mnu);
+            /**
+             * Create a combo_box and store with 4 columns,
+             * The label, a pointer to the pattern, 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_pattern_menu(combo);
+            g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(sp_psel_pattern_change), psel);
+            g_signal_connect(G_OBJECT(combo), "destroy", G_CALLBACK(sp_psel_pattern_destroy), psel);
+            g_object_set_data(G_OBJECT(psel), "patternmenu", 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));
         }
 
         {
@@ -1078,37 +1070,54 @@ static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSel
 #endif
 }
 
+gboolean SPPaintSelector::isSeparator (GtkTreeModel *model, GtkTreeIter *iter, gpointer /*data*/) {
+
+    gboolean sep = FALSE;
+    gtk_tree_model_get(model, iter, COMBO_COL_SEP, &sep, -1);
+    return sep;
+}
+
 SPPattern *SPPaintSelector::getPattern()
 {
     SPPattern *pat = 0;
     g_return_val_if_fail((mode == MODE_PATTERN) , NULL);
 
-    GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(this), "patternmenu");
+    GtkWidget *combo = (GtkWidget *) g_object_get_data(G_OBJECT(this), "patternmenu");
+
     /* no pattern menu if we were just selected */
-    if ( patmnu == NULL ) return NULL;
+    if ( combo == NULL ) {
+        return NULL;
+    }
 
-    GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(patmnu)));
+    GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
 
-    /* Get Pattern */
-    if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern"))
-    {
+    /* Get the selected pattern */
+    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 *patid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
-                                               "pattern");
-    //gchar *pattern = "";
+
+    gchar *patid = NULL;
+    gboolean stockid = FALSE;
+    gchar *label = NULL;
+    gtk_tree_model_get (store, &iter, COMBO_COL_LABEL, &label, COMBO_COL_STOCK, &stockid, COMBO_COL_PATTERN, &patid,  -1);
+    if (patid == NULL) {
+        return NULL;
+    }
+
     if (strcmp(patid, "none")){
 
-        gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
-                                                     "stockid");
-        gchar *paturn = patid;
-        if (!strcmp(stockid,"true")) paturn = g_strconcat("urn:inkscape:pattern:",patid,NULL);
+        gchar *paturn = g_strdup(patid);
+        if (stockid)  {
+            paturn = g_strconcat("urn:inkscape:pattern:",patid,NULL);
+        }
         SPObject *pat_obj = get_stock_item(paturn);
         if (pat_obj) {
             pat = SP_PATTERN(pat_obj);
         }
     } else {
-        pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
+        pat = pattern_getroot(SP_PATTERN(patid));
     }
 
     if (pat && !SP_IS_PATTERN(pat)) {
diff --git a/src/widgets/paint-selector.h b/src/widgets/paint-selector.h
index 7400987ee..d6ad3f50c 100644
--- a/src/widgets/paint-selector.h
+++ b/src/widgets/paint-selector.h
@@ -77,6 +77,7 @@ struct SPPaintSelector {
     SPColor color;
     float alpha;
 
+
     static Mode getModeForStyle(SPStyle const & style, FillOrStroke kind);
 
     void setMode( Mode mode );
@@ -97,10 +98,15 @@ struct SPPaintSelector {
     SPPattern * getPattern();
     void updatePatternList( SPPattern *pat );
 
+    static gboolean isSeparator (GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
+
     // TODO move this elsewhere:
     void setFlatColor( SPDesktop *desktop, const gchar *color_property, const gchar *opacity_property );
 };
 
+enum {COMBO_COL_LABEL=0, COMBO_COL_STOCK=1, COMBO_COL_PATTERN=2, COMBO_COL_SEP=3, COMBO_N_COLS=4};
+
+
 /// The SPPaintSelector vtable
 struct SPPaintSelectorClass {
     GtkVBoxClass parent_class;
diff --git a/src/widgets/ruler.cpp b/src/widgets/ruler.cpp
index a76bf3081..b4fbb13c5 100644
--- a/src/widgets/ruler.cpp
+++ b/src/widgets/ruler.cpp
@@ -61,6 +61,17 @@ static void     gtk_deprecated_ruler_realize         (GtkWidget      *widget);
 static void     gtk_deprecated_ruler_unrealize       (GtkWidget      *widget);
 static void     gtk_deprecated_ruler_size_request    (GtkWidget      *widget,
                                                       GtkRequisition *requisition);
+
+#if GTK_CHECK_VERSION(3,0,0)
+static void     gtk_deprecated_ruler_get_preferred_width(GtkWidget *widget, 
+                                                         gint *minimal_width,
+							 gint *natural_width);
+
+static void     gtk_deprecated_ruler_get_preferred_height(GtkWidget *widget, 
+                                                    gint *minimal_height,
+						    gint *natural_height);
+#endif
+
 static void     gtk_deprecated_ruler_size_allocate   (GtkWidget      *widget,
                                                       GtkAllocation  *allocation);
 static gboolean gtk_deprecated_ruler_motion_notify   (GtkWidget      *widget,
@@ -96,7 +107,12 @@ gtk_deprecated_ruler_class_init (GtkDeprecatedRulerClass *klass)
 
   widget_class->realize = gtk_deprecated_ruler_realize;
   widget_class->unrealize = gtk_deprecated_ruler_unrealize;
+#if GTK_CHECK_VERSION(3,0,0)
+  widget_class->get_preferred_width = gtk_deprecated_ruler_get_preferred_width;
+  widget_class->get_preferred_height = gtk_deprecated_ruler_get_preferred_height;
+#else
   widget_class->size_request = gtk_deprecated_ruler_size_request;
+#endif
   widget_class->size_allocate = gtk_deprecated_ruler_size_allocate;
   widget_class->motion_notify_event = gtk_deprecated_ruler_motion_notify;
   widget_class->expose_event = gtk_deprecated_ruler_expose;
@@ -359,16 +375,15 @@ gtk_deprecated_ruler_set_metric (GtkDeprecatedRuler      *ruler,
  *
  * Return value: the units currently used for @ruler
  **/
-GtkMetricType
-gtk_deprecated_ruler_get_metric (GtkDeprecatedRuler *ruler)
+GtkMetricType gtk_deprecated_ruler_get_metric (GtkDeprecatedRuler *ruler)
 {
-  gint i;
+  g_return_val_if_fail(GTK_DEPRECATED_IS_RULER(ruler), static_cast<GtkMetricType>(0));
 
-  g_return_val_if_fail (GTK_DEPRECATED_IS_RULER (ruler), static_cast<GtkMetricType>(0));
-
-  for (i = 0; i < G_N_ELEMENTS (ruler_metrics); i++)
-    if (ruler->metric == &ruler_metrics[i])
+  for (size_t i = 0; i < G_N_ELEMENTS(ruler_metrics); i++) {
+    if (ruler->metric == &ruler_metrics[i]) {
       return static_cast<GtkMetricType>(i);
+    }
+  }
 
   g_assert_not_reached ();
 
@@ -470,6 +485,22 @@ gtk_deprecated_ruler_size_request (GtkWidget      *widget,
     }
 }
 
+#if GTK_CHECK_VERSION(3,0,0)
+static void gtk_deprecated_ruler_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+	gtk_deprecated_ruler_size_request(widget, &requisition);
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void gtk_deprecated_ruler_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+	gtk_deprecated_ruler_size_request(widget, &requisition);
+	*minimal_height = *natural_height = requisition.height;
+}
+#endif
+
 static void
 gtk_deprecated_ruler_size_allocate (GtkWidget     *widget,
 			 GtkAllocation *allocation)
@@ -995,6 +1026,16 @@ static gint sp_vruler_motion_notify (GtkWidget      *widget,
 				      GdkEventMotion *event);
 static void sp_vruler_size_request (GtkWidget *widget, GtkRequisition *requisition);
 
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_vruler_get_preferred_width(GtkWidget *widget, 
+                                          gint *minimal_width,
+					  gint *natural_width);
+
+static void sp_vruler_get_preferred_height(GtkWidget *widget, 
+                                           gint *minimal_height,
+					   gint *natural_height);
+#endif
+
 static GtkWidgetClass *vruler_parent_class;
 
 GType
@@ -1033,7 +1074,13 @@ sp_vruler_class_init (SPVRulerClass *klass)
   ruler_class = (GtkDeprecatedRulerClass*) klass;
 
   widget_class->motion_notify_event = sp_vruler_motion_notify;
+
+#if GTK_CHECK_VERSION(3,0,0)
+  widget_class->get_preferred_width = sp_vruler_get_preferred_width;
+  widget_class->get_preferred_height = sp_vruler_get_preferred_height;
+#else
   widget_class->size_request = sp_vruler_size_request;
+#endif
 
   ruler_class->draw_ticks = sp_ruler_common_draw_ticks;
 }
@@ -1091,6 +1138,22 @@ sp_vruler_size_request (GtkWidget *widget, GtkRequisition *requisition)
   requisition->width = style->xthickness * 2 + RULER_WIDTH;
 }
 
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_vruler_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+	sp_vruler_size_request(widget, &requisition);
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void sp_vruler_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+	sp_vruler_size_request(widget, &requisition);
+	*minimal_height = *natural_height = requisition.height;
+}
+#endif
+
 static void
 sp_ruler_common_draw_ticks(GtkDeprecatedRuler *ruler)
 {
diff --git a/src/widgets/ruler.h b/src/widgets/ruler.h
index 03eace0cb..0e7d32b2a 100644
--- a/src/widgets/ruler.h
+++ b/src/widgets/ruler.h
@@ -70,8 +70,8 @@ struct _GtkDeprecatedRulerClass
 
 struct _GtkDeprecatedRulerMetric
 {
-  gchar *metric_name;
-  gchar *abbrev;
+  gchar const *metric_name;
+  gchar const *abbrev;
   /* This should be points_per_unit. This is the size of the unit
    * in 1/72nd's of an inch and has nothing to do with screen pixels */
   gdouble pixels_per_unit;
diff --git a/src/widgets/sp-color-slider.cpp b/src/widgets/sp-color-slider.cpp
index b74be502b..3b690afc9 100644
--- a/src/widgets/sp-color-slider.cpp
+++ b/src/widgets/sp-color-slider.cpp
@@ -32,6 +32,17 @@ static void sp_color_slider_destroy (GtkObject *object);
 
 static void sp_color_slider_realize (GtkWidget *widget);
 static void sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition);
+
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_color_slider_get_preferred_width(GtkWidget *widget, 
+                                                   gint *minimal_width,
+						   gint *natural_width);
+
+static void sp_color_slider_get_preferred_height(GtkWidget *widget, 
+                                                    gint *minimal_height,
+						    gint *natural_height);
+#endif
+
 static void sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
 /*  static void sp_color_slider_draw (GtkWidget *widget, GdkRectangle *area); */
 /*  static void sp_color_slider_draw_focus (GtkWidget *widget); */
@@ -117,7 +128,12 @@ sp_color_slider_class_init (SPColorSliderClass *klass)
 	object_class->destroy = sp_color_slider_destroy;
 
 	widget_class->realize = sp_color_slider_realize;
+#if GTK_CHECK_VERSION(3,0,0)
+	widget_class->get_preferred_width = sp_color_slider_get_preferred_width;
+	widget_class->get_preferred_height = sp_color_slider_get_preferred_height;
+#else
 	widget_class->size_request = sp_color_slider_size_request;
+#endif
 	widget_class->size_allocate = sp_color_slider_size_allocate;
 /*  	widget_class->draw = sp_color_slider_draw; */
 /*  	widget_class->draw_focus = sp_color_slider_draw_focus; */
@@ -225,6 +241,22 @@ sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition)
 	requisition->height = SLIDER_HEIGHT + style->ythickness * 2;
 }
 
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_color_slider_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+	sp_color_slider_size_request(widget, &requisition);
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void sp_color_slider_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+	sp_color_slider_size_request(widget, &requisition);
+	*minimal_height = *natural_height = requisition.height;
+}
+#endif
+
 static void
 sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 {
@@ -512,12 +544,18 @@ sp_color_slider_paint (SPColorSlider *slider, GdkRectangle *area)
 			b = sp_color_slider_render_map (cpaint.x - carea.x, cpaint.y - carea.y, cpaint.width, cpaint.height,
 																			slider->map, s, d,
 																			slider->b0, slider->b1, slider->bmask);
-			if (b != NULL) {
-				gdk_draw_rgb_image(window, style->black_gc,
-														cpaint.x, cpaint.y,
-														cpaint.width, cpaint.height,
-														GDK_RGB_DITHER_MAX,
-														(guchar *) b, cpaint.width * 3);
+			if (b != NULL && cpaint.width > 0) {
+
+                    GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB,
+                            0, 8, cpaint.width, cpaint.height, cpaint.width * 3, NULL, NULL);
+
+                    cairo_t *ct = gdk_cairo_create(window);
+                    gdk_cairo_set_source_pixbuf (ct, pb,  cpaint.x, cpaint.y);
+                    cairo_paint(ct);
+                    cairo_destroy(ct);
+
+                    g_object_unref(pb);
+
 			}
 
 		} else {
@@ -537,13 +575,18 @@ sp_color_slider_paint (SPColorSlider *slider, GdkRectangle *area)
 													 c, dc,
 													 slider->b0, slider->b1, slider->bmask);
 
-				/* Draw pixelstore */
-				if (b != NULL) {
-					gdk_draw_rgb_image(window, style->black_gc,
-															cpaint.x, cpaint.y,
-															wi, cpaint.height,
-															GDK_RGB_DITHER_MAX,
-															(guchar *) b, wi * 3);
+				/* Draw pixelstore 1 */
+				if (b != NULL && wi > 0) {
+
+                    GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB,
+                        0, 8, wi, cpaint.height, wi * 3, NULL, NULL);
+
+                    cairo_t *ct = gdk_cairo_create(window);
+                    gdk_cairo_set_source_pixbuf (ct, pb, cpaint.x, cpaint.y);
+                    cairo_paint(ct);
+                    cairo_destroy(ct);
+
+                    g_object_unref(pb);
 				}
 			}
 
@@ -560,19 +603,24 @@ sp_color_slider_paint (SPColorSlider *slider, GdkRectangle *area)
 												 c, dc,
 												 slider->b0, slider->b1, slider->bmask);
 
-				/* Draw pixelstore */
-				if (b != NULL) {
-					gdk_draw_rgb_image(window, style->black_gc,
-															MAX(cpaint.x, carea.width/2 + carea.x), cpaint.y,
-															wi, cpaint.height,
-															GDK_RGB_DITHER_MAX,
-															(guchar *) b, wi * 3);
+				/* Draw pixelstore 2 */
+				if (b != NULL && wi > 0) {
+
+					GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB,
+				            0, 8, wi, cpaint.height, wi * 3, NULL, NULL);
+
+                    cairo_t *ct = gdk_cairo_create(window);
+                    gdk_cairo_set_source_pixbuf (ct, pb, MAX(cpaint.x, carea.width/2 + carea.x), cpaint.y);
+                    cairo_paint(ct);
+                    cairo_destroy(ct);
+
+                    g_object_unref(pb);
 				}
 			}
 		}
 	}
 
-        /* Draw shadow */
+	    /* Draw shadow */
         if (!colorsOnTop) {
             gtk_paint_shadow( style, window,
                               gtk_widget_get_state(widget), GTK_SHADOW_IN,
diff --git a/src/widgets/sp-widget.cpp b/src/widgets/sp-widget.cpp
index 8645d90f7..c0ee44f83 100644
--- a/src/widgets/sp-widget.cpp
+++ b/src/widgets/sp-widget.cpp
@@ -35,6 +35,17 @@ static void sp_widget_show (GtkWidget *widget);
 static void sp_widget_hide (GtkWidget *widget);
 static gint sp_widget_expose (GtkWidget *widget, GdkEventExpose *event);
 static void sp_widget_size_request (GtkWidget *widget, GtkRequisition *requisition);
+
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_widget_get_preferred_width(GtkWidget *widget, 
+                                                   gint *minimal_width,
+						   gint *natural_width);
+
+static void sp_widget_get_preferred_height(GtkWidget *widget, 
+                                                    gint *minimal_height,
+						    gint *natural_height);
+#endif
+
 static void sp_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
 
 static void sp_widget_modify_selection (Inkscape::Application *inkscape, Inkscape::Selection *selection, guint flags, SPWidget *spw);
@@ -115,7 +126,12 @@ sp_widget_class_init (SPWidgetClass *klass)
 	widget_class->show = sp_widget_show;
 	widget_class->hide = sp_widget_hide;
 	widget_class->expose_event = sp_widget_expose;
+#if GTK_CHECK_VERSION(3,0,0)
+	widget_class->get_preferred_width = sp_widget_get_preferred_width;
+	widget_class->get_preferred_height = sp_widget_get_preferred_height;
+#else
 	widget_class->size_request = sp_widget_size_request;
+#endif
 	widget_class->size_allocate = sp_widget_size_allocate;
 }
 
@@ -212,6 +228,22 @@ sp_widget_size_request (GtkWidget *widget, GtkRequisition *requisition)
 		gtk_widget_size_request (child, requisition);
 }
 
+#if GTK_CHECK_VERSION(3,0,0)
+static void sp_widget_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+	sp_widget_size_request(widget, &requisition);
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void sp_widget_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+	sp_widget_size_request(widget, &requisition);
+	*minimal_height = *natural_height = requisition.height;
+}
+#endif
+
 static void
 sp_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 {
diff --git a/src/widgets/sp-xmlview-tree.cpp b/src/widgets/sp-xmlview-tree.cpp
index ade5bec39..aafd4ab79 100644
--- a/src/widgets/sp-xmlview-tree.cpp
+++ b/src/widgets/sp-xmlview-tree.cpp
@@ -43,12 +43,12 @@ static void text_content_changed (Inkscape::XML::Node * repr, const gchar * old_
 static void comment_content_changed (Inkscape::XML::Node * repr, const gchar * old_content, const gchar * new_content, gpointer data);
 static void pi_content_changed (Inkscape::XML::Node * repr, const gchar * old_content, const gchar * new_content, gpointer data);
 
-static void ref_to_sibling (NodeData *node, Inkscape::XML::Node * ref, GtkTreeIter *);
-static void repr_to_child (NodeData *node, Inkscape::XML::Node * repr, GtkTreeIter *);
+static gboolean ref_to_sibling (NodeData *node, Inkscape::XML::Node * ref, GtkTreeIter *);
+static gboolean repr_to_child (NodeData *node, Inkscape::XML::Node * repr, GtkTreeIter *);
 static Inkscape::XML::Node * sibling_to_ref (GtkTreeView * tree, GtkTreeIter * parent, GtkTreeIter * sibling);
 static gboolean tree_model_iter_compare(GtkTreeModel* store, GtkTreeIter * iter1, GtkTreeIter * iter2);
 GtkTreeRowReference  *tree_iter_to_ref (SPXMLViewTree * tree, GtkTreeIter* iter);
-static void tree_ref_to_iter (SPXMLViewTree * tree, GtkTreeIter* iter, GtkTreeRowReference  *ref);
+static gboolean tree_ref_to_iter (SPXMLViewTree * tree, GtkTreeIter* iter, GtkTreeRowReference  *ref);
 
 gboolean search_equal_func (GtkTreeModel *model, gint column, const gchar *key, GtkTreeIter *iter, gpointer search_data);
 gboolean foreach_func (GtkTreeModel *model, GtkTreePath  *path, GtkTreeIter  *iter, gpointer user_data);
@@ -204,6 +204,10 @@ add_node (SPXMLViewTree * tree, GtkTreeIter *parent, GtkTreeIter *before, Inksca
 	GtkTreeIter iter;
     gtk_tree_store_insert_before (tree->store, &iter, parent, before);
 
+    if (!gtk_tree_store_iter_is_valid(tree->store, &iter)) {
+        return NULL;
+    }
+
     GtkTreeRowReference  *rowref = tree_iter_to_ref (tree, &iter);
     data = node_data_new (tree, &iter, rowref, repr);
     g_assert (data != NULL);
@@ -264,7 +268,9 @@ element_child_added (Inkscape::XML::Node * /*repr*/, Inkscape::XML::Node * child
 
 	if (data->tree->blocked) return;
 
-	ref_to_sibling (data, ref, &before);
+	if (!ref_to_sibling (data, ref, &before)) {
+	    return;
+	}
 
     GtkTreeIter data_iter;
     tree_ref_to_iter(data->tree, &data_iter,  data->rowref);
@@ -297,8 +303,9 @@ element_attr_changed (Inkscape::XML::Node * repr, const gchar * key, const gchar
 	}
 
 	GtkTreeIter iter;
-	tree_ref_to_iter(data->tree, &iter,  data->rowref);
-	gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, label, -1);
+	if (tree_ref_to_iter(data->tree, &iter,  data->rowref)) {
+	    gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, label, -1);
+	}
 	g_free (label);
 }
 
@@ -311,8 +318,9 @@ element_child_removed (Inkscape::XML::Node * /*repr*/, Inkscape::XML::Node * chi
 	if (data->tree->blocked) return;
 
 	GtkTreeIter iter;
-	repr_to_child (data, child, &iter);
-	gtk_tree_store_remove (GTK_TREE_STORE(data->tree->store), &iter);
+	if (repr_to_child (data, child, &iter)) {
+        gtk_tree_store_remove (GTK_TREE_STORE(data->tree->store), &iter);
+    }
 
 }
 
@@ -348,8 +356,9 @@ text_content_changed (Inkscape::XML::Node * /*repr*/, const gchar * /*old_conten
 
 	label = g_strdup_printf ("\"%s\"", new_content);
     GtkTreeIter iter;
-    tree_ref_to_iter(data->tree, &iter,  data->rowref);
-    gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, label, -1);
+    if (tree_ref_to_iter(data->tree, &iter,  data->rowref)) {
+        gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, label, -1);
+    }
 
 	g_free (label);
 }
@@ -366,9 +375,9 @@ comment_content_changed (Inkscape::XML::Node */*repr*/, const gchar * /*old_cont
 
 	label = g_strdup_printf ("<!--%s-->", new_content);
     GtkTreeIter iter;
-    tree_ref_to_iter(data->tree, &iter,  data->rowref);
-    gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, label, -1);
-
+    if (tree_ref_to_iter(data->tree, &iter,  data->rowref)) {
+        gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, label, -1);
+    }
 	g_free (label);
 }
 
@@ -384,9 +393,9 @@ pi_content_changed(Inkscape::XML::Node *repr, const gchar * /*old_content*/, con
 
 	label = g_strdup_printf ("<?%s %s?>", repr->name(), new_content);
     GtkTreeIter iter;
-    tree_ref_to_iter(data->tree, &iter,  data->rowref);
-    gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, label, -1);
-
+    if (tree_ref_to_iter(data->tree, &iter,  data->rowref)) {
+        gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, label, -1);
+    }
 	g_free (label);
 }
 
@@ -452,8 +461,7 @@ void on_row_changed(GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *it
     }
 
     GtkTreeIter old_parent;
-    tree_ref_to_iter(tree, &old_parent,  old_parent_ref);
-    if (!gtk_tree_store_iter_is_valid(GTK_TREE_STORE(tree_model), &old_parent)){
+    if (!tree_ref_to_iter(tree, &old_parent,  old_parent_ref)) {
         //Drag source parent is not valid
         g_signal_emit_by_name(G_OBJECT (tree), "tree_move", GUINT_TO_POINTER(0) );
         return;
@@ -501,30 +509,41 @@ void on_row_changed(GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *it
 /*
  * Set iter to ref or node data's child with the same repr or first child
  */
-void ref_to_sibling (NodeData *data, Inkscape::XML::Node *repr, GtkTreeIter *iter)
+gboolean ref_to_sibling (NodeData *data, Inkscape::XML::Node *repr, GtkTreeIter *iter)
 {
 	if (repr) {
-		repr_to_child (data, repr, iter);
+		if (!repr_to_child (data, repr, iter)) {
+            return false;
+        }
         gtk_tree_model_iter_next (GTK_TREE_MODEL(data->tree->store), iter);
 	} else {
 	    GtkTreeIter data_iter;
-	    tree_ref_to_iter(data->tree, &data_iter,  data->rowref);
+	    if (!tree_ref_to_iter(data->tree, &data_iter,  data->rowref)) {
+	        return false;
+	    }
 	    gtk_tree_model_iter_children(GTK_TREE_MODEL(data->tree->store), iter, &data_iter);
 	}
+	return true;
 }
 
 /*
  * Set iter to the node data's child with the same repr
  */
-void repr_to_child (NodeData *data, Inkscape::XML::Node * repr, GtkTreeIter *iter)
+gboolean repr_to_child (NodeData *data, Inkscape::XML::Node * repr, GtkTreeIter *iter)
 {
     GtkTreeIter data_iter;
     tree_ref_to_iter(data->tree, &data_iter,  data->rowref);
 
+    if (!gtk_tree_store_iter_is_valid(GTK_TREE_STORE(data->tree->store), &data_iter)) {
+        return false;
+    }
+
     gboolean valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(data->tree->store), iter, &data_iter);
     while (valid && sp_xmlview_tree_node_get_repr (GTK_TREE_VIEW(data->tree), iter) != repr) {
         valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(data->tree->store), iter);
 	}
+
+    return valid;
 }
 
 /*
@@ -542,10 +561,15 @@ GtkTreeRowReference  *tree_iter_to_ref (SPXMLViewTree * tree, GtkTreeIter* iter)
 /*
  * Get a matching GtkTreeIter for a GtkTreeRowReference
  */
-void tree_ref_to_iter (SPXMLViewTree * tree, GtkTreeIter* iter, GtkTreeRowReference  *ref)
+gboolean tree_ref_to_iter (SPXMLViewTree * tree, GtkTreeIter* iter, GtkTreeRowReference  *ref)
 {
     GtkTreePath* path = gtk_tree_row_reference_get_path(ref);
+    if (!path) {
+        return false;
+    }
     gtk_tree_model_get_iter(GTK_TREE_MODEL(tree->store), iter, path);
+
+    return gtk_tree_store_iter_is_valid(GTK_TREE_STORE(tree->store), iter);
 }
 
 /*
diff --git a/src/widgets/spinbutton-events.cpp b/src/widgets/spinbutton-events.cpp
index 994d954cc..565c89ece 100644
--- a/src/widgets/spinbutton-events.cpp
+++ b/src/widgets/spinbutton-events.cpp
@@ -48,7 +48,7 @@ spinbutton_undo (GtkWidget *w)
 }
 
 void
-spinbutton_defocus (GtkObject *container)
+spinbutton_defocus (GtkWidget *container)
 {
 	// defocus spinbuttons by moving focus to the canvas, unless "stay" is on
 	gboolean stay = GPOINTER_TO_INT(g_object_get_data(G_OBJECT (container), "stay"));
@@ -71,12 +71,12 @@ spinbutton_keypress (GtkWidget *w, GdkEventKey *event, gpointer data)
 	switch (get_group0_keyval (event)) {
 	case GDK_Escape: // defocus
 		spinbutton_undo (w);
-		spinbutton_defocus (GTK_OBJECT (spw));
+		spinbutton_defocus(GTK_WIDGET(spw));
 		return TRUE; // I consumed the event
 		break;
 	case GDK_Return: // defocus
 	case GDK_KP_Enter:
-		spinbutton_defocus (GTK_OBJECT (spw));
+		spinbutton_defocus (GTK_WIDGET(spw));
 		return TRUE; // I consumed the event
 		break;
 	case GDK_Tab:
diff --git a/src/widgets/spinbutton-events.h b/src/widgets/spinbutton-events.h
index cf8c7b44b..c1df88c8a 100644
--- a/src/widgets/spinbutton-events.h
+++ b/src/widgets/spinbutton-events.h
@@ -15,7 +15,7 @@
 gboolean spinbutton_focus_in (GtkWidget *w, GdkEventKey *event, gpointer data);
 void spinbutton_undo (GtkWidget *w);
 gboolean spinbutton_keypress (GtkWidget *w, GdkEventKey *event, gpointer data);
-void spinbutton_defocus (GtkObject *container);
+void spinbutton_defocus (GtkWidget *container);
 
 /*
   Local Variables:
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index 58c7958ba..7d73c042b 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -538,6 +538,7 @@ static gchar const * ui_descr =
         "    <toolitem action='GradientNewFillStrokeAction' />"
         "    <separator />"
         "    <toolitem action='GradientSelectGradientAction' />"
+        "    <toolitem action='GradientEditLinkAction' />"
         "    <toolitem action='GradientEditReverseAction' />"
         "    <toolitem action='GradientSelectRepeatAction' />"
         "    <separator />"
@@ -584,7 +585,7 @@ static void update_aux_toolbox(SPDesktop *desktop, SPEventContext *eventcontext,
 static void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
 static void update_commands_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 
-static GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick( GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
+static GtkToolItem * sp_toolbox_button_item_new_from_verb_with_doubleclick( GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
                                                                      Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb,
                                                                      Inkscape::UI::View::View *view);
 
@@ -656,18 +657,19 @@ Gtk::Widget* VerbAction::create_tool_item_vfunc()
 //     Gtk::Widget* widg = Gtk::Action::create_tool_item_vfunc();
     Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/tools/small");
     GtkWidget* toolbox = 0;
-    GtkWidget *button = sp_toolbox_button_new_from_verb_with_doubleclick( toolbox, toolboxSize,
-                                                                          SP_BUTTON_TYPE_TOGGLE,
-                                                                          verb,
-                                                                          verb2,
-                                                                          view );
+    GtkToolItem *button_toolitem = sp_toolbox_button_item_new_from_verb_with_doubleclick( toolbox, toolboxSize,
+                                                                                      SP_BUTTON_TYPE_TOGGLE,
+                                                                                      verb,
+                                                                                      verb2,
+                                                                                      view );
+
+    GtkWidget* button_widget = gtk_bin_get_child(GTK_BIN(button_toolitem));
+
     if ( active ) {
-        sp_button_toggle_set_down( SP_BUTTON(button), active);
+        sp_button_toggle_set_down( SP_BUTTON(button_widget), active);
     }
-    gtk_widget_show_all( button );
-    Gtk::Widget* wrapped = Glib::wrap(button);
-    Gtk::ToolItem* holder = Gtk::manage(new Gtk::ToolItem());
-    holder->add(*wrapped);
+    gtk_widget_show_all( button_widget );
+    Gtk::ToolItem* holder = Glib::wrap(button_toolitem);
 
 //     g_message("create_tool_item_vfunc() = %p  for '%s'", holder, verb->get_id());
     return holder;
@@ -833,7 +835,7 @@ void PrefPusher::notify(Inkscape::Preferences::Entry const &newVal)
     }
 }
 
-static void delete_prefspusher(GtkObject * /*obj*/, PrefPusher *watcher )
+static void delete_prefspusher(GObject * /*obj*/, PrefPusher *watcher )
 {
     delete watcher;
 }
@@ -841,7 +843,7 @@ static void delete_prefspusher(GtkObject * /*obj*/, PrefPusher *watcher )
 // ------------------------------------------------------
 
 
-GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick(GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
+GtkToolItem * sp_toolbox_button_item_new_from_verb_with_doubleclick(GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
                                                              Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb,
                                                              Inkscape::UI::View::View *view)
 {
@@ -861,24 +863,27 @@ GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick(GtkWidget *t, Inksc
     /* fixme: Implement sp_button_new_from_action */
     GtkWidget *b = sp_button_new(size, type, action, doubleclick_action);
     gtk_widget_show(b);
-
+    GtkToolItem *b_toolitem = gtk_tool_item_new();
+    gtk_container_add(GTK_CONTAINER(b_toolitem), b);
 
     unsigned int shortcut = sp_shortcut_get_primary(verb);
     if (shortcut != GDK_KEY_VoidSymbol) {
         gchar *key = sp_shortcut_get_label(shortcut);
         gchar *tip = g_strdup_printf ("%s (%s)", action->tip, key);
         if ( t ) {
-            gtk_toolbar_append_widget( GTK_TOOLBAR(t), b, tip, 0 );
+           gtk_toolbar_insert(GTK_TOOLBAR(t), b_toolitem, -1);
+           gtk_widget_set_tooltip_text(b, tip);
         }
         g_free(tip);
         g_free(key);
     } else {
         if ( t ) {
-            gtk_toolbar_append_widget( GTK_TOOLBAR(t), b, action->tip, 0 );
+            gtk_toolbar_insert(GTK_TOOLBAR(t), b_toolitem, -1);
+            gtk_widget_set_tooltip_text(b, action->tip);
         }
     }
 
-    return b;
+    return b_toolitem;
 }
 
 
@@ -1063,8 +1068,8 @@ static GtkWidget* toolboxNewCommon( GtkWidget* tb, BarId id, GtkPositionType han
 GtkWidget *ToolboxFactory::createToolToolbox()
 {
 #if GTK_CHECK_VERSION(3,0,0)
-    GtkWidget *tb = gtk_box_new(GTK_ORIENTATION, 0);
-    gtk_box_new(GTK_BOX(tb), FALSE);
+    GtkWidget *tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+    gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
 #else
     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 #endif
@@ -1076,7 +1081,7 @@ GtkWidget *ToolboxFactory::createAuxToolbox()
 {
 #if GTK_CHECK_VERSION(3,0,0)
     GtkWidget *tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
-    gtk_box_new(GTK_BOX(tb), FALSE);
+    gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
 #else
     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 #endif
@@ -1092,7 +1097,7 @@ GtkWidget *ToolboxFactory::createCommandsToolbox()
 {
 #if GTK_CHECK_VERSION(3,0,0)
     GtkWidget *tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
-    gtk_box_new(GTK_BOX(tb), FALSE);
+    gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
 #else
     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 #endif
@@ -1104,7 +1109,7 @@ GtkWidget *ToolboxFactory::createSnapToolbox()
 {
 #if GTK_CHECK_VERSION(3,0,0)
     GtkWidget *tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
-    gtk_box_new(GTK_BOX(tb), FALSE);
+    gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
 #else
     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 #endif
@@ -2075,7 +2080,7 @@ void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 void update_tool_toolbox( SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget * /*toolbox*/ )
 {
     gchar const *const tname = ( eventcontext
-                                 ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext))
+                                 ? g_type_name(G_OBJECT_TYPE(eventcontext))
                                  : NULL );
     Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
 
@@ -2178,7 +2183,7 @@ void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 void update_aux_toolbox(SPDesktop * /*desktop*/, SPEventContext *eventcontext, GtkWidget *toolbox)
 {
     gchar const *tname = ( eventcontext
-                           ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext))
+                           ? g_type_name(G_OBJECT_TYPE(eventcontext))
                            : NULL );
     for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
         GtkWidget *sub_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name));
@@ -4041,7 +4046,7 @@ static void sp_spl_tb_t0_value_changed(GtkAdjustment *adj, GObject *tbl)
     sp_spl_tb_value_changed(adj, tbl, "t0");
 }
 
-static void sp_spl_tb_defaults(GtkWidget * /*widget*/, GtkObject *obj)
+static void sp_spl_tb_defaults(GtkWidget * /*widget*/, GObject *obj)
 {
     GtkWidget *tbl = GTK_WIDGET(obj);
 
@@ -4052,19 +4057,19 @@ static void sp_spl_tb_defaults(GtkWidget * /*widget*/, GtkObject *obj)
     gdouble exp = 1.0;
     gdouble t0 = 0.0;
 
-    adj = (GtkAdjustment*)g_object_get_data(G_OBJECT(obj), "revolution");
+    adj = (GtkAdjustment*)g_object_get_data(obj, "revolution");
     gtk_adjustment_set_value(adj, rev);
     gtk_adjustment_value_changed(adj);
 
-    adj = (GtkAdjustment*)g_object_get_data(G_OBJECT(obj), "expansion");
+    adj = (GtkAdjustment*)g_object_get_data(obj, "expansion");
     gtk_adjustment_set_value(adj, exp);
     gtk_adjustment_value_changed(adj);
 
-    adj = (GtkAdjustment*)g_object_get_data(G_OBJECT(obj), "t0");
+    adj = (GtkAdjustment*)g_object_get_data(obj, "t0");
     gtk_adjustment_set_value(adj, t0);
     gtk_adjustment_value_changed(adj);
 
-    spinbutton_defocus(GTK_OBJECT(tbl));
+    spinbutton_defocus(tbl);
 }
 
 
@@ -4374,7 +4379,7 @@ static void sp_pen_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainAct
 }
 
 
-static void sp_pencil_tb_defaults(GtkWidget * /*widget*/, GtkObject *obj)
+static void sp_pencil_tb_defaults(GtkWidget * /*widget*/, GObject *obj)
 {
     GtkWidget *tbl = GTK_WIDGET(obj);
 
@@ -4383,11 +4388,11 @@ static void sp_pencil_tb_defaults(GtkWidget * /*widget*/, GtkObject *obj)
     // fixme: make settable
     gdouble tolerance = 4;
 
-    adj = (GtkAdjustment*)g_object_get_data(G_OBJECT(obj), "tolerance");
+    adj = (GtkAdjustment*)g_object_get_data(obj, "tolerance");
     gtk_adjustment_set_value(adj, tolerance);
     gtk_adjustment_value_changed(adj);
 
-    spinbutton_defocus(GTK_OBJECT(tbl));
+    spinbutton_defocus(tbl);
 }
 
 static void sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl)
@@ -5720,7 +5725,7 @@ static void sp_arctb_defaults(GtkWidget *, GObject *obj)
     gtk_adjustment_set_value(adj, 0.0);
     gtk_adjustment_value_changed(adj);
 
-    spinbutton_defocus( GTK_OBJECT(obj) );
+    spinbutton_defocus(GTK_WIDGET(obj));
 }
 
 static void arc_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const * /*name*/,
@@ -5941,14 +5946,14 @@ static void toggle_dropper_pick_alpha( GtkToggleAction* act, gpointer tbl )
         }
     }
 
-    spinbutton_defocus(GTK_OBJECT(tbl));
+    spinbutton_defocus(GTK_WIDGET(tbl));
 }
 
 static void toggle_dropper_set_alpha( GtkToggleAction* act, gpointer tbl )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setBool( "/tools/dropper/setalpha", gtk_toggle_action_get_active( act ) );
-    spinbutton_defocus(GTK_OBJECT(tbl));
+    spinbutton_defocus(GTK_WIDGET(tbl));
 }
 
 
@@ -8172,7 +8177,7 @@ static void sp_text_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions
 //##      Connector      ##
 //#########################
 
-static void sp_connector_mode_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
+static void sp_connector_mode_toggled( GtkToggleAction* act, GObject * /*tbl*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setBool("/tools/connector/mode",
@@ -8357,14 +8362,14 @@ static void sp_connector_graph_layout(void)
     DocumentUndo::done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network"));
 }
 
-static void sp_directed_graph_layout_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
+static void sp_directed_graph_layout_toggled( GtkToggleAction* act, GObject * /*tbl*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setBool("/tools/connector/directedlayout",
                 gtk_toggle_action_get_active( act ));
 }
 
-static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
+static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GObject * /*tbl*/ )
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setBool("/tools/connector/avoidoverlaplayout",
@@ -8393,7 +8398,7 @@ static void connector_tb_event_attr_changed(Inkscape::XML::Node *repr,
         gtk_adjustment_set_value(adj, spacing);
         gtk_adjustment_value_changed(adj);
 
-        spinbutton_defocus(GTK_OBJECT(tbl));
+        spinbutton_defocus(tbl);
     }
 }