Replace deprecated GtkSignal

(bzr r10282.1.1)

15 files changed, 249 insertions, 225 deletions

diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
index d5ec5deff..69b27d6e4 100644
--- a/src/widgets/desktop-widget.cpp
+++ b/src/widgets/desktop-widget.cpp
@@ -498,8 +498,8 @@ void SPDesktopWidget::init( SPDesktopWidget *dtw )
     g_signal_connect (G_OBJECT (dtw->zoom_status), "input", G_CALLBACK (sp_dtw_zoom_input), dtw);
     g_signal_connect (G_OBJECT (dtw->zoom_status), "output", G_CALLBACK (sp_dtw_zoom_output), dtw);
     gtk_object_set_data (GTK_OBJECT (dtw->zoom_status), "dtw", dtw->canvas);
-    gtk_signal_connect (GTK_OBJECT (dtw->zoom_status), "focus-in-event", GTK_SIGNAL_FUNC (spinbutton_focus_in), dtw->zoom_status);
-    gtk_signal_connect (GTK_OBJECT (dtw->zoom_status), "key-press-event", GTK_SIGNAL_FUNC (spinbutton_keypress), dtw->zoom_status);
+    g_signal_connect (G_OBJECT (dtw->zoom_status), "focus-in-event", G_CALLBACK (spinbutton_focus_in), dtw->zoom_status);
+    g_signal_connect (G_OBJECT (dtw->zoom_status), "key-press-event", G_CALLBACK (spinbutton_keypress), dtw->zoom_status);
     dtw->zoom_update = g_signal_connect (G_OBJECT (dtw->zoom_status), "value_changed", G_CALLBACK (sp_dtw_zoom_value_changed), dtw);
     dtw->zoom_update = g_signal_connect (G_OBJECT (dtw->zoom_status), "populate_popup", G_CALLBACK (sp_dtw_zoom_populate_popup), dtw);
 
@@ -599,7 +599,7 @@ sp_desktop_widget_destroy (GtkObject *object)
         }
         g_signal_handlers_disconnect_by_func(G_OBJECT (dtw->zoom_status), (gpointer) G_CALLBACK(sp_dtw_zoom_input), dtw);
         g_signal_handlers_disconnect_by_func(G_OBJECT (dtw->zoom_status), (gpointer) G_CALLBACK(sp_dtw_zoom_output), dtw);
-        gtk_signal_disconnect_by_data (GTK_OBJECT (dtw->zoom_status), dtw->zoom_status);
+        g_signal_handlers_disconnect_matched (G_OBJECT (dtw->zoom_status), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, dtw->zoom_status);
         g_signal_handlers_disconnect_by_func (G_OBJECT (dtw->zoom_status), (gpointer) G_CALLBACK (sp_dtw_zoom_value_changed), dtw);
         g_signal_handlers_disconnect_by_func (G_OBJECT (dtw->zoom_status), (gpointer) G_CALLBACK (sp_dtw_zoom_populate_popup), dtw);
         g_signal_handlers_disconnect_by_func (G_OBJECT (dtw->canvas), (gpointer) G_CALLBACK (sp_desktop_widget_event), dtw);
diff --git a/src/widgets/font-selector.cpp b/src/widgets/font-selector.cpp
index efeaa980c..f493c393a 100644
--- a/src/widgets/font-selector.cpp
+++ b/src/widgets/font-selector.cpp
@@ -130,12 +130,13 @@ static void sp_font_selector_class_init(SPFontSelectorClass *c)
 
     fs_parent_class = (GtkHBoxClass* )gtk_type_class(GTK_TYPE_HBOX);
 
-    fs_signals[FONT_SET] = gtk_signal_new ("font_set",
-                                           GTK_RUN_FIRST,
-                                           GTK_CLASS_TYPE(object_class),
-                                           GTK_SIGNAL_OFFSET(SPFontSelectorClass, font_set),
+    fs_signals[FONT_SET] = g_signal_new ("font_set",
+                                           G_TYPE_FROM_CLASS(object_class),
+                                           G_SIGNAL_RUN_FIRST,
+                                           G_STRUCT_OFFSET(SPFontSelectorClass, font_set),
+					   NULL, NULL,
                                            gtk_marshal_NONE__POINTER,
-                                           GTK_TYPE_NONE,
+                                           G_TYPE_NONE,
                                            1, GTK_TYPE_POINTER);
 
     object_class->destroy = sp_font_selector_destroy;
@@ -388,7 +389,7 @@ static void sp_font_selector_emit_set (SPFontSelector *fsel)
             fsel->font->Unref();
         }
         fsel->font = font;
