Use g_signal* instead of deprecated gtk_signal*. Use proper casts for the arguments.

Worth norting from the GTK+ docs: "For future usage, direct use of the GSignal API is recommended, this avoids
significant performance hits where GtkArg structures have to be converted into GValues."


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@37061 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

src/gtk/bmpbuttn.cpp

@@ -155,17 +155,18 @@ bool wxBitmapButton::Create( wxWindow *parent,
         OnSetBitmap();
     }
 
-    gtk_signal_connect_after( GTK_OBJECT(m_widget), "clicked",
-      GTK_SIGNAL_FUNC(gtk_bmpbutton_clicked_callback), (gpointer*)this );
+    g_signal_connect_after (m_widget, "clicked",
+                            G_CALLBACK (gtk_bmpbutton_clicked_callback),
+                            this);
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "enter",
-      GTK_SIGNAL_FUNC(gtk_bmpbutton_enter_callback), (gpointer*)this );
-    gtk_signal_connect( GTK_OBJECT(m_widget), "leave",
-      GTK_SIGNAL_FUNC(gtk_bmpbutton_leave_callback), (gpointer*)this );
-    gtk_signal_connect( GTK_OBJECT(m_widget), "pressed",
-      GTK_SIGNAL_FUNC(gtk_bmpbutton_press_callback), (gpointer*)this );
-    gtk_signal_connect( GTK_OBJECT(m_widget), "released",
-      GTK_SIGNAL_FUNC(gtk_bmpbutton_release_callback), (gpointer*)this );
+    g_signal_connect (m_widget, "enter",
+                      G_CALLBACK (gtk_bmpbutton_enter_callback), this);
+    g_signal_connect (m_widget, "leave",
+                      G_CALLBACK (gtk_bmpbutton_leave_callback), this);
+    g_signal_connect (m_widget, "pressed",
+                      G_CALLBACK (gtk_bmpbutton_press_callback), this);
+    g_signal_connect (m_widget, "released",
+                      G_CALLBACK (gtk_bmpbutton_release_callback), this);
 
     m_parent->DoAddChild( this );
 

src/gtk/button.cpp

@@ -155,11 +155,13 @@ bool wxButton::Create(  wxWindow *parent, wxWindowID id, const wxString &label,
     if (style & wxNO_BORDER)
        gtk_button_set_relief( GTK_BUTTON(m_widget), GTK_RELIEF_NONE );
 
-    gtk_signal_connect_after( GTK_OBJECT(m_widget), "clicked",
-      GTK_SIGNAL_FUNC(gtk_button_clicked_callback), (gpointer*)this );
+    g_signal_connect_after (m_widget, "clicked",
+                            G_CALLBACK (gtk_button_clicked_callback),
+                            this);
 
-    gtk_signal_connect_after( GTK_OBJECT(m_widget), "style_set",
-      GTK_SIGNAL_FUNC(gtk_button_style_set_callback), (gpointer*) this );
+    g_signal_connect_after (m_widget, "style_set",
+                            G_CALLBACK (gtk_button_style_set_callback),
+                            this);
 
     m_parent->DoAddChild( this );
 

src/gtk/checkbox.cpp

@@ -161,10 +161,8 @@ bool wxCheckBox::Create(wxWindow *parent,
     }
     SetLabel( label );
 
-    gtk_signal_connect( GTK_OBJECT(m_widgetCheckbox),
-                        "toggled",
-                        GTK_SIGNAL_FUNC(gtk_checkbox_toggled_callback),
-                        (gpointer *)this );
+    g_signal_connect (m_widgetCheckbox, "toggled",
+                      G_CALLBACK (gtk_checkbox_toggled_callback), this);
 
     m_parent->DoAddChild( this );
 

src/gtk/choice.cpp

@@ -541,8 +541,9 @@ int wxChoice::GtkAddHelper(GtkWidget *menu, int pos, const wxString& item)
     // it has to change. Adapted from Matt Ownby.
     InvalidateBestSize();
 
-    gtk_signal_connect_after( GTK_OBJECT( menu_item ), "activate",
-      GTK_SIGNAL_FUNC(gtk_choice_clicked_callback), (gpointer*)this );
+    g_signal_connect_after (menu_item, "activate",
+                            G_CALLBACK (gtk_choice_clicked_callback),
+                            this);
 
     gtk_widget_show( menu_item );
 

src/gtk/clipbrd.cpp

@@ -320,25 +320,19 @@ wxClipboard::wxClipboard()
     m_targetsWidget = gtk_window_new( GTK_WINDOW_POPUP );
     gtk_widget_realize( m_targetsWidget );
 
-    gtk_signal_connect( GTK_OBJECT(m_targetsWidget),
-                        "selection_received",
-                        GTK_SIGNAL_FUNC( targets_selection_received ),
-                        (gpointer) this );
+    g_signal_connect (m_targetsWidget, "selection_received",
+                      G_CALLBACK (targets_selection_received), this);
 
     /* we use m_clipboardWidget to get and to offer data */
 
     m_clipboardWidget = gtk_window_new( GTK_WINDOW_POPUP );
     gtk_widget_realize( m_clipboardWidget );
 
-    gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
-                        "selection_received",
-                        GTK_SIGNAL_FUNC( selection_received ),
-                        (gpointer) this );
+    g_signal_connect (m_clipboardWidget, "selection_received",
+                      G_CALLBACK (selection_received), this);
 
-    gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
-                        "selection_clear_event",
-                        GTK_SIGNAL_FUNC( selection_clear_clip ),
-                        (gpointer) NULL );
+    g_signal_connect (m_clipboardWidget, "selection_clear_event",
+                      G_CALLBACK (selection_clear_clip), NULL);
 
     if (!g_clipboardAtom) g_clipboardAtom = gdk_atom_intern( "CLIPBOARD", FALSE );
     if (!g_targetsAtom) g_targetsAtom = gdk_atom_intern ("TARGETS", FALSE);
@@ -459,10 +453,8 @@ bool wxClipboard::AddData( wxDataObject *data )
 
     delete[] array;
 
-    gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
-                        "selection_get",
-                        GTK_SIGNAL_FUNC(selection_handler),
-                        (gpointer) NULL );
+    g_signal_connect (m_clipboardWidget, "selection_get",
+                      G_CALLBACK (selection_handler), NULL);
 
 #if wxUSE_THREADS
     /* disable GUI threads */

src/gtk/combobox.cpp

@@ -136,11 +136,12 @@ gtk_combo_select_child_callback( GtkList *WXUNUSED(list), GtkWidget *WXUNUSED(wi
     // Quickly set the value of the combo box
     // as GTK+ does that only AFTER the event
     // is sent.
-    gtk_signal_disconnect_by_func( GTK_OBJECT(GTK_COMBO(combo->GetHandle())->entry),
-      GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)combo );
+    g_signal_handlers_disconnect_by_func (GTK_COMBO (combo->GetHandle())->entry,
+                                          (gpointer) gtk_text_changed_callback,
+                                          combo);
     combo->SetValue( combo->GetStringSelection() );
-    gtk_signal_connect_after( GTK_OBJECT(GTK_COMBO(combo->GetHandle())->entry), "changed",
-      GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)combo );
+    g_signal_connect_after (GTK_COMBO (combo->GetHandle())->entry, "changed",
+                            G_CALLBACK (gtk_text_changed_callback), combo);
 
     // throw a SELECTED event only if the combobox popup is hidden (wxID_NONE)
     // because when combobox popup is shown, gtk_combo_select_child_callback is
@@ -227,10 +228,11 @@ bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
     GtkCombo *combo = GTK_COMBO(m_widget);
 
     // Disable GTK's broken events ...
-    gtk_signal_disconnect( GTK_OBJECT(combo->entry), combo->entry_change_id );
+    g_signal_handler_disconnect (combo->entry, combo->entry_change_id);
     // ... and add surrogate handler.
-    combo->entry_change_id = gtk_signal_connect (GTK_OBJECT (combo->entry), "changed",
-                  (GtkSignalFunc) gtk_dummy_callback, combo);
+    combo->entry_change_id = g_signal_connect (combo->entry, "changed",
+                                               G_CALLBACK (gtk_dummy_callback),
+                                               combo);
 
     // make it more useable
     gtk_combo_set_use_arrows_always( GTK_COMBO(m_widget), TRUE );
@@ -272,16 +274,17 @@ bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
 
     // "show" and "hide" events are generated when user click on the combobox button which popups a list
     // this list is the "popwin" gtk widget
-    gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "hide",
-                        GTK_SIGNAL_FUNC(gtk_popup_hide_callback), (gpointer)this );
-    gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "show",
-                        GTK_SIGNAL_FUNC(gtk_popup_show_callback), (gpointer)this );
+    g_signal_connect (GTK_COMBO(combo)->popwin, "hide",
+                      G_CALLBACK (gtk_popup_hide_callback), this);
+    g_signal_connect (GTK_COMBO(combo)->popwin, "show",
+                      G_CALLBACK (gtk_popup_show_callback), this);
 
-    gtk_signal_connect_after( GTK_OBJECT(combo->entry), "changed",
-      GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this );
+    g_signal_connect_after (combo->entry, "changed",
+                            G_CALLBACK (gtk_text_changed_callback), this);
 
-    gtk_signal_connect_after( GTK_OBJECT(combo->list), "select-child",
-      GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this );
+    g_signal_connect_after (combo->list, "select-child",
+                            G_CALLBACK (gtk_combo_select_child_callback),
+                            this);
 
     SetBestSize(size); // need this too because this is a wxControlWithItems
 
