OnSetBitmap();
}
- gtk_signal_connect_after( GTK_OBJECT(m_widget), "clicked",
- GTK_SIGNAL_FUNC(gtk_bmpbutton_clicked_callback), (gpointer*)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_after (m_widget, "clicked",
+ G_CALLBACK (gtk_bmpbutton_clicked_callback),
+ 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 );
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 );
}
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 );
// 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 );
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);
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 */
// 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
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 );
// "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
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 )
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 )
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);
}
//----------------------------------------------------------------------------
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);
{
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
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() )
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
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 );
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 );
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)
{
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;
}
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 )
{
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 );
-
- 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_after (list_item, "deselect",
+ G_CALLBACK (gtk_listitem_deselect_callback),
+ 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 );
{
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 ;
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);
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 );
// 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);
}
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.
{
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 )
{
}
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);
}
}
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;
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);
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;
}
!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
{
// 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;
}
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;
}
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 );
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;
}
// 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);
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);
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 );
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;
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;
}
}
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 );
/* 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;
}
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))
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 );
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 );
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();
}
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();
}
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 );
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 );
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,
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 */
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()
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 );
GtkDisableEvents();
- gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "value_changed" );
+ g_signal_emit_by_name (m_adjust, "value_changed");
GtkEnableEvents();
}
GtkDisableEvents();
- gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+ g_signal_emit_by_name (m_adjust, "changed");
GtkEnableEvents();
}
GtkDisableEvents();
- gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+ g_signal_emit_by_name (m_adjust, "changed");
GtkEnableEvents();
}
GtkDisableEvents();
- gtk_signal_emit_by_name( GTK_OBJECT(m_adjust), "changed" );
+ g_signal_emit_by_name (m_adjust, "changed");
GtkEnableEvents();
}
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
/* 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;
}
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 );
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)
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();
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
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();
}
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();
// 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;
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;
gtk_main_iteration();
}
- gtk_signal_disconnect(GTK_OBJECT(menu->m_menu), handler);
+ g_signal_handler_disconnect (menu->m_menu, handler);
return true;
}
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;
// 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
/////////////////////////////////////////////////////////////////////////////
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);
}
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())
{
gtk_text_iter_get_line(start) );
gtk_text_iter_forward_line(¶_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, ¶_start, ¶_end );
- g_signal_handler_disconnect( text_buffer, remove_handler_id );
+ g_signal_handler_disconnect (text_buffer, remove_handler_id);
GtkJustification align;
switch (attr.GetAlignment())
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
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");
}
}
if(n < WXSIZEOF(URIPrefixes))
{
- gulong signal_id = g_signal_handler_find(buffer,
- (GSignalMatchType) (G_SIGNAL_MATCH_FUNC),
- 0, 0, NULL,
- (gpointer)au_apply_tag_callback, NULL);
+ 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);
}
}
}
// 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)
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
// 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);
}
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 );
// 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);
}
}
}
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);
}
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);
}
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);
}
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));
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);
}
}
}
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);
// 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);
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;
}
}
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();
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
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();
// 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))
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;
}
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;
}
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;
}
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;
}
}
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;
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
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;
}
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 );
// 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)
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 ) );
}
// 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
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
/* 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
{
// 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();
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()
}
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) )
flags);
}
-void GDK_WINDOW_SET_ICON (GdkWindow *window,
+void GDK_WINDOW_SET_ICON (GdkWindow *window,
GdkWindow *icon_window,
GdkPixmap *pixmap,
GdkBitmap *mask)
{
- gdk_window_set_icon (window,
+ gdk_window_set_icon (window,
icon_window,
pixmap,
mask);
gboolean use_static)
{
return gdk_window_set_static_gravities (window,
- use_static);
+ use_static);
}
void GDK_WINDOW_SET_USER_DATA (GdkWindow *window,
return gtk_combo_new ();
}
-void GTK_COMBO_SET_USE_ARROWS_ALWAYS (GtkCombo* combo,
+void GTK_COMBO_SET_USE_ARROWS_ALWAYS (GtkCombo* combo,
gint val)
{
- gtk_combo_set_use_arrows_always (combo,
+ gtk_combo_set_use_arrows_always (combo,
val);
}
guint i;
va_list args;
guint signal_id;
-
+
g_return_val_if_fail (nparams < MAX_SIGNAL_PARAMS, 0);
-
+
if (nparams > 0)
{
params = g_new (GtkType, nparams);
-
+
va_start (args, nparams);
-
+
for (i = 0; i < nparams; i++)
params[i] = va_arg (args, GtkType);
-
+
va_end (args);
}
else
params = NULL;
-
+
signal_id = gtk_signal_newv (name,
signal_flags,
object_type,
return_val,
nparams,
params);
-
+
g_free (params);
-
+
return signal_id;
}
title);
}
-void GTK_WINDOW_SET_TRANSIENT_FOR (GtkWindow *window,
+void GTK_WINDOW_SET_TRANSIENT_FOR (GtkWindow *window,
GtkWindow *parent)
{
- gtk_window_set_transient_for (window,
+ gtk_window_set_transient_for (window,
parent);
}
...)
{
va_list args;
-
+
va_start (args, format);
g_logv (log_domain, log_level, format, args);
va_end (args);
projects / wxWidgets.git / commitdiff