-        gtk_signal_emit(GTK_OBJECT(fsel), fs_signals[FONT_SET], fsel->font);
+        g_signal_emit(G_OBJECT(fsel), fs_signals[FONT_SET], 0, fsel->font);
     }
     fsel->fontsize_dirty = false;
     if (font) {
diff --git a/src/widgets/gradient-selector.cpp b/src/widgets/gradient-selector.cpp
index 3f07e09c8..a3110ed5b 100644
--- a/src/widgets/gradient-selector.cpp
+++ b/src/widgets/gradient-selector.cpp
@@ -85,30 +85,34 @@ sp_gradient_selector_class_init (SPGradientSelectorClass *klass)
 
     parent_class = (GtkVBoxClass*)gtk_type_class (GTK_TYPE_VBOX);
 
-    signals[GRABBED] =  gtk_signal_new ("grabbed",
-                                        (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                        GTK_CLASS_TYPE(object_class),
-                                        GTK_SIGNAL_OFFSET (SPGradientSelectorClass, grabbed),
+    signals[GRABBED] =  g_signal_new ("grabbed",
+                                        G_TYPE_FROM_CLASS(object_class),
+                                        (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                        G_STRUCT_OFFSET (SPGradientSelectorClass, grabbed),
+					NULL, NULL,
                                         gtk_marshal_NONE__NONE,
-                                        GTK_TYPE_NONE, 0);
-    signals[DRAGGED] =  gtk_signal_new ("dragged",
-                                        (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                        GTK_CLASS_TYPE(object_class),
-                                        GTK_SIGNAL_OFFSET (SPGradientSelectorClass, dragged),
+                                        G_TYPE_NONE, 0);
+    signals[DRAGGED] =  g_signal_new ("dragged",
+                                        G_TYPE_FROM_CLASS(object_class),
+                                        (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                        G_STRUCT_OFFSET (SPGradientSelectorClass, dragged),
+					NULL, NULL,
                                         gtk_marshal_NONE__NONE,
-                                        GTK_TYPE_NONE, 0);
-    signals[RELEASED] = gtk_signal_new ("released",
-                                        (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                        GTK_CLASS_TYPE(object_class),
-                                        GTK_SIGNAL_OFFSET (SPGradientSelectorClass, released),
+                                        G_TYPE_NONE, 0);
+    signals[RELEASED] = g_signal_new ("released",
+                                        G_TYPE_FROM_CLASS(object_class),
+                                        (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                        G_STRUCT_OFFSET (SPGradientSelectorClass, released),
+					NULL, NULL,
                                         gtk_marshal_NONE__NONE,
-                                        GTK_TYPE_NONE, 0);
-    signals[CHANGED] =  gtk_signal_new ("changed",
-                                        (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                        GTK_CLASS_TYPE(object_class),
-                                        GTK_SIGNAL_OFFSET (SPGradientSelectorClass, changed),
+                                        G_TYPE_NONE, 0);
+    signals[CHANGED] =  g_signal_new ("changed",
+                                        G_TYPE_FROM_CLASS(object_class),
+                                        (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                        G_STRUCT_OFFSET (SPGradientSelectorClass, changed),
+					NULL, NULL,
                                         gtk_marshal_NONE__NONE,
-                                        GTK_TYPE_NONE, 0);
+                                        G_TYPE_NONE, 0);
 
     object_class->destroy = sp_gradient_selector_destroy;
 }
diff --git a/src/widgets/gradient-toolbar.cpp b/src/widgets/gradient-toolbar.cpp
index 10e1fb95a..9186044de 100644
--- a/src/widgets/gradient-toolbar.cpp
+++ b/src/widgets/gradient-toolbar.cpp
@@ -485,7 +485,7 @@ GtkWidget * gr_change_widget(SPDesktop *desktop)
         gtk_widget_set_tooltip_text(b, _("Edit the stops of the gradient"));
         gtk_widget_show(b);
         gtk_container_add(GTK_CONTAINER(hb), b);
-        gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(gr_edit), widget);
+        g_signal_connect(G_OBJECT(b), "clicked", G_CALLBACK(gr_edit), widget);
         gtk_box_pack_start (GTK_BOX(buttons), hb, FALSE, FALSE, 0);
     }
 
diff --git a/src/widgets/gradient-vector.cpp b/src/widgets/gradient-vector.cpp
index 9aa414ab6..bc29bc974 100644
--- a/src/widgets/gradient-vector.cpp
+++ b/src/widgets/gradient-vector.cpp
@@ -104,13 +104,14 @@ static void sp_gradient_vector_selector_class_init(SPGradientVectorSelectorClass
 
     parent_class = static_cast<GtkVBoxClass*>(gtk_type_class(GTK_TYPE_VBOX));
 
-    signals[VECTOR_SET] = gtk_signal_new( "vector_set",
-                                          GTK_RUN_LAST,
-                                          GTK_CLASS_TYPE(object_class),
-                                          GTK_SIGNAL_OFFSET(SPGradientVectorSelectorClass, vector_set),
-                                          gtk_marshal_NONE__POINTER,
-                                          GTK_TYPE_NONE, 1,
-                                          GTK_TYPE_POINTER);
+    signals[VECTOR_SET] = g_signal_new( "vector_set",
+		                        G_TYPE_FROM_CLASS(object_class),
+					G_SIGNAL_RUN_LAST,
+                                        G_STRUCT_OFFSET(SPGradientVectorSelectorClass, vector_set),
+					NULL, NULL,
+					gtk_marshal_NONE__POINTER,
+					G_TYPE_NONE, 1,
+					GTK_TYPE_POINTER);
 
     object_class->destroy = sp_gradient_vector_selector_destroy;
 }
@@ -793,7 +794,7 @@ static GtkWidget * sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *s
     GtkWidget *mnu = gtk_option_menu_new();
     /* Create new menu widget */
     update_stop_list(GTK_WIDGET(mnu), gradient, NULL);
-    gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_grad_edit_select), vb);
+    g_signal_connect(G_OBJECT(mnu), "changed", G_CALLBACK(sp_grad_edit_select), vb);
     gtk_widget_show(mnu);
     gtk_object_set_data(GTK_OBJECT(vb), "stopmenu", mnu);
     gtk_box_pack_start(GTK_BOX(vb), mnu, FALSE, FALSE, 0);
@@ -805,12 +806,12 @@ static GtkWidget * sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *s
     gtk_widget_show(b);
     gtk_container_add(GTK_CONTAINER(hb), b);
     gtk_widget_set_tooltip_text(b, _("Add another control stop to gradient"));
-    gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_grd_ed_add_stop), vb);
+    g_signal_connect(G_OBJECT(b), "clicked", G_CALLBACK(sp_grd_ed_add_stop), vb);
     b = gtk_button_new_with_label(_("Delete stop"));
     gtk_widget_show(b);
     gtk_container_add(GTK_CONTAINER(hb), b);
     gtk_widget_set_tooltip_text(b, _("Delete current control stop from gradient"));
-    gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_grd_ed_del_stop), vb);
+    g_signal_connect(G_OBJECT(b), "clicked", G_CALLBACK(sp_grd_ed_del_stop), vb);
 
     gtk_widget_show(hb);
     gtk_box_pack_start(GTK_BOX(vb),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
@@ -857,10 +858,10 @@ static GtkWidget * sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *s
 
 
     /* Signals */
-    gtk_signal_connect(GTK_OBJECT(Offset_adj), "value_changed",
-                        GTK_SIGNAL_FUNC(offadjustmentChanged), vb);
+    g_signal_connect(G_OBJECT(Offset_adj), "value_changed",
+                        G_CALLBACK(offadjustmentChanged), vb);
 
-    // gtk_signal_connect(GTK_OBJECT(slider), "changed",  GTK_SIGNAL_FUNC(offsliderChanged), vb);
+    // g_signal_connect(G_OBJECT(slider), "changed",  G_CALLBACK(offsliderChanged), vb);
     gtk_widget_show(hb);
     gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, PAD);
 
@@ -924,9 +925,9 @@ GtkWidget * sp_gradient_vector_editor_new(SPGradient *gradient, SPStop *stop)
         wd.win = dlg;
         wd.stop = 0;
         g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK(sp_transientize_callback), &wd);