@@ -866,18 +869,22 @@ void wxComboBox::OnChar( wxKeyEvent &event )
 
 void wxComboBox::DisableEvents()
 {
-    gtk_signal_disconnect_by_func( GTK_OBJECT(GTK_COMBO(m_widget)->list),
-      GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this );
-    gtk_signal_disconnect_by_func( GTK_OBJECT(GTK_COMBO(m_widget)->entry),
-      GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this );
+    g_signal_handlers_disconnect_by_func (GTK_COMBO(m_widget)->list,
+                                          (gpointer) gtk_combo_select_child_callback,
+                                          this);
+    g_signal_handlers_disconnect_by_func (GTK_COMBO(m_widget)->entry,
+                                          (gpointer) gtk_text_changed_callback,
+                                          this);
 }
 
 void wxComboBox::EnableEvents()
 {
-    gtk_signal_connect_after( GTK_OBJECT(GTK_COMBO(m_widget)->list), "select-child",
-      GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this );
-    gtk_signal_connect_after( GTK_OBJECT(GTK_COMBO(m_widget)->entry), "changed",
-      GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this );
+    g_signal_connect_after (GTK_COMBO(m_widget)->list, "select-child",
+                            G_CALLBACK (gtk_combo_select_child_callback),
+                            this);
+    g_signal_connect_after (GTK_COMBO(m_widget)->entry, "changed",
+                            G_CALLBACK (gtk_text_changed_callback),
+                            this );
 }
 
 void wxComboBox::OnSize( wxSizeEvent &event )

src/gtk/dnd.cpp

@@ -547,17 +547,14 @@ void wxDropTarget::UnregisterWidget( GtkWidget *widget )
 
     gtk_drag_dest_unset( widget );
 
-    gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
-                      GTK_SIGNAL_FUNC(target_drag_leave), (gpointer) this );
-
-    gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
-                      GTK_SIGNAL_FUNC(target_drag_motion), (gpointer) this );
-
-    gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
-                      GTK_SIGNAL_FUNC(target_drag_drop), (gpointer) this );
-
-    gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
-                      GTK_SIGNAL_FUNC(target_drag_data_received), (gpointer) this );
+    g_signal_handlers_disconnect_by_func (widget,
+                                          (gpointer) target_drag_leave, this);
+    g_signal_handlers_disconnect_by_func (widget,
+                                          (gpointer) target_drag_motion, this);
+    g_signal_handlers_disconnect_by_func (widget,
+                                          (gpointer) target_drag_drop, this);
+    g_signal_handlers_disconnect_by_func (widget,
+                                          (gpointer) target_drag_data_received, this);
 }
 
 void wxDropTarget::RegisterWidget( GtkWidget *widget )
@@ -580,17 +577,17 @@ void wxDropTarget::RegisterWidget( GtkWidget *widget )
                        0,                           /* number of targets = 0 */
                        (GdkDragAction) 0 );         /* we don't supply any actions here */
 
-    gtk_signal_connect( GTK_OBJECT(widget), "drag_leave",
-                      GTK_SIGNAL_FUNC(target_drag_leave), (gpointer) this );
+    g_signal_connect (widget, "drag_leave",
+                      G_CALLBACK (target_drag_leave), this);
 
-    gtk_signal_connect( GTK_OBJECT(widget), "drag_motion",
-                      GTK_SIGNAL_FUNC(target_drag_motion), (gpointer) this );
+    g_signal_connect (widget, "drag_motion",
+                      G_CALLBACK (target_drag_motion), this);
 
-    gtk_signal_connect( GTK_OBJECT(widget), "drag_drop",
-                      GTK_SIGNAL_FUNC(target_drag_drop), (gpointer) this );
+    g_signal_connect (widget, "drag_drop",
+                      G_CALLBACK (target_drag_drop), this);
 
-    gtk_signal_connect( GTK_OBJECT(widget), "drag_data_received",
-                      GTK_SIGNAL_FUNC(target_drag_data_received), (gpointer) this );
+    g_signal_connect (widget, "drag_data_received",
+                      G_CALLBACK (target_drag_data_received), this);
 }
 
 //----------------------------------------------------------------------------
@@ -828,8 +825,8 @@ void wxDropSource::PrepareIcon( int action, GdkDragContext *context )
     gtk_widget_set_usize (m_iconWindow, width, height);
     gtk_widget_realize (m_iconWindow);
 
-    gtk_signal_connect( GTK_OBJECT(m_iconWindow), "configure_event",
-        GTK_SIGNAL_FUNC(gtk_dnd_window_configure_callback), (gpointer)this );
+    g_signal_connect (m_iconWindow, "configure_event",
+                      G_CALLBACK (gtk_dnd_window_configure_callback), this);
 
     gdk_window_set_back_pixmap (m_iconWindow->window, pixmap, FALSE);
 
@@ -934,29 +931,34 @@ void wxDropSource::RegisterWindow()
 {
     if (!m_widget) return;
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "drag_data_get",
-                      GTK_SIGNAL_FUNC (source_drag_data_get), (gpointer) this);
-    gtk_signal_connect (GTK_OBJECT(m_widget), "drag_data_delete",
-                      GTK_SIGNAL_FUNC (source_drag_data_delete),  (gpointer) this );
-    gtk_signal_connect (GTK_OBJECT(m_widget), "drag_begin",
-                      GTK_SIGNAL_FUNC (source_drag_begin),  (gpointer) this );
-    gtk_signal_connect (GTK_OBJECT(m_widget), "drag_end",
-                      GTK_SIGNAL_FUNC (source_drag_end),  (gpointer) this );
+    g_signal_connect (m_widget, "drag_data_get",
+                      G_CALLBACK (source_drag_data_get), this);
+    g_signal_connect (m_widget, "drag_data_delete",
+                      G_CALLBACK (source_drag_data_delete), this);
+    g_signal_connect (m_widget, "drag_begin",
+                      G_CALLBACK (source_drag_begin), this);
+    g_signal_connect (m_widget, "drag_end",
+                      G_CALLBACK (source_drag_end), this);
 
 }
 
 void wxDropSource::UnregisterWindow()
 {
-    if (!m_widget) return;
+    if (!m_widget)
+        return;
 
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
-                      GTK_SIGNAL_FUNC(source_drag_data_get), (gpointer) this );
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
-                      GTK_SIGNAL_FUNC(source_drag_data_delete), (gpointer) this );
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
-                      GTK_SIGNAL_FUNC(source_drag_begin), (gpointer) this );
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
-                      GTK_SIGNAL_FUNC(source_drag_end), (gpointer) this );
+    g_signal_handlers_disconnect_by_func (m_widget,
+                                          (gpointer) source_drag_data_get,
+                                          this);
+    g_signal_handlers_disconnect_by_func (m_widget,
+                                          (gpointer) source_drag_data_delete,
+                                          this);
+    g_signal_handlers_disconnect_by_func (m_widget,
+                                          (gpointer) source_drag_begin,
+                                          this);
+    g_signal_handlers_disconnect_by_func (m_widget,
+                                          (gpointer) source_drag_end,
+                                          this);
 }
 
 #endif

src/gtk/fontdlg.cpp

@@ -124,14 +124,14 @@ bool wxFontDialog::DoCreate(wxWindow *parent)
 
     GtkFontSelectionDialog *sel = GTK_FONT_SELECTION_DIALOG(m_widget);
 
-    gtk_signal_connect( GTK_OBJECT(sel->ok_button), "clicked",
-      GTK_SIGNAL_FUNC(gtk_fontdialog_ok_callback), (gpointer*)this );
+    g_signal_connect (sel->ok_button, "clicked",
+                      G_CALLBACK (gtk_fontdialog_ok_callback), this);
 
-    gtk_signal_connect( GTK_OBJECT(sel->cancel_button), "clicked",
-      GTK_SIGNAL_FUNC(gtk_fontdialog_cancel_callback), (gpointer*)this );
+    g_signal_connect (sel->cancel_button, "clicked",
+                      G_CALLBACK (gtk_fontdialog_cancel_callback), this);
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
-        GTK_SIGNAL_FUNC(gtk_fontdialog_delete_callback), (gpointer)this );
+    g_signal_connect (m_widget, "delete_event",
+                      G_CALLBACK (gtk_fontdialog_delete_callback), this);
 
     wxFont font = m_fontData.GetInitialFont();
     if( font.Ok() )

src/gtk/frame.cpp

@@ -180,11 +180,12 @@ static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
             wxToolBar *toolBar = (wxToolBar*) child;
             if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
             {
-                gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
-                    GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
-
-                gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
-                    GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
+                g_signal_connect (toolBar->m_widget, "child_attached",
+                                  G_CALLBACK (gtk_toolbar_attached_callback),
+                                  parent);
+                g_signal_connect (toolBar->m_widget, "child_detached",
+                                  G_CALLBACK (gtk_toolbar_detached_callback),
+                                  parent);
             }
         }
 #endif // wxUSE_TOOLBAR
@@ -558,11 +559,13 @@ void wxFrame::DetachMenuBar()
 
         if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE)
         {
-            gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
-                GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
+            g_signal_handlers_disconnect_by_func (m_frameMenuBar->m_widget,
+                    (gpointer) gtk_menu_attached_callback,
+                    this);
 
-            gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
-                GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
+            g_signal_handlers_disconnect_by_func (m_frameMenuBar->m_widget,
+                    (gpointer) gtk_menu_detached_callback,
+                    this);
         }
 
         gtk_widget_ref( m_frameMenuBar->m_widget );
@@ -591,11 +594,12 @@ void wxFrame::AttachMenuBar( wxMenuBar *menuBar )
 
         if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
         {
-            gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
-                GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
-
-            gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
-                GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
+            g_signal_connect (menuBar->m_widget, "child_attached",
+                              G_CALLBACK (gtk_menu_attached_callback),
+                              this);
+            g_signal_connect (menuBar->m_widget, "child_detached",
+                              G_CALLBACK (gtk_menu_detached_callback),
+                              this);
         }
 
         gtk_widget_show( m_frameMenuBar->m_widget );

src/gtk/glcanvas.cpp