-        gtk_signal_connect(GTK_OBJECT(dlg), "event", GTK_SIGNAL_FUNC(sp_dialog_event_handler), dlg);
-        gtk_signal_connect(GTK_OBJECT(dlg), "destroy", G_CALLBACK(sp_gradient_vector_dialog_destroy), dlg);
-        gtk_signal_connect(GTK_OBJECT(dlg), "delete_event", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
+        g_signal_connect(G_OBJECT(dlg), "event", G_CALLBACK(sp_dialog_event_handler), dlg);
+        g_signal_connect(G_OBJECT(dlg), "destroy", G_CALLBACK(sp_gradient_vector_dialog_destroy), dlg);
+        g_signal_connect(G_OBJECT(dlg), "delete_event", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
         g_signal_connect(G_OBJECT(INKSCAPE), "shut_down", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
         g_signal_connect( G_OBJECT(INKSCAPE), "dialogs_hide", G_CALLBACK(sp_dialog_hide), dlg );
         g_signal_connect( G_OBJECT(INKSCAPE), "dialogs_unhide", G_CALLBACK(sp_dialog_unhide), dlg );
diff --git a/src/widgets/paint-selector.cpp b/src/widgets/paint-selector.cpp
index 631675ede..642837e61 100644
--- a/src/widgets/paint-selector.cpp
+++ b/src/widgets/paint-selector.cpp
@@ -164,42 +164,48 @@ sp_paint_selector_class_init(SPPaintSelectorClass *klass)
 
     parent_class = (GtkVBoxClass*)gtk_type_class(GTK_TYPE_VBOX);
 
-    psel_signals[MODE_CHANGED] = gtk_signal_new("mode_changed",
-                                                (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                                GTK_CLASS_TYPE(object_class),
-                                                GTK_SIGNAL_OFFSET(SPPaintSelectorClass, mode_changed),
+    psel_signals[MODE_CHANGED] = g_signal_new("mode_changed",
+                                                G_TYPE_FROM_CLASS(object_class),
+                                                (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                                G_STRUCT_OFFSET(SPPaintSelectorClass, mode_changed),
+						NULL, NULL,
                                                 gtk_marshal_NONE__UINT,
-                                                GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
-    psel_signals[GRABBED] =  gtk_signal_new("grabbed",
-                                            (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                            GTK_CLASS_TYPE(object_class),
-                                            GTK_SIGNAL_OFFSET(SPPaintSelectorClass, grabbed),
+                                                G_TYPE_NONE, 1, GTK_TYPE_UINT);
+    psel_signals[GRABBED] =  g_signal_new("grabbed",
+                                            G_TYPE_FROM_CLASS(object_class),
+                                            (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                            G_STRUCT_OFFSET(SPPaintSelectorClass, grabbed),
+					    NULL, NULL,
                                             gtk_marshal_NONE__NONE,
-                                            GTK_TYPE_NONE, 0);
-    psel_signals[DRAGGED] =  gtk_signal_new("dragged",
-                                            (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                            GTK_CLASS_TYPE(object_class),
-                                            GTK_SIGNAL_OFFSET(SPPaintSelectorClass, dragged),
+                                            G_TYPE_NONE, 0);
+    psel_signals[DRAGGED] =  g_signal_new("dragged",
+                                            G_TYPE_FROM_CLASS(object_class),
+                                            (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                            G_STRUCT_OFFSET(SPPaintSelectorClass, dragged),
+					    NULL, NULL,
                                             gtk_marshal_NONE__NONE,
-                                            GTK_TYPE_NONE, 0);
-    psel_signals[RELEASED] = gtk_signal_new("released",
-                                            (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                            GTK_CLASS_TYPE(object_class),
-                                            GTK_SIGNAL_OFFSET(SPPaintSelectorClass, released),
+                                            G_TYPE_NONE, 0);
+    psel_signals[RELEASED] = g_signal_new("released",
+                                            G_TYPE_FROM_CLASS(object_class),
+                                            (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                            G_STRUCT_OFFSET(SPPaintSelectorClass, released),
+					    NULL, NULL,
                                             gtk_marshal_NONE__NONE,
-                                            GTK_TYPE_NONE, 0);
-    psel_signals[CHANGED] =  gtk_signal_new("changed",
-                                            (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                            GTK_CLASS_TYPE(object_class),
-                                            GTK_SIGNAL_OFFSET(SPPaintSelectorClass, changed),
+                                            G_TYPE_NONE, 0);
+    psel_signals[CHANGED] =  g_signal_new("changed",
+                                            G_TYPE_FROM_CLASS(object_class),
+                                            (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                            G_STRUCT_OFFSET(SPPaintSelectorClass, changed),
+					    NULL, NULL,
                                             gtk_marshal_NONE__NONE,
-                                            GTK_TYPE_NONE, 0);
-    psel_signals[FILLRULE_CHANGED] = gtk_signal_new("fillrule_changed",
-                                                    (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                                    GTK_CLASS_TYPE(object_class),
-                                                    GTK_SIGNAL_OFFSET(SPPaintSelectorClass, fillrule_changed),
+                                            G_TYPE_NONE, 0);
+    psel_signals[FILLRULE_CHANGED] = g_signal_new("fillrule_changed",
+                                                    G_TYPE_FROM_CLASS(object_class),
+                                                    (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                                    G_STRUCT_OFFSET(SPPaintSelectorClass, fillrule_changed),
+						    NULL, NULL,
                                                     gtk_marshal_NONE__UINT,
-                                                    GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
+                                                    G_TYPE_NONE, 1, GTK_TYPE_UINT);
 
     object_class->destroy = sp_paint_selector_destroy;
 }
@@ -249,7 +255,7 @@ sp_paint_selector_init(SPPaintSelector *psel)
         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_EVEN_ODD);
         gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(psel->evenodd), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
+        g_signal_connect(G_OBJECT(psel->evenodd), "toggled", G_CALLBACK(sp_paint_selector_fillrule_toggled), psel);
 
         psel->nonzero = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(psel->evenodd)));
         gtk_button_set_relief(GTK_BUTTON(psel->nonzero), GTK_RELIEF_NONE);
@@ -260,7 +266,7 @@ sp_paint_selector_init(SPPaintSelector *psel)
         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_NONZERO);
         gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
-        gtk_signal_connect(GTK_OBJECT(psel->nonzero), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
+        g_signal_connect(G_OBJECT(psel->nonzero), "toggled", G_CALLBACK(sp_paint_selector_fillrule_toggled), psel);
     }
 
     /* Frame */
@@ -308,7 +314,7 @@ static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel,
     gtk_container_add(GTK_CONTAINER(b), w);
 
     gtk_box_pack_start(GTK_BOX(psel->style), b, FALSE, FALSE, 0);
-    gtk_signal_connect(GTK_OBJECT(b), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_style_button_toggled), psel);
+    g_signal_connect(G_OBJECT(b), "toggled", G_CALLBACK(sp_paint_selector_style_button_toggled), psel);
 
     return b;
 }
@@ -326,7 +332,7 @@ sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 {
     if (!psel->update && gtk_toggle_button_get_active(tb)) {
         SPPaintSelector::FillRule fr = static_cast<SPPaintSelector::FillRule>(GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(tb), "mode")));
-        gtk_signal_emit(GTK_OBJECT(psel), psel_signals[FILLRULE_CHANGED], fr);
+        g_signal_emit(G_OBJECT(psel), psel_signals[FILLRULE_CHANGED], 0, fr);
     }
 }
 
@@ -397,7 +403,7 @@ void SPPaintSelector::setMode(Mode mode)
                 break;
         }
         this->mode = mode;
-        gtk_signal_emit(GTK_OBJECT(this), psel_signals[MODE_CHANGED], this->mode);
+        g_signal_emit(G_OBJECT(this), psel_signals[MODE_CHANGED], 0, this->mode);
         update = FALSE;
     }
 }
@@ -610,17 +616,17 @@ sp_paint_selector_set_mode_none(SPPaintSelector *psel)
 
 static void sp_paint_selector_color_grabbed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[GRABBED], 0);
 }
 
 static void sp_paint_selector_color_dragged(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[DRAGGED], 0);
 }
 
 static void sp_paint_selector_color_released(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[RELEASED], 0);
 }
 
 static void
@@ -628,7 +634,7 @@ sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
 {
     csel->base->getColorAlpha( psel->color, psel->alpha );
 
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[CHANGED], 0);
 }
 
 static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelector::Mode /*mode*/)
@@ -654,10 +660,10 @@ static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelec
         gtk_widget_show(csel);
         gtk_object_set_data(GTK_OBJECT(vb), "color-selector", csel);
         gtk_box_pack_start(GTK_BOX(vb), csel, TRUE, TRUE, 0);
-        gtk_signal_connect(GTK_OBJECT(csel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_color_grabbed), psel);
-        gtk_signal_connect(GTK_OBJECT(csel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_color_dragged), psel);
-        gtk_signal_connect(GTK_OBJECT(csel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_color_released), psel);
-        gtk_signal_connect(GTK_OBJECT(csel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_color_changed), psel);
+        g_signal_connect(G_OBJECT(csel), "grabbed", G_CALLBACK(sp_paint_selector_color_grabbed), psel);
+        g_signal_connect(G_OBJECT(csel), "dragged", G_CALLBACK(sp_paint_selector_color_dragged), psel);
+        g_signal_connect(G_OBJECT(csel), "released", G_CALLBACK(sp_paint_selector_color_released), psel);
+        g_signal_connect(G_OBJECT(csel), "changed", G_CALLBACK(sp_paint_selector_color_changed), psel);
         /* Pack everything to frame */
         gtk_container_add(GTK_CONTAINER(psel->frame), vb);
         psel->selector = vb;
@@ -677,22 +683,22 @@ static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelec
 
 static void sp_paint_selector_gradient_grabbed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[GRABBED], 0);
 }
 
 static void sp_paint_selector_gradient_dragged(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[DRAGGED], 0);
 }
 
 static void sp_paint_selector_gradient_released(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[RELEASED], 0);
 }
 
 static void sp_paint_selector_gradient_changed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
 {
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[CHANGED], 0);
 }
 
 static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelector::Mode mode)
@@ -716,10 +722,10 @@ static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSe
         /* Create new gradient selector */
         gsel = sp_gradient_selector_new();
         gtk_widget_show(gsel);
-        gtk_signal_connect(GTK_OBJECT(gsel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_grabbed), psel);
-        gtk_signal_connect(GTK_OBJECT(gsel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_dragged), psel);
-        gtk_signal_connect(GTK_OBJECT(gsel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_released), psel);
-        gtk_signal_connect(GTK_OBJECT(gsel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_changed), psel);
+        g_signal_connect(G_OBJECT(gsel), "grabbed", G_CALLBACK(sp_paint_selector_gradient_grabbed), psel);
+        g_signal_connect(G_OBJECT(gsel), "dragged", G_CALLBACK(sp_paint_selector_gradient_dragged), psel);
+        g_signal_connect(G_OBJECT(gsel), "released", G_CALLBACK(sp_paint_selector_gradient_released), psel);
+        g_signal_connect(G_OBJECT(gsel), "changed", G_CALLBACK(sp_paint_selector_gradient_changed), psel);
         /* Pack everything to frame */
         gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
         psel->selector = gsel;
@@ -760,7 +766,7 @@ static void sp_psel_pattern_destroy(GtkWidget *widget, SPPaintSelector * /*psel*
 
 static void sp_psel_pattern_change(GtkWidget * /*widget*/, SPPaintSelector *psel)
 {
-    gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
+    g_signal_emit(G_OBJECT(psel), psel_signals[CHANGED], 0);
 }
 
 
@@ -991,8 +997,8 @@ static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSel
 
             GtkWidget *mnu = gtk_option_menu_new();
             ink_pattern_menu(mnu);
-            gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_psel_pattern_change), psel);
-            gtk_signal_connect(GTK_OBJECT(mnu), "destroy", GTK_SIGNAL_FUNC(sp_psel_pattern_destroy), psel);
+            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);
             gtk_object_set_data(GTK_OBJECT(psel), "patternmenu", mnu);
             g_object_ref( G_OBJECT(mnu));
 
diff --git a/src/widgets/select-toolbar.cpp b/src/widgets/select-toolbar.cpp
index 108fae1ef..7012badf8 100644
--- a/src/widgets/select-toolbar.cpp
+++ b/src/widgets/select-toolbar.cpp
@@ -295,7 +295,7 @@ static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
         g_object_set( act, "short_label", Q_(shortLabel), NULL );
     }
 
-    gtk_signal_connect( GTK_OBJECT(adj), "value_changed", GTK_SIGNAL_FUNC(sp_object_layout_any_value_changed), spw );
+    g_signal_connect( G_OBJECT(adj), "value_changed", G_CALLBACK(sp_object_layout_any_value_changed), spw );
     if ( focusTarget ) {
         ege_adjustment_action_set_focuswidget( act, focusTarget );
     }
@@ -398,7 +398,7 @@ static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::Vi
     InkAction* inky = ink_action_new( verb->get_id(), verb->get_name(), verb->get_tip(), verb->get_image(), size  );
     act = GTK_ACTION(inky);
 
-    g_signal_connect( G_OBJECT(inky), "activate", GTK_SIGNAL_FUNC(trigger_sp_action), targetAction );
+    g_signal_connect( G_OBJECT(inky), "activate", G_CALLBACK(trigger_sp_action), targetAction );
 
     Inkscape::queueIconPrerender( verb->get_image(), size );
 
@@ -518,8 +518,8 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb
     g_object_set_data( G_OBJECT(spw), "contextActions", contextActions );
 
     // Force update when selection changes.
-    gtk_signal_connect(GTK_OBJECT(spw), "modify_selection", GTK_SIGNAL_FUNC(sp_selection_layout_widget_modify_selection), desktop);
-    gtk_signal_connect(GTK_OBJECT(spw), "change_selection", GTK_SIGNAL_FUNC(sp_selection_layout_widget_change_selection), desktop);
+    g_signal_connect(G_OBJECT(spw), "modify_selection", G_CALLBACK(sp_selection_layout_widget_modify_selection), desktop);
+    g_signal_connect(G_OBJECT(spw), "change_selection", G_CALLBACK(sp_selection_layout_widget_change_selection), desktop);
 
     // Update now.
     sp_selection_layout_widget_update(SP_WIDGET(spw), SP_ACTIVE_DESKTOP ? sp_desktop_selection(SP_ACTIVE_DESKTOP) : NULL);