@@ -413,17 +413,18 @@ bool wxGLCanvas::Create( wxWindow *parent,
 
     gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
 
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
-                            GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this );
-
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "map",
-                            GTK_SIGNAL_FUNC(gtk_glwindow_map_callback), (gpointer) this );
-
-    gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
-        GTK_SIGNAL_FUNC(gtk_glwindow_expose_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
-        GTK_SIGNAL_FUNC(gtk_glcanvas_size_callback), (gpointer)this );
+    g_signal_connect (m_wxwindow, "realize",
+                      G_CALLBACK (gtk_glwindow_realized_callback),
+                      this);
+    g_signal_connect (m_wxwindow, "map",
+                      G_CALLBACK (gtk_glwindow_map_callback),
+                      this);
+    g_signal_connect (m_wxwindow, "expose_event",
+                      G_CALLBACK (gtk_glwindow_expose_callback),
+                      this);
+    g_signal_connect (m_widget, "size_allocate",
+                      G_CALLBACK (gtk_glcanvas_size_callback),
+                      this);
 
     if (gtk_check_version(2,2,0) != NULL)
     {

src/gtk/listbox.cpp

@@ -349,7 +349,7 @@ gtk_listbox_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxLis
 
     if (ret)
     {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+        g_signal_stop_emission_by_name (widget, "key_press_event");
         return TRUE;
     }
 
@@ -534,8 +534,8 @@ bool wxListBox::Create( wxWindow *parent, wxWindowID id,
 
     gtk_widget_show( GTK_WIDGET(m_list) );
 
-    gtk_signal_connect( GTK_OBJECT(m_list), "realize",
-                        GTK_SIGNAL_FUNC(gtk_listbox_realized_callback), (gpointer) this );
+    g_signal_connect (m_list, "realize",
+                      G_CALLBACK (gtk_listbox_realized_callback), this);
 
     if ( style & wxLB_SORT )
     {
@@ -696,34 +696,30 @@ void wxListBox::GtkAddItem( const wxString &item, int pos )
     else
         gtk_list_insert_items( GTK_LIST (m_list), gitem_list, pos );
 
-    gtk_signal_connect_after( GTK_OBJECT(list_item), "select",
-      GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
+    g_signal_connect_after (list_item, "select",
+                            G_CALLBACK (gtk_listitem_select_callback),
+                            this);
 
     if (HasFlag(wxLB_MULTIPLE) || HasFlag(wxLB_EXTENDED))
-        gtk_signal_connect_after( GTK_OBJECT(list_item), "deselect",
-          GTK_SIGNAL_FUNC(gtk_listitem_deselect_callback), (gpointer)this );
+        g_signal_connect_after (list_item, "deselect",
+                                G_CALLBACK (gtk_listitem_deselect_callback),
+                                this);
 
-    gtk_signal_connect( GTK_OBJECT(list_item),
-                        "button_press_event",
-                        (GtkSignalFunc)gtk_listbox_button_press_callback,
-                        (gpointer) this );
-
-    gtk_signal_connect_after( GTK_OBJECT(list_item),
-                        "button_release_event",
-                        (GtkSignalFunc)gtk_listbox_button_release_callback,
-                        (gpointer) this );
-
-    gtk_signal_connect( GTK_OBJECT(list_item),
-                           "key_press_event",
-                           (GtkSignalFunc)gtk_listbox_key_press_callback,
-                           (gpointer)this );
-
-
-    gtk_signal_connect( GTK_OBJECT(list_item), "focus_in_event",
-            GTK_SIGNAL_FUNC(gtk_listitem_focus_in_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(list_item), "focus_out_event",
-            GTK_SIGNAL_FUNC(gtk_listitem_focus_out_callback), (gpointer)this );
+    g_signal_connect (list_item, "button_press_event",
+                      G_CALLBACK (gtk_listbox_button_press_callback),
+                      this);
+    g_signal_connect_after (list_item, "button_release_event",
+                            G_CALLBACK (gtk_listbox_button_release_callback),
+                            this);
+    g_signal_connect (list_item, "key_press_event",
+                      G_CALLBACK (gtk_listbox_key_press_callback),
+                           this);
+    g_signal_connect (list_item, "focus_in_event",
+                      G_CALLBACK (gtk_listitem_focus_in_callback),
+                      this);
+    g_signal_connect (list_item, "focus_out_event",
+                      G_CALLBACK (gtk_listitem_focus_out_callback),
+                      this);
 
     ConnectWidget( list_item );
 

src/gtk/mdi.cpp

@@ -81,7 +81,7 @@ gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
     {
         wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
         // CE: we come here in the destructor with a null child_frame - I think because
-        // gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page", (see below)
+        // g_signal_connect (m_widget, "switch_page", (see below)
         // isn't deleted early enough
         if (!child_frame)
           return ;
@@ -463,8 +463,8 @@ static void wxInsertChildInMDI( wxMDIClientWindow* parent, wxMDIChildFrame* chil
     GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
     gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
 
-    gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
-      GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
+    g_signal_connect (child->m_widget, "size_allocate",
+                      G_CALLBACK (gtk_page_size_callback), child);
 
     GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
 
@@ -511,8 +511,8 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
 
     m_widget = gtk_notebook_new();
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
-      GTK_SIGNAL_FUNC(gtk_mdi_page_change_callback), (gpointer)parent );
+    g_signal_connect (m_widget, "switch_page",
+                      G_CALLBACK (gtk_mdi_page_change_callback), parent);
 
     gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
 

src/gtk/menu.cpp

@@ -185,10 +185,8 @@ void wxMenuBar::Init(size_t n, wxMenu *menus[], const wxString titles[], long st
     //     don't get it when the menu is dismissed by clicking outside the
     //     toolbar) so we connect to the global one, even if it means that we
     //     can't pass the menu which was closed in wxMenuEvent object
-    gtk_signal_connect( GTK_OBJECT(GTK_MENU_SHELL(m_menubar)),
-                        "deactivate",
-                        GTK_SIGNAL_FUNC(gtk_menu_close_callback),
-                        (gpointer)this );
+    g_signal_connect (m_menubar, "deactivate",
+                      G_CALLBACK (gtk_menu_close_callback), this);
 
 }
 
@@ -311,9 +309,9 @@ bool wxMenuBar::GtkAppend(wxMenu *menu, const wxString& title, int pos)
     else
         gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar), menu->m_owner, pos );
 
-    gtk_signal_connect( GTK_OBJECT(menu->m_owner), "activate",
-                        GTK_SIGNAL_FUNC(gtk_menu_open_callback),
-                        (gpointer)menu );
+    g_signal_connect (menu->m_owner, "activate",
+                      G_CALLBACK (gtk_menu_open_callback),
+                      menu);
 
     // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
     // addings menu later on.
@@ -1062,13 +1060,10 @@ bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
     {
         wxASSERT_MSG( menuItem, wxT("invalid menuitem") );
 
-        gtk_signal_connect( GTK_OBJECT(menuItem), "select",
-                            GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),
-                            (gpointer)this );
-
-        gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",
-                            GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),
-                            (gpointer)this );
+        g_signal_connect (menuItem, "select",
+                          G_CALLBACK (gtk_menu_hilight_callback), this);
+        g_signal_connect (menuItem, "deselect",
+                          G_CALLBACK (gtk_menu_nolight_callback), this);
 
         if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
         {
@@ -1084,9 +1079,9 @@ bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
         }
         else
         {
-            gtk_signal_connect( GTK_OBJECT(menuItem), "activate",
-                                GTK_SIGNAL_FUNC(gtk_menu_clicked_callback),
-                                (gpointer)this );
+            g_signal_connect (menuItem, "activate",
+                              G_CALLBACK (gtk_menu_clicked_callback),
+                              this);
         }
     }
 
@@ -1485,10 +1480,9 @@ bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
 
     bool is_waiting = true;
 
-    gulong handler = gtk_signal_connect( GTK_OBJECT(menu->m_menu),
-                                         "hide",
-                                         GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
-                                         (gpointer)&is_waiting );
+    gulong handler = g_signal_connect (menu->m_menu, "hide",
+                                       G_CALLBACK (gtk_pop_hide_callback),
+                                       &is_waiting);
 
     wxPoint pos;
     gpointer userdata;
@@ -1524,7 +1518,7 @@ bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
         gtk_main_iteration();
     }
 
-    gtk_signal_disconnect(GTK_OBJECT(menu->m_menu), handler);
+    g_signal_handler_disconnect (menu->m_menu, handler);
 
     wxMenuEvent eventClose(wxEVT_MENU_CLOSE, -1, menu);
     DoCommonMenuCallbackCode(menu, eventClose);

src/gtk/minifram.cpp

@@ -323,23 +323,22 @@ bool wxMiniFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title
 
         gtk_widget_show( close_button );
 
-        gtk_signal_connect( GTK_OBJECT(close_button), "clicked",
-          GTK_SIGNAL_FUNC(gtk_button_clicked_callback), (gpointer*)this );
+        g_signal_connect (close_button, "clicked",
+                          G_CALLBACK (gtk_button_clicked_callback),
+                          this);
     }
 
     /* these are called when the borders are drawn */
-    gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
-        GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
+    g_signal_connect (m_mainWidget, "expose_event",
+                      G_CALLBACK (gtk_window_own_expose_callback), this );
 
     /* these are required for dragging the mini frame around */
-    gtk_signal_connect( GTK_OBJECT(m_mainWidget), "button_press_event",
-      GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(m_mainWidget), "button_release_event",
-      GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(m_mainWidget), "motion_notify_event",
-      GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
+    g_signal_connect (m_mainWidget, "button_press_event",
+                      G_CALLBACK (gtk_window_button_press_callback), this);
+    g_signal_connect (m_mainWidget, "button_release_event",
+                      G_CALLBACK (gtk_window_button_release_callback), this);
+    g_signal_connect (m_mainWidget, "motion_notify_event",
+                      G_CALLBACK (gtk_window_motion_notify_callback), this);
 
     return true;
 }

src/gtk/notebook.cpp

@@ -111,8 +111,8 @@ static void gtk_notebook_page_change_callback(GtkNotebook *WXUNUSED(widget),
          !eventChanging.IsAllowed() )
     {
         /* program doesn't allow the page change */
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(notebook->m_widget),
-                                      "switch_page" );
+        g_signal_stop_emission_by_name (notebook->m_widget,
+                                        "switch_page");
     }
     else // change allowed
     {
@@ -219,7 +219,7 @@ static gint gtk_notebook_key_press_callback( GtkWidget *widget, GdkEventKey *gdk
         // m_selection = page;
         gtk_notebook_set_page( GTK_NOTEBOOK(widget), page );
 
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+        g_signal_stop_emission_by_name (widget, "key_press_event");
         return TRUE;
     }
 
@@ -247,7 +247,7 @@ static gint gtk_notebook_key_press_callback( GtkWidget *widget, GdkEventKey *gdk
              client->SetFocus();
         }
 
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+        g_signal_stop_emission_by_name (widget, "key_press_event");
         return TRUE;
     }
 
@@ -334,8 +334,8 @@ bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
 
     gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
-      GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
+    g_signal_connect (m_widget, "switch_page",
+                      G_CALLBACK (gtk_notebook_page_change_callback), this);
 
     m_parent->DoAddChild( this );
 
@@ -346,13 +346,13 @@ bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
     if (m_windowStyle & wxBK_BOTTOM)
         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM );
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
-      GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );
+    g_signal_connect (m_widget, "key_press_event",
+                      G_CALLBACK (gtk_notebook_key_press_callback), this);
 
     PostCreation(size);
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
-                            GTK_SIGNAL_FUNC(gtk_notebook_realized_callback), (gpointer) this );
+    g_signal_connect (m_widget, "realize",
+                      G_CALLBACK (gtk_notebook_realized_callback), this);
 
     return TRUE;
 }
@@ -600,13 +600,14 @@ wxNotebookPage *wxNotebook::DoRemovePage( size_t page )
     // gtk_notebook_remove_page() sends "switch_page" signal with some strange
     // new page index (when deleting selected page 0, new page is 1 although,
     // clearly, the selection should stay 0), so suppress this
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
-      GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this );
+    g_signal_handlers_disconnect_by_func (m_widget,
+                                          (gpointer) gtk_notebook_page_change_callback,
+                                          this);
 
     gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page );
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
-      GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
+    g_signal_connect (m_widget, "switch_page",
+                      G_CALLBACK (gtk_notebook_page_change_callback), this);
 
     wxGtkNotebookPage* p = GetNotebookPage(page);
     m_pagesData.DeleteObject(p);
@@ -637,8 +638,9 @@ bool wxNotebook::InsertPage( size_t position,
     win->m_widget->parent = NULL;
 
     // don't receive switch page during addition
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
-      GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this );
+    g_signal_handlers_disconnect_by_func (m_widget,
+                                          (gpointer) gtk_notebook_page_change_callback,
+                                          this);
 
     if (m_themeEnabled)
         win->SetThemeEnabled(TRUE);
@@ -657,8 +659,8 @@ bool wxNotebook::InsertPage( size_t position,
     nb_page->m_box = gtk_hbox_new( FALSE, 1 );
     gtk_container_border_width( GTK_CONTAINER(nb_page->m_box), 2 );
 
-    gtk_signal_connect( GTK_OBJECT(win->m_widget), "size_allocate",
-      GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)win );
+    g_signal_connect (win->m_widget, "size_allocate",
+                      G_CALLBACK (gtk_page_size_callback), win);
 
     gtk_notebook_insert_page( notebook, win->m_widget, nb_page->m_box, position );
 
@@ -709,8 +711,8 @@ bool wxNotebook::InsertPage( size_t position,
       SetSelection( position );
     }
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
-      GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
+    g_signal_connect (m_widget, "switch_page",
+                      G_CALLBACK (gtk_notebook_page_change_callback), this);
 
     InvalidateBestSize();
     return TRUE;

src/gtk/popupwin.cpp

@@ -76,7 +76,7 @@ static gint gtk_dialog_focus_callback( GtkWidget *widget, GtkDirectionType WXUNU
         wxapp_install_idle_handler();
 
     // This disables GTK's tab traversal
-    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
+    g_signal_stop_emission_by_name (widget, "focus");
     return TRUE;
 }
 }
@@ -192,8 +192,8 @@ bool wxPopupWindow::Create( wxWindow *parent, int style )
 
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
-        GTK_SIGNAL_FUNC(gtk_dialog_delete_callback), (gpointer)this );
+    g_signal_connect (m_widget, "delete_event",
+                      G_CALLBACK (gtk_dialog_delete_callback), this);
 
     m_wxwindow = gtk_pizza_new();
     gtk_widget_show( m_wxwindow );
@@ -207,15 +207,15 @@ bool wxPopupWindow::Create( wxWindow *parent, int style )
 
     /*  we cannot set MWM hints  before the widget has
         been realized, so we do this directly after realization */
-    gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
-                        GTK_SIGNAL_FUNC(gtk_dialog_realized_callback), (gpointer) this );
+    g_signal_connect (m_widget, "realize",
+                      G_CALLBACK (gtk_dialog_realized_callback), this);
 
     // disable native tab traversal
-    gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
-        GTK_SIGNAL_FUNC(gtk_dialog_focus_callback), (gpointer)this );
+    g_signal_connect (m_widget, "focus",
+                      G_CALLBACK (gtk_dialog_focus_callback), this);
 
-    gtk_signal_connect (GTK_OBJECT(m_widget), "button_press_event",
-        GTK_SIGNAL_FUNC(gtk_popup_button_press), (gpointer)this );
+    g_signal_connect (m_widget, "button_press_event",
+                      G_CALLBACK (gtk_popup_button_press), this);
 
     return TRUE;
 }

src/gtk/radiobox.cpp

@@ -86,7 +86,7 @@ static gint gtk_radiobox_keypress_callback( GtkWidget *widget, GdkEventKey *gdk_
         return FALSE;
     }
 
-    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+    g_signal_stop_emission_by_name (widget, "key_press_event");
 
     if ((gdk_event->keyval == GDK_Up) ||
         (gdk_event->keyval == GDK_Left))
@@ -234,8 +234,8 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
         m_radio = GTK_RADIO_BUTTON( gtk_radio_button_new_with_label( radio_button_group, wxGTK_CONV( label ) ) );
         gtk_widget_show( GTK_WIDGET(m_radio) );
 
-        gtk_signal_connect( GTK_OBJECT(m_radio), "key_press_event",
-           GTK_SIGNAL_FUNC(gtk_radiobox_keypress_callback), (gpointer)this );
+        g_signal_connect (m_radio, "key_press_event",
+                          G_CALLBACK (gtk_radiobox_keypress_callback), this);
 
         m_boxes.Append( (wxObject*) m_radio );
 
@@ -262,14 +262,12 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
 
         if (!i) gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(m_radio), TRUE );
 
-        gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
-            GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
-
-        gtk_signal_connect( GTK_OBJECT(m_radio), "focus_in_event",
-            GTK_SIGNAL_FUNC(gtk_radiobutton_focus_in), (gpointer)this );
-
-        gtk_signal_connect( GTK_OBJECT(m_radio), "focus_out_event",
-            GTK_SIGNAL_FUNC(gtk_radiobutton_focus_out), (gpointer)this );
+        g_signal_connect (m_radio, "clicked",
+                          G_CALLBACK (gtk_radiobutton_clicked_callback), this);
+        g_signal_connect (m_radio, "focus_in_event",
+                          G_CALLBACK (gtk_radiobutton_focus_in), this);
+        g_signal_connect (m_radio, "focus_out_event",
+                          G_CALLBACK (gtk_radiobutton_focus_out), this);
     }
 
     m_parent->DoAddChild( this );
@@ -502,8 +500,9 @@ void wxRadioBox::GtkDisableEvents()
     wxList::compatibility_iterator node = m_boxes.GetFirst();
     while (node)
     {
-        gtk_signal_disconnect_by_func( GTK_OBJECT(node->GetData()),
-           GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
+        g_signal_handlers_disconnect_by_func (node->GetData(),
+                                              (gpointer) gtk_radiobutton_clicked_callback,
+                                              this);
 
         node = node->GetNext();
     }
@@ -514,8 +513,8 @@ void wxRadioBox::GtkEnableEvents()
     wxList::compatibility_iterator node = m_boxes.GetFirst();
     while (node)
     {
-        gtk_signal_connect( GTK_OBJECT(node->GetData()), "clicked",
-           GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
+        g_signal_connect (node->GetData(), "clicked",
+                          G_CALLBACK (gtk_radiobutton_clicked_callback), this);
 
         node = node->GetNext();
     }

src/gtk/radiobut.cpp

@@ -111,8 +111,8 @@ bool wxRadioButton::Create( wxWindow *parent,
 
     SetLabel(label);
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "clicked",
-      GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
+    g_signal_connect (m_widget, "clicked",
+                      G_CALLBACK (gtk_radiobutton_clicked_callback), this);
 
     m_parent->DoAddChild( this );
 

src/gtk/scrolbar.cpp

@@ -188,18 +188,14 @@ bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
 
     m_adjust = gtk_range_get_adjustment( GTK_RANGE(m_widget) );
 
-    gtk_signal_connect( GTK_OBJECT(m_adjust),
-                        "value_changed",
-                        (GtkSignalFunc) gtk_scrollbar_callback,
-                        (gpointer) this );
-    gtk_signal_connect( GTK_OBJECT(m_widget),
-                        "button_press_event",
-                        (GtkSignalFunc)gtk_scrollbar_button_press_callback,
-                        (gpointer) this );
-    gtk_signal_connect( GTK_OBJECT(m_widget),
-                        "button_release_event",
-                        (GtkSignalFunc)gtk_scrollbar_button_release_callback,
-                        (gpointer) this );
+    g_signal_connect (m_adjust, "value_changed",
+                      G_CALLBACK (gtk_scrollbar_callback), this);
+    g_signal_connect (m_widget, "button_press_event",
+                      G_CALLBACK (gtk_scrollbar_button_press_callback),
+                      this);
+    g_signal_connect (m_widget, "button_release_event",
+                      G_CALLBACK (gtk_scrollbar_button_release_callback),
+                      this);
 
     m_parent->DoAddChild( this );
 
@@ -238,16 +234,14 @@ void wxScrollBar::SetThumbPosition( int viewStart )
     if (fabs(fpos-m_adjust->value) < 0.2) return;
     m_adjust->value = fpos;
 
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_adjust),
-                        (GtkSignalFunc) gtk_scrollbar_callback,
-                        (gpointer) this );
+    g_signal_handlers_disconnect_by_func (m_adjust,
+                                          (gpointer) gtk_scrollbar_callback,
+                                          this);
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "value_changed" );
+    g_signal_emit_by_name (m_adjust, "value_changed");
 