diff --git a/src/widgets/sp-color-icc-selector.cpp b/src/widgets/sp-color-icc-selector.cpp
index 0bae54655..3a2c7fbed 100644
--- a/src/widgets/sp-color-icc-selector.cpp
+++ b/src/widgets/sp-color-icc-selector.cpp
@@ -358,11 +358,11 @@ void ColorICCSelector::init()
 
 
         /* Signals */
-        gtk_signal_connect( GTK_OBJECT( _fooAdj[i] ), "value_changed", GTK_SIGNAL_FUNC( _adjustmentChanged ), _csel );
+        g_signal_connect( G_OBJECT( _fooAdj[i] ), "value_changed", G_CALLBACK( _adjustmentChanged ), _csel );
 
-        gtk_signal_connect( GTK_OBJECT( _fooSlider[i] ), "grabbed", GTK_SIGNAL_FUNC( _sliderGrabbed ), _csel );
-        gtk_signal_connect( GTK_OBJECT( _fooSlider[i] ), "released", GTK_SIGNAL_FUNC( _sliderReleased ), _csel );
-        gtk_signal_connect( GTK_OBJECT( _fooSlider[i] ), "changed", GTK_SIGNAL_FUNC( _sliderChanged ), _csel );
+        g_signal_connect( G_OBJECT( _fooSlider[i] ), "grabbed", G_CALLBACK( _sliderGrabbed ), _csel );
+        g_signal_connect( G_OBJECT( _fooSlider[i] ), "released", G_CALLBACK( _sliderReleased ), _csel );
+        g_signal_connect( G_OBJECT( _fooSlider[i] ), "changed", G_CALLBACK( _sliderChanged ), _csel );
 
         row++;
     }
@@ -397,15 +397,15 @@ void ColorICCSelector::init()
     gtk_table_attach (GTK_TABLE (t), _sbtn, 2, 3, row, row + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD);
 
     /* Signals */
-    gtk_signal_connect (GTK_OBJECT (_adj), "value_changed",
-                        GTK_SIGNAL_FUNC (_adjustmentChanged), _csel);
-
-    gtk_signal_connect (GTK_OBJECT (_slider), "grabbed",
-                        GTK_SIGNAL_FUNC (_sliderGrabbed), _csel);
-    gtk_signal_connect (GTK_OBJECT (_slider), "released",
-                        GTK_SIGNAL_FUNC (_sliderReleased), _csel);
-    gtk_signal_connect (GTK_OBJECT (_slider), "changed",
-                        GTK_SIGNAL_FUNC (_sliderChanged), _csel);
+    g_signal_connect (G_OBJECT (_adj), "value_changed",
+                        G_CALLBACK (_adjustmentChanged), _csel);
+
+    g_signal_connect (G_OBJECT (_slider), "grabbed",
+                        G_CALLBACK (_sliderGrabbed), _csel);
+    g_signal_connect (G_OBJECT (_slider), "released",
+                        G_CALLBACK (_sliderReleased), _csel);
+    g_signal_connect (G_OBJECT (_slider), "changed",
+                        G_CALLBACK (_sliderChanged), _csel);
 }
 
 static void
@@ -700,7 +700,7 @@ void ColorICCSelector::_setProfile( SVGICCColor* profile )
                                                 SPColor(1.0, 1.0, 1.0).toRGBA32(0xff) );
 /*
                     _fooAdj[i] = GTK_ADJUSTMENT( gtk_adjustment_new( val, 0.0, _fooScales[i],  step, page, page ) );
-                    gtk_signal_connect( GTK_OBJECT( _fooAdj[i] ), "value_changed", GTK_SIGNAL_FUNC( _adjustmentChanged ), _csel );
+                    g_signal_connect( G_OBJECT( _fooAdj[i] ), "value_changed", G_CALLBACK( _adjustmentChanged ), _csel );
 
                     sp_color_slider_set_adjustment( SP_COLOR_SLIDER(_fooSlider[i]), _fooAdj[i] );
                     gtk_spin_button_set_adjustment( GTK_SPIN_BUTTON(_fooBtn[i]), _fooAdj[i] );
diff --git a/src/widgets/sp-color-notebook.cpp b/src/widgets/sp-color-notebook.cpp
index 4c2c03e8a..06e990dfb 100644
--- a/src/widgets/sp-color-notebook.cpp
+++ b/src/widgets/sp-color-notebook.cpp
@@ -318,7 +318,7 @@ void ColorNotebook::init()
         // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!)
         //gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 
-        gtk_signal_connect_object(GTK_OBJECT(_btn), "event", GTK_SIGNAL_FUNC (sp_color_notebook_menu_handler), GTK_OBJECT(_csel));
+        g_signal_connect_swapped(G_OBJECT(_btn), "event", G_CALLBACK (sp_color_notebook_menu_handler), G_OBJECT(_csel));
         if ( !found )
         {
             gtk_widget_set_sensitive (_btn, FALSE);
@@ -383,10 +383,10 @@ void ColorNotebook::init()
     gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 #endif
 
-    _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
-                                 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
+    _switchId = g_signal_connect(G_OBJECT (_book), "switch-page",
+                                 G_CALLBACK (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
 
-    _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
+    _entryId = g_signal_connect (G_OBJECT (_rgbae), "changed", G_CALLBACK (ColorNotebook::_rgbaEntryChangedHook), _csel);
 }
 
 static void
@@ -648,10 +648,10 @@ GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
 //         g_message( "Hitting up for tab for '%s'", str );
         tab_label = gtk_label_new(_(str));
         gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
-        gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
-        gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
-        gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
-        gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
+        g_signal_connect (G_OBJECT (page), "grabbed", G_CALLBACK (_entryGrabbed), _csel);
+        g_signal_connect (G_OBJECT (page), "dragged", G_CALLBACK (_entryDragged), _csel);
+        g_signal_connect (G_OBJECT (page), "released", G_CALLBACK (_entryReleased), _csel);
+        g_signal_connect (G_OBJECT (page), "changed", G_CALLBACK (_entryChanged), _csel);
     }
 
     return page;
diff --git a/src/widgets/sp-color-scales.cpp b/src/widgets/sp-color-scales.cpp
index 001b54752..25162dead 100644
--- a/src/widgets/sp-color-scales.cpp
+++ b/src/widgets/sp-color-scales.cpp
@@ -168,14 +168,14 @@ void ColorScales::init()
 		/* Attach channel value to adjustment */
 		gtk_object_set_data (GTK_OBJECT (_a[i]), "channel", GINT_TO_POINTER (i));
 		/* Signals */