-    gtk_signal_connect( GTK_OBJECT(m_adjust),
-                        "value_changed",
-                        (GtkSignalFunc) gtk_scrollbar_callback,
-                        (gpointer) this );
+    g_signal_connect (m_adjust, "value_changed",
+                      G_CALLBACK (gtk_scrollbar_callback), this);
 }
 
 void wxScrollBar::SetScrollbar( int position, int thumbSize, int range, int pageSize,
@@ -275,7 +269,7 @@ void wxScrollBar::SetScrollbar( int position, int thumbSize, int range, int page
     m_adjust->page_increment = (float)(wxMax(fpage,0));
     m_adjust->page_size = fthumb;
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+    g_signal_emit_by_name (m_adjust, "changed");
 }
 
 /* Backward compatibility */

src/gtk/scrolwin.cpp

@@ -117,14 +117,14 @@ void wxScrollHelperNative::DoAdjustScrollbar(GtkAdjustment *adj,
             else
             {
                 // We need to actually scroll window
-                gtk_signal_emit_by_name( GTK_OBJECT(adj), "value_changed" );
+                g_signal_emit_by_name (adj, "value_changed");
             }
         }
     }
 
     *lines = (int)(adj->upper + 0.5);
     *linesPerPage = (int)(adj->page_increment + 0.5);
-    gtk_signal_emit_by_name( GTK_OBJECT(adj), "changed" );
+    g_signal_emit_by_name (adj, "changed");
 }
 
 void wxScrollHelperNative::AdjustScrollbars()

src/gtk/slider.cpp

@@ -202,14 +202,12 @@ bool wxSlider::Create(wxWindow *parent, wxWindowID id,
         gtk_range_set_inverted( GTK_RANGE(m_widget), TRUE );
 
     GtkEnableEvents();
-    gtk_signal_connect( GTK_OBJECT(m_widget),
-                        "button_press_event",
-                        (GtkSignalFunc)gtk_slider_button_press_callback,
-                        (gpointer) this );
-    gtk_signal_connect( GTK_OBJECT(m_widget),
-                        "button_release_event",
-                        (GtkSignalFunc)gtk_slider_button_release_callback,
-                        (gpointer) this );
+    g_signal_connect (m_widget, "button_press_event",
+                      G_CALLBACK (gtk_slider_button_press_callback),
+                      this);
+    g_signal_connect (m_widget, "button_release_event",
+                      G_CALLBACK (gtk_slider_button_release_callback),
+                      this);
 
     SetRange( minValue, maxValue );
     SetValue( value );
@@ -237,7 +235,7 @@ void wxSlider::SetValue( int value )
 
     GtkDisableEvents();
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "value_changed" );
+    g_signal_emit_by_name (m_adjust, "value_changed");
 
     GtkEnableEvents();
 }
@@ -260,7 +258,7 @@ void wxSlider::SetRange( int minValue, int maxValue )
 
     GtkDisableEvents();
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+    g_signal_emit_by_name (m_adjust, "changed");
 
     GtkEnableEvents();
 }
@@ -285,7 +283,7 @@ void wxSlider::SetPageSize( int pageSize )
 
     GtkDisableEvents();
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+    g_signal_emit_by_name (m_adjust, "changed");
 
     GtkEnableEvents();
 }
@@ -305,7 +303,7 @@ void wxSlider::SetThumbLength( int len )
 
     GtkDisableEvents();
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+    g_signal_emit_by_name (m_adjust, "changed");
 
     GtkEnableEvents();
 }
@@ -332,17 +330,15 @@ bool wxSlider::IsOwnGtkWindow( GdkWindow *window )
 
 void wxSlider::GtkDisableEvents()
 {
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_adjust),
-                        GTK_SIGNAL_FUNC(gtk_slider_callback),
-                        (gpointer) this );
+    g_signal_handlers_disconnect_by_func (m_adjust,
+                                          (gpointer) gtk_slider_callback,
+                                          this);
 }
 
 void wxSlider::GtkEnableEvents()
 {
-    gtk_signal_connect( GTK_OBJECT (m_adjust),
-                        "value_changed",
-                        GTK_SIGNAL_FUNC(gtk_slider_callback),
-                        (gpointer) this );
+    g_signal_connect (m_adjust, "value_changed",
+                      G_CALLBACK (gtk_slider_callback), this);
 }
 
 // static

src/gtk/spinbutt.cpp

@@ -69,16 +69,14 @@ static void gtk_spinbutt_callback( GtkWidget *WXUNUSED(widget), wxSpinButton *wi
         /* program has vetoed */
         win->m_adjust->value = win->m_oldPos;
 
-        gtk_signal_disconnect_by_func( GTK_OBJECT (win->m_adjust),
-                                       (GtkSignalFunc) gtk_spinbutt_callback,
-                                       (gpointer) win );
+        g_signal_handlers_disconnect_by_func (win->m_adjust,
+                                              (gpointer) gtk_spinbutt_callback,
+                                              win);
 
-        gtk_signal_emit_by_name( GTK_OBJECT(win->m_adjust), "value_changed" );
+        g_signal_emit_by_name (win->m_adjust, "value_changed");
 
-        gtk_signal_connect( GTK_OBJECT (win->m_adjust),
-                            "value_changed",
-                            (GtkSignalFunc) gtk_spinbutt_callback,
-                            (gpointer) win );
+        g_signal_connect (win->m_adjust, "value_changed",
+                          G_CALLBACK (gtk_spinbutt_callback), win);
         return;
     }
 
@@ -138,10 +136,8 @@ bool wxSpinButton::Create(wxWindow *parent,
     gtk_spin_button_set_wrap( GTK_SPIN_BUTTON(m_widget),
                               (int)(m_windowStyle & wxSP_WRAP) );
 
-    gtk_signal_connect( GTK_OBJECT (m_adjust),
-                        "value_changed",
-                        (GtkSignalFunc) gtk_spinbutt_callback,
-                        (gpointer) this );
+    g_signal_connect (m_adjust, "value_changed",
+                      G_CALLBACK (gtk_spinbutt_callback), this);
 
     m_parent->DoAddChild( this );
 
@@ -181,7 +177,7 @@ void wxSpinButton::SetValue( int value )
 
     m_adjust->value = fpos;
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "value_changed" );
+    g_signal_emit_by_name (m_adjust, "value_changed");
 }
 
 void wxSpinButton::SetRange(int minVal, int maxVal)
@@ -200,7 +196,7 @@ void wxSpinButton::SetRange(int minVal, int maxVal)
     m_adjust->lower = fmin;
     m_adjust->upper = fmax;
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+    g_signal_emit_by_name (m_adjust, "changed");
 
     // these two calls are required due to some bug in GTK
     Refresh();

src/gtk/spinctrl.cpp

@@ -133,26 +133,22 @@ bool wxSpinCtrl::Create(wxWindow *parent, wxWindowID id,
 
 void wxSpinCtrl::GtkDisableEvents()
 {
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_adjust),
-                        GTK_SIGNAL_FUNC(gtk_spinctrl_callback),
-                        (gpointer) this );
-
-    gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
-                        GTK_SIGNAL_FUNC(gtk_spinctrl_text_changed_callback),
-                        (gpointer) this );
+    g_signal_handlers_disconnect_by_func (m_adjust,
+                                          (gpointer) gtk_spinctrl_callback,
+                                          this);
+    g_signal_handlers_disconnect_by_func (m_widget,
+                                          (gpointer) gtk_spinctrl_text_changed_callback,
+                                          this);
 }
 
 void wxSpinCtrl::GtkEnableEvents()
 {
-    gtk_signal_connect( GTK_OBJECT (m_adjust),
-                        "value_changed",
-                        GTK_SIGNAL_FUNC(gtk_spinctrl_callback),
-                        (gpointer) this );
-
-    gtk_signal_connect( GTK_OBJECT(m_widget),
-                        "changed",
-                        GTK_SIGNAL_FUNC(gtk_spinctrl_text_changed_callback),
-                        (gpointer)this);
+    g_signal_connect (m_adjust, "value_changed",
+                      G_CALLBACK (gtk_spinctrl_callback),
+                      this);
+    g_signal_connect (m_widget, "changed",
+                      G_CALLBACK (gtk_spinctrl_text_changed_callback),
+                      this);
 }
 
 int wxSpinCtrl::GetMin() const
@@ -208,7 +204,7 @@ void wxSpinCtrl::SetValue( int value )
     m_adjust->value = fpos;
 
     GtkDisableEvents();
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "value_changed" );
+    g_signal_emit_by_name (m_adjust, "value_changed");
     GtkEnableEvents();
 }
 
@@ -241,7 +237,7 @@ void wxSpinCtrl::SetRange(int minVal, int maxVal)
     m_adjust->lower = fmin;
     m_adjust->upper = fmax;
 
-    gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+    g_signal_emit_by_name (m_adjust, "changed");
 
     // these two calls are required due to some bug in GTK
     Refresh();

src/gtk/stattext.cpp

@@ -94,12 +94,9 @@ bool wxStaticText::Create(wxWindow *parent,
         // always shrinks to its minimal size for some reason and so no
         // alignment except the default left doesn't work (in fact it does,
         // but you don't see it)
-        gtk_signal_disconnect_by_func
-        (
-            GTK_OBJECT(m_widget),
-            GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
-            (gpointer) this
-        );
+        g_signal_handlers_disconnect_by_func (m_widget,
+                                              (gpointer) wxgtk_window_size_request_callback,
+                                              this);
     }
 
     return TRUE;