-		gtk_signal_connect (GTK_OBJECT (_a[i]), "value_changed",
-					GTK_SIGNAL_FUNC (_adjustmentAnyChanged), _csel);
-		gtk_signal_connect (GTK_OBJECT (_s[i]), "grabbed",
-					GTK_SIGNAL_FUNC (_sliderAnyGrabbed), _csel);
-		gtk_signal_connect (GTK_OBJECT (_s[i]), "released",
-					GTK_SIGNAL_FUNC (_sliderAnyReleased), _csel);
-		gtk_signal_connect (GTK_OBJECT (_s[i]), "changed",
-					GTK_SIGNAL_FUNC (_sliderAnyChanged), _csel);
+		g_signal_connect (G_OBJECT (_a[i]), "value_changed",
+					G_CALLBACK (_adjustmentAnyChanged), _csel);
+		g_signal_connect (G_OBJECT (_s[i]), "grabbed",
+					G_CALLBACK (_sliderAnyGrabbed), _csel);
+		g_signal_connect (G_OBJECT (_s[i]), "released",
+					G_CALLBACK (_sliderAnyReleased), _csel);
+		g_signal_connect (G_OBJECT (_s[i]), "changed",
+					G_CALLBACK (_sliderAnyChanged), _csel);
 	}
 
 	/* Initial mode is none, so it works */
diff --git a/src/widgets/sp-color-selector.cpp b/src/widgets/sp-color-selector.cpp
index 794cbdb42..bf3564d2e 100644
--- a/src/widgets/sp-color-selector.cpp
+++ b/src/widgets/sp-color-selector.cpp
@@ -70,28 +70,32 @@ void sp_color_selector_class_init( SPColorSelectorClass *klass )
 
     parent_class = GTK_VBOX_CLASS( gtk_type_class(GTK_TYPE_VBOX) );
 
-    csel_signals[GRABBED] = gtk_signal_new( "grabbed",
-                                            (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                            GTK_CLASS_TYPE(object_class),
-                                            GTK_SIGNAL_OFFSET(SPColorSelectorClass, grabbed),
+    csel_signals[GRABBED] = g_signal_new( "grabbed",
+                                            G_TYPE_FROM_CLASS(object_class),
+                                            (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                            G_STRUCT_OFFSET(SPColorSelectorClass, grabbed),
+					    NULL, NULL,
                                             gtk_marshal_NONE__NONE,
                                             GTK_TYPE_NONE, 0 );
-    csel_signals[DRAGGED] = gtk_signal_new( "dragged",
-                                            (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                            GTK_CLASS_TYPE(object_class),
-                                            GTK_SIGNAL_OFFSET(SPColorSelectorClass, dragged),
+    csel_signals[DRAGGED] = g_signal_new( "dragged",
+                                            G_TYPE_FROM_CLASS(object_class),
+                                            (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                            G_STRUCT_OFFSET(SPColorSelectorClass, dragged),
+					    NULL, NULL,
                                             gtk_marshal_NONE__NONE,
                                             GTK_TYPE_NONE, 0 );
-    csel_signals[RELEASED] = gtk_signal_new( "released",
-                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                             GTK_CLASS_TYPE(object_class),
-                                             GTK_SIGNAL_OFFSET(SPColorSelectorClass, released),
+    csel_signals[RELEASED] = g_signal_new( "released",
+                                             G_TYPE_FROM_CLASS(object_class),
+                                             (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                             G_STRUCT_OFFSET(SPColorSelectorClass, released),
+					     NULL, NULL,
                                              gtk_marshal_NONE__NONE,
                                              GTK_TYPE_NONE, 0 );
-    csel_signals[CHANGED] = gtk_signal_new( "changed",
-                                            (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-                                            GTK_CLASS_TYPE(object_class),
-                                            GTK_SIGNAL_OFFSET(SPColorSelectorClass, changed),
+    csel_signals[CHANGED] = g_signal_new( "changed",
+                                            G_TYPE_FROM_CLASS(object_class),
+                                            (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+                                            G_STRUCT_OFFSET(SPColorSelectorClass, changed),
+					    NULL, NULL,
                                             gtk_marshal_NONE__NONE,
                                             GTK_TYPE_NONE, 0 );
 
@@ -111,7 +115,7 @@ void sp_color_selector_init( SPColorSelector *csel )
     {
         csel->base->init();
     }
-/*   gtk_signal_connect(GTK_OBJECT(csel->rgbae), "changed", GTK_SIGNAL_FUNC(sp_color_selector_rgba_entry_changed), csel); */
+/*   g_signal_connect(G_OBJECT(csel->rgbae), "changed", G_CALLBACK(sp_color_selector_rgba_entry_changed), csel); */
 }
 
 void sp_color_selector_destroy( GtkObject *object )
@@ -230,7 +234,7 @@ void ColorSelector::setColorAlpha( const SPColor& color, gfloat alpha, bool emit
         _colorChanged();
 
         if (emit) {
-            gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[CHANGED]);
+            g_signal_emit(G_OBJECT(_csel), csel_signals[CHANGED], 0);
         }
 #ifdef DUMP_CHANGE_INFO
     } else {
@@ -248,7 +252,7 @@ void ColorSelector::_grabbed()
                "GRABBED",
                FOO_NAME(_csel));
 #endif
-    gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[GRABBED]);
+    g_signal_emit(G_OBJECT(_csel), csel_signals[GRABBED], 0);
 }
 
 void ColorSelector::_released()
@@ -259,8 +263,8 @@ void ColorSelector::_released()
                "RELEASED",
                FOO_NAME(_csel));
 #endif
-    gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[RELEASED]);
-    gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[CHANGED]);
+    g_signal_emit(G_OBJECT(_csel), csel_signals[RELEASED], 0);
+    g_signal_emit(G_OBJECT(_csel), csel_signals[CHANGED], 0);
 }
 
 // Called from subclasses to update color and broadcast if needed
@@ -288,7 +292,7 @@ void ColorSelector::_updateInternals( const SPColor& color, gfloat alpha, gboole
                    "GRABBED",
                    color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
 #endif
-        gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[GRABBED]);
+        g_signal_emit(G_OBJECT(_csel), csel_signals[GRABBED], 0);
     }
     else if ( released )
     {
@@ -297,7 +301,7 @@ void ColorSelector::_updateInternals( const SPColor& color, gfloat alpha, gboole
                    "RELEASED",
                    color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
 #endif
-        gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[RELEASED]);
+        g_signal_emit(G_OBJECT(_csel), csel_signals[RELEASED], 0);
     }
 
     if ( colorDifferent || released )
@@ -307,7 +311,7 @@ void ColorSelector::_updateInternals( const SPColor& color, gfloat alpha, gboole
                    (_held ? "CHANGED" : "DRAGGED" ),
                    color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
 #endif
-        gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[_held ? CHANGED : DRAGGED]);
+        g_signal_emit(G_OBJECT(_csel), csel_signals[_held ? CHANGED : DRAGGED], 0);
     }
 }
 
diff --git a/src/widgets/sp-color-slider.cpp b/src/widgets/sp-color-slider.cpp
index 2d0789ec4..efea69590 100644
--- a/src/widgets/sp-color-slider.cpp
+++ b/src/widgets/sp-color-slider.cpp
@@ -87,30 +87,34 @@ sp_color_slider_class_init (SPColorSliderClass *klass)
 
 	parent_class = (GtkWidgetClass*)gtk_type_class (GTK_TYPE_WIDGET);
 