src/gtk/taskbar.cpp

@@ -98,10 +98,9 @@ bool wxTaskBarIconAreaBase::DoPopupMenu( wxMenu *menu, int x, int y )
 
     bool is_waiting = true;
 
-    gulong handler = gtk_signal_connect( GTK_OBJECT(menu->m_menu),
-                                         "hide",
-                                         GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
-                                         (gpointer)&is_waiting );
+    gulong handler = g_signal_connect (menu->m_menu, "hide",
+                                       G_CALLBACK (gtk_pop_hide_callback),
+                                       &is_waiting);
 
     wxPoint pos;
     gpointer userdata;
@@ -134,7 +133,7 @@ bool wxTaskBarIconAreaBase::DoPopupMenu( wxMenu *menu, int x, int y )
         gtk_main_iteration();
     }
 
-    gtk_signal_disconnect(GTK_OBJECT(menu->m_menu), handler);
+    g_signal_handler_disconnect (menu->m_menu, handler);
 
     return true;
 }

src/gtk/tbargtk.cpp

@@ -456,14 +456,12 @@ bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
                     return false;
                 }
 
-                gtk_signal_connect( GTK_OBJECT(tool->m_item),
-                                    "enter_notify_event",
-                                    GTK_SIGNAL_FUNC(gtk_toolbar_tool_callback),
-                                    (gpointer)tool );
-                gtk_signal_connect( GTK_OBJECT(tool->m_item),
-                                    "leave_notify_event",
-                                    GTK_SIGNAL_FUNC(gtk_toolbar_tool_callback),
-                                    (gpointer)tool );
+                g_signal_connect (tool->m_item, "enter_notify_event",
+                                  G_CALLBACK (gtk_toolbar_tool_callback),
+                                  tool);
+                g_signal_connect (tool->m_item, "leave_notify_event",
+                                  G_CALLBACK (gtk_toolbar_tool_callback),
+                                  tool);
             }
             break;
 

src/gtk/textctrl.cpp

@@ -3,7 +3,7 @@
 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$
-// Copyright:   (c) 1998 Robert Roebling, Vadim Zeitlin
+// Copyright:   (c) 1998 Robert Roebling, Vadim Zeitlin, 2005 Mart Raudsepp
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -58,7 +58,7 @@ static void wxGtkOnRemoveTag(GtkTextBuffer *buffer,
 
     if (!name || strncmp(name, prefix, strlen(prefix)))
         // anonymous tag or not starting with prefix - don't remove
-        g_signal_stop_emission_by_name(buffer, "remove_tag");
+        g_signal_stop_emission_by_name (buffer, "remove_tag");
 
     g_free(name);
 }
@@ -73,10 +73,10 @@ static void wxGtkTextApplyTagsFromAttr(GtkTextBuffer *text_buffer,
     static gchar buf[1024];
     GtkTextTag *tag;
 
-    gulong remove_handler_id = g_signal_connect( text_buffer, "remove_tag",
-            G_CALLBACK(wxGtkOnRemoveTag), gpointer("WX"));
+    gulong remove_handler_id = g_signal_connect (text_buffer, "remove_tag",
+            G_CALLBACK (wxGtkOnRemoveTag), gpointer("WX"));
     gtk_text_buffer_remove_all_tags(text_buffer, start, end);
-    g_signal_handler_disconnect( text_buffer, remove_handler_id );
+    g_signal_handler_disconnect (text_buffer, remove_handler_id);
 
     if (attr.HasFont())
     {
@@ -128,11 +128,11 @@ static void wxGtkTextApplyTagsFromAttr(GtkTextBuffer *text_buffer,
                                           gtk_text_iter_get_line(start) );
         gtk_text_iter_forward_line(&para_end);
 
-        remove_handler_id = g_signal_connect( text_buffer, "remove_tag",
+        remove_handler_id = g_signal_connect (text_buffer, "remove_tag",
                                               G_CALLBACK(wxGtkOnRemoveTag),
                                               gpointer("WXALIGNMENT"));
         gtk_text_buffer_remove_all_tags( text_buffer, &para_start, &para_end );
-        g_signal_handler_disconnect( text_buffer, remove_handler_id );
+        g_signal_handler_disconnect (text_buffer, remove_handler_id);
 
         GtkJustification align;
         switch (attr.GetAlignment())
@@ -208,7 +208,7 @@ gtk_insert_text_callback(GtkEditable *editable,
     if ( entry->text_length == entry->text_max_length )
     {
         // we don't need to run the base class version at all
-        gtk_signal_emit_stop_by_name(GTK_OBJECT(editable), "insert_text");
+        g_signal_stop_emission_by_name (editable, "insert_text");
 
         // remember that the next changed signal is to be ignored to avoid
         // generating a dummy wxEVT_COMMAND_TEXT_UPDATED event
@@ -234,7 +234,7 @@ au_apply_tag_callback(GtkTextBuffer *buffer,
                       gpointer textctrl)
 {
     if(tag == gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl"))
-        g_signal_stop_emission_by_name(buffer, "apply_tag");
+        g_signal_stop_emission_by_name (buffer, "apply_tag");
 }
 }
 
@@ -330,14 +330,14 @@ au_check_word( GtkTextIter *s, GtkTextIter *e )
 
     if(n < WXSIZEOF(URIPrefixes))
     {
-        gulong signal_id = g_signal_handler_find(buffer,
+        gulong signal_id = g_signal_handler_find (buffer,
                                                   (GSignalMatchType) (G_SIGNAL_MATCH_FUNC),
                                                   0, 0, NULL,
                                                   (gpointer)au_apply_tag_callback, NULL);
 
-        g_signal_handler_block(buffer, signal_id);
+        g_signal_handler_block (buffer, signal_id);
         gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
-        g_signal_handler_unblock(buffer, signal_id);
+        g_signal_handler_unblock (buffer, signal_id);
     }
 }
 }
@@ -664,8 +664,8 @@ bool wxTextCtrl::Create( wxWindow *parent,
     // We want to be notified about text changes.
     if (multi_line)
     {
-        g_signal_connect( G_OBJECT(m_buffer), "changed",
-            GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
+        g_signal_connect (m_buffer, "changed",
+                          G_CALLBACK (gtk_text_changed_callback), this);
 
         // .. and handle URLs on multi-line controls with wxTE_AUTO_URL style
         if (style & wxTE_AUTO_URL)
@@ -683,10 +683,10 @@ bool wxTextCtrl::Create( wxWindow *parent,
                                        NULL);
 
             // Check for URLs after each text change
-            g_signal_connect_after( G_OBJECT(m_buffer), "insert_text",
-                GTK_SIGNAL_FUNC(au_insert_text_callback), (gpointer)this);
-            g_signal_connect_after( G_OBJECT(m_buffer), "delete_range",
-                GTK_SIGNAL_FUNC(au_delete_range_callback), (gpointer)this);
+            g_signal_connect_after (m_buffer, "insert_text",
+                                    G_CALLBACK (au_insert_text_callback), this);
+            g_signal_connect_after (m_buffer, "delete_range",
+                                    G_CALLBACK (au_delete_range_callback), this);
 
             // Block all wxUrl tag applying unless we do it ourselves, in which case we
             // block this callback temporarily. This takes care of gtk+ internal
@@ -694,8 +694,8 @@ bool wxTextCtrl::Create( wxWindow *parent,
             // which is undesired because only a part of the URL might be copied.
             // The insert-text signal emitted inside it will take care of newly formed
             // or wholly copied URLs.
-            g_signal_connect( G_OBJECT(m_buffer), "apply_tag",
-                GTK_SIGNAL_FUNC(au_apply_tag_callback), NULL);
+            g_signal_connect (m_buffer, "apply_tag",
+                              G_CALLBACK (au_apply_tag_callback), NULL);
 
             // Check for URLs in the initial string passed to Create
             gtk_text_buffer_get_start_iter(m_buffer, &start);
@@ -705,8 +705,8 @@ bool wxTextCtrl::Create( wxWindow *parent,
     }
     else
     {
-        gtk_signal_connect( GTK_OBJECT(m_text), "changed",
-            GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
+        g_signal_connect (m_text, "changed",
+                          G_CALLBACK (gtk_text_changed_callback), this);
     }
 
     m_cursor = wxCursor( wxCURSOR_IBEAM );
@@ -1099,19 +1099,13 @@ void wxTextCtrl::SetMaxLength(unsigned long len)
         // we shouldn't check anything any more
         if ( len )
         {
-            gtk_signal_connect( GTK_OBJECT(m_text),
-                                "insert_text",
-                                GTK_SIGNAL_FUNC(gtk_insert_text_callback),
-                                (gpointer)this);
+            g_signal_connect (m_text, "insert_text",
+                              G_CALLBACK (gtk_insert_text_callback), this);
         }
         else // no checking
         {
-            gtk_signal_disconnect_by_func
-            (
-                GTK_OBJECT(m_text),
-                GTK_SIGNAL_FUNC(gtk_insert_text_callback),
-                (gpointer)this
-            );
+            g_signal_handlers_disconnect_by_func (m_text,
+                    (gpointer) gtk_insert_text_callback, this);
         }
     }
 }
@@ -1256,7 +1250,7 @@ void wxTextCtrl::Cut()
     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 
     if (m_windowStyle & wxTE_MULTILINE)
-        g_signal_emit_by_name(m_text, "cut-clipboard");
+        g_signal_emit_by_name (m_text, "cut-clipboard");
     else
         gtk_editable_cut_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
 }
@@ -1266,7 +1260,7 @@ void wxTextCtrl::Copy()
     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 
     if (m_windowStyle & wxTE_MULTILINE)
-        g_signal_emit_by_name(m_text, "copy-clipboard");
+        g_signal_emit_by_name (m_text, "copy-clipboard");
     else
         gtk_editable_copy_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
 }
@@ -1276,7 +1270,7 @@ void wxTextCtrl::Paste()
     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 
     if (m_windowStyle & wxTE_MULTILINE)
-        g_signal_emit_by_name(m_text, "paste-clipboard");
+        g_signal_emit_by_name (m_text, "paste-clipboard");
     else
         gtk_editable_paste_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
 }
@@ -1628,10 +1622,10 @@ void wxTextCtrl::Freeze()
         if ( !m_frozenness++ )
         {
             // freeze textview updates and remove buffer
-            g_signal_connect( G_OBJECT(m_text), "expose_event",
-                GTK_SIGNAL_FUNC(gtk_text_exposed_callback), (gpointer)this);
-            g_signal_connect( G_OBJECT(m_widget), "expose_event",
-                GTK_SIGNAL_FUNC(gtk_text_exposed_callback), (gpointer)this);
+            g_signal_connect (m_text, "expose_event",
+                              G_CALLBACK (gtk_text_exposed_callback), this);
+            g_signal_connect (m_widget, "expose_event",
+                              G_CALLBACK (gtk_text_exposed_callback), this);
             gtk_widget_set_sensitive(m_widget, false);
             g_object_ref(m_buffer);
             gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), gtk_text_buffer_new(NULL));
@@ -1651,8 +1645,10 @@ void wxTextCtrl::Thaw()
             gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), m_buffer);
             g_object_unref(m_buffer);
             gtk_widget_set_sensitive(m_widget, true);
-            g_signal_handlers_disconnect_by_func(m_widget, (gpointer)gtk_text_exposed_callback, this);
-            g_signal_handlers_disconnect_by_func(m_text, (gpointer)gtk_text_exposed_callback, this);
+            g_signal_handlers_disconnect_by_func (m_widget,
+                    (gpointer) gtk_text_exposed_callback, this);
+            g_signal_handlers_disconnect_by_func (m_text,
+                    (gpointer) gtk_text_exposed_callback, this);
         }
     }
 }

src/gtk/tglbtn.cpp

@@ -83,9 +83,9 @@ bool wxToggleBitmapButton::Create(wxWindow *parent, wxWindowID id,
         OnSetBitmap();
     }
 
-    gtk_signal_connect(GTK_OBJECT(m_widget), "clicked",
-                      GTK_SIGNAL_FUNC(gtk_togglebutton_clicked_callback),
-                      (gpointer *)this);
+    g_signal_connect (m_widget, "clicked",
+                      G_CALLBACK (gtk_togglebutton_clicked_callback),
+                      this);
 
     m_parent->DoAddChild(this);
 
@@ -247,9 +247,9 @@ bool wxToggleButton::Create(wxWindow *parent, wxWindowID id,
     // Create the gtk widget.
     m_widget = gtk_toggle_button_new_with_label( wxGTK_CONV( m_label ) );
 
-    gtk_signal_connect(GTK_OBJECT(m_widget), "clicked",
-                       GTK_SIGNAL_FUNC(gtk_togglebutton_clicked_callback),
-                       (gpointer *)this);
+    g_signal_connect (m_widget, "clicked",
+                      G_CALLBACK (gtk_togglebutton_clicked_callback),
+                      this);
 
     m_parent->DoAddChild(this);
 

src/gtk/toplevel.cpp

@@ -223,7 +223,7 @@ static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUS
         wxapp_install_idle_handler();
 
     // This disables GTK's tab traversal
-    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
+    g_signal_stop_emission_by_name (widget, "focus");
     return TRUE;
 }
 }
@@ -561,8 +561,8 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
-    gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
-        GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
+    g_signal_connect (m_widget, "delete_event",
+                      G_CALLBACK (gtk_frame_delete_callback), this);
 
     // m_mainWidget holds the toolbar, the menubar and the client area
     m_mainWidget = gtk_pizza_new();
@@ -573,8 +573,8 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
     if (m_miniEdge == 0) // wxMiniFrame has its own version.
     {
        // For m_mainWidget themes
-       gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
-                GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+       g_signal_connect (m_mainWidget, "expose_event",
+                         G_CALLBACK (gtk_window_expose_callback), this);
     }
 
     // m_wxwindow only represents the client area without toolbar and menubar
@@ -589,8 +589,8 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
     if (m_parent) m_parent->AddChild( this );
 
     // the user resized the frame by dragging etc.
-    gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
-        GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
+    g_signal_connect (m_widget, "size_allocate",
+                      G_CALLBACK (gtk_frame_size_callback), this);
 
     PostCreation();
 
@@ -601,28 +601,28 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 
     //  we cannot set MWM hints and icons before the widget has
     //  been realized, so we do this directly after realization
-    gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
-                        GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this );
+    g_signal_connect (m_widget, "realize",
+                      G_CALLBACK (gtk_frame_realized_callback), this);
 
     // map and unmap for iconized state
-    gtk_signal_connect( GTK_OBJECT(m_widget), "map_event",
-        GTK_SIGNAL_FUNC(gtk_frame_map_callback), (gpointer)this );
-    gtk_signal_connect( GTK_OBJECT(m_widget), "unmap_event",
-        GTK_SIGNAL_FUNC(gtk_frame_unmap_callback), (gpointer)this );
+    g_signal_connect (m_widget, "map_event",
+                      G_CALLBACK (gtk_frame_map_callback), this);
+    g_signal_connect (m_widget, "unmap_event",
+                      G_CALLBACK (gtk_frame_unmap_callback), this);
 
     // the only way to get the window size is to connect to this event
-    gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
-        GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
+    g_signal_connect (m_widget, "configure_event",
+                      G_CALLBACK (gtk_frame_configure_callback), this);
 
     // disable native tab traversal
-    gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
-        GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
+    g_signal_connect (m_widget, "focus",
+                      G_CALLBACK (gtk_frame_focus_callback), this);
 
     // activation
-    gtk_signal_connect( GTK_OBJECT(m_widget), "focus_in_event",
-        GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback), (gpointer)this );
-    gtk_signal_connect( GTK_OBJECT(m_widget), "focus_out_event",
-        GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback), (gpointer)this );
+    g_signal_connect (m_widget, "focus_in_event",
+                      G_CALLBACK (gtk_frame_focus_in_callback), this);
+    g_signal_connect (m_widget, "focus_out_event",
+                      G_CALLBACK (gtk_frame_focus_out_callback), this);
 
     // decorations
     if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))

src/gtk/treegtk.cpp

@@ -534,16 +534,14 @@ printf("m_tree = %p\n", m_tree);
 
   gtk_widget_show(GTK_WIDGET(item));
 
-  gtk_signal_connect(GTK_OBJECT(item), "select",
-    GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
-
-  gtk_signal_connect(GTK_OBJECT(item), "deselect",
-    GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
-
-  gtk_signal_connect(GTK_OBJECT(item), "expand",
-    GTK_SIGNAL_FUNC(gtk_treeitem_expand_callback), (gpointer)this );
-  gtk_signal_connect(GTK_OBJECT(item), "collapse",
-    GTK_SIGNAL_FUNC(gtk_treeitem_collapse_callback), (gpointer)this );
+  g_signal_connect (item, "select",
+                    G_CALLBACK (gtk_treeitem_select_callback), this);
+  g_signal_connect (item, "deselect",
+                    G_CALLBACK (gtk_treeitem_select_callback), this);
+  g_signal_connect (item, "expand",
+                    G_CALLBACK (gtk_treeitem_expand_callback), this);
+  g_signal_connect (item, "collapse",
+                    G_CALLBACK (gtk_treeitem_collapse_callback), this);
 
   return item;
 }
@@ -856,16 +854,14 @@ long wxTreeCtrl::InsertItem(long parent, wxTreeItem& info, long insertAfter) {
 
   gtk_widget_show(GTK_WIDGET(item));
 
-  gtk_signal_connect(GTK_OBJECT(item), "select",
-    GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
-
-  gtk_signal_connect(GTK_OBJECT(item), "deselect",
-    GTK_SIGNAL_FUNC(gtk_treeitem_select_callback), (gpointer)this );
-
-  gtk_signal_connect(GTK_OBJECT(item), "expand",
-    GTK_SIGNAL_FUNC(gtk_treeitem_expand_callback), (gpointer)this );
-  gtk_signal_connect(GTK_OBJECT(item), "collapse",
-    GTK_SIGNAL_FUNC(gtk_treeitem_collapse_callback), (gpointer)this );
+  g_signal_connect (item, "select",
+                    G_CALLBACK (gtk_treeitem_select_callback), this);
+  g_signal_connect (item, "deselect",
+                    G_CALLBACK (gtk_treeitem_select_callback), this);
+  g_signal_connect (item, "expand",
+                    G_CALLBACK (gtk_treeitem_expand_callback), this);
+  g_signal_connect (item, "collapse",
+                    G_CALLBACK (gtk_treeitem_collapse_callback), this);
 
   return info.m_itemId;
 }

src/gtk/window.cpp

@@ -1147,7 +1147,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget,
 
     if (ret)
     {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+        g_signal_stop_emission_by_name (widget, "key_press_event");
         return TRUE;
     }
 
@@ -1242,7 +1242,7 @@ static gint gtk_window_key_release_callback( GtkWidget *widget,
     if ( !win->GetEventHandler()->ProcessEvent( event ) )
         return FALSE;
 
-    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
+    g_signal_stop_emission_by_name (widget, "key_release_event");
     return TRUE;
 }
 }
@@ -1550,7 +1550,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget,
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
+        g_signal_stop_emission_by_name (widget, "button_press_event");
         return TRUE;
     }
 
@@ -1629,7 +1629,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget,
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
+        g_signal_stop_emission_by_name (widget, "button_release_event");
         return TRUE;
     }
 
@@ -1705,7 +1705,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
+        g_signal_stop_emission_by_name (widget, "motion_notify_event");
         return TRUE;
     }
 
@@ -1762,7 +1762,7 @@ static gint gtk_window_wheel_callback (GtkWidget * widget,
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "scroll_event" );
+        g_signal_stop_emission_by_name (widget, "scroll_event");
         return TRUE;
     }
 