-	slider_signals[GRABBED] = gtk_signal_new ("grabbed",
-						  (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-						  GTK_CLASS_TYPE(object_class),
-						  GTK_SIGNAL_OFFSET (SPColorSliderClass, grabbed),
+	slider_signals[GRABBED] = g_signal_new ("grabbed",
+						  G_TYPE_FROM_CLASS(object_class),
+						  (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+						  G_STRUCT_OFFSET (SPColorSliderClass, grabbed),
+						  NULL, NULL,
 						  gtk_marshal_NONE__NONE,
-						  GTK_TYPE_NONE, 0);
-	slider_signals[DRAGGED] = gtk_signal_new ("dragged",
-						  (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-						  GTK_CLASS_TYPE(object_class),
-						  GTK_SIGNAL_OFFSET (SPColorSliderClass, dragged),
+						  G_TYPE_NONE, 0);
+	slider_signals[DRAGGED] = g_signal_new ("dragged",
+						  G_TYPE_FROM_CLASS(object_class),
+						  (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+						  G_STRUCT_OFFSET (SPColorSliderClass, dragged),
+						  NULL, NULL,
 						  gtk_marshal_NONE__NONE,
-						  GTK_TYPE_NONE, 0);
-	slider_signals[RELEASED] = gtk_signal_new ("released",
-						  (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-						  GTK_CLASS_TYPE(object_class),
-						  GTK_SIGNAL_OFFSET (SPColorSliderClass, released),
+						  G_TYPE_NONE, 0);
+	slider_signals[RELEASED] = g_signal_new ("released",
+						  G_TYPE_FROM_CLASS(object_class),
+						  (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+						  G_STRUCT_OFFSET (SPColorSliderClass, released),
+						  NULL, NULL,
 						  gtk_marshal_NONE__NONE,
-						  GTK_TYPE_NONE, 0);
-	slider_signals[CHANGED] = gtk_signal_new ("changed",
-						  (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
-						  GTK_CLASS_TYPE(object_class),
-						  GTK_SIGNAL_OFFSET (SPColorSliderClass, changed),
+						  G_TYPE_NONE, 0);
+	slider_signals[CHANGED] = g_signal_new ("changed",
+						  G_TYPE_FROM_CLASS(object_class),
+						  (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+						  G_STRUCT_OFFSET (SPColorSliderClass, changed),
+						  NULL, NULL,
 						  gtk_marshal_NONE__NONE,
-						  GTK_TYPE_NONE, 0);
+						  G_TYPE_NONE, 0);
 
 	object_class->destroy = sp_color_slider_destroy;
 
@@ -168,7 +172,7 @@ sp_color_slider_destroy (GtkObject *object)
 	slider = SP_COLOR_SLIDER (object);
 
 	if (slider->adjustment) {
-		gtk_signal_disconnect_by_data (GTK_OBJECT (slider->adjustment), slider);
+		g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider);
 		gtk_object_unref (GTK_OBJECT (slider->adjustment));
 		slider->adjustment = NULL;
 	}
@@ -265,11 +269,11 @@ sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event)
 		gint cx, cw;
 		cx = widget->style->xthickness;
 		cw = widget->allocation.width - 2 * cx;
-		gtk_signal_emit (GTK_OBJECT (slider), slider_signals[GRABBED]);
+		g_signal_emit (G_OBJECT (slider), slider_signals[GRABBED], 0);
 		slider->dragging = TRUE;
 		slider->oldvalue = slider->value;
 		ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) );
-		gtk_signal_emit (GTK_OBJECT (slider), slider_signals[DRAGGED]);
+		g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0);
 		gdk_pointer_grab (widget->window, FALSE,
 				  (GdkEventMask)(GDK_POINTER_MOTION_MASK |
 				  GDK_BUTTON_RELEASE_MASK),
@@ -289,8 +293,8 @@ sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event)
 	if (event->button == 1) {
 		gdk_pointer_ungrab (event->time);
 		slider->dragging = FALSE;
-		gtk_signal_emit (GTK_OBJECT (slider), slider_signals[RELEASED]);
-		if (slider->value != slider->oldvalue) gtk_signal_emit (GTK_OBJECT (slider), slider_signals[CHANGED]);
+		g_signal_emit (G_OBJECT (slider), slider_signals[RELEASED], 0);
+		if (slider->value != slider->oldvalue) g_signal_emit (G_OBJECT (slider), slider_signals[CHANGED], 0);
 	}
 
 	return FALSE;
@@ -308,7 +312,7 @@ sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event)
 		cx = widget->style->xthickness;
 		cw = widget->allocation.width - 2 * cx;
 		ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) );
-		gtk_signal_emit (GTK_OBJECT (slider), slider_signals[DRAGGED]);
+		g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0);
 	}
 
 	return FALSE;
@@ -340,7 +344,7 @@ void sp_color_slider_set_adjustment(SPColorSlider *slider, GtkAdjustment *adjust
 
 	if (slider->adjustment != adjustment) {
 		if (slider->adjustment) {
-			gtk_signal_disconnect_by_data (GTK_OBJECT (slider->adjustment), slider);
+			g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider);
 			gtk_object_unref (GTK_OBJECT (slider->adjustment));
 		}
 
@@ -348,10 +352,10 @@ void sp_color_slider_set_adjustment(SPColorSlider *slider, GtkAdjustment *adjust
 		gtk_object_ref (GTK_OBJECT (adjustment));
 		gtk_object_sink (GTK_OBJECT (adjustment));
 
-		gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
-				    GTK_SIGNAL_FUNC (sp_color_slider_adjustment_changed), slider);
-		gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
-				    GTK_SIGNAL_FUNC (sp_color_slider_adjustment_value_changed), slider);
+		g_signal_connect (G_OBJECT (adjustment), "changed",
+				    G_CALLBACK (sp_color_slider_adjustment_changed), slider);
+		g_signal_connect (G_OBJECT (adjustment), "value_changed",
+				    G_CALLBACK (sp_color_slider_adjustment_value_changed), slider);
 
 		slider->value = ColorScales::getScaled( adjustment );
 
diff --git a/src/widgets/sp-color-wheel-selector.cpp b/src/widgets/sp-color-wheel-selector.cpp
index 25ba250a7..4bbda79a6 100644
--- a/src/widgets/sp-color-wheel-selector.cpp
+++ b/src/widgets/sp-color-wheel-selector.cpp
@@ -196,25 +196,25 @@ void ColorWheelSelector::init()
     gtk_table_attach (GTK_TABLE (t), _sbtn, 2, 3, row, row + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD);
 
     /* Signals */
-    gtk_signal_connect (GTK_OBJECT (_adj), "value_changed",
-                        GTK_SIGNAL_FUNC (_adjustmentChanged), _csel);
+    g_signal_connect (G_OBJECT (_adj), "value_changed",
+                        G_CALLBACK (_adjustmentChanged), _csel);
 
-    gtk_signal_connect (GTK_OBJECT (_slider), "grabbed",
-                        GTK_SIGNAL_FUNC (_sliderGrabbed), _csel);
-    gtk_signal_connect (GTK_OBJECT (_slider), "released",
-                        GTK_SIGNAL_FUNC (_sliderReleased), _csel);
-    gtk_signal_connect (GTK_OBJECT (_slider), "changed",
-                        GTK_SIGNAL_FUNC (_sliderChanged), _csel);
+    g_signal_connect (G_OBJECT (_slider), "grabbed",
+                        G_CALLBACK (_sliderGrabbed), _csel);
+    g_signal_connect (G_OBJECT (_slider), "released",
+                        G_CALLBACK (_sliderReleased), _csel);
+    g_signal_connect (G_OBJECT (_slider), "changed",
+                        G_CALLBACK (_sliderChanged), _csel);
 
-    gtk_signal_connect( GTK_OBJECT(_wheel), "changed",
-                        GTK_SIGNAL_FUNC(_wheelChanged), _csel );
+    g_signal_connect( G_OBJECT(_wheel), "changed",
+                        G_CALLBACK (_wheelChanged), _csel );
 
 
     // GTK does not automatically scale the color wheel, so we have to add that in:
-    gtk_signal_connect( GTK_OBJECT(_wheel), "size-allocate",
-                        GTK_SIGNAL_FUNC(handleWheelAllocation), _csel );
-    gtk_signal_connect( GTK_OBJECT(_wheel), "style-set",
-                        GTK_SIGNAL_FUNC(handleWheelStyleSet), _csel );
+    g_signal_connect( G_OBJECT (_wheel), "size-allocate",
+                        G_CALLBACK (handleWheelAllocation), _csel );
+    g_signal_connect( G_OBJECT (_wheel), "style-set",
+                        G_CALLBACK (handleWheelStyleSet), _csel );
 }
 
 static void
diff --git a/src/widgets/sp-widget.cpp b/src/widgets/sp-widget.cpp
index f694c461c..fd20d8e17 100644
--- a/src/widgets/sp-widget.cpp
+++ b/src/widgets/sp-widget.cpp
@@ -78,32 +78,36 @@ sp_widget_class_init (SPWidgetClass *klass)
 
 	object_class->destroy = sp_widget_destroy;
 
-	signals[CONSTRUCT] =        gtk_signal_new ("construct",
-						    GTK_RUN_FIRST,
-						    GTK_CLASS_TYPE(object_class),
-						    GTK_SIGNAL_OFFSET (SPWidgetClass, construct),
+	signals[CONSTRUCT] =        g_signal_new ("construct",
+						    G_TYPE_FROM_CLASS(object_class),
+						    G_SIGNAL_RUN_FIRST,
+						    G_STRUCT_OFFSET (SPWidgetClass, construct),
+						    NULL, NULL,
 						    gtk_marshal_NONE__NONE,
-						    GTK_TYPE_NONE, 0);
-	signals[CHANGE_SELECTION] = gtk_signal_new ("change_selection",
-						    GTK_RUN_FIRST,
-						    GTK_CLASS_TYPE(object_class),
-						    GTK_SIGNAL_OFFSET (SPWidgetClass, change_selection),
+						    G_TYPE_NONE, 0);
+	signals[CHANGE_SELECTION] = g_signal_new ("change_selection",
+						    G_TYPE_FROM_CLASS(object_class),
+						    G_SIGNAL_RUN_FIRST,
+						    G_STRUCT_OFFSET (SPWidgetClass, change_selection),
+						    NULL, NULL,
 						    gtk_marshal_NONE__POINTER,
-						    GTK_TYPE_NONE, 1,
+						    G_TYPE_NONE, 1,
 						    GTK_TYPE_POINTER);
-	signals[MODIFY_SELECTION] = gtk_signal_new ("modify_selection",
-						    GTK_RUN_FIRST,
-						    GTK_CLASS_TYPE(object_class),
-						    GTK_SIGNAL_OFFSET (SPWidgetClass, modify_selection),
+	signals[MODIFY_SELECTION] = g_signal_new ("modify_selection",
+						    G_TYPE_FROM_CLASS(object_class),
+						    G_SIGNAL_RUN_FIRST,
+						    G_STRUCT_OFFSET (SPWidgetClass, modify_selection),
+						    NULL, NULL,
 						    gtk_marshal_NONE__POINTER_UINT,
-						    GTK_TYPE_NONE, 2,
+						    G_TYPE_NONE, 2,
 						    GTK_TYPE_POINTER, GTK_TYPE_UINT);
-	signals[SET_SELECTION] =    gtk_signal_new ("set_selection",
-						    GTK_RUN_FIRST,
-						    GTK_CLASS_TYPE(object_class),
-						    GTK_SIGNAL_OFFSET (SPWidgetClass, set_selection),
+	signals[SET_SELECTION] =    g_signal_new ("set_selection",
+						    G_TYPE_FROM_CLASS(object_class),
+						    G_SIGNAL_RUN_FIRST,
+						    G_STRUCT_OFFSET (SPWidgetClass, set_selection),
+						    NULL, NULL,
 						    gtk_marshal_NONE__POINTER,
-						    GTK_TYPE_NONE, 1,
+						    G_TYPE_NONE, 1,
 						    GTK_TYPE_POINTER);
 
 	widget_class->show = sp_widget_show;
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
index 7f1548df4..f248e22af 100644
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
@@ -885,7 +885,7 @@ static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::Vi
     act = GTK_ACTION(inky);
     gtk_action_set_sensitive( act, targetAction->sensitive );
 
-    g_signal_connect( G_OBJECT(inky), "activate", GTK_SIGNAL_FUNC(trigger_sp_action), targetAction );
+    g_signal_connect( G_OBJECT(inky), "activate", G_CALLBACK(trigger_sp_action), targetAction );
 
     SPAction*rebound = dynamic_cast<SPAction *>( nr_object_ref( dynamic_cast<NRObject *>(targetAction) ) );
     nr_active_object_add_listener( (NRActiveObject *)rebound, (NRObjectEventVector *)&action_event_vector, sizeof(SPActionEventVector), inky );
@@ -1089,7 +1089,7 @@ static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
         sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), adj );
     }
 
-    gtk_signal_connect( GTK_OBJECT(adj), "value-changed", GTK_SIGNAL_FUNC(callback), dataKludge );
+    g_signal_connect( G_OBJECT(adj), "value-changed", G_CALLBACK(callback), dataKludge );
 
     EgeAdjustmentAction* act = ege_adjustment_action_new( adj, name, label, tooltip, 0, climb, digits );
     if ( shortLabel ) {