@@ -1845,7 +1845,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget,
 
         if ( DoSendFocusEvents(win) )
         {
-           gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
+           g_signal_stop_emission_by_name (widget, "focus_in_event");
            return TRUE;
         }
     }
@@ -1950,7 +1950,7 @@ gint gtk_window_enter_callback( GtkWidget *widget,
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
-       gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
+       g_signal_stop_emission_by_name (widget, "enter_notify_event");
        return TRUE;
     }
 
@@ -2002,7 +2002,7 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
 
     if (win->GetEventHandler()->ProcessEvent( event ))
     {
-        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
+        g_signal_stop_emission_by_name (widget, "leave_notify_event");
         return TRUE;
     }
 
@@ -2555,39 +2555,35 @@ bool wxWindowGTK::Create( wxWindow *parent,
     m_vAdjust->step_increment = 1.0;
     m_vAdjust->page_increment = 1.0;
     m_vAdjust->page_size = 5.0;
-    gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
+    g_signal_emit_by_name (m_vAdjust, "changed");
     m_hAdjust->lower = 0.0;
     m_hAdjust->upper = 1.0;
     m_hAdjust->value = 0.0;
     m_hAdjust->step_increment = 1.0;
     m_hAdjust->page_increment = 1.0;
     m_hAdjust->page_size = 5.0;
-    gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
+    g_signal_emit_by_name (m_hAdjust, "changed");
 
     // these handlers block mouse events to any window during scrolling such as
     // motion events and prevent GTK and wxWidgets from fighting over where the
     // slider should be
-
-    gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
-          (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
-
-    gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
-          (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
-
-    gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
-          (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
-
-    gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
-          (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
+    g_signal_connect (scrolledWindow->vscrollbar, "button_press_event",
+                      G_CALLBACK (gtk_scrollbar_button_press_callback), this);
+    g_signal_connect (scrolledWindow->hscrollbar, "button_press_event",
+                      G_CALLBACK (gtk_scrollbar_button_press_callback), this);
+    g_signal_connect (scrolledWindow->vscrollbar, "button_release_event",
+                      G_CALLBACK (gtk_scrollbar_button_release_callback), this);
+    g_signal_connect (scrolledWindow->hscrollbar, "button_release_event",
+                      G_CALLBACK (gtk_scrollbar_button_release_callback), this);
 
     // these handlers get notified when screen updates are required either when
     // scrolling or when the window size (and therefore scrollbar configuration)
     // has changed
 
-    gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
-          (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
-    gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
-          (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
+    g_signal_connect (m_hAdjust, "value_changed",
+                      G_CALLBACK (gtk_window_hscroll_callback), this);
+    g_signal_connect (m_vAdjust, "value_changed",
+                      G_CALLBACK (gtk_window_vscroll_callback), this);
 
     gtk_widget_show( m_wxwindow );
 
@@ -2621,10 +2617,12 @@ wxWindowGTK::~wxWindowGTK()
     // propagated to this (soon to be) dead object
     if (m_focusWidget != NULL)
     {
-        gtk_signal_disconnect_by_func( GTK_OBJECT(m_focusWidget),
-            (GtkSignalFunc) gtk_window_focus_in_callback, (gpointer) this );
-        gtk_signal_disconnect_by_func( GTK_OBJECT(m_focusWidget),
-            (GtkSignalFunc) gtk_window_focus_out_callback, (gpointer) this );
+        g_signal_handlers_disconnect_by_func (m_focusWidget,
+                                              (gpointer) gtk_window_focus_in_callback,
+                                              this);
+        g_signal_handlers_disconnect_by_func (m_focusWidget,
+                                              (gpointer) gtk_window_focus_out_callback,
+                                              this);
     }
 
     if (m_widget)
@@ -2680,8 +2678,8 @@ void wxWindowGTK::PostCreation()
 
             gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
 
-            gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
-                GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
+            g_signal_connect (m_wxwindow, "expose_event",
+                              G_CALLBACK (gtk_window_expose_callback), this);
 
             // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
         }
@@ -2692,13 +2690,12 @@ void wxWindowGTK::PostCreation()
         // Cannot handle drawing preedited text yet
         gtk_im_context_set_use_preedit( m_imData->context, FALSE );
 
-        g_signal_connect (G_OBJECT (m_imData->context), "commit",
+        g_signal_connect (m_imData->context, "commit",
                           G_CALLBACK (gtk_wxwindow_commit_cb), this);
 
         // these are called when the "sunken" or "raised" borders are drawn
-        gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
-          GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
-
+        g_signal_connect (m_widget, "expose_event",
+                          G_CALLBACK (gtk_window_own_expose_callback), this);
     }
 
     // focus handling
@@ -2708,11 +2705,10 @@ void wxWindowGTK::PostCreation()
         if (m_focusWidget == NULL)
             m_focusWidget = m_widget;
 
-        gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
-            GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
-
-        gtk_signal_connect_after( GTK_OBJECT(m_focusWidget), "focus_out_event",
-            GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
+        g_signal_connect (m_focusWidget, "focus_in_event",
+                          G_CALLBACK (gtk_window_focus_in_callback), this);
+        g_signal_connect_after (m_focusWidget, "focus_out_event",
+                                G_CALLBACK (gtk_window_focus_out_callback), this);
     }
 
     // connect to the various key and mouse handlers
@@ -2723,31 +2719,31 @@ void wxWindowGTK::PostCreation()
 
     /* We cannot set colours, fonts and cursors before the widget has
        been realized, so we do this directly after realization */
-    gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
-                            GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
+    g_signal_connect (connect_widget, "realize",
+                      G_CALLBACK (gtk_window_realized_callback), this);
 
     if (m_wxwindow)
     {
         // Catch native resize events
-        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
-                            GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
+        g_signal_connect (m_wxwindow, "size_allocate",
+                          G_CALLBACK (gtk_window_size_callback), this);
 
         // Initialize XIM support
-        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
-                            GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
+        g_signal_connect (m_wxwindow, "realize",
+                          G_CALLBACK (gtk_wxwindow_realized_callback), this);
 
         // And resize XIM window
-        gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
-                            GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
+        g_signal_connect (m_wxwindow, "size_allocate",
+                          G_CALLBACK (gtk_wxwindow_size_callback), this);
     }
 
     if (GTK_IS_COMBO(m_widget))
     {
         GtkCombo *gcombo = GTK_COMBO(m_widget);
 
-        gtk_signal_connect( GTK_OBJECT(gcombo->entry), "size_request",
-                            GTK_SIGNAL_FUNC(wxgtk_combo_size_request_callback),
-                            (gpointer) this );
+        g_signal_connect (gcombo->entry, "size_request",
+                          G_CALLBACK (wxgtk_combo_size_request_callback),
+                          this);
     }
     else
     {
@@ -2755,9 +2751,9 @@ void wxWindowGTK::PostCreation()
         // GTK controls, such as the toolbar. With this callback, the
         // toolbar gets to know the correct size (the one set by the
         // programmer). Sadly, it misbehaves for wxComboBox.
-        gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
-                            GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
-                            (gpointer) this );
+        g_signal_connect (m_widget, "size_request",
+                          G_CALLBACK (wxgtk_window_size_request_callback),
+                          this);
     }
 
     InheritAttributes();
@@ -2772,31 +2768,24 @@ void wxWindowGTK::PostCreation()
 
 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
 {
-    gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
-      GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
-      GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
-      GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
-      GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
-      GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
-      GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
-    g_signal_connect(widget, "popup_menu",
-        G_CALLBACK(wxgtk_window_popup_menu_callback), this);
-
-    gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
-      GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
-
-    gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
-      GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
+    g_signal_connect (widget, "key_press_event",
+                      G_CALLBACK (gtk_window_key_press_callback), this);
+    g_signal_connect (widget, "key_release_event",
+                      G_CALLBACK (gtk_window_key_release_callback), this);
+    g_signal_connect (widget, "button_press_event",
+                      G_CALLBACK (gtk_window_button_press_callback), this);
+    g_signal_connect (widget, "button_release_event",
+                      G_CALLBACK (gtk_window_button_release_callback), this);
+    g_signal_connect (widget, "motion_notify_event",
+                      G_CALLBACK (gtk_window_motion_notify_callback), this);
+    g_signal_connect (widget, "scroll_event",
+                      G_CALLBACK (gtk_window_wheel_callback), this);
+    g_signal_connect (widget, "popup_menu",
+                     G_CALLBACK (wxgtk_window_popup_menu_callback), this);
+    g_signal_connect (widget, "enter_notify_event",
+                      G_CALLBACK (gtk_window_enter_callback), this);
+    g_signal_connect (widget, "leave_notify_event",
+                      G_CALLBACK (gtk_window_leave_callback), this);
 }
 
 bool wxWindowGTK::Destroy()
@@ -4087,21 +4076,21 @@ void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
     }
 
     if (orient == wxHORIZONTAL)
-        gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
+        g_signal_emit_by_name (m_hAdjust, "changed");
     else
-        gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
+        g_signal_emit_by_name (m_vAdjust, "changed");
 }
 
 void wxWindowGTK::GtkUpdateScrollbar(int orient)
 {
     GtkAdjustment *adj = orient == wxHORIZONTAL ? m_hAdjust : m_vAdjust;
-    GtkSignalFunc fn = orient == wxHORIZONTAL
-                        ? (GtkSignalFunc)gtk_window_hscroll_callback
-                        : (GtkSignalFunc)gtk_window_vscroll_callback;
+    gpointer fn = orient == wxHORIZONTAL
+            ? (gpointer) gtk_window_hscroll_callback
+            : (gpointer) gtk_window_vscroll_callback;
 
-    gtk_signal_disconnect_by_func(GTK_OBJECT(adj), fn, (gpointer)this);
-    gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
-    gtk_signal_connect(GTK_OBJECT(adj), "value_changed", fn, (gpointer)this);
+    g_signal_handlers_disconnect_by_func (adj, fn, this);
+    g_signal_emit_by_name (adj, "value_changed");
+    g_signal_connect (adj, "value_changed", G_CALLBACK (fn), this);
 }
 
 void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )