// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.

#include <gtk/gtk.h>

static const gchar *__prefix = "__gtksharp_";

#define HAS_PREFIX(a) (*((guint64 *)(a)) == *((guint64 *) __prefix))

static GObjectClass *
get_threshold_class (GObject *obj)
{
	GType gtype = G_TYPE_FROM_INSTANCE (obj);
	while (HAS_PREFIX (g_type_name (gtype)))
		gtype = g_type_parent (gtype);
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL) klass = g_type_class_ref (gtype);
	return klass;
}

void gtksharp_accelgroup_override_accel_changed (GType gtype, gpointer cb);

void
gtksharp_accelgroup_override_accel_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkAccelGroupClass *)klass)->accel_changed = cb;
}

void gtksharp_accelgroup_base_accel_changed (GtkAccelGroup* accel_group, guint keyval, GdkModifierType modifier, GClosure* accel_closure);

void
gtksharp_accelgroup_base_accel_changed (GtkAccelGroup* accel_group, guint keyval, GdkModifierType modifier, GClosure* accel_closure)
{
	GtkAccelGroupClass *klass = (GtkAccelGroupClass *) get_threshold_class (G_OBJECT (accel_group));
	if (klass->accel_changed)
		(* klass->accel_changed) (accel_group, keyval, modifier, accel_closure);
}
void gtksharp_action_override_activate (GType gtype, gpointer cb);

void
gtksharp_action_override_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkActionClass *)klass)->activate = cb;
}

void gtksharp_action_base_activate (GtkAction* action);

void
gtksharp_action_base_activate (GtkAction* action)
{
	GtkActionClass *klass = (GtkActionClass *) get_threshold_class (G_OBJECT (action));
	if (klass->activate)
		(* klass->activate) (action);
}
void gtksharp_adjustment_override_value_changed (GType gtype, gpointer cb);

void
gtksharp_adjustment_override_value_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkAdjustmentClass *)klass)->value_changed = cb;
}

void gtksharp_adjustment_base_value_changed (GtkAdjustment* adjustment);

void
gtksharp_adjustment_base_value_changed (GtkAdjustment* adjustment)
{
	GtkAdjustmentClass *klass = (GtkAdjustmentClass *) get_threshold_class (G_OBJECT (adjustment));
	if (klass->value_changed)
		(* klass->value_changed) (adjustment);
}
void gtksharp_adjustment_override_changed (GType gtype, gpointer cb);

void
gtksharp_adjustment_override_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkAdjustmentClass *)klass)->changed = cb;
}

void gtksharp_adjustment_base_changed (GtkAdjustment* adjustment);

void
gtksharp_adjustment_base_changed (GtkAdjustment* adjustment)
{
	GtkAdjustmentClass *klass = (GtkAdjustmentClass *) get_threshold_class (G_OBJECT (adjustment));
	if (klass->changed)
		(* klass->changed) (adjustment);
}
void gtksharp_assistant_override_close (GType gtype, gpointer cb);

void
gtksharp_assistant_override_close (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkAssistantClass *)klass)->close = cb;
}

void gtksharp_assistant_base_close (GtkAssistant* assistant);

void
gtksharp_assistant_base_close (GtkAssistant* assistant)
{
	GtkAssistantClass *klass = (GtkAssistantClass *) get_threshold_class (G_OBJECT (assistant));
	if (klass->close)
		(* klass->close) (assistant);
}
void gtksharp_assistant_override_cancel (GType gtype, gpointer cb);

void
gtksharp_assistant_override_cancel (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkAssistantClass *)klass)->cancel = cb;
}

void gtksharp_assistant_base_cancel (GtkAssistant* assistant);

void
gtksharp_assistant_base_cancel (GtkAssistant* assistant)
{
	GtkAssistantClass *klass = (GtkAssistantClass *) get_threshold_class (G_OBJECT (assistant));
	if (klass->cancel)
		(* klass->cancel) (assistant);
}
void gtksharp_assistant_override_prepare (GType gtype, gpointer cb);

void
gtksharp_assistant_override_prepare (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkAssistantClass *)klass)->prepare = cb;
}

void gtksharp_assistant_base_prepare (GtkAssistant* assistant, GtkWidget* page);

void
gtksharp_assistant_base_prepare (GtkAssistant* assistant, GtkWidget* page)
{
	GtkAssistantClass *klass = (GtkAssistantClass *) get_threshold_class (G_OBJECT (assistant));
	if (klass->prepare)
		(* klass->prepare) (assistant, page);
}
void gtksharp_assistant_override_apply (GType gtype, gpointer cb);

void
gtksharp_assistant_override_apply (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkAssistantClass *)klass)->apply = cb;
}

void gtksharp_assistant_base_apply (GtkAssistant* assistant);

void
gtksharp_assistant_base_apply (GtkAssistant* assistant)
{
	GtkAssistantClass *klass = (GtkAssistantClass *) get_threshold_class (G_OBJECT (assistant));
	if (klass->apply)
		(* klass->apply) (assistant);
}
gboolean gtksharp_gtk_button_get_in_button (GtkButton *button);
void gtksharp_gtk_button_set_in_button (GtkButton *button, gboolean value);

gboolean
gtksharp_gtk_button_get_in_button (GtkButton *button)
{
	return (gboolean)button->in_button;
}

void
gtksharp_gtk_button_set_in_button (GtkButton *button, gboolean value)
{
	button->in_button = (gboolean)value;
}

void gtksharp_button_override_released (GType gtype, gpointer cb);

void
gtksharp_button_override_released (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkButtonClass *)klass)->released = cb;
}

void gtksharp_button_base_released (GtkButton* button);

void
gtksharp_button_base_released (GtkButton* button)
{
	GtkButtonClass *klass = (GtkButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->released)
		(* klass->released) (button);
}
void gtksharp_button_override_pressed (GType gtype, gpointer cb);

void
gtksharp_button_override_pressed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkButtonClass *)klass)->pressed = cb;
}

void gtksharp_button_base_pressed (GtkButton* button);

void
gtksharp_button_base_pressed (GtkButton* button)
{
	GtkButtonClass *klass = (GtkButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->pressed)
		(* klass->pressed) (button);
}
void gtksharp_button_override_leave (GType gtype, gpointer cb);

void
gtksharp_button_override_leave (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkButtonClass *)klass)->leave = cb;
}

void gtksharp_button_base_leave (GtkButton* button);

void
gtksharp_button_base_leave (GtkButton* button)
{
	GtkButtonClass *klass = (GtkButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->leave)
		(* klass->leave) (button);
}
void gtksharp_button_override_activate (GType gtype, gpointer cb);

void
gtksharp_button_override_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkButtonClass *)klass)->activate = cb;
}

void gtksharp_button_base_activate (GtkButton* button);

void
gtksharp_button_base_activate (GtkButton* button)
{
	GtkButtonClass *klass = (GtkButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->activate)
		(* klass->activate) (button);
}
void gtksharp_button_override_enter (GType gtype, gpointer cb);

void
gtksharp_button_override_enter (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkButtonClass *)klass)->enter = cb;
}

void gtksharp_button_base_enter (GtkButton* button);

void
gtksharp_button_base_enter (GtkButton* button)
{
	GtkButtonClass *klass = (GtkButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->enter)
		(* klass->enter) (button);
}
void gtksharp_button_override_clicked (GType gtype, gpointer cb);

void
gtksharp_button_override_clicked (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkButtonClass *)klass)->clicked = cb;
}

void gtksharp_button_base_clicked (GtkButton* button);

void
gtksharp_button_base_clicked (GtkButton* button)
{
	GtkButtonClass *klass = (GtkButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->clicked)
		(* klass->clicked) (button);
}
void gtksharp_calendar_override_next_month (GType gtype, gpointer cb);

void
gtksharp_calendar_override_next_month (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCalendarClass *)klass)->next_month = cb;
}

void gtksharp_calendar_base_next_month (GtkCalendar* calendar);

void
gtksharp_calendar_base_next_month (GtkCalendar* calendar)
{
	GtkCalendarClass *klass = (GtkCalendarClass *) get_threshold_class (G_OBJECT (calendar));
	if (klass->next_month)
		(* klass->next_month) (calendar);
}
void gtksharp_calendar_override_day_selected (GType gtype, gpointer cb);

void
gtksharp_calendar_override_day_selected (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCalendarClass *)klass)->day_selected = cb;
}

void gtksharp_calendar_base_day_selected (GtkCalendar* calendar);

void
gtksharp_calendar_base_day_selected (GtkCalendar* calendar)
{
	GtkCalendarClass *klass = (GtkCalendarClass *) get_threshold_class (G_OBJECT (calendar));
	if (klass->day_selected)
		(* klass->day_selected) (calendar);
}
void gtksharp_calendar_override_prev_month (GType gtype, gpointer cb);

void
gtksharp_calendar_override_prev_month (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCalendarClass *)klass)->prev_month = cb;
}

void gtksharp_calendar_base_prev_month (GtkCalendar* calendar);

void
gtksharp_calendar_base_prev_month (GtkCalendar* calendar)
{
	GtkCalendarClass *klass = (GtkCalendarClass *) get_threshold_class (G_OBJECT (calendar));
	if (klass->prev_month)
		(* klass->prev_month) (calendar);
}
void gtksharp_calendar_override_month_changed (GType gtype, gpointer cb);

void
gtksharp_calendar_override_month_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCalendarClass *)klass)->month_changed = cb;
}

void gtksharp_calendar_base_month_changed (GtkCalendar* calendar);

void
gtksharp_calendar_base_month_changed (GtkCalendar* calendar)
{
	GtkCalendarClass *klass = (GtkCalendarClass *) get_threshold_class (G_OBJECT (calendar));
	if (klass->month_changed)
		(* klass->month_changed) (calendar);
}
void gtksharp_calendar_override_day_selected_double_click (GType gtype, gpointer cb);

void
gtksharp_calendar_override_day_selected_double_click (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCalendarClass *)klass)->day_selected_double_click = cb;
}

void gtksharp_calendar_base_day_selected_double_click (GtkCalendar* calendar);

void
gtksharp_calendar_base_day_selected_double_click (GtkCalendar* calendar)
{
	GtkCalendarClass *klass = (GtkCalendarClass *) get_threshold_class (G_OBJECT (calendar));
	if (klass->day_selected_double_click)
		(* klass->day_selected_double_click) (calendar);
}
void gtksharp_calendar_override_prev_year (GType gtype, gpointer cb);

void
gtksharp_calendar_override_prev_year (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCalendarClass *)klass)->prev_year = cb;
}

void gtksharp_calendar_base_prev_year (GtkCalendar* calendar);

void
gtksharp_calendar_base_prev_year (GtkCalendar* calendar)
{
	GtkCalendarClass *klass = (GtkCalendarClass *) get_threshold_class (G_OBJECT (calendar));
	if (klass->prev_year)
		(* klass->prev_year) (calendar);
}
void gtksharp_calendar_override_next_year (GType gtype, gpointer cb);

void
gtksharp_calendar_override_next_year (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCalendarClass *)klass)->next_year = cb;
}

void gtksharp_calendar_base_next_year (GtkCalendar* calendar);

void
gtksharp_calendar_base_next_year (GtkCalendar* calendar)
{
	GtkCalendarClass *klass = (GtkCalendarClass *) get_threshold_class (G_OBJECT (calendar));
	if (klass->next_year)
		(* klass->next_year) (calendar);
}
void gtksharp_cellrenderer_override_editing_started (GType gtype, gpointer cb);

void
gtksharp_cellrenderer_override_editing_started (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCellRendererClass *)klass)->editing_started = cb;
}

void gtksharp_cellrenderer_base_editing_started (GtkCellRenderer* cell, GtkCellEditable* editable, const gchar* path);

void
gtksharp_cellrenderer_base_editing_started (GtkCellRenderer* cell, GtkCellEditable* editable, const gchar* path)
{
	GtkCellRendererClass *klass = (GtkCellRendererClass *) get_threshold_class (G_OBJECT (cell));
	if (klass->editing_started)
		(* klass->editing_started) (cell, editable, path);
}
void gtksharp_cellrenderer_override_editing_canceled (GType gtype, gpointer cb);

void
gtksharp_cellrenderer_override_editing_canceled (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCellRendererClass *)klass)->editing_canceled = cb;
}

void gtksharp_cellrenderer_base_editing_canceled (GtkCellRenderer* cell);

void
gtksharp_cellrenderer_base_editing_canceled (GtkCellRenderer* cell)
{
	GtkCellRendererClass *klass = (GtkCellRendererClass *) get_threshold_class (G_OBJECT (cell));
	if (klass->editing_canceled)
		(* klass->editing_canceled) (cell);
}
void gtksharp_cellrendereraccel_override_accel_edited (GType gtype, gpointer cb);

void
gtksharp_cellrendereraccel_override_accel_edited (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCellRendererAccelClass *)klass)->accel_edited = cb;
}

void gtksharp_cellrendereraccel_base_accel_edited (GtkCellRendererAccel* accel, const gchar* path_string, guint accel_key, GdkModifierType accel_mods, guint hardware_keycode);

void
gtksharp_cellrendereraccel_base_accel_edited (GtkCellRendererAccel* accel, const gchar* path_string, guint accel_key, GdkModifierType accel_mods, guint hardware_keycode)
{
	GtkCellRendererAccelClass *klass = (GtkCellRendererAccelClass *) get_threshold_class (G_OBJECT (accel));
	if (klass->accel_edited)
		(* klass->accel_edited) (accel, path_string, accel_key, accel_mods, hardware_keycode);
}
void gtksharp_cellrendereraccel_override_accel_cleared (GType gtype, gpointer cb);

void
gtksharp_cellrendereraccel_override_accel_cleared (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCellRendererAccelClass *)klass)->accel_cleared = cb;
}

void gtksharp_cellrendereraccel_base_accel_cleared (GtkCellRendererAccel* accel, const gchar* path_string);

void
gtksharp_cellrendereraccel_base_accel_cleared (GtkCellRendererAccel* accel, const gchar* path_string)
{
	GtkCellRendererAccelClass *klass = (GtkCellRendererAccelClass *) get_threshold_class (G_OBJECT (accel));
	if (klass->accel_cleared)
		(* klass->accel_cleared) (accel, path_string);
}
void gtksharp_cellrenderertext_override_edited (GType gtype, gpointer cb);

void
gtksharp_cellrenderertext_override_edited (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCellRendererTextClass *)klass)->edited = cb;
}

void gtksharp_cellrenderertext_base_edited (GtkCellRendererText* cell_renderer_text, const gchar* path, const gchar* new_text);

void
gtksharp_cellrenderertext_base_edited (GtkCellRendererText* cell_renderer_text, const gchar* path, const gchar* new_text)
{
	GtkCellRendererTextClass *klass = (GtkCellRendererTextClass *) get_threshold_class (G_OBJECT (cell_renderer_text));
	if (klass->edited)
		(* klass->edited) (cell_renderer_text, path, new_text);
}
void gtksharp_cellrenderertoggle_override_toggled (GType gtype, gpointer cb);

void
gtksharp_cellrenderertoggle_override_toggled (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCellRendererToggleClass *)klass)->toggled = cb;
}

void gtksharp_cellrenderertoggle_base_toggled (GtkCellRendererToggle* cell_renderer_toggle, const gchar* path);

void
gtksharp_cellrenderertoggle_base_toggled (GtkCellRendererToggle* cell_renderer_toggle, const gchar* path)
{
	GtkCellRendererToggleClass *klass = (GtkCellRendererToggleClass *) get_threshold_class (G_OBJECT (cell_renderer_toggle));
	if (klass->toggled)
		(* klass->toggled) (cell_renderer_toggle, path);
}
void gtksharp_checkmenuitem_override_toggled (GType gtype, gpointer cb);

void
gtksharp_checkmenuitem_override_toggled (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCheckMenuItemClass *)klass)->toggled = cb;
}

void gtksharp_checkmenuitem_base_toggled (GtkCheckMenuItem* check_menu_item);

void
gtksharp_checkmenuitem_base_toggled (GtkCheckMenuItem* check_menu_item)
{
	GtkCheckMenuItemClass *klass = (GtkCheckMenuItemClass *) get_threshold_class (G_OBJECT (check_menu_item));
	if (klass->toggled)
		(* klass->toggled) (check_menu_item);
}
void gtksharp_colorbutton_override_color_set (GType gtype, gpointer cb);

void
gtksharp_colorbutton_override_color_set (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkColorButtonClass *)klass)->color_set = cb;
}

void gtksharp_colorbutton_base_color_set (GtkColorButton* cp);

void
gtksharp_colorbutton_base_color_set (GtkColorButton* cp)
{
	GtkColorButtonClass *klass = (GtkColorButtonClass *) get_threshold_class (G_OBJECT (cp));
	if (klass->color_set)
		(* klass->color_set) (cp);
}
void gtksharp_colorselection_override_color_changed (GType gtype, gpointer cb);

void
gtksharp_colorselection_override_color_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkColorSelectionClass *)klass)->color_changed = cb;
}

void gtksharp_colorselection_base_color_changed (GtkColorSelection* color_selection);

void
gtksharp_colorselection_base_color_changed (GtkColorSelection* color_selection)
{
	GtkColorSelectionClass *klass = (GtkColorSelectionClass *) get_threshold_class (G_OBJECT (color_selection));
	if (klass->color_changed)
		(* klass->color_changed) (color_selection);
}
guint gtksharp_gtk_combo_get_button_offset (void);

guint
gtksharp_gtk_combo_get_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkCombo, button);
}

guint gtksharp_gtk_combo_get_entry_offset (void);

guint
gtksharp_gtk_combo_get_entry_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkCombo, entry);
}

guint gtksharp_gtk_combo_get_list_offset (void);

guint
gtksharp_gtk_combo_get_list_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkCombo, list);
}

void gtksharp_combobox_override_changed (GType gtype, gpointer cb);

void
gtksharp_combobox_override_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkComboBoxClass *)klass)->changed = cb;
}

void gtksharp_combobox_base_changed (GtkComboBox* combo_box);

void
gtksharp_combobox_base_changed (GtkComboBox* combo_box)
{
	GtkComboBoxClass *klass = (GtkComboBoxClass *) get_threshold_class (G_OBJECT (combo_box));
	if (klass->changed)
		(* klass->changed) (combo_box);
}
guint gtksharp_gtk_container_get_focus_child_offset (void);

guint
gtksharp_gtk_container_get_focus_child_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkContainer, focus_child);
}

void gtksharp_container_override_add (GType gtype, gpointer cb);

void
gtksharp_container_override_add (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkContainerClass *)klass)->add = cb;
}

void gtksharp_container_base_add (GtkContainer* container, GtkWidget* widget);

void
gtksharp_container_base_add (GtkContainer* container, GtkWidget* widget)
{
	GtkContainerClass *klass = (GtkContainerClass *) get_threshold_class (G_OBJECT (container));
	if (klass->add)
		(* klass->add) (container, widget);
}
void gtksharp_container_override_set_focus_child (GType gtype, gpointer cb);

void
gtksharp_container_override_set_focus_child (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkContainerClass *)klass)->set_focus_child = cb;
}

void gtksharp_container_base_set_focus_child (GtkContainer* container, GtkWidget* widget);

void
gtksharp_container_base_set_focus_child (GtkContainer* container, GtkWidget* widget)
{
	GtkContainerClass *klass = (GtkContainerClass *) get_threshold_class (G_OBJECT (container));
	if (klass->set_focus_child)
		(* klass->set_focus_child) (container, widget);
}
void gtksharp_container_override_remove (GType gtype, gpointer cb);

void
gtksharp_container_override_remove (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkContainerClass *)klass)->remove = cb;
}

void gtksharp_container_base_remove (GtkContainer* container, GtkWidget* widget);

void
gtksharp_container_base_remove (GtkContainer* container, GtkWidget* widget)
{
	GtkContainerClass *klass = (GtkContainerClass *) get_threshold_class (G_OBJECT (container));
	if (klass->remove)
		(* klass->remove) (container, widget);
}
void gtksharp_container_override_check_resize (GType gtype, gpointer cb);

void
gtksharp_container_override_check_resize (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkContainerClass *)klass)->check_resize = cb;
}

void gtksharp_container_base_check_resize (GtkContainer* container);

void
gtksharp_container_base_check_resize (GtkContainer* container)
{
	GtkContainerClass *klass = (GtkContainerClass *) get_threshold_class (G_OBJECT (container));
	if (klass->check_resize)
		(* klass->check_resize) (container);
}
void gtksharp_curve_override_curve_type_changed (GType gtype, gpointer cb);

void
gtksharp_curve_override_curve_type_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkCurveClass *)klass)->curve_type_changed = cb;
}

void gtksharp_curve_base_curve_type_changed (GtkCurve* curve);

void
gtksharp_curve_base_curve_type_changed (GtkCurve* curve)
{
	GtkCurveClass *klass = (GtkCurveClass *) get_threshold_class (G_OBJECT (curve));
	if (klass->curve_type_changed)
		(* klass->curve_type_changed) (curve);
}
guint gtksharp_gtk_dialog_get_action_area_offset (void);

guint
gtksharp_gtk_dialog_get_action_area_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkDialog, action_area);
}

guint gtksharp_gtk_dialog_get_vbox_offset (void);

guint
gtksharp_gtk_dialog_get_vbox_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkDialog, vbox);
}

void gtksharp_dialog_override_close (GType gtype, gpointer cb);

void
gtksharp_dialog_override_close (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkDialogClass *)klass)->close = cb;
}

void gtksharp_dialog_base_close (GtkDialog* dialog);

void
gtksharp_dialog_base_close (GtkDialog* dialog)
{
	GtkDialogClass *klass = (GtkDialogClass *) get_threshold_class (G_OBJECT (dialog));
	if (klass->close)
		(* klass->close) (dialog);
}
void gtksharp_dialog_override_response (GType gtype, gpointer cb);

void
gtksharp_dialog_override_response (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkDialogClass *)klass)->response = cb;
}

void gtksharp_dialog_base_response (GtkDialog* dialog, GtkResponseType response_id);

void
gtksharp_dialog_base_response (GtkDialog* dialog, GtkResponseType response_id)
{
	GtkDialogClass *klass = (GtkDialogClass *) get_threshold_class (G_OBJECT (dialog));
	if (klass->response)
		(* klass->response) (dialog, response_id);
}
void gtksharp_entry_override_insert_at_cursor (GType gtype, gpointer cb);

void
gtksharp_entry_override_insert_at_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->insert_at_cursor = cb;
}

void gtksharp_entry_base_insert_at_cursor (GtkEntry* entry, const gchar* str);

void
gtksharp_entry_base_insert_at_cursor (GtkEntry* entry, const gchar* str)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->insert_at_cursor)
		(* klass->insert_at_cursor) (entry, str);
}
void gtksharp_entry_override_paste_clipboard (GType gtype, gpointer cb);

void
gtksharp_entry_override_paste_clipboard (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->paste_clipboard = cb;
}

void gtksharp_entry_base_paste_clipboard (GtkEntry* entry);

void
gtksharp_entry_base_paste_clipboard (GtkEntry* entry)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->paste_clipboard)
		(* klass->paste_clipboard) (entry);
}
void gtksharp_entry_override_cut_clipboard (GType gtype, gpointer cb);

void
gtksharp_entry_override_cut_clipboard (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->cut_clipboard = cb;
}

void gtksharp_entry_base_cut_clipboard (GtkEntry* entry);

void
gtksharp_entry_base_cut_clipboard (GtkEntry* entry)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->cut_clipboard)
		(* klass->cut_clipboard) (entry);
}
void gtksharp_entry_override_activate (GType gtype, gpointer cb);

void
gtksharp_entry_override_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->activate = cb;
}

void gtksharp_entry_base_activate (GtkEntry* entry);

void
gtksharp_entry_base_activate (GtkEntry* entry)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->activate)
		(* klass->activate) (entry);
}
void gtksharp_entry_override_move_cursor (GType gtype, gpointer cb);

void
gtksharp_entry_override_move_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->move_cursor = cb;
}

void gtksharp_entry_base_move_cursor (GtkEntry* entry, GtkMovementStep step, gint count, gboolean extend_selection);

void
gtksharp_entry_base_move_cursor (GtkEntry* entry, GtkMovementStep step, gint count, gboolean extend_selection)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->move_cursor)
		(* klass->move_cursor) (entry, step, count, extend_selection);
}
void gtksharp_entry_override_populate_popup (GType gtype, gpointer cb);

void
gtksharp_entry_override_populate_popup (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->populate_popup = cb;
}

void gtksharp_entry_base_populate_popup (GtkEntry* entry, GtkMenu* menu);

void
gtksharp_entry_base_populate_popup (GtkEntry* entry, GtkMenu* menu)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->populate_popup)
		(* klass->populate_popup) (entry, menu);
}
void gtksharp_entry_override_backspace (GType gtype, gpointer cb);

void
gtksharp_entry_override_backspace (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->backspace = cb;
}

void gtksharp_entry_base_backspace (GtkEntry* entry);

void
gtksharp_entry_base_backspace (GtkEntry* entry)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->backspace)
		(* klass->backspace) (entry);
}
void gtksharp_entry_override_delete_from_cursor (GType gtype, gpointer cb);

void
gtksharp_entry_override_delete_from_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->delete_from_cursor = cb;
}

void gtksharp_entry_base_delete_from_cursor (GtkEntry* entry, GtkDeleteType type, gint count);

void
gtksharp_entry_base_delete_from_cursor (GtkEntry* entry, GtkDeleteType type, gint count)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->delete_from_cursor)
		(* klass->delete_from_cursor) (entry, type, count);
}
void gtksharp_entry_override_toggle_overwrite (GType gtype, gpointer cb);

void
gtksharp_entry_override_toggle_overwrite (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->toggle_overwrite = cb;
}

void gtksharp_entry_base_toggle_overwrite (GtkEntry* entry);

void
gtksharp_entry_base_toggle_overwrite (GtkEntry* entry)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->toggle_overwrite)
		(* klass->toggle_overwrite) (entry);
}
void gtksharp_entry_override_copy_clipboard (GType gtype, gpointer cb);

void
gtksharp_entry_override_copy_clipboard (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryClass *)klass)->copy_clipboard = cb;
}

void gtksharp_entry_base_copy_clipboard (GtkEntry* entry);

void
gtksharp_entry_base_copy_clipboard (GtkEntry* entry)
{
	GtkEntryClass *klass = (GtkEntryClass *) get_threshold_class (G_OBJECT (entry));
	if (klass->copy_clipboard)
		(* klass->copy_clipboard) (entry);
}
void gtksharp_entrycompletion_override_insert_prefix (GType gtype, gpointer cb);

void
gtksharp_entrycompletion_override_insert_prefix (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryCompletionClass *)klass)->insert_prefix = cb;
}

gboolean gtksharp_entrycompletion_base_insert_prefix (GtkEntryCompletion* completion, const gchar* prefix);

gboolean
gtksharp_entrycompletion_base_insert_prefix (GtkEntryCompletion* completion, const gchar* prefix)
{
	GtkEntryCompletionClass *klass = (GtkEntryCompletionClass *) get_threshold_class (G_OBJECT (completion));
	if (klass->insert_prefix)
		return (* klass->insert_prefix) (completion, prefix);
	return FALSE;
}
void gtksharp_entrycompletion_override_action_activated (GType gtype, gpointer cb);

void
gtksharp_entrycompletion_override_action_activated (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryCompletionClass *)klass)->action_activated = cb;
}

void gtksharp_entrycompletion_base_action_activated (GtkEntryCompletion* completion, gint index_);

void
gtksharp_entrycompletion_base_action_activated (GtkEntryCompletion* completion, gint index_)
{
	GtkEntryCompletionClass *klass = (GtkEntryCompletionClass *) get_threshold_class (G_OBJECT (completion));
	if (klass->action_activated)
		(* klass->action_activated) (completion, index_);
}
void gtksharp_entrycompletion_override_match_selected (GType gtype, gpointer cb);

void
gtksharp_entrycompletion_override_match_selected (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryCompletionClass *)klass)->match_selected = cb;
}

gboolean gtksharp_entrycompletion_base_match_selected (GtkEntryCompletion* completion, GtkTreeModel* model, GtkTreeIter* iter);

gboolean
gtksharp_entrycompletion_base_match_selected (GtkEntryCompletion* completion, GtkTreeModel* model, GtkTreeIter* iter)
{
	GtkEntryCompletionClass *klass = (GtkEntryCompletionClass *) get_threshold_class (G_OBJECT (completion));
	if (klass->match_selected)
		return (* klass->match_selected) (completion, model, iter);
	return FALSE;
}
void gtksharp_entrycompletion_override_cursor_on_match (GType gtype, gpointer cb);

void
gtksharp_entrycompletion_override_cursor_on_match (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkEntryCompletionClass *)klass)->cursor_on_match = cb;
}

gboolean gtksharp_entrycompletion_base_cursor_on_match (GtkEntryCompletion* completion, GtkTreeModel* model, GtkTreeIter* iter);

gboolean
gtksharp_entrycompletion_base_cursor_on_match (GtkEntryCompletion* completion, GtkTreeModel* model, GtkTreeIter* iter)
{
	GtkEntryCompletionClass *klass = (GtkEntryCompletionClass *) get_threshold_class (G_OBJECT (completion));
	if (klass->cursor_on_match)
		return (* klass->cursor_on_match) (completion, model, iter);
	return FALSE;
}
void gtksharp_expander_override_activate (GType gtype, gpointer cb);

void
gtksharp_expander_override_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkExpanderClass *)klass)->activate = cb;
}

void gtksharp_expander_base_activate (GtkExpander* expander);

void
gtksharp_expander_base_activate (GtkExpander* expander)
{
	GtkExpanderClass *klass = (GtkExpanderClass *) get_threshold_class (G_OBJECT (expander));
	if (klass->activate)
		(* klass->activate) (expander);
}
void gtksharp_filechooserbutton_override_file_set (GType gtype, gpointer cb);

void
gtksharp_filechooserbutton_override_file_set (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkFileChooserButtonClass *)klass)->file_set = cb;
}

void gtksharp_filechooserbutton_base_file_set (GtkFileChooserButton* fc);

void
gtksharp_filechooserbutton_base_file_set (GtkFileChooserButton* fc)
{
	GtkFileChooserButtonClass *klass = (GtkFileChooserButtonClass *) get_threshold_class (G_OBJECT (fc));
	if (klass->file_set)
		(* klass->file_set) (fc);
}
guint gtksharp_gtk_fileselection_get_fileop_entry_offset (void);

guint
gtksharp_gtk_fileselection_get_fileop_entry_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, fileop_entry);
}

guint gtksharp_gtk_fileselection_get_history_menu_offset (void);

guint
gtksharp_gtk_fileselection_get_history_menu_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, history_menu);
}

guint gtksharp_gtk_fileselection_get_action_area_offset (void);

guint
gtksharp_gtk_fileselection_get_action_area_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, action_area);
}

guint gtksharp_gtk_fileselection_get_ok_button_offset (void);

guint
gtksharp_gtk_fileselection_get_ok_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, ok_button);
}

guint gtksharp_gtk_fileselection_get_selection_text_offset (void);

guint
gtksharp_gtk_fileselection_get_selection_text_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, selection_text);
}

guint gtksharp_gtk_fileselection_get_fileop_ren_file_offset (void);

guint
gtksharp_gtk_fileselection_get_fileop_ren_file_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, fileop_ren_file);
}

guint gtksharp_gtk_fileselection_get_fileop_dialog_offset (void);

guint
gtksharp_gtk_fileselection_get_fileop_dialog_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, fileop_dialog);
}

guint gtksharp_gtk_fileselection_get_history_pulldown_offset (void);

guint
gtksharp_gtk_fileselection_get_history_pulldown_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, history_pulldown);
}

guint gtksharp_gtk_fileselection_get_button_area_offset (void);

guint
gtksharp_gtk_fileselection_get_button_area_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, button_area);
}

guint gtksharp_gtk_fileselection_get_cancel_button_offset (void);

guint
gtksharp_gtk_fileselection_get_cancel_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, cancel_button);
}

guint gtksharp_gtk_fileselection_get_fileop_file_offset (void);

guint
gtksharp_gtk_fileselection_get_fileop_file_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, fileop_file);
}

guint gtksharp_gtk_fileselection_get_dir_list_offset (void);

guint
gtksharp_gtk_fileselection_get_dir_list_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, dir_list);
}

guint gtksharp_gtk_fileselection_get_main_vbox_offset (void);

guint
gtksharp_gtk_fileselection_get_main_vbox_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, main_vbox);
}

guint gtksharp_gtk_fileselection_get_file_list_offset (void);

guint
gtksharp_gtk_fileselection_get_file_list_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, file_list);
}

guint gtksharp_gtk_fileselection_get_help_button_offset (void);

guint
gtksharp_gtk_fileselection_get_help_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, help_button);
}

guint gtksharp_gtk_fileselection_get_selection_entry_offset (void);

guint
gtksharp_gtk_fileselection_get_selection_entry_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, selection_entry);
}

guint gtksharp_gtk_fileselection_get_fileop_del_file_offset (void);

guint
gtksharp_gtk_fileselection_get_fileop_del_file_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, fileop_del_file);
}

guint gtksharp_gtk_fileselection_get_fileop_c_dir_offset (void);

guint
gtksharp_gtk_fileselection_get_fileop_c_dir_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFileSelection, fileop_c_dir);
}

void gtksharp_fontbutton_override_font_set (GType gtype, gpointer cb);

void
gtksharp_fontbutton_override_font_set (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkFontButtonClass *)klass)->font_set = cb;
}

void gtksharp_fontbutton_base_font_set (GtkFontButton* gfp);

void
gtksharp_fontbutton_base_font_set (GtkFontButton* gfp)
{
	GtkFontButtonClass *klass = (GtkFontButtonClass *) get_threshold_class (G_OBJECT (gfp));
	if (klass->font_set)
		(* klass->font_set) (gfp);
}
guint gtksharp_gtk_fontselectiondialog_get_ok_button_offset (void);

guint
gtksharp_gtk_fontselectiondialog_get_ok_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFontSelectionDialog, ok_button);
}

guint gtksharp_gtk_fontselectiondialog_get_apply_button_offset (void);

guint
gtksharp_gtk_fontselectiondialog_get_apply_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFontSelectionDialog, apply_button);
}

guint gtksharp_gtk_fontselectiondialog_get_cancel_button_offset (void);

guint
gtksharp_gtk_fontselectiondialog_get_cancel_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkFontSelectionDialog, cancel_button);
}

void gtksharp_handlebox_override_child_detached (GType gtype, gpointer cb);

void
gtksharp_handlebox_override_child_detached (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkHandleBoxClass *)klass)->child_detached = cb;
}

void gtksharp_handlebox_base_child_detached (GtkHandleBox* handle_box, GtkWidget* child);

void
gtksharp_handlebox_base_child_detached (GtkHandleBox* handle_box, GtkWidget* child)
{
	GtkHandleBoxClass *klass = (GtkHandleBoxClass *) get_threshold_class (G_OBJECT (handle_box));
	if (klass->child_detached)
		(* klass->child_detached) (handle_box, child);
}
void gtksharp_handlebox_override_child_attached (GType gtype, gpointer cb);

void
gtksharp_handlebox_override_child_attached (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkHandleBoxClass *)klass)->child_attached = cb;
}

void gtksharp_handlebox_base_child_attached (GtkHandleBox* handle_box, GtkWidget* child);

void
gtksharp_handlebox_base_child_attached (GtkHandleBox* handle_box, GtkWidget* child)
{
	GtkHandleBoxClass *klass = (GtkHandleBoxClass *) get_threshold_class (G_OBJECT (handle_box));
	if (klass->child_attached)
		(* klass->child_attached) (handle_box, child);
}
void gtksharp_icontheme_override_changed (GType gtype, gpointer cb);

void
gtksharp_icontheme_override_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconThemeClass *)klass)->changed = cb;
}

void gtksharp_icontheme_base_changed (GtkIconTheme* icon_theme);

void
gtksharp_icontheme_base_changed (GtkIconTheme* icon_theme)
{
	GtkIconThemeClass *klass = (GtkIconThemeClass *) get_threshold_class (G_OBJECT (icon_theme));
	if (klass->changed)
		(* klass->changed) (icon_theme);
}
void gtksharp_iconview_override_select_all (GType gtype, gpointer cb);

void
gtksharp_iconview_override_select_all (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconViewClass *)klass)->select_all = cb;
}

void gtksharp_iconview_base_select_all (GtkIconView* icon_view);

void
gtksharp_iconview_base_select_all (GtkIconView* icon_view)
{
	GtkIconViewClass *klass = (GtkIconViewClass *) get_threshold_class (G_OBJECT (icon_view));
	if (klass->select_all)
		(* klass->select_all) (icon_view);
}
void gtksharp_iconview_override_unselect_all (GType gtype, gpointer cb);

void
gtksharp_iconview_override_unselect_all (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconViewClass *)klass)->unselect_all = cb;
}

void gtksharp_iconview_base_unselect_all (GtkIconView* icon_view);

void
gtksharp_iconview_base_unselect_all (GtkIconView* icon_view)
{
	GtkIconViewClass *klass = (GtkIconViewClass *) get_threshold_class (G_OBJECT (icon_view));
	if (klass->unselect_all)
		(* klass->unselect_all) (icon_view);
}
void gtksharp_iconview_override_move_cursor (GType gtype, gpointer cb);

void
gtksharp_iconview_override_move_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconViewClass *)klass)->move_cursor = cb;
}

gboolean gtksharp_iconview_base_move_cursor (GtkIconView* icon_view, GtkMovementStep step, gint count);

gboolean
gtksharp_iconview_base_move_cursor (GtkIconView* icon_view, GtkMovementStep step, gint count)
{
	GtkIconViewClass *klass = (GtkIconViewClass *) get_threshold_class (G_OBJECT (icon_view));
	if (klass->move_cursor)
		return (* klass->move_cursor) (icon_view, step, count);
	return FALSE;
}
void gtksharp_iconview_override_item_activated (GType gtype, gpointer cb);

void
gtksharp_iconview_override_item_activated (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconViewClass *)klass)->item_activated = cb;
}

void gtksharp_iconview_base_item_activated (GtkIconView* icon_view, GtkTreePath* path);

void
gtksharp_iconview_base_item_activated (GtkIconView* icon_view, GtkTreePath* path)
{
	GtkIconViewClass *klass = (GtkIconViewClass *) get_threshold_class (G_OBJECT (icon_view));
	if (klass->item_activated)
		(* klass->item_activated) (icon_view, path);
}
void gtksharp_iconview_override_selection_changed (GType gtype, gpointer cb);

void
gtksharp_iconview_override_selection_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconViewClass *)klass)->selection_changed = cb;
}

void gtksharp_iconview_base_selection_changed (GtkIconView* icon_view);

void
gtksharp_iconview_base_selection_changed (GtkIconView* icon_view)
{
	GtkIconViewClass *klass = (GtkIconViewClass *) get_threshold_class (G_OBJECT (icon_view));
	if (klass->selection_changed)
		(* klass->selection_changed) (icon_view);
}
void gtksharp_iconview_override_toggle_cursor_item (GType gtype, gpointer cb);

void
gtksharp_iconview_override_toggle_cursor_item (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconViewClass *)klass)->toggle_cursor_item = cb;
}

void gtksharp_iconview_base_toggle_cursor_item (GtkIconView* icon_view);

void
gtksharp_iconview_base_toggle_cursor_item (GtkIconView* icon_view)
{
	GtkIconViewClass *klass = (GtkIconViewClass *) get_threshold_class (G_OBJECT (icon_view));
	if (klass->toggle_cursor_item)
		(* klass->toggle_cursor_item) (icon_view);
}
void gtksharp_iconview_override_select_cursor_item (GType gtype, gpointer cb);

void
gtksharp_iconview_override_select_cursor_item (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconViewClass *)klass)->select_cursor_item = cb;
}

void gtksharp_iconview_base_select_cursor_item (GtkIconView* icon_view);

void
gtksharp_iconview_base_select_cursor_item (GtkIconView* icon_view)
{
	GtkIconViewClass *klass = (GtkIconViewClass *) get_threshold_class (G_OBJECT (icon_view));
	if (klass->select_cursor_item)
		(* klass->select_cursor_item) (icon_view);
}
void gtksharp_iconview_override_activate_cursor_item (GType gtype, gpointer cb);

void
gtksharp_iconview_override_activate_cursor_item (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIconViewClass *)klass)->activate_cursor_item = cb;
}

gboolean gtksharp_iconview_base_activate_cursor_item (GtkIconView* icon_view);

gboolean
gtksharp_iconview_base_activate_cursor_item (GtkIconView* icon_view)
{
	GtkIconViewClass *klass = (GtkIconViewClass *) get_threshold_class (G_OBJECT (icon_view));
	if (klass->activate_cursor_item)
		return (* klass->activate_cursor_item) (icon_view);
	return FALSE;
}
void gtksharp_imcontext_override_preedit_start (GType gtype, gpointer cb);

void
gtksharp_imcontext_override_preedit_start (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIMContextClass *)klass)->preedit_start = cb;
}

void gtksharp_imcontext_base_preedit_start (GtkIMContext* context);

void
gtksharp_imcontext_base_preedit_start (GtkIMContext* context)
{
	GtkIMContextClass *klass = (GtkIMContextClass *) get_threshold_class (G_OBJECT (context));
	if (klass->preedit_start)
		(* klass->preedit_start) (context);
}
void gtksharp_imcontext_override_retrieve_surrounding (GType gtype, gpointer cb);

void
gtksharp_imcontext_override_retrieve_surrounding (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIMContextClass *)klass)->retrieve_surrounding = cb;
}

gboolean gtksharp_imcontext_base_retrieve_surrounding (GtkIMContext* context);

gboolean
gtksharp_imcontext_base_retrieve_surrounding (GtkIMContext* context)
{
	GtkIMContextClass *klass = (GtkIMContextClass *) get_threshold_class (G_OBJECT (context));
	if (klass->retrieve_surrounding)
		return (* klass->retrieve_surrounding) (context);
	return FALSE;
}
void gtksharp_imcontext_override_delete_surrounding (GType gtype, gpointer cb);

void
gtksharp_imcontext_override_delete_surrounding (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIMContextClass *)klass)->delete_surrounding = cb;
}

gboolean gtksharp_imcontext_base_delete_surrounding (GtkIMContext* context, gint offset, gint n_chars);

gboolean
gtksharp_imcontext_base_delete_surrounding (GtkIMContext* context, gint offset, gint n_chars)
{
	GtkIMContextClass *klass = (GtkIMContextClass *) get_threshold_class (G_OBJECT (context));
	if (klass->delete_surrounding)
		return (* klass->delete_surrounding) (context, offset, n_chars);
	return FALSE;
}
void gtksharp_imcontext_override_preedit_end (GType gtype, gpointer cb);

void
gtksharp_imcontext_override_preedit_end (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIMContextClass *)klass)->preedit_end = cb;
}

void gtksharp_imcontext_base_preedit_end (GtkIMContext* context);

void
gtksharp_imcontext_base_preedit_end (GtkIMContext* context)
{
	GtkIMContextClass *klass = (GtkIMContextClass *) get_threshold_class (G_OBJECT (context));
	if (klass->preedit_end)
		(* klass->preedit_end) (context);
}
void gtksharp_imcontext_override_commit (GType gtype, gpointer cb);

void
gtksharp_imcontext_override_commit (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIMContextClass *)klass)->commit = cb;
}

void gtksharp_imcontext_base_commit (GtkIMContext* context, const gchar* str);

void
gtksharp_imcontext_base_commit (GtkIMContext* context, const gchar* str)
{
	GtkIMContextClass *klass = (GtkIMContextClass *) get_threshold_class (G_OBJECT (context));
	if (klass->commit)
		(* klass->commit) (context, str);
}
void gtksharp_imcontext_override_preedit_changed (GType gtype, gpointer cb);

void
gtksharp_imcontext_override_preedit_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkIMContextClass *)klass)->preedit_changed = cb;
}

void gtksharp_imcontext_base_preedit_changed (GtkIMContext* context);

void
gtksharp_imcontext_base_preedit_changed (GtkIMContext* context)
{
	GtkIMContextClass *klass = (GtkIMContextClass *) get_threshold_class (G_OBJECT (context));
	if (klass->preedit_changed)
		(* klass->preedit_changed) (context);
}
guint gtksharp_gtk_inputdialog_get_save_button_offset (void);

guint
gtksharp_gtk_inputdialog_get_save_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkInputDialog, save_button);
}

guint gtksharp_gtk_inputdialog_get_close_button_offset (void);

guint
gtksharp_gtk_inputdialog_get_close_button_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkInputDialog, close_button);
}

void gtksharp_inputdialog_override_enable_device (GType gtype, gpointer cb);

void
gtksharp_inputdialog_override_enable_device (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkInputDialogClass *)klass)->enable_device = cb;
}

void gtksharp_inputdialog_base_enable_device (GtkInputDialog* inputd, GdkDevice* device);

void
gtksharp_inputdialog_base_enable_device (GtkInputDialog* inputd, GdkDevice* device)
{
	GtkInputDialogClass *klass = (GtkInputDialogClass *) get_threshold_class (G_OBJECT (inputd));
	if (klass->enable_device)
		(* klass->enable_device) (inputd, device);
}
void gtksharp_inputdialog_override_disable_device (GType gtype, gpointer cb);

void
gtksharp_inputdialog_override_disable_device (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkInputDialogClass *)klass)->disable_device = cb;
}

void gtksharp_inputdialog_base_disable_device (GtkInputDialog* inputd, GdkDevice* device);

void
gtksharp_inputdialog_base_disable_device (GtkInputDialog* inputd, GdkDevice* device)
{
	GtkInputDialogClass *klass = (GtkInputDialogClass *) get_threshold_class (G_OBJECT (inputd));
	if (klass->disable_device)
		(* klass->disable_device) (inputd, device);
}
void gtksharp_item_override_deselect (GType gtype, gpointer cb);

void
gtksharp_item_override_deselect (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkItemClass *)klass)->deselect = cb;
}

void gtksharp_item_base_deselect (GtkItem* item);

void
gtksharp_item_base_deselect (GtkItem* item)
{
	GtkItemClass *klass = (GtkItemClass *) get_threshold_class (G_OBJECT (item));
	if (klass->deselect)
		(* klass->deselect) (item);
}
void gtksharp_item_override_select (GType gtype, gpointer cb);

void
gtksharp_item_override_select (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkItemClass *)klass)->select = cb;
}

void gtksharp_item_base_select (GtkItem* item);

void
gtksharp_item_base_select (GtkItem* item)
{
	GtkItemClass *klass = (GtkItemClass *) get_threshold_class (G_OBJECT (item));
	if (klass->select)
		(* klass->select) (item);
}
void gtksharp_item_override_toggle (GType gtype, gpointer cb);

void
gtksharp_item_override_toggle (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkItemClass *)klass)->toggle = cb;
}

void gtksharp_item_base_toggle (GtkItem* item);

void
gtksharp_item_base_toggle (GtkItem* item)
{
	GtkItemClass *klass = (GtkItemClass *) get_threshold_class (G_OBJECT (item));
	if (klass->toggle)
		(* klass->toggle) (item);
}
void gtksharp_label_override_populate_popup (GType gtype, gpointer cb);

void
gtksharp_label_override_populate_popup (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkLabelClass *)klass)->populate_popup = cb;
}

void gtksharp_label_base_populate_popup (GtkLabel* label, GtkMenu* menu);

void
gtksharp_label_base_populate_popup (GtkLabel* label, GtkMenu* menu)
{
	GtkLabelClass *klass = (GtkLabelClass *) get_threshold_class (G_OBJECT (label));
	if (klass->populate_popup)
		(* klass->populate_popup) (label, menu);
}
void gtksharp_label_override_copy_clipboard (GType gtype, gpointer cb);

void
gtksharp_label_override_copy_clipboard (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkLabelClass *)klass)->copy_clipboard = cb;
}

void gtksharp_label_base_copy_clipboard (GtkLabel* label);

void
gtksharp_label_base_copy_clipboard (GtkLabel* label)
{
	GtkLabelClass *klass = (GtkLabelClass *) get_threshold_class (G_OBJECT (label));
	if (klass->copy_clipboard)
		(* klass->copy_clipboard) (label);
}
void gtksharp_label_override_move_cursor (GType gtype, gpointer cb);

void
gtksharp_label_override_move_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkLabelClass *)klass)->move_cursor = cb;
}

void gtksharp_label_base_move_cursor (GtkLabel* label, GtkMovementStep step, gint count, gboolean extend_selection);

void
gtksharp_label_base_move_cursor (GtkLabel* label, GtkMovementStep step, gint count, gboolean extend_selection)
{
	GtkLabelClass *klass = (GtkLabelClass *) get_threshold_class (G_OBJECT (label));
	if (klass->move_cursor)
		(* klass->move_cursor) (label, step, count, extend_selection);
}
guint gtksharp_gtk_layout_get_bin_window_offset (void);

guint
gtksharp_gtk_layout_get_bin_window_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkLayout, bin_window);
}

void gtksharp_layout_override_set_scroll_adjustments (GType gtype, gpointer cb);

void
gtksharp_layout_override_set_scroll_adjustments (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkLayoutClass *)klass)->set_scroll_adjustments = cb;
}

void gtksharp_layout_base_set_scroll_adjustments (GtkLayout* layout, GtkAdjustment* hadjustment, GtkAdjustment* vadjustment);

void
gtksharp_layout_base_set_scroll_adjustments (GtkLayout* layout, GtkAdjustment* hadjustment, GtkAdjustment* vadjustment)
{
	GtkLayoutClass *klass = (GtkLayoutClass *) get_threshold_class (G_OBJECT (layout));
	if (klass->set_scroll_adjustments)
		(* klass->set_scroll_adjustments) (layout, hadjustment, vadjustment);
}
void gtksharp_menuitem_override_toggle_size_request (GType gtype, gpointer cb);

void
gtksharp_menuitem_override_toggle_size_request (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuItemClass *)klass)->toggle_size_request = cb;
}

void gtksharp_menuitem_base_toggle_size_request (GtkMenuItem* menu_item, gint* requisition);

void
gtksharp_menuitem_base_toggle_size_request (GtkMenuItem* menu_item, gint* requisition)
{
	GtkMenuItemClass *klass = (GtkMenuItemClass *) get_threshold_class (G_OBJECT (menu_item));
	if (klass->toggle_size_request)
		(* klass->toggle_size_request) (menu_item, requisition);
}
void gtksharp_menuitem_override_activate_item (GType gtype, gpointer cb);

void
gtksharp_menuitem_override_activate_item (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuItemClass *)klass)->activate_item = cb;
}

void gtksharp_menuitem_base_activate_item (GtkMenuItem* menu_item);

void
gtksharp_menuitem_base_activate_item (GtkMenuItem* menu_item)
{
	GtkMenuItemClass *klass = (GtkMenuItemClass *) get_threshold_class (G_OBJECT (menu_item));
	if (klass->activate_item)
		(* klass->activate_item) (menu_item);
}
void gtksharp_menuitem_override_activate (GType gtype, gpointer cb);

void
gtksharp_menuitem_override_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuItemClass *)klass)->activate = cb;
}

void gtksharp_menuitem_base_activate (GtkMenuItem* menu_item);

void
gtksharp_menuitem_base_activate (GtkMenuItem* menu_item)
{
	GtkMenuItemClass *klass = (GtkMenuItemClass *) get_threshold_class (G_OBJECT (menu_item));
	if (klass->activate)
		(* klass->activate) (menu_item);
}
void gtksharp_menuitem_override_toggle_size_allocate (GType gtype, gpointer cb);

void
gtksharp_menuitem_override_toggle_size_allocate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuItemClass *)klass)->toggle_size_allocate = cb;
}

void gtksharp_menuitem_base_toggle_size_allocate (GtkMenuItem* menu_item, gint allocation);

void
gtksharp_menuitem_base_toggle_size_allocate (GtkMenuItem* menu_item, gint allocation)
{
	GtkMenuItemClass *klass = (GtkMenuItemClass *) get_threshold_class (G_OBJECT (menu_item));
	if (klass->toggle_size_allocate)
		(* klass->toggle_size_allocate) (menu_item, allocation);
}
void gtksharp_menushell_override_move_selected (GType gtype, gpointer cb);

void
gtksharp_menushell_override_move_selected (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuShellClass *)klass)->move_selected = cb;
}

gboolean gtksharp_menushell_base_move_selected (GtkMenuShell* menu_shell, gint distance);

gboolean
gtksharp_menushell_base_move_selected (GtkMenuShell* menu_shell, gint distance)
{
	GtkMenuShellClass *klass = (GtkMenuShellClass *) get_threshold_class (G_OBJECT (menu_shell));
	if (klass->move_selected)
		return (* klass->move_selected) (menu_shell, distance);
	return FALSE;
}
void gtksharp_menushell_override_deactivate (GType gtype, gpointer cb);

void
gtksharp_menushell_override_deactivate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuShellClass *)klass)->deactivate = cb;
}

void gtksharp_menushell_base_deactivate (GtkMenuShell* menu_shell);

void
gtksharp_menushell_base_deactivate (GtkMenuShell* menu_shell)
{
	GtkMenuShellClass *klass = (GtkMenuShellClass *) get_threshold_class (G_OBJECT (menu_shell));
	if (klass->deactivate)
		(* klass->deactivate) (menu_shell);
}
void gtksharp_menushell_override_move_current (GType gtype, gpointer cb);

void
gtksharp_menushell_override_move_current (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuShellClass *)klass)->move_current = cb;
}

void gtksharp_menushell_base_move_current (GtkMenuShell* menu_shell, GtkMenuDirectionType direction);

void
gtksharp_menushell_base_move_current (GtkMenuShell* menu_shell, GtkMenuDirectionType direction)
{
	GtkMenuShellClass *klass = (GtkMenuShellClass *) get_threshold_class (G_OBJECT (menu_shell));
	if (klass->move_current)
		(* klass->move_current) (menu_shell, direction);
}
void gtksharp_menushell_override_activate_current (GType gtype, gpointer cb);

void
gtksharp_menushell_override_activate_current (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuShellClass *)klass)->activate_current = cb;
}

void gtksharp_menushell_base_activate_current (GtkMenuShell* menu_shell, gboolean force_hide);

void
gtksharp_menushell_base_activate_current (GtkMenuShell* menu_shell, gboolean force_hide)
{
	GtkMenuShellClass *klass = (GtkMenuShellClass *) get_threshold_class (G_OBJECT (menu_shell));
	if (klass->activate_current)
		(* klass->activate_current) (menu_shell, force_hide);
}
void gtksharp_menushell_override_selection_done (GType gtype, gpointer cb);

void
gtksharp_menushell_override_selection_done (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuShellClass *)klass)->selection_done = cb;
}

void gtksharp_menushell_base_selection_done (GtkMenuShell* menu_shell);

void
gtksharp_menushell_base_selection_done (GtkMenuShell* menu_shell)
{
	GtkMenuShellClass *klass = (GtkMenuShellClass *) get_threshold_class (G_OBJECT (menu_shell));
	if (klass->selection_done)
		(* klass->selection_done) (menu_shell);
}
void gtksharp_menushell_override_cancel (GType gtype, gpointer cb);

void
gtksharp_menushell_override_cancel (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuShellClass *)klass)->cancel = cb;
}

void gtksharp_menushell_base_cancel (GtkMenuShell* menu_shell);

void
gtksharp_menushell_base_cancel (GtkMenuShell* menu_shell)
{
	GtkMenuShellClass *klass = (GtkMenuShellClass *) get_threshold_class (G_OBJECT (menu_shell));
	if (klass->cancel)
		(* klass->cancel) (menu_shell);
}
void gtksharp_menutoolbutton_override_show_menu (GType gtype, gpointer cb);

void
gtksharp_menutoolbutton_override_show_menu (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkMenuToolButtonClass *)klass)->show_menu = cb;
}

void gtksharp_menutoolbutton_base_show_menu (GtkMenuToolButton* button);

void
gtksharp_menutoolbutton_base_show_menu (GtkMenuToolButton* button)
{
	GtkMenuToolButtonClass *klass = (GtkMenuToolButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->show_menu)
		(* klass->show_menu) (button);
}
void gtksharp_notebook_override_select_page (GType gtype, gpointer cb);

void
gtksharp_notebook_override_select_page (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkNotebookClass *)klass)->select_page = cb;
}

gboolean gtksharp_notebook_base_select_page (GtkNotebook* notebook, gboolean move_focus);

gboolean
gtksharp_notebook_base_select_page (GtkNotebook* notebook, gboolean move_focus)
{
	GtkNotebookClass *klass = (GtkNotebookClass *) get_threshold_class (G_OBJECT (notebook));
	if (klass->select_page)
		return (* klass->select_page) (notebook, move_focus);
	return FALSE;
}
void gtksharp_notebook_override_switch_page (GType gtype, gpointer cb);

void
gtksharp_notebook_override_switch_page (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkNotebookClass *)klass)->switch_page = cb;
}

void gtksharp_notebook_base_switch_page (GtkNotebook* notebook, GtkNotebookPage* page, guint page_num);

void
gtksharp_notebook_base_switch_page (GtkNotebook* notebook, GtkNotebookPage* page, guint page_num)
{
	GtkNotebookClass *klass = (GtkNotebookClass *) get_threshold_class (G_OBJECT (notebook));
	if (klass->switch_page)
		(* klass->switch_page) (notebook, page, page_num);
}
void gtksharp_notebook_override_focus_tab (GType gtype, gpointer cb);

void
gtksharp_notebook_override_focus_tab (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkNotebookClass *)klass)->focus_tab = cb;
}

gboolean gtksharp_notebook_base_focus_tab (GtkNotebook* notebook, GtkNotebookTab type);

gboolean
gtksharp_notebook_base_focus_tab (GtkNotebook* notebook, GtkNotebookTab type)
{
	GtkNotebookClass *klass = (GtkNotebookClass *) get_threshold_class (G_OBJECT (notebook));
	if (klass->focus_tab)
		return (* klass->focus_tab) (notebook, type);
	return FALSE;
}
void gtksharp_notebook_override_reorder_tab (GType gtype, gpointer cb);

void
gtksharp_notebook_override_reorder_tab (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkNotebookClass *)klass)->reorder_tab = cb;
}

void gtksharp_notebook_base_reorder_tab (GtkNotebook* notebook, GtkDirectionType direction, gboolean move_to_last);

void
gtksharp_notebook_base_reorder_tab (GtkNotebook* notebook, GtkDirectionType direction, gboolean move_to_last)
{
	GtkNotebookClass *klass = (GtkNotebookClass *) get_threshold_class (G_OBJECT (notebook));
	if (klass->reorder_tab)
		(* klass->reorder_tab) (notebook, direction, move_to_last);
}
void gtksharp_notebook_override_create_window (GType gtype, gpointer cb);

void
gtksharp_notebook_override_create_window (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkNotebookClass *)klass)->create_window = cb;
}

GtkNotebook* gtksharp_notebook_base_create_window (GtkNotebook* notebook, GtkWidget* page, gint x, gint y);

GtkNotebook*
gtksharp_notebook_base_create_window (GtkNotebook* notebook, GtkWidget* page, gint x, gint y)
{
	GtkNotebookClass *klass = (GtkNotebookClass *) get_threshold_class (G_OBJECT (notebook));
	if (klass->create_window)
		return (* klass->create_window) (notebook, page, x, y);
	return NULL;
}
void gtksharp_notebook_override_change_current_page (GType gtype, gpointer cb);

void
gtksharp_notebook_override_change_current_page (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkNotebookClass *)klass)->change_current_page = cb;
}

void gtksharp_notebook_base_change_current_page (GtkNotebook* notebook, gint offset);

void
gtksharp_notebook_base_change_current_page (GtkNotebook* notebook, gint offset)
{
	GtkNotebookClass *klass = (GtkNotebookClass *) get_threshold_class (G_OBJECT (notebook));
	if (klass->change_current_page)
		(* klass->change_current_page) (notebook, offset);
}
void gtksharp_notebook_override_move_focus_out (GType gtype, gpointer cb);

void
gtksharp_notebook_override_move_focus_out (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkNotebookClass *)klass)->move_focus_out = cb;
}

void gtksharp_notebook_base_move_focus_out (GtkNotebook* notebook, GtkDirectionType direction);

void
gtksharp_notebook_base_move_focus_out (GtkNotebook* notebook, GtkDirectionType direction)
{
	GtkNotebookClass *klass = (GtkNotebookClass *) get_threshold_class (G_OBJECT (notebook));
	if (klass->move_focus_out)
		(* klass->move_focus_out) (notebook, direction);
}
void gtksharp_optionmenu_override_changed (GType gtype, gpointer cb);

void
gtksharp_optionmenu_override_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkOptionMenuClass *)klass)->changed = cb;
}

void gtksharp_optionmenu_base_changed (GtkOptionMenu* option_menu);

void
gtksharp_optionmenu_base_changed (GtkOptionMenu* option_menu)
{
	GtkOptionMenuClass *klass = (GtkOptionMenuClass *) get_threshold_class (G_OBJECT (option_menu));
	if (klass->changed)
		(* klass->changed) (option_menu);
}
void gtksharp_paned_override_move_handle (GType gtype, gpointer cb);

void
gtksharp_paned_override_move_handle (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPanedClass *)klass)->move_handle = cb;
}

gboolean gtksharp_paned_base_move_handle (GtkPaned* paned, GtkScrollType scroll);

gboolean
gtksharp_paned_base_move_handle (GtkPaned* paned, GtkScrollType scroll)
{
	GtkPanedClass *klass = (GtkPanedClass *) get_threshold_class (G_OBJECT (paned));
	if (klass->move_handle)
		return (* klass->move_handle) (paned, scroll);
	return FALSE;
}
void gtksharp_paned_override_cancel_position (GType gtype, gpointer cb);

void
gtksharp_paned_override_cancel_position (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPanedClass *)klass)->cancel_position = cb;
}

gboolean gtksharp_paned_base_cancel_position (GtkPaned* paned);

gboolean
gtksharp_paned_base_cancel_position (GtkPaned* paned)
{
	GtkPanedClass *klass = (GtkPanedClass *) get_threshold_class (G_OBJECT (paned));
	if (klass->cancel_position)
		return (* klass->cancel_position) (paned);
	return FALSE;
}
void gtksharp_paned_override_toggle_handle_focus (GType gtype, gpointer cb);

void
gtksharp_paned_override_toggle_handle_focus (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPanedClass *)klass)->toggle_handle_focus = cb;
}

gboolean gtksharp_paned_base_toggle_handle_focus (GtkPaned* paned);

gboolean
gtksharp_paned_base_toggle_handle_focus (GtkPaned* paned)
{
	GtkPanedClass *klass = (GtkPanedClass *) get_threshold_class (G_OBJECT (paned));
	if (klass->toggle_handle_focus)
		return (* klass->toggle_handle_focus) (paned);
	return FALSE;
}
void gtksharp_paned_override_cycle_handle_focus (GType gtype, gpointer cb);

void
gtksharp_paned_override_cycle_handle_focus (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPanedClass *)klass)->cycle_handle_focus = cb;
}

gboolean gtksharp_paned_base_cycle_handle_focus (GtkPaned* paned, gboolean reverse);

gboolean
gtksharp_paned_base_cycle_handle_focus (GtkPaned* paned, gboolean reverse)
{
	GtkPanedClass *klass = (GtkPanedClass *) get_threshold_class (G_OBJECT (paned));
	if (klass->cycle_handle_focus)
		return (* klass->cycle_handle_focus) (paned, reverse);
	return FALSE;
}
void gtksharp_paned_override_cycle_child_focus (GType gtype, gpointer cb);

void
gtksharp_paned_override_cycle_child_focus (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPanedClass *)klass)->cycle_child_focus = cb;
}

gboolean gtksharp_paned_base_cycle_child_focus (GtkPaned* paned, gboolean reverse);

gboolean
gtksharp_paned_base_cycle_child_focus (GtkPaned* paned, gboolean reverse)
{
	GtkPanedClass *klass = (GtkPanedClass *) get_threshold_class (G_OBJECT (paned));
	if (klass->cycle_child_focus)
		return (* klass->cycle_child_focus) (paned, reverse);
	return FALSE;
}
void gtksharp_paned_override_accept_position (GType gtype, gpointer cb);

void
gtksharp_paned_override_accept_position (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPanedClass *)klass)->accept_position = cb;
}

gboolean gtksharp_paned_base_accept_position (GtkPaned* paned);

gboolean
gtksharp_paned_base_accept_position (GtkPaned* paned)
{
	GtkPanedClass *klass = (GtkPanedClass *) get_threshold_class (G_OBJECT (paned));
	if (klass->accept_position)
		return (* klass->accept_position) (paned);
	return FALSE;
}
void gtksharp_plug_override_embedded (GType gtype, gpointer cb);

void
gtksharp_plug_override_embedded (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPlugClass *)klass)->embedded = cb;
}

void gtksharp_plug_base_embedded (GtkPlug* plug);

void
gtksharp_plug_base_embedded (GtkPlug* plug)
{
	GtkPlugClass *klass = (GtkPlugClass *) get_threshold_class (G_OBJECT (plug));
	if (klass->embedded)
		(* klass->embedded) (plug);
}
void gtksharp_printoperation_override_draw_page (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_draw_page (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->draw_page = cb;
}

void gtksharp_printoperation_base_draw_page (GtkPrintOperation* operation, GtkPrintContext* context, gint page_nr);

void
gtksharp_printoperation_base_draw_page (GtkPrintOperation* operation, GtkPrintContext* context, gint page_nr)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->draw_page)
		(* klass->draw_page) (operation, context, page_nr);
}
void gtksharp_printoperation_override_status_changed (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_status_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->status_changed = cb;
}

void gtksharp_printoperation_base_status_changed (GtkPrintOperation* operation);

void
gtksharp_printoperation_base_status_changed (GtkPrintOperation* operation)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->status_changed)
		(* klass->status_changed) (operation);
}
void gtksharp_printoperation_override_done (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_done (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->done = cb;
}

void gtksharp_printoperation_base_done (GtkPrintOperation* operation, GtkPrintOperationResult result);

void
gtksharp_printoperation_base_done (GtkPrintOperation* operation, GtkPrintOperationResult result)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->done)
		(* klass->done) (operation, result);
}
void gtksharp_printoperation_override_custom_widget_apply (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_custom_widget_apply (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->custom_widget_apply = cb;
}

void gtksharp_printoperation_base_custom_widget_apply (GtkPrintOperation* operation, GtkWidget* widget);

void
gtksharp_printoperation_base_custom_widget_apply (GtkPrintOperation* operation, GtkWidget* widget)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->custom_widget_apply)
		(* klass->custom_widget_apply) (operation, widget);
}
void gtksharp_printoperation_override_request_page_setup (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_request_page_setup (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->request_page_setup = cb;
}

void gtksharp_printoperation_base_request_page_setup (GtkPrintOperation* operation, GtkPrintContext* context, gint page_nr, GtkPageSetup* setup);

void
gtksharp_printoperation_base_request_page_setup (GtkPrintOperation* operation, GtkPrintContext* context, gint page_nr, GtkPageSetup* setup)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->request_page_setup)
		(* klass->request_page_setup) (operation, context, page_nr, setup);
}
void gtksharp_printoperation_override_create_custom_widget (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_create_custom_widget (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->create_custom_widget = cb;
}

GtkWidget* gtksharp_printoperation_base_create_custom_widget (GtkPrintOperation* operation);

GtkWidget*
gtksharp_printoperation_base_create_custom_widget (GtkPrintOperation* operation)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->create_custom_widget)
		return (* klass->create_custom_widget) (operation);
	return NULL;
}
void gtksharp_printoperation_override_paginate (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_paginate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->paginate = cb;
}

gboolean gtksharp_printoperation_base_paginate (GtkPrintOperation* operation, GtkPrintContext* context);

gboolean
gtksharp_printoperation_base_paginate (GtkPrintOperation* operation, GtkPrintContext* context)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->paginate)
		return (* klass->paginate) (operation, context);
	return FALSE;
}
void gtksharp_printoperation_override_preview (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_preview (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->preview = cb;
}

gboolean gtksharp_printoperation_base_preview (GtkPrintOperation* operation, GtkPrintOperationPreview* preview, GtkPrintContext* context, GtkWindow* parent);

gboolean
gtksharp_printoperation_base_preview (GtkPrintOperation* operation, GtkPrintOperationPreview* preview, GtkPrintContext* context, GtkWindow* parent)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->preview)
		return (* klass->preview) (operation, preview, context, parent);
	return FALSE;
}
void gtksharp_printoperation_override_begin_print (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_begin_print (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->begin_print = cb;
}

void gtksharp_printoperation_base_begin_print (GtkPrintOperation* operation, GtkPrintContext* context);

void
gtksharp_printoperation_base_begin_print (GtkPrintOperation* operation, GtkPrintContext* context)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->begin_print)
		(* klass->begin_print) (operation, context);
}
void gtksharp_printoperation_override_end_print (GType gtype, gpointer cb);

void
gtksharp_printoperation_override_end_print (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkPrintOperationClass *)klass)->end_print = cb;
}

void gtksharp_printoperation_base_end_print (GtkPrintOperation* operation, GtkPrintContext* context);

void
gtksharp_printoperation_base_end_print (GtkPrintOperation* operation, GtkPrintContext* context)
{
	GtkPrintOperationClass *klass = (GtkPrintOperationClass *) get_threshold_class (G_OBJECT (operation));
	if (klass->end_print)
		(* klass->end_print) (operation, context);
}
void gtksharp_radioaction_override_changed (GType gtype, gpointer cb);

void
gtksharp_radioaction_override_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkRadioActionClass *)klass)->changed = cb;
}

void gtksharp_radioaction_base_changed (GtkRadioAction* action, GtkRadioAction* current);

void
gtksharp_radioaction_base_changed (GtkRadioAction* action, GtkRadioAction* current)
{
	GtkRadioActionClass *klass = (GtkRadioActionClass *) get_threshold_class (G_OBJECT (action));
	if (klass->changed)
		(* klass->changed) (action, current);
}
void gtksharp_radiobutton_override_group_changed (GType gtype, gpointer cb);

void
gtksharp_radiobutton_override_group_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkRadioButtonClass *)klass)->group_changed = cb;
}

void gtksharp_radiobutton_base_group_changed (GtkRadioButton* radio_button);

void
gtksharp_radiobutton_base_group_changed (GtkRadioButton* radio_button)
{
	GtkRadioButtonClass *klass = (GtkRadioButtonClass *) get_threshold_class (G_OBJECT (radio_button));
	if (klass->group_changed)
		(* klass->group_changed) (radio_button);
}
void gtksharp_radiomenuitem_override_group_changed (GType gtype, gpointer cb);

void
gtksharp_radiomenuitem_override_group_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkRadioMenuItemClass *)klass)->group_changed = cb;
}

void gtksharp_radiomenuitem_base_group_changed (GtkRadioMenuItem* radio_menu_item);

void
gtksharp_radiomenuitem_base_group_changed (GtkRadioMenuItem* radio_menu_item)
{
	GtkRadioMenuItemClass *klass = (GtkRadioMenuItemClass *) get_threshold_class (G_OBJECT (radio_menu_item));
	if (klass->group_changed)
		(* klass->group_changed) (radio_menu_item);
}
void gtksharp_range_override_move_slider (GType gtype, gpointer cb);

void
gtksharp_range_override_move_slider (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkRangeClass *)klass)->move_slider = cb;
}

void gtksharp_range_base_move_slider (GtkRange* range, GtkScrollType scroll);

void
gtksharp_range_base_move_slider (GtkRange* range, GtkScrollType scroll)
{
	GtkRangeClass *klass = (GtkRangeClass *) get_threshold_class (G_OBJECT (range));
	if (klass->move_slider)
		(* klass->move_slider) (range, scroll);
}
void gtksharp_range_override_change_value (GType gtype, gpointer cb);

void
gtksharp_range_override_change_value (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkRangeClass *)klass)->change_value = cb;
}

gboolean gtksharp_range_base_change_value (GtkRange* range, GtkScrollType scroll, gdouble new_value);

gboolean
gtksharp_range_base_change_value (GtkRange* range, GtkScrollType scroll, gdouble new_value)
{
	GtkRangeClass *klass = (GtkRangeClass *) get_threshold_class (G_OBJECT (range));
	if (klass->change_value)
		return (* klass->change_value) (range, scroll, new_value);
	return FALSE;
}
void gtksharp_range_override_value_changed (GType gtype, gpointer cb);

void
gtksharp_range_override_value_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkRangeClass *)klass)->value_changed = cb;
}

void gtksharp_range_base_value_changed (GtkRange* range);

void
gtksharp_range_base_value_changed (GtkRange* range)
{
	GtkRangeClass *klass = (GtkRangeClass *) get_threshold_class (G_OBJECT (range));
	if (klass->value_changed)
		(* klass->value_changed) (range);
}
void gtksharp_range_override_adjust_bounds (GType gtype, gpointer cb);

void
gtksharp_range_override_adjust_bounds (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkRangeClass *)klass)->adjust_bounds = cb;
}

void gtksharp_range_base_adjust_bounds (GtkRange* range, gdouble new_value);

void
gtksharp_range_base_adjust_bounds (GtkRange* range, gdouble new_value)
{
	GtkRangeClass *klass = (GtkRangeClass *) get_threshold_class (G_OBJECT (range));
	if (klass->adjust_bounds)
		(* klass->adjust_bounds) (range, new_value);
}
guint gtksharp_gtk_rcstyle_get_ythickness_offset (void);

guint
gtksharp_gtk_rcstyle_get_ythickness_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkRcStyle, ythickness);
}

guint gtksharp_gtk_rcstyle_get_xthickness_offset (void);

guint
gtksharp_gtk_rcstyle_get_xthickness_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkRcStyle, xthickness);
}

guint gtksharp_gtk_rcstyle_get_name_offset (void);

guint
gtksharp_gtk_rcstyle_get_name_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkRcStyle, name);
}

guint gtksharp_gtk_rcstyle_get_font_desc_offset (void);

guint
gtksharp_gtk_rcstyle_get_font_desc_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkRcStyle, font_desc);
}

void gtksharp_recentmanager_override_changed (GType gtype, gpointer cb);

void
gtksharp_recentmanager_override_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkRecentManagerClass *)klass)->changed = cb;
}

void gtksharp_recentmanager_base_changed (GtkRecentManager* manager);

void
gtksharp_recentmanager_base_changed (GtkRecentManager* manager)
{
	GtkRecentManagerClass *klass = (GtkRecentManagerClass *) get_threshold_class (G_OBJECT (manager));
	if (klass->changed)
		(* klass->changed) (manager);
}
void gtksharp_scale_override_format_value (GType gtype, gpointer cb);

void
gtksharp_scale_override_format_value (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkScaleClass *)klass)->format_value = cb;
}

gchar* gtksharp_scale_base_format_value (GtkScale* scale, gdouble value);

gchar*
gtksharp_scale_base_format_value (GtkScale* scale, gdouble value)
{
	GtkScaleClass *klass = (GtkScaleClass *) get_threshold_class (G_OBJECT (scale));
	if (klass->format_value)
		return (* klass->format_value) (scale, value);
	return NULL;
}
void gtksharp_scalebutton_override_value_changed (GType gtype, gpointer cb);

void
gtksharp_scalebutton_override_value_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkScaleButtonClass *)klass)->value_changed = cb;
}

void gtksharp_scalebutton_base_value_changed (GtkScaleButton* button, gdouble value);

void
gtksharp_scalebutton_base_value_changed (GtkScaleButton* button, gdouble value)
{
	GtkScaleButtonClass *klass = (GtkScaleButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->value_changed)
		(* klass->value_changed) (button, value);
}
void gtksharp_scrolledwindow_override_move_focus_out (GType gtype, gpointer cb);

void
gtksharp_scrolledwindow_override_move_focus_out (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkScrolledWindowClass *)klass)->move_focus_out = cb;
}

void gtksharp_scrolledwindow_base_move_focus_out (GtkScrolledWindow* scrolled_window, GtkDirectionType direction);

void
gtksharp_scrolledwindow_base_move_focus_out (GtkScrolledWindow* scrolled_window, GtkDirectionType direction)
{
	GtkScrolledWindowClass *klass = (GtkScrolledWindowClass *) get_threshold_class (G_OBJECT (scrolled_window));
	if (klass->move_focus_out)
		(* klass->move_focus_out) (scrolled_window, direction);
}
void gtksharp_scrolledwindow_override_scroll_child (GType gtype, gpointer cb);

void
gtksharp_scrolledwindow_override_scroll_child (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkScrolledWindowClass *)klass)->scroll_child = cb;
}

void gtksharp_scrolledwindow_base_scroll_child (GtkScrolledWindow* scrolled_window, GtkScrollType scroll, gboolean horizontal);

void
gtksharp_scrolledwindow_base_scroll_child (GtkScrolledWindow* scrolled_window, GtkScrollType scroll, gboolean horizontal)
{
	GtkScrolledWindowClass *klass = (GtkScrolledWindowClass *) get_threshold_class (G_OBJECT (scrolled_window));
	if (klass->scroll_child)
		(* klass->scroll_child) (scrolled_window, scroll, horizontal);
}
void gtksharp_socket_override_plug_added (GType gtype, gpointer cb);

void
gtksharp_socket_override_plug_added (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkSocketClass *)klass)->plug_added = cb;
}

void gtksharp_socket_base_plug_added (GtkSocket* socket_);

void
gtksharp_socket_base_plug_added (GtkSocket* socket_)
{
	GtkSocketClass *klass = (GtkSocketClass *) get_threshold_class (G_OBJECT (socket_));
	if (klass->plug_added)
		(* klass->plug_added) (socket_);
}
void gtksharp_socket_override_plug_removed (GType gtype, gpointer cb);

void
gtksharp_socket_override_plug_removed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkSocketClass *)klass)->plug_removed = cb;
}

gboolean gtksharp_socket_base_plug_removed (GtkSocket* socket_);

gboolean
gtksharp_socket_base_plug_removed (GtkSocket* socket_)
{
	GtkSocketClass *klass = (GtkSocketClass *) get_threshold_class (G_OBJECT (socket_));
	if (klass->plug_removed)
		return (* klass->plug_removed) (socket_);
	return FALSE;
}
void gtksharp_spinbutton_override_input (GType gtype, gpointer cb);

void
gtksharp_spinbutton_override_input (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkSpinButtonClass *)klass)->input = cb;
}

gint gtksharp_spinbutton_base_input (GtkSpinButton* spin_button, gdouble* new_value);

gint
gtksharp_spinbutton_base_input (GtkSpinButton* spin_button, gdouble* new_value)
{
	GtkSpinButtonClass *klass = (GtkSpinButtonClass *) get_threshold_class (G_OBJECT (spin_button));
	if (klass->input)
		return (* klass->input) (spin_button, new_value);
	return 0;
}
void gtksharp_spinbutton_override_change_value (GType gtype, gpointer cb);

void
gtksharp_spinbutton_override_change_value (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkSpinButtonClass *)klass)->change_value = cb;
}

void gtksharp_spinbutton_base_change_value (GtkSpinButton* spin_button, GtkScrollType scroll);

void
gtksharp_spinbutton_base_change_value (GtkSpinButton* spin_button, GtkScrollType scroll)
{
	GtkSpinButtonClass *klass = (GtkSpinButtonClass *) get_threshold_class (G_OBJECT (spin_button));
	if (klass->change_value)
		(* klass->change_value) (spin_button, scroll);
}
void gtksharp_spinbutton_override_value_changed (GType gtype, gpointer cb);

void
gtksharp_spinbutton_override_value_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkSpinButtonClass *)klass)->value_changed = cb;
}

void gtksharp_spinbutton_base_value_changed (GtkSpinButton* spin_button);

void
gtksharp_spinbutton_base_value_changed (GtkSpinButton* spin_button)
{
	GtkSpinButtonClass *klass = (GtkSpinButtonClass *) get_threshold_class (G_OBJECT (spin_button));
	if (klass->value_changed)
		(* klass->value_changed) (spin_button);
}
void gtksharp_spinbutton_override_wrapped (GType gtype, gpointer cb);

void
gtksharp_spinbutton_override_wrapped (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkSpinButtonClass *)klass)->wrapped = cb;
}

void gtksharp_spinbutton_base_wrapped (GtkSpinButton* spin_button);

void
gtksharp_spinbutton_base_wrapped (GtkSpinButton* spin_button)
{
	GtkSpinButtonClass *klass = (GtkSpinButtonClass *) get_threshold_class (G_OBJECT (spin_button));
	if (klass->wrapped)
		(* klass->wrapped) (spin_button);
}
void gtksharp_spinbutton_override_output (GType gtype, gpointer cb);

void
gtksharp_spinbutton_override_output (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkSpinButtonClass *)klass)->output = cb;
}

gint gtksharp_spinbutton_base_output (GtkSpinButton* spin_button);

gint
gtksharp_spinbutton_base_output (GtkSpinButton* spin_button)
{
	GtkSpinButtonClass *klass = (GtkSpinButtonClass *) get_threshold_class (G_OBJECT (spin_button));
	if (klass->output)
		return (* klass->output) (spin_button);
	return 0;
}
void gtksharp_statusbar_override_text_popped (GType gtype, gpointer cb);

void
gtksharp_statusbar_override_text_popped (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkStatusbarClass *)klass)->text_popped = cb;
}

void gtksharp_statusbar_base_text_popped (GtkStatusbar* statusbar, guint context_id, const gchar* text);

void
gtksharp_statusbar_base_text_popped (GtkStatusbar* statusbar, guint context_id, const gchar* text)
{
	GtkStatusbarClass *klass = (GtkStatusbarClass *) get_threshold_class (G_OBJECT (statusbar));
	if (klass->text_popped)
		(* klass->text_popped) (statusbar, context_id, text);
}
void gtksharp_statusbar_override_text_pushed (GType gtype, gpointer cb);

void
gtksharp_statusbar_override_text_pushed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkStatusbarClass *)klass)->text_pushed = cb;
}

void gtksharp_statusbar_base_text_pushed (GtkStatusbar* statusbar, guint context_id, const gchar* text);

void
gtksharp_statusbar_base_text_pushed (GtkStatusbar* statusbar, guint context_id, const gchar* text)
{
	GtkStatusbarClass *klass = (GtkStatusbarClass *) get_threshold_class (G_OBJECT (statusbar));
	if (klass->text_pushed)
		(* klass->text_pushed) (statusbar, context_id, text);
}
void gtksharp_statusicon_override_popup_menu (GType gtype, gpointer cb);

void
gtksharp_statusicon_override_popup_menu (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkStatusIconClass *)klass)->popup_menu = cb;
}

void gtksharp_statusicon_base_popup_menu (GtkStatusIcon* status_icon, guint button, guint32 activate_time);

void
gtksharp_statusicon_base_popup_menu (GtkStatusIcon* status_icon, guint button, guint32 activate_time)
{
	GtkStatusIconClass *klass = (GtkStatusIconClass *) get_threshold_class (G_OBJECT (status_icon));
	if (klass->popup_menu)
		(* klass->popup_menu) (status_icon, button, activate_time);
}
void gtksharp_statusicon_override_activate (GType gtype, gpointer cb);

void
gtksharp_statusicon_override_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkStatusIconClass *)klass)->activate = cb;
}

void gtksharp_statusicon_base_activate (GtkStatusIcon* status_icon);

void
gtksharp_statusicon_base_activate (GtkStatusIcon* status_icon)
{
	GtkStatusIconClass *klass = (GtkStatusIconClass *) get_threshold_class (G_OBJECT (status_icon));
	if (klass->activate)
		(* klass->activate) (status_icon);
}
void gtksharp_statusicon_override_size_changed (GType gtype, gpointer cb);

void
gtksharp_statusicon_override_size_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkStatusIconClass *)klass)->size_changed = cb;
}

gboolean gtksharp_statusicon_base_size_changed (GtkStatusIcon* status_icon, gint size);

gboolean
gtksharp_statusicon_base_size_changed (GtkStatusIcon* status_icon, gint size)
{
	GtkStatusIconClass *klass = (GtkStatusIconClass *) get_threshold_class (G_OBJECT (status_icon));
	if (klass->size_changed)
		return (* klass->size_changed) (status_icon, size);
	return FALSE;
}
guint gtksharp_gtk_style_get_xthickness_offset (void);

guint
gtksharp_gtk_style_get_xthickness_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkStyle, xthickness);
}

guint gtksharp_gtk_style_get_white_offset (void);

guint
gtksharp_gtk_style_get_white_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkStyle, white);
}

guint gtksharp_gtk_style_get_black_offset (void);

guint
gtksharp_gtk_style_get_black_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkStyle, black);
}

guint gtksharp_gtk_style_get_ythickness_offset (void);

guint
gtksharp_gtk_style_get_ythickness_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkStyle, ythickness);
}

guint gtksharp_gtk_style_get_font_desc_offset (void);

guint
gtksharp_gtk_style_get_font_desc_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkStyle, font_desc);
}

void gtksharp_style_override_realize (GType gtype, gpointer cb);

void
gtksharp_style_override_realize (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkStyleClass *)klass)->realize = cb;
}

void gtksharp_style_base_realize (GtkStyle* style);

void
gtksharp_style_base_realize (GtkStyle* style)
{
	GtkStyleClass *klass = (GtkStyleClass *) get_threshold_class (G_OBJECT (style));
	if (klass->realize)
		(* klass->realize) (style);
}
void gtksharp_style_override_unrealize (GType gtype, gpointer cb);

void
gtksharp_style_override_unrealize (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkStyleClass *)klass)->unrealize = cb;
}

void gtksharp_style_base_unrealize (GtkStyle* style);

void
gtksharp_style_base_unrealize (GtkStyle* style)
{
	GtkStyleClass *klass = (GtkStyleClass *) get_threshold_class (G_OBJECT (style));
	if (klass->unrealize)
		(* klass->unrealize) (style);
}
void gtksharp_textbuffer_override_insert_text (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_insert_text (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->insert_text = cb;
}

void gtksharp_textbuffer_base_insert_text (GtkTextBuffer* buffer, GtkTextIter* pos, const gchar* text, gint length);

void
gtksharp_textbuffer_base_insert_text (GtkTextBuffer* buffer, GtkTextIter* pos, const gchar* text, gint length)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->insert_text)
		(* klass->insert_text) (buffer, pos, text, length);
}
void gtksharp_textbuffer_override_remove_tag (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_remove_tag (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->remove_tag = cb;
}

void gtksharp_textbuffer_base_remove_tag (GtkTextBuffer* buffer, GtkTextTag* tag, const GtkTextIter* start_char, const GtkTextIter* end_char);

void
gtksharp_textbuffer_base_remove_tag (GtkTextBuffer* buffer, GtkTextTag* tag, const GtkTextIter* start_char, const GtkTextIter* end_char)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->remove_tag)
		(* klass->remove_tag) (buffer, tag, start_char, end_char);
}
void gtksharp_textbuffer_override_mark_set (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_mark_set (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->mark_set = cb;
}

void gtksharp_textbuffer_base_mark_set (GtkTextBuffer* buffer, const GtkTextIter* location, GtkTextMark* mark);

void
gtksharp_textbuffer_base_mark_set (GtkTextBuffer* buffer, const GtkTextIter* location, GtkTextMark* mark)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->mark_set)
		(* klass->mark_set) (buffer, location, mark);
}
void gtksharp_textbuffer_override_changed (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->changed = cb;
}

void gtksharp_textbuffer_base_changed (GtkTextBuffer* buffer);

void
gtksharp_textbuffer_base_changed (GtkTextBuffer* buffer)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->changed)
		(* klass->changed) (buffer);
}
void gtksharp_textbuffer_override_begin_user_action (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_begin_user_action (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->begin_user_action = cb;
}

void gtksharp_textbuffer_base_begin_user_action (GtkTextBuffer* buffer);

void
gtksharp_textbuffer_base_begin_user_action (GtkTextBuffer* buffer)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->begin_user_action)
		(* klass->begin_user_action) (buffer);
}
void gtksharp_textbuffer_override_end_user_action (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_end_user_action (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->end_user_action = cb;
}

void gtksharp_textbuffer_base_end_user_action (GtkTextBuffer* buffer);

void
gtksharp_textbuffer_base_end_user_action (GtkTextBuffer* buffer)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->end_user_action)
		(* klass->end_user_action) (buffer);
}
void gtksharp_textbuffer_override_delete_range (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_delete_range (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->delete_range = cb;
}

void gtksharp_textbuffer_base_delete_range (GtkTextBuffer* buffer, GtkTextIter* start, GtkTextIter* end);

void
gtksharp_textbuffer_base_delete_range (GtkTextBuffer* buffer, GtkTextIter* start, GtkTextIter* end)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->delete_range)
		(* klass->delete_range) (buffer, start, end);
}
void gtksharp_textbuffer_override_apply_tag (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_apply_tag (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->apply_tag = cb;
}

void gtksharp_textbuffer_base_apply_tag (GtkTextBuffer* buffer, GtkTextTag* tag, const GtkTextIter* start_char, const GtkTextIter* end_char);

void
gtksharp_textbuffer_base_apply_tag (GtkTextBuffer* buffer, GtkTextTag* tag, const GtkTextIter* start_char, const GtkTextIter* end_char)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->apply_tag)
		(* klass->apply_tag) (buffer, tag, start_char, end_char);
}
void gtksharp_textbuffer_override_modified_changed (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_modified_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->modified_changed = cb;
}

void gtksharp_textbuffer_base_modified_changed (GtkTextBuffer* buffer);

void
gtksharp_textbuffer_base_modified_changed (GtkTextBuffer* buffer)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->modified_changed)
		(* klass->modified_changed) (buffer);
}
void gtksharp_textbuffer_override_mark_deleted (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_mark_deleted (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->mark_deleted = cb;
}

void gtksharp_textbuffer_base_mark_deleted (GtkTextBuffer* buffer, GtkTextMark* mark);

void
gtksharp_textbuffer_base_mark_deleted (GtkTextBuffer* buffer, GtkTextMark* mark)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->mark_deleted)
		(* klass->mark_deleted) (buffer, mark);
}
void gtksharp_textbuffer_override_insert_child_anchor (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_insert_child_anchor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->insert_child_anchor = cb;
}

void gtksharp_textbuffer_base_insert_child_anchor (GtkTextBuffer* buffer, GtkTextIter* pos, GtkTextChildAnchor* anchor);

void
gtksharp_textbuffer_base_insert_child_anchor (GtkTextBuffer* buffer, GtkTextIter* pos, GtkTextChildAnchor* anchor)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->insert_child_anchor)
		(* klass->insert_child_anchor) (buffer, pos, anchor);
}
void gtksharp_textbuffer_override_insert_pixbuf (GType gtype, gpointer cb);

void
gtksharp_textbuffer_override_insert_pixbuf (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextBufferClass *)klass)->insert_pixbuf = cb;
}

void gtksharp_textbuffer_base_insert_pixbuf (GtkTextBuffer* buffer, GtkTextIter* pos, GdkPixbuf* pixbuf);

void
gtksharp_textbuffer_base_insert_pixbuf (GtkTextBuffer* buffer, GtkTextIter* pos, GdkPixbuf* pixbuf)
{
	GtkTextBufferClass *klass = (GtkTextBufferClass *) get_threshold_class (G_OBJECT (buffer));
	if (klass->insert_pixbuf)
		(* klass->insert_pixbuf) (buffer, pos, pixbuf);
}
void gtksharp_texttag_override_event (GType gtype, gpointer cb);

void
gtksharp_texttag_override_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextTagClass *)klass)->event = cb;
}

gboolean gtksharp_texttag_base_event (GtkTextTag* tag, GObject* event_object, GdkEvent* evnt, const GtkTextIter* iter);

gboolean
gtksharp_texttag_base_event (GtkTextTag* tag, GObject* event_object, GdkEvent* evnt, const GtkTextIter* iter)
{
	GtkTextTagClass *klass = (GtkTextTagClass *) get_threshold_class (G_OBJECT (tag));
	if (klass->event)
		return (* klass->event) (tag, event_object, evnt, iter);
	return FALSE;
}
void gtksharp_texttagtable_override_tag_added (GType gtype, gpointer cb);

void
gtksharp_texttagtable_override_tag_added (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextTagTableClass *)klass)->tag_added = cb;
}

void gtksharp_texttagtable_base_tag_added (GtkTextTagTable* table, GtkTextTag* tag);

void
gtksharp_texttagtable_base_tag_added (GtkTextTagTable* table, GtkTextTag* tag)
{
	GtkTextTagTableClass *klass = (GtkTextTagTableClass *) get_threshold_class (G_OBJECT (table));
	if (klass->tag_added)
		(* klass->tag_added) (table, tag);
}
void gtksharp_texttagtable_override_tag_removed (GType gtype, gpointer cb);

void
gtksharp_texttagtable_override_tag_removed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextTagTableClass *)klass)->tag_removed = cb;
}

void gtksharp_texttagtable_base_tag_removed (GtkTextTagTable* table, GtkTextTag* tag);

void
gtksharp_texttagtable_base_tag_removed (GtkTextTagTable* table, GtkTextTag* tag)
{
	GtkTextTagTableClass *klass = (GtkTextTagTableClass *) get_threshold_class (G_OBJECT (table));
	if (klass->tag_removed)
		(* klass->tag_removed) (table, tag);
}
void gtksharp_texttagtable_override_tag_changed (GType gtype, gpointer cb);

void
gtksharp_texttagtable_override_tag_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextTagTableClass *)klass)->tag_changed = cb;
}

void gtksharp_texttagtable_base_tag_changed (GtkTextTagTable* table, GtkTextTag* tag, gboolean size_changed);

void
gtksharp_texttagtable_base_tag_changed (GtkTextTagTable* table, GtkTextTag* tag, gboolean size_changed)
{
	GtkTextTagTableClass *klass = (GtkTextTagTableClass *) get_threshold_class (G_OBJECT (table));
	if (klass->tag_changed)
		(* klass->tag_changed) (table, tag, size_changed);
}
void gtksharp_textview_override_toggle_overwrite (GType gtype, gpointer cb);

void
gtksharp_textview_override_toggle_overwrite (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->toggle_overwrite = cb;
}

void gtksharp_textview_base_toggle_overwrite (GtkTextView* text_view);

void
gtksharp_textview_base_toggle_overwrite (GtkTextView* text_view)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->toggle_overwrite)
		(* klass->toggle_overwrite) (text_view);
}
void gtksharp_textview_override_move_cursor (GType gtype, gpointer cb);

void
gtksharp_textview_override_move_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->move_cursor = cb;
}

void gtksharp_textview_base_move_cursor (GtkTextView* text_view, GtkMovementStep step, gint count, gboolean extend_selection);

void
gtksharp_textview_base_move_cursor (GtkTextView* text_view, GtkMovementStep step, gint count, gboolean extend_selection)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->move_cursor)
		(* klass->move_cursor) (text_view, step, count, extend_selection);
}
void gtksharp_textview_override_insert_at_cursor (GType gtype, gpointer cb);

void
gtksharp_textview_override_insert_at_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->insert_at_cursor = cb;
}

void gtksharp_textview_base_insert_at_cursor (GtkTextView* text_view, const gchar* str);

void
gtksharp_textview_base_insert_at_cursor (GtkTextView* text_view, const gchar* str)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->insert_at_cursor)
		(* klass->insert_at_cursor) (text_view, str);
}
void gtksharp_textview_override_cut_clipboard (GType gtype, gpointer cb);

void
gtksharp_textview_override_cut_clipboard (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->cut_clipboard = cb;
}

void gtksharp_textview_base_cut_clipboard (GtkTextView* text_view);

void
gtksharp_textview_base_cut_clipboard (GtkTextView* text_view)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->cut_clipboard)
		(* klass->cut_clipboard) (text_view);
}
void gtksharp_textview_override_backspace (GType gtype, gpointer cb);

void
gtksharp_textview_override_backspace (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->backspace = cb;
}

void gtksharp_textview_base_backspace (GtkTextView* text_view);

void
gtksharp_textview_base_backspace (GtkTextView* text_view)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->backspace)
		(* klass->backspace) (text_view);
}
void gtksharp_textview_override_populate_popup (GType gtype, gpointer cb);

void
gtksharp_textview_override_populate_popup (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->populate_popup = cb;
}

void gtksharp_textview_base_populate_popup (GtkTextView* text_view, GtkMenu* menu);

void
gtksharp_textview_base_populate_popup (GtkTextView* text_view, GtkMenu* menu)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->populate_popup)
		(* klass->populate_popup) (text_view, menu);
}
void gtksharp_textview_override_paste_clipboard (GType gtype, gpointer cb);

void
gtksharp_textview_override_paste_clipboard (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->paste_clipboard = cb;
}

void gtksharp_textview_base_paste_clipboard (GtkTextView* text_view);

void
gtksharp_textview_base_paste_clipboard (GtkTextView* text_view)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->paste_clipboard)
		(* klass->paste_clipboard) (text_view);
}
void gtksharp_textview_override_delete_from_cursor (GType gtype, gpointer cb);

void
gtksharp_textview_override_delete_from_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->delete_from_cursor = cb;
}

void gtksharp_textview_base_delete_from_cursor (GtkTextView* text_view, GtkDeleteType type, gint count);

void
gtksharp_textview_base_delete_from_cursor (GtkTextView* text_view, GtkDeleteType type, gint count)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->delete_from_cursor)
		(* klass->delete_from_cursor) (text_view, type, count);
}
void gtksharp_textview_override_copy_clipboard (GType gtype, gpointer cb);

void
gtksharp_textview_override_copy_clipboard (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->copy_clipboard = cb;
}

void gtksharp_textview_base_copy_clipboard (GtkTextView* text_view);

void
gtksharp_textview_base_copy_clipboard (GtkTextView* text_view)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->copy_clipboard)
		(* klass->copy_clipboard) (text_view);
}
void gtksharp_textview_override_set_anchor (GType gtype, gpointer cb);

void
gtksharp_textview_override_set_anchor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->set_anchor = cb;
}

void gtksharp_textview_base_set_anchor (GtkTextView* text_view);

void
gtksharp_textview_base_set_anchor (GtkTextView* text_view)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->set_anchor)
		(* klass->set_anchor) (text_view);
}
void gtksharp_textview_override_page_horizontally (GType gtype, gpointer cb);

void
gtksharp_textview_override_page_horizontally (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->page_horizontally = cb;
}

void gtksharp_textview_base_page_horizontally (GtkTextView* text_view, gint count, gboolean extend_selection);

void
gtksharp_textview_base_page_horizontally (GtkTextView* text_view, gint count, gboolean extend_selection)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->page_horizontally)
		(* klass->page_horizontally) (text_view, count, extend_selection);
}
void gtksharp_textview_override_set_scroll_adjustments (GType gtype, gpointer cb);

void
gtksharp_textview_override_set_scroll_adjustments (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTextViewClass *)klass)->set_scroll_adjustments = cb;
}

void gtksharp_textview_base_set_scroll_adjustments (GtkTextView* text_view, GtkAdjustment* hadjustment, GtkAdjustment* vadjustment);

void
gtksharp_textview_base_set_scroll_adjustments (GtkTextView* text_view, GtkAdjustment* hadjustment, GtkAdjustment* vadjustment)
{
	GtkTextViewClass *klass = (GtkTextViewClass *) get_threshold_class (G_OBJECT (text_view));
	if (klass->set_scroll_adjustments)
		(* klass->set_scroll_adjustments) (text_view, hadjustment, vadjustment);
}
void gtksharp_toggleaction_override_toggled (GType gtype, gpointer cb);

void
gtksharp_toggleaction_override_toggled (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToggleActionClass *)klass)->toggled = cb;
}

void gtksharp_toggleaction_base_toggled (GtkToggleAction* action);

void
gtksharp_toggleaction_base_toggled (GtkToggleAction* action)
{
	GtkToggleActionClass *klass = (GtkToggleActionClass *) get_threshold_class (G_OBJECT (action));
	if (klass->toggled)
		(* klass->toggled) (action);
}
void gtksharp_togglebutton_override_toggled (GType gtype, gpointer cb);

void
gtksharp_togglebutton_override_toggled (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToggleButtonClass *)klass)->toggled = cb;
}

void gtksharp_togglebutton_base_toggled (GtkToggleButton* toggle_button);

void
gtksharp_togglebutton_base_toggled (GtkToggleButton* toggle_button)
{
	GtkToggleButtonClass *klass = (GtkToggleButtonClass *) get_threshold_class (G_OBJECT (toggle_button));
	if (klass->toggled)
		(* klass->toggled) (toggle_button);
}
void gtksharp_toggletoolbutton_override_toggled (GType gtype, gpointer cb);

void
gtksharp_toggletoolbutton_override_toggled (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToggleToolButtonClass *)klass)->toggled = cb;
}

void gtksharp_toggletoolbutton_base_toggled (GtkToggleToolButton* button);

void
gtksharp_toggletoolbutton_base_toggled (GtkToggleToolButton* button)
{
	GtkToggleToolButtonClass *klass = (GtkToggleToolButtonClass *) get_threshold_class (G_OBJECT (button));
	if (klass->toggled)
		(* klass->toggled) (button);
}
guint gtksharp_gtk_toolbar_get_num_children_offset (void);

guint
gtksharp_gtk_toolbar_get_num_children_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkToolbar, num_children);
}

void gtksharp_toolbar_override_style_changed (GType gtype, gpointer cb);

void
gtksharp_toolbar_override_style_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToolbarClass *)klass)->style_changed = cb;
}

void gtksharp_toolbar_base_style_changed (GtkToolbar* toolbar, GtkToolbarStyle style);

void
gtksharp_toolbar_base_style_changed (GtkToolbar* toolbar, GtkToolbarStyle style)
{
	GtkToolbarClass *klass = (GtkToolbarClass *) get_threshold_class (G_OBJECT (toolbar));
	if (klass->style_changed)
		(* klass->style_changed) (toolbar, style);
}
void gtksharp_toolbar_override_orientation_changed (GType gtype, gpointer cb);

void
gtksharp_toolbar_override_orientation_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToolbarClass *)klass)->orientation_changed = cb;
}

void gtksharp_toolbar_base_orientation_changed (GtkToolbar* toolbar, GtkOrientation orientation);

void
gtksharp_toolbar_base_orientation_changed (GtkToolbar* toolbar, GtkOrientation orientation)
{
	GtkToolbarClass *klass = (GtkToolbarClass *) get_threshold_class (G_OBJECT (toolbar));
	if (klass->orientation_changed)
		(* klass->orientation_changed) (toolbar, orientation);
}
void gtksharp_toolbar_override_popup_context_menu (GType gtype, gpointer cb);

void
gtksharp_toolbar_override_popup_context_menu (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToolbarClass *)klass)->popup_context_menu = cb;
}

gboolean gtksharp_toolbar_base_popup_context_menu (GtkToolbar* toolbar, gint x, gint y, gint button_number);

gboolean
gtksharp_toolbar_base_popup_context_menu (GtkToolbar* toolbar, gint x, gint y, gint button_number)
{
	GtkToolbarClass *klass = (GtkToolbarClass *) get_threshold_class (G_OBJECT (toolbar));
	if (klass->popup_context_menu)
		return (* klass->popup_context_menu) (toolbar, x, y, button_number);
	return FALSE;
}
void gtksharp_toolbutton_override_clicked (GType gtype, gpointer cb);

void
gtksharp_toolbutton_override_clicked (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToolButtonClass *)klass)->clicked = cb;
}

void gtksharp_toolbutton_base_clicked (GtkToolButton* tool_item);

void
gtksharp_toolbutton_base_clicked (GtkToolButton* tool_item)
{
	GtkToolButtonClass *klass = (GtkToolButtonClass *) get_threshold_class (G_OBJECT (tool_item));
	if (klass->clicked)
		(* klass->clicked) (tool_item);
}
void gtksharp_toolitem_override_create_menu_proxy (GType gtype, gpointer cb);

void
gtksharp_toolitem_override_create_menu_proxy (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToolItemClass *)klass)->create_menu_proxy = cb;
}

gboolean gtksharp_toolitem_base_create_menu_proxy (GtkToolItem* tool_item);

gboolean
gtksharp_toolitem_base_create_menu_proxy (GtkToolItem* tool_item)
{
	GtkToolItemClass *klass = (GtkToolItemClass *) get_threshold_class (G_OBJECT (tool_item));
	if (klass->create_menu_proxy)
		return (* klass->create_menu_proxy) (tool_item);
	return FALSE;
}
void gtksharp_toolitem_override_toolbar_reconfigured (GType gtype, gpointer cb);

void
gtksharp_toolitem_override_toolbar_reconfigured (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToolItemClass *)klass)->toolbar_reconfigured = cb;
}

void gtksharp_toolitem_base_toolbar_reconfigured (GtkToolItem* tool_item);

void
gtksharp_toolitem_base_toolbar_reconfigured (GtkToolItem* tool_item)
{
	GtkToolItemClass *klass = (GtkToolItemClass *) get_threshold_class (G_OBJECT (tool_item));
	if (klass->toolbar_reconfigured)
		(* klass->toolbar_reconfigured) (tool_item);
}
void gtksharp_toolitem_override_set_tooltip (GType gtype, gpointer cb);

void
gtksharp_toolitem_override_set_tooltip (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkToolItemClass *)klass)->set_tooltip = cb;
}

gboolean gtksharp_toolitem_base_set_tooltip (GtkToolItem* tool_item, GtkTooltips* tooltips, const gchar* tip_text, const gchar* tip_private);

gboolean
gtksharp_toolitem_base_set_tooltip (GtkToolItem* tool_item, GtkTooltips* tooltips, const gchar* tip_text, const gchar* tip_private)
{
	GtkToolItemClass *klass = (GtkToolItemClass *) get_threshold_class (G_OBJECT (tool_item));
	if (klass->set_tooltip)
		return (* klass->set_tooltip) (tool_item, tooltips, tip_text, tip_private);
	return FALSE;
}
void gtksharp_treeselection_override_changed (GType gtype, gpointer cb);

void
gtksharp_treeselection_override_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeSelectionClass *)klass)->changed = cb;
}

void gtksharp_treeselection_base_changed (GtkTreeSelection* selection);

void
gtksharp_treeselection_base_changed (GtkTreeSelection* selection)
{
	GtkTreeSelectionClass *klass = (GtkTreeSelectionClass *) get_threshold_class (G_OBJECT (selection));
	if (klass->changed)
		(* klass->changed) (selection);
}
void gtksharp_treeview_override_row_collapsed (GType gtype, gpointer cb);

void
gtksharp_treeview_override_row_collapsed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->row_collapsed = cb;
}

void gtksharp_treeview_base_row_collapsed (GtkTreeView* tree_view, GtkTreeIter* iter, GtkTreePath* path);

void
gtksharp_treeview_base_row_collapsed (GtkTreeView* tree_view, GtkTreeIter* iter, GtkTreePath* path)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->row_collapsed)
		(* klass->row_collapsed) (tree_view, iter, path);
}
void gtksharp_treeview_override_select_cursor_row (GType gtype, gpointer cb);

void
gtksharp_treeview_override_select_cursor_row (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->select_cursor_row = cb;
}

gboolean gtksharp_treeview_base_select_cursor_row (GtkTreeView* tree_view, gboolean start_editing);

gboolean
gtksharp_treeview_base_select_cursor_row (GtkTreeView* tree_view, gboolean start_editing)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->select_cursor_row)
		return (* klass->select_cursor_row) (tree_view, start_editing);
	return FALSE;
}
void gtksharp_treeview_override_toggle_cursor_row (GType gtype, gpointer cb);

void
gtksharp_treeview_override_toggle_cursor_row (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->toggle_cursor_row = cb;
}

gboolean gtksharp_treeview_base_toggle_cursor_row (GtkTreeView* tree_view);

gboolean
gtksharp_treeview_base_toggle_cursor_row (GtkTreeView* tree_view)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->toggle_cursor_row)
		return (* klass->toggle_cursor_row) (tree_view);
	return FALSE;
}
void gtksharp_treeview_override_select_all (GType gtype, gpointer cb);

void
gtksharp_treeview_override_select_all (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->select_all = cb;
}

gboolean gtksharp_treeview_base_select_all (GtkTreeView* tree_view);

gboolean
gtksharp_treeview_base_select_all (GtkTreeView* tree_view)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->select_all)
		return (* klass->select_all) (tree_view);
	return FALSE;
}
void gtksharp_treeview_override_move_cursor (GType gtype, gpointer cb);

void
gtksharp_treeview_override_move_cursor (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->move_cursor = cb;
}

gboolean gtksharp_treeview_base_move_cursor (GtkTreeView* tree_view, GtkMovementStep step, gint count);

gboolean
gtksharp_treeview_base_move_cursor (GtkTreeView* tree_view, GtkMovementStep step, gint count)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->move_cursor)
		return (* klass->move_cursor) (tree_view, step, count);
	return FALSE;
}
void gtksharp_treeview_override_test_expand_row (GType gtype, gpointer cb);

void
gtksharp_treeview_override_test_expand_row (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->test_expand_row = cb;
}

gboolean gtksharp_treeview_base_test_expand_row (GtkTreeView* tree_view, GtkTreeIter* iter, GtkTreePath* path);

gboolean
gtksharp_treeview_base_test_expand_row (GtkTreeView* tree_view, GtkTreeIter* iter, GtkTreePath* path)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->test_expand_row)
		return (* klass->test_expand_row) (tree_view, iter, path);
	return FALSE;
}
void gtksharp_treeview_override_row_expanded (GType gtype, gpointer cb);

void
gtksharp_treeview_override_row_expanded (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->row_expanded = cb;
}

void gtksharp_treeview_base_row_expanded (GtkTreeView* tree_view, GtkTreeIter* iter, GtkTreePath* path);

void
gtksharp_treeview_base_row_expanded (GtkTreeView* tree_view, GtkTreeIter* iter, GtkTreePath* path)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->row_expanded)
		(* klass->row_expanded) (tree_view, iter, path);
}
void gtksharp_treeview_override_cursor_changed (GType gtype, gpointer cb);

void
gtksharp_treeview_override_cursor_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->cursor_changed = cb;
}

void gtksharp_treeview_base_cursor_changed (GtkTreeView* tree_view);

void
gtksharp_treeview_base_cursor_changed (GtkTreeView* tree_view)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->cursor_changed)
		(* klass->cursor_changed) (tree_view);
}
void gtksharp_treeview_override_start_interactive_search (GType gtype, gpointer cb);

void
gtksharp_treeview_override_start_interactive_search (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->start_interactive_search = cb;
}

gboolean gtksharp_treeview_base_start_interactive_search (GtkTreeView* tree_view);

gboolean
gtksharp_treeview_base_start_interactive_search (GtkTreeView* tree_view)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->start_interactive_search)
		return (* klass->start_interactive_search) (tree_view);
	return FALSE;
}
void gtksharp_treeview_override_test_collapse_row (GType gtype, gpointer cb);

void
gtksharp_treeview_override_test_collapse_row (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->test_collapse_row = cb;
}

gboolean gtksharp_treeview_base_test_collapse_row (GtkTreeView* tree_view, GtkTreeIter* iter, GtkTreePath* path);

gboolean
gtksharp_treeview_base_test_collapse_row (GtkTreeView* tree_view, GtkTreeIter* iter, GtkTreePath* path)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->test_collapse_row)
		return (* klass->test_collapse_row) (tree_view, iter, path);
	return FALSE;
}
void gtksharp_treeview_override_expand_collapse_cursor_row (GType gtype, gpointer cb);

void
gtksharp_treeview_override_expand_collapse_cursor_row (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->expand_collapse_cursor_row = cb;
}

gboolean gtksharp_treeview_base_expand_collapse_cursor_row (GtkTreeView* tree_view, gboolean logical, gboolean expand, gboolean open_all);

gboolean
gtksharp_treeview_base_expand_collapse_cursor_row (GtkTreeView* tree_view, gboolean logical, gboolean expand, gboolean open_all)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->expand_collapse_cursor_row)
		return (* klass->expand_collapse_cursor_row) (tree_view, logical, expand, open_all);
	return FALSE;
}
void gtksharp_treeview_override_row_activated (GType gtype, gpointer cb);

void
gtksharp_treeview_override_row_activated (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->row_activated = cb;
}

void gtksharp_treeview_base_row_activated (GtkTreeView* tree_view, GtkTreePath* path, GtkTreeViewColumn* column);

void
gtksharp_treeview_base_row_activated (GtkTreeView* tree_view, GtkTreePath* path, GtkTreeViewColumn* column)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->row_activated)
		(* klass->row_activated) (tree_view, path, column);
}
void gtksharp_treeview_override_select_cursor_parent (GType gtype, gpointer cb);

void
gtksharp_treeview_override_select_cursor_parent (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->select_cursor_parent = cb;
}

gboolean gtksharp_treeview_base_select_cursor_parent (GtkTreeView* tree_view);

gboolean
gtksharp_treeview_base_select_cursor_parent (GtkTreeView* tree_view)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->select_cursor_parent)
		return (* klass->select_cursor_parent) (tree_view);
	return FALSE;
}
void gtksharp_treeview_override_columns_changed (GType gtype, gpointer cb);

void
gtksharp_treeview_override_columns_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->columns_changed = cb;
}

void gtksharp_treeview_base_columns_changed (GtkTreeView* tree_view);

void
gtksharp_treeview_base_columns_changed (GtkTreeView* tree_view)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->columns_changed)
		(* klass->columns_changed) (tree_view);
}
void gtksharp_treeview_override_unselect_all (GType gtype, gpointer cb);

void
gtksharp_treeview_override_unselect_all (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->unselect_all = cb;
}

gboolean gtksharp_treeview_base_unselect_all (GtkTreeView* tree_view);

gboolean
gtksharp_treeview_base_unselect_all (GtkTreeView* tree_view)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->unselect_all)
		return (* klass->unselect_all) (tree_view);
	return FALSE;
}
void gtksharp_treeview_override_set_scroll_adjustments (GType gtype, gpointer cb);

void
gtksharp_treeview_override_set_scroll_adjustments (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewClass *)klass)->set_scroll_adjustments = cb;
}

void gtksharp_treeview_base_set_scroll_adjustments (GtkTreeView* tree_view, GtkAdjustment* hadjustment, GtkAdjustment* vadjustment);

void
gtksharp_treeview_base_set_scroll_adjustments (GtkTreeView* tree_view, GtkAdjustment* hadjustment, GtkAdjustment* vadjustment)
{
	GtkTreeViewClass *klass = (GtkTreeViewClass *) get_threshold_class (G_OBJECT (tree_view));
	if (klass->set_scroll_adjustments)
		(* klass->set_scroll_adjustments) (tree_view, hadjustment, vadjustment);
}
void gtksharp_treeviewcolumn_override_clicked (GType gtype, gpointer cb);

void
gtksharp_treeviewcolumn_override_clicked (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkTreeViewColumnClass *)klass)->clicked = cb;
}

void gtksharp_treeviewcolumn_base_clicked (GtkTreeViewColumn* tree_column);

void
gtksharp_treeviewcolumn_base_clicked (GtkTreeViewColumn* tree_column)
{
	GtkTreeViewColumnClass *klass = (GtkTreeViewColumnClass *) get_threshold_class (G_OBJECT (tree_column));
	if (klass->clicked)
		(* klass->clicked) (tree_column);
}
void gtksharp_uimanager_override_disconnect_proxy (GType gtype, gpointer cb);

void
gtksharp_uimanager_override_disconnect_proxy (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkUIManagerClass *)klass)->disconnect_proxy = cb;
}

void gtksharp_uimanager_base_disconnect_proxy (GtkUIManager* merge, GtkAction* action, GtkWidget* proxy);

void
gtksharp_uimanager_base_disconnect_proxy (GtkUIManager* merge, GtkAction* action, GtkWidget* proxy)
{
	GtkUIManagerClass *klass = (GtkUIManagerClass *) get_threshold_class (G_OBJECT (merge));
	if (klass->disconnect_proxy)
		(* klass->disconnect_proxy) (merge, action, proxy);
}
void gtksharp_uimanager_override_connect_proxy (GType gtype, gpointer cb);

void
gtksharp_uimanager_override_connect_proxy (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkUIManagerClass *)klass)->connect_proxy = cb;
}

void gtksharp_uimanager_base_connect_proxy (GtkUIManager* merge, GtkAction* action, GtkWidget* proxy);

void
gtksharp_uimanager_base_connect_proxy (GtkUIManager* merge, GtkAction* action, GtkWidget* proxy)
{
	GtkUIManagerClass *klass = (GtkUIManagerClass *) get_threshold_class (G_OBJECT (merge));
	if (klass->connect_proxy)
		(* klass->connect_proxy) (merge, action, proxy);
}
void gtksharp_uimanager_override_post_activate (GType gtype, gpointer cb);

void
gtksharp_uimanager_override_post_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkUIManagerClass *)klass)->post_activate = cb;
}

void gtksharp_uimanager_base_post_activate (GtkUIManager* merge, GtkAction* action);

void
gtksharp_uimanager_base_post_activate (GtkUIManager* merge, GtkAction* action)
{
	GtkUIManagerClass *klass = (GtkUIManagerClass *) get_threshold_class (G_OBJECT (merge));
	if (klass->post_activate)
		(* klass->post_activate) (merge, action);
}
void gtksharp_uimanager_override_pre_activate (GType gtype, gpointer cb);

void
gtksharp_uimanager_override_pre_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkUIManagerClass *)klass)->pre_activate = cb;
}

void gtksharp_uimanager_base_pre_activate (GtkUIManager* merge, GtkAction* action);

void
gtksharp_uimanager_base_pre_activate (GtkUIManager* merge, GtkAction* action)
{
	GtkUIManagerClass *klass = (GtkUIManagerClass *) get_threshold_class (G_OBJECT (merge));
	if (klass->pre_activate)
		(* klass->pre_activate) (merge, action);
}
void gtksharp_uimanager_override_add_widget (GType gtype, gpointer cb);

void
gtksharp_uimanager_override_add_widget (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkUIManagerClass *)klass)->add_widget = cb;
}

void gtksharp_uimanager_base_add_widget (GtkUIManager* merge, GtkWidget* widget);

void
gtksharp_uimanager_base_add_widget (GtkUIManager* merge, GtkWidget* widget)
{
	GtkUIManagerClass *klass = (GtkUIManagerClass *) get_threshold_class (G_OBJECT (merge));
	if (klass->add_widget)
		(* klass->add_widget) (merge, widget);
}
void gtksharp_uimanager_override_actions_changed (GType gtype, gpointer cb);

void
gtksharp_uimanager_override_actions_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkUIManagerClass *)klass)->actions_changed = cb;
}

void gtksharp_uimanager_base_actions_changed (GtkUIManager* merge);

void
gtksharp_uimanager_base_actions_changed (GtkUIManager* merge)
{
	GtkUIManagerClass *klass = (GtkUIManagerClass *) get_threshold_class (G_OBJECT (merge));
	if (klass->actions_changed)
		(* klass->actions_changed) (merge);
}
void gtksharp_viewport_override_set_scroll_adjustments (GType gtype, gpointer cb);

void
gtksharp_viewport_override_set_scroll_adjustments (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkViewportClass *)klass)->set_scroll_adjustments = cb;
}

void gtksharp_viewport_base_set_scroll_adjustments (GtkViewport* viewport, GtkAdjustment* hadjustment, GtkAdjustment* vadjustment);

void
gtksharp_viewport_base_set_scroll_adjustments (GtkViewport* viewport, GtkAdjustment* hadjustment, GtkAdjustment* vadjustment)
{
	GtkViewportClass *klass = (GtkViewportClass *) get_threshold_class (G_OBJECT (viewport));
	if (klass->set_scroll_adjustments)
		(* klass->set_scroll_adjustments) (viewport, hadjustment, vadjustment);
}
guint gtksharp_gtk_widget_get_requisition_offset (void);

guint
gtksharp_gtk_widget_get_requisition_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkWidget, requisition);
}

void gtksharp_widget_override_drag_data_received (GType gtype, gpointer cb);

void
gtksharp_widget_override_drag_data_received (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->drag_data_received = cb;
}

void gtksharp_widget_base_drag_data_received (GtkWidget* widget, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint info, guint time_);

void
gtksharp_widget_base_drag_data_received (GtkWidget* widget, GdkDragContext* context, gint x, gint y, GtkSelectionData* selection_data, guint info, guint time_)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->drag_data_received)
		(* klass->drag_data_received) (widget, context, x, y, selection_data, info, time_);
}
void gtksharp_widget_override_proximity_in_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_proximity_in_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->proximity_in_event = cb;
}

gboolean gtksharp_widget_base_proximity_in_event (GtkWidget* widget, GdkEventProximity* evnt);

gboolean
gtksharp_widget_base_proximity_in_event (GtkWidget* widget, GdkEventProximity* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->proximity_in_event)
		return (* klass->proximity_in_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_proximity_out_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_proximity_out_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->proximity_out_event = cb;
}

gboolean gtksharp_widget_base_proximity_out_event (GtkWidget* widget, GdkEventProximity* evnt);

gboolean
gtksharp_widget_base_proximity_out_event (GtkWidget* widget, GdkEventProximity* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->proximity_out_event)
		return (* klass->proximity_out_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_grab_broken_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_grab_broken_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->grab_broken_event = cb;
}

gboolean gtksharp_widget_base_grab_broken_event (GtkWidget* widget, GdkEventGrabBroken* evnt);

gboolean
gtksharp_widget_base_grab_broken_event (GtkWidget* widget, GdkEventGrabBroken* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->grab_broken_event)
		return (* klass->grab_broken_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_selection_clear_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_selection_clear_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->selection_clear_event = cb;
}

gboolean gtksharp_widget_base_selection_clear_event (GtkWidget* widget, GdkEventSelection* evnt);

gboolean
gtksharp_widget_base_selection_clear_event (GtkWidget* widget, GdkEventSelection* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->selection_clear_event)
		return (* klass->selection_clear_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_show_help (GType gtype, gpointer cb);

void
gtksharp_widget_override_show_help (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->show_help = cb;
}

gboolean gtksharp_widget_base_show_help (GtkWidget* widget, GtkWidgetHelpType help_type);

gboolean
gtksharp_widget_base_show_help (GtkWidget* widget, GtkWidgetHelpType help_type)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->show_help)
		return (* klass->show_help) (widget, help_type);
	return FALSE;
}
void gtksharp_widget_override_hierarchy_changed (GType gtype, gpointer cb);

void
gtksharp_widget_override_hierarchy_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->hierarchy_changed = cb;
}

void gtksharp_widget_base_hierarchy_changed (GtkWidget* widget, GtkWidget* previous_toplevel);

void
gtksharp_widget_base_hierarchy_changed (GtkWidget* widget, GtkWidget* previous_toplevel)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->hierarchy_changed)
		(* klass->hierarchy_changed) (widget, previous_toplevel);
}
void gtksharp_widget_override_query_tooltip (GType gtype, gpointer cb);

void
gtksharp_widget_override_query_tooltip (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->query_tooltip = cb;
}

gboolean gtksharp_widget_base_query_tooltip (GtkWidget* widget, gint x, gint y, gboolean keyboard_tooltip, GtkTooltip* tooltip);

gboolean
gtksharp_widget_base_query_tooltip (GtkWidget* widget, gint x, gint y, gboolean keyboard_tooltip, GtkTooltip* tooltip)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->query_tooltip)
		return (* klass->query_tooltip) (widget, x, y, keyboard_tooltip, tooltip);
	return FALSE;
}
void gtksharp_widget_override_no_expose_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_no_expose_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->no_expose_event = cb;
}

gboolean gtksharp_widget_base_no_expose_event (GtkWidget* widget, GdkEventAny* evnt);

gboolean
gtksharp_widget_base_no_expose_event (GtkWidget* widget, GdkEventAny* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->no_expose_event)
		return (* klass->no_expose_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_enter_notify_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_enter_notify_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->enter_notify_event = cb;
}

gboolean gtksharp_widget_base_enter_notify_event (GtkWidget* widget, GdkEventCrossing* evnt);

gboolean
gtksharp_widget_base_enter_notify_event (GtkWidget* widget, GdkEventCrossing* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->enter_notify_event)
		return (* klass->enter_notify_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_grab_focus (GType gtype, gpointer cb);

void
gtksharp_widget_override_grab_focus (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->grab_focus = cb;
}

void gtksharp_widget_base_grab_focus (GtkWidget* widget);

void
gtksharp_widget_base_grab_focus (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->grab_focus)
		(* klass->grab_focus) (widget);
}
void gtksharp_widget_override_state_changed (GType gtype, gpointer cb);

void
gtksharp_widget_override_state_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->state_changed = cb;
}

void gtksharp_widget_base_state_changed (GtkWidget* widget, GtkStateType previous_state);

void
gtksharp_widget_base_state_changed (GtkWidget* widget, GtkStateType previous_state)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->state_changed)
		(* klass->state_changed) (widget, previous_state);
}
void gtksharp_widget_override_show (GType gtype, gpointer cb);

void
gtksharp_widget_override_show (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->show = cb;
}

void gtksharp_widget_base_show (GtkWidget* widget);

void
gtksharp_widget_base_show (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->show)
		(* klass->show) (widget);
}
void gtksharp_widget_override_expose_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_expose_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->expose_event = cb;
}

gboolean gtksharp_widget_base_expose_event (GtkWidget* widget, GdkEventExpose* evnt);

gboolean
gtksharp_widget_base_expose_event (GtkWidget* widget, GdkEventExpose* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->expose_event)
		return (* klass->expose_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_unmap (GType gtype, gpointer cb);

void
gtksharp_widget_override_unmap (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->unmap = cb;
}

void gtksharp_widget_base_unmap (GtkWidget* widget);

void
gtksharp_widget_base_unmap (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->unmap)
		(* klass->unmap) (widget);
}
void gtksharp_widget_override_size_allocate (GType gtype, gpointer cb);

void
gtksharp_widget_override_size_allocate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->size_allocate = cb;
}

void gtksharp_widget_base_size_allocate (GtkWidget* widget, GtkAllocation* allocation);

void
gtksharp_widget_base_size_allocate (GtkWidget* widget, GtkAllocation* allocation)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->size_allocate)
		(* klass->size_allocate) (widget, allocation);
}
void gtksharp_widget_override_grab_notify (GType gtype, gpointer cb);

void
gtksharp_widget_override_grab_notify (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->grab_notify = cb;
}

void gtksharp_widget_base_grab_notify (GtkWidget* widget, gboolean was_grabbed);

void
gtksharp_widget_base_grab_notify (GtkWidget* widget, gboolean was_grabbed)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->grab_notify)
		(* klass->grab_notify) (widget, was_grabbed);
}
void gtksharp_widget_override_destroy_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_destroy_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->destroy_event = cb;
}

gboolean gtksharp_widget_base_destroy_event (GtkWidget* widget, GdkEventAny* evnt);

gboolean
gtksharp_widget_base_destroy_event (GtkWidget* widget, GdkEventAny* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->destroy_event)
		return (* klass->destroy_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_focus_out_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_focus_out_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->focus_out_event = cb;
}

gboolean gtksharp_widget_base_focus_out_event (GtkWidget* widget, GdkEventFocus* evnt);

gboolean
gtksharp_widget_base_focus_out_event (GtkWidget* widget, GdkEventFocus* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->focus_out_event)
		return (* klass->focus_out_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_key_press_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_key_press_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->key_press_event = cb;
}

gboolean gtksharp_widget_base_key_press_event (GtkWidget* widget, GdkEventKey* evnt);

gboolean
gtksharp_widget_base_key_press_event (GtkWidget* widget, GdkEventKey* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->key_press_event)
		return (* klass->key_press_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_property_notify_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_property_notify_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->property_notify_event = cb;
}

gboolean gtksharp_widget_base_property_notify_event (GtkWidget* widget, GdkEventProperty* evnt);

gboolean
gtksharp_widget_base_property_notify_event (GtkWidget* widget, GdkEventProperty* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->property_notify_event)
		return (* klass->property_notify_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_can_activate_accel (GType gtype, gpointer cb);

void
gtksharp_widget_override_can_activate_accel (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->can_activate_accel = cb;
}

gboolean gtksharp_widget_base_can_activate_accel (GtkWidget* widget, guint signal_id);

gboolean
gtksharp_widget_base_can_activate_accel (GtkWidget* widget, guint signal_id)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->can_activate_accel)
		return (* klass->can_activate_accel) (widget, signal_id);
	return FALSE;
}
void gtksharp_widget_override_selection_get (GType gtype, gpointer cb);

void
gtksharp_widget_override_selection_get (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->selection_get = cb;
}

void gtksharp_widget_base_selection_get (GtkWidget* widget, GtkSelectionData* selection_data, guint info, guint time_);

void
gtksharp_widget_base_selection_get (GtkWidget* widget, GtkSelectionData* selection_data, guint info, guint time_)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->selection_get)
		(* klass->selection_get) (widget, selection_data, info, time_);
}
void gtksharp_widget_override_direction_changed (GType gtype, gpointer cb);

void
gtksharp_widget_override_direction_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->direction_changed = cb;
}

void gtksharp_widget_base_direction_changed (GtkWidget* widget, GtkTextDirection previous_direction);

void
gtksharp_widget_base_direction_changed (GtkWidget* widget, GtkTextDirection previous_direction)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->direction_changed)
		(* klass->direction_changed) (widget, previous_direction);
}
void gtksharp_widget_override_selection_request_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_selection_request_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->selection_request_event = cb;
}

gboolean gtksharp_widget_base_selection_request_event (GtkWidget* widget, GdkEventSelection* evnt);

gboolean
gtksharp_widget_base_selection_request_event (GtkWidget* widget, GdkEventSelection* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->selection_request_event)
		return (* klass->selection_request_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_drag_begin (GType gtype, gpointer cb);

void
gtksharp_widget_override_drag_begin (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->drag_begin = cb;
}

void gtksharp_widget_base_drag_begin (GtkWidget* widget, GdkDragContext* context);

void
gtksharp_widget_base_drag_begin (GtkWidget* widget, GdkDragContext* context)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->drag_begin)
		(* klass->drag_begin) (widget, context);
}
void gtksharp_widget_override_drag_end (GType gtype, gpointer cb);

void
gtksharp_widget_override_drag_end (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->drag_end = cb;
}

void gtksharp_widget_base_drag_end (GtkWidget* widget, GdkDragContext* context);

void
gtksharp_widget_base_drag_end (GtkWidget* widget, GdkDragContext* context)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->drag_end)
		(* klass->drag_end) (widget, context);
}
void gtksharp_widget_override_popup_menu (GType gtype, gpointer cb);

void
gtksharp_widget_override_popup_menu (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->popup_menu = cb;
}

gboolean gtksharp_widget_base_popup_menu (GtkWidget* widget);

gboolean
gtksharp_widget_base_popup_menu (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->popup_menu)
		return (* klass->popup_menu) (widget);
	return FALSE;
}
void gtksharp_widget_override_hide (GType gtype, gpointer cb);

void
gtksharp_widget_override_hide (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->hide = cb;
}

void gtksharp_widget_base_hide (GtkWidget* widget);

void
gtksharp_widget_base_hide (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->hide)
		(* klass->hide) (widget);
}
void gtksharp_widget_override_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->event = cb;
}

gboolean gtksharp_widget_base_event (GtkWidget* widget, GdkEvent* evnt);

gboolean
gtksharp_widget_base_event (GtkWidget* widget, GdkEvent* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->event)
		return (* klass->event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_drag_data_delete (GType gtype, gpointer cb);

void
gtksharp_widget_override_drag_data_delete (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->drag_data_delete = cb;
}

void gtksharp_widget_base_drag_data_delete (GtkWidget* widget, GdkDragContext* context);

void
gtksharp_widget_base_drag_data_delete (GtkWidget* widget, GdkDragContext* context)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->drag_data_delete)
		(* klass->drag_data_delete) (widget, context);
}
void gtksharp_widget_override_drag_drop (GType gtype, gpointer cb);

void
gtksharp_widget_override_drag_drop (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->drag_drop = cb;
}

gboolean gtksharp_widget_base_drag_drop (GtkWidget* widget, GdkDragContext* context, gint x, gint y, guint time_);

gboolean
gtksharp_widget_base_drag_drop (GtkWidget* widget, GdkDragContext* context, gint x, gint y, guint time_)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->drag_drop)
		return (* klass->drag_drop) (widget, context, x, y, time_);
	return FALSE;
}
void gtksharp_widget_override_drag_data_get (GType gtype, gpointer cb);

void
gtksharp_widget_override_drag_data_get (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->drag_data_get = cb;
}

void gtksharp_widget_base_drag_data_get (GtkWidget* widget, GdkDragContext* context, GtkSelectionData* selection_data, guint info, guint time_);

void
gtksharp_widget_base_drag_data_get (GtkWidget* widget, GdkDragContext* context, GtkSelectionData* selection_data, guint info, guint time_)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->drag_data_get)
		(* klass->drag_data_get) (widget, context, selection_data, info, time_);
}
void gtksharp_widget_override_button_press_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_button_press_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->button_press_event = cb;
}

gboolean gtksharp_widget_base_button_press_event (GtkWidget* widget, GdkEventButton* evnt);

gboolean
gtksharp_widget_base_button_press_event (GtkWidget* widget, GdkEventButton* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->button_press_event)
		return (* klass->button_press_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_visibility_notify_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_visibility_notify_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->visibility_notify_event = cb;
}

gboolean gtksharp_widget_base_visibility_notify_event (GtkWidget* widget, GdkEventVisibility* evnt);

gboolean
gtksharp_widget_base_visibility_notify_event (GtkWidget* widget, GdkEventVisibility* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->visibility_notify_event)
		return (* klass->visibility_notify_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_button_release_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_button_release_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->button_release_event = cb;
}

gboolean gtksharp_widget_base_button_release_event (GtkWidget* widget, GdkEventButton* evnt);

gboolean
gtksharp_widget_base_button_release_event (GtkWidget* widget, GdkEventButton* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->button_release_event)
		return (* klass->button_release_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_map (GType gtype, gpointer cb);

void
gtksharp_widget_override_map (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->map = cb;
}

void gtksharp_widget_base_map (GtkWidget* widget);

void
gtksharp_widget_base_map (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->map)
		(* klass->map) (widget);
}
void gtksharp_widget_override_mnemonic_activate (GType gtype, gpointer cb);

void
gtksharp_widget_override_mnemonic_activate (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->mnemonic_activate = cb;
}

gboolean gtksharp_widget_base_mnemonic_activate (GtkWidget* widget, gboolean group_cycling);

gboolean
gtksharp_widget_base_mnemonic_activate (GtkWidget* widget, gboolean group_cycling)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->mnemonic_activate)
		return (* klass->mnemonic_activate) (widget, group_cycling);
	return FALSE;
}
void gtksharp_widget_override_composited_changed (GType gtype, gpointer cb);

void
gtksharp_widget_override_composited_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->composited_changed = cb;
}

void gtksharp_widget_base_composited_changed (GtkWidget* widget);

void
gtksharp_widget_base_composited_changed (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->composited_changed)
		(* klass->composited_changed) (widget);
}
void gtksharp_widget_override_focus (GType gtype, gpointer cb);

void
gtksharp_widget_override_focus (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->focus = cb;
}

gboolean gtksharp_widget_base_focus (GtkWidget* widget, GtkDirectionType direction);

gboolean
gtksharp_widget_base_focus (GtkWidget* widget, GtkDirectionType direction)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->focus)
		return (* klass->focus) (widget, direction);
	return FALSE;
}
void gtksharp_widget_override_child_notify (GType gtype, gpointer cb);

void
gtksharp_widget_override_child_notify (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->child_notify = cb;
}

void gtksharp_widget_base_child_notify (GtkWidget* widget, GParamSpec* pspec);

void
gtksharp_widget_base_child_notify (GtkWidget* widget, GParamSpec* pspec)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->child_notify)
		(* klass->child_notify) (widget, pspec);
}
void gtksharp_widget_override_delete_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_delete_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->delete_event = cb;
}

gboolean gtksharp_widget_base_delete_event (GtkWidget* widget, GdkEventAny* evnt);

gboolean
gtksharp_widget_base_delete_event (GtkWidget* widget, GdkEventAny* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->delete_event)
		return (* klass->delete_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_realize (GType gtype, gpointer cb);

void
gtksharp_widget_override_realize (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->realize = cb;
}

void gtksharp_widget_base_realize (GtkWidget* widget);

void
gtksharp_widget_base_realize (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->realize)
		(* klass->realize) (widget);
}
void gtksharp_widget_override_leave_notify_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_leave_notify_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->leave_notify_event = cb;
}

gboolean gtksharp_widget_base_leave_notify_event (GtkWidget* widget, GdkEventCrossing* evnt);

gboolean
gtksharp_widget_base_leave_notify_event (GtkWidget* widget, GdkEventCrossing* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->leave_notify_event)
		return (* klass->leave_notify_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_client_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_client_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->client_event = cb;
}

gboolean gtksharp_widget_base_client_event (GtkWidget* widget, GdkEventClient* evnt);

gboolean
gtksharp_widget_base_client_event (GtkWidget* widget, GdkEventClient* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->client_event)
		return (* klass->client_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_focus_in_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_focus_in_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->focus_in_event = cb;
}

gboolean gtksharp_widget_base_focus_in_event (GtkWidget* widget, GdkEventFocus* evnt);

gboolean
gtksharp_widget_base_focus_in_event (GtkWidget* widget, GdkEventFocus* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->focus_in_event)
		return (* klass->focus_in_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_configure_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_configure_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->configure_event = cb;
}

gboolean gtksharp_widget_base_configure_event (GtkWidget* widget, GdkEventConfigure* evnt);

gboolean
gtksharp_widget_base_configure_event (GtkWidget* widget, GdkEventConfigure* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->configure_event)
		return (* klass->configure_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_map_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_map_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->map_event = cb;
}

gboolean gtksharp_widget_base_map_event (GtkWidget* widget, GdkEventAny* evnt);

gboolean
gtksharp_widget_base_map_event (GtkWidget* widget, GdkEventAny* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->map_event)
		return (* klass->map_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_key_release_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_key_release_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->key_release_event = cb;
}

gboolean gtksharp_widget_base_key_release_event (GtkWidget* widget, GdkEventKey* evnt);

gboolean
gtksharp_widget_base_key_release_event (GtkWidget* widget, GdkEventKey* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->key_release_event)
		return (* klass->key_release_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_size_request (GType gtype, gpointer cb);

void
gtksharp_widget_override_size_request (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->size_request = cb;
}

void gtksharp_widget_base_size_request (GtkWidget* widget, GtkRequisition* requisition);

void
gtksharp_widget_base_size_request (GtkWidget* widget, GtkRequisition* requisition)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->size_request)
		(* klass->size_request) (widget, requisition);
}
void gtksharp_widget_override_motion_notify_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_motion_notify_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->motion_notify_event = cb;
}

gboolean gtksharp_widget_base_motion_notify_event (GtkWidget* widget, GdkEventMotion* evnt);

gboolean
gtksharp_widget_base_motion_notify_event (GtkWidget* widget, GdkEventMotion* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->motion_notify_event)
		return (* klass->motion_notify_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_selection_notify_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_selection_notify_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->selection_notify_event = cb;
}

gboolean gtksharp_widget_base_selection_notify_event (GtkWidget* widget, GdkEventSelection* evnt);

gboolean
gtksharp_widget_base_selection_notify_event (GtkWidget* widget, GdkEventSelection* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->selection_notify_event)
		return (* klass->selection_notify_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_scroll_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_scroll_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->scroll_event = cb;
}

gboolean gtksharp_widget_base_scroll_event (GtkWidget* widget, GdkEventScroll* evnt);

gboolean
gtksharp_widget_base_scroll_event (GtkWidget* widget, GdkEventScroll* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->scroll_event)
		return (* klass->scroll_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_unmap_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_unmap_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->unmap_event = cb;
}

gboolean gtksharp_widget_base_unmap_event (GtkWidget* widget, GdkEventAny* evnt);

gboolean
gtksharp_widget_base_unmap_event (GtkWidget* widget, GdkEventAny* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->unmap_event)
		return (* klass->unmap_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_parent_set (GType gtype, gpointer cb);

void
gtksharp_widget_override_parent_set (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->parent_set = cb;
}

void gtksharp_widget_base_parent_set (GtkWidget* widget, GtkWidget* previous_parent);

void
gtksharp_widget_base_parent_set (GtkWidget* widget, GtkWidget* previous_parent)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->parent_set)
		(* klass->parent_set) (widget, previous_parent);
}
void gtksharp_widget_override_drag_leave (GType gtype, gpointer cb);

void
gtksharp_widget_override_drag_leave (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->drag_leave = cb;
}

void gtksharp_widget_base_drag_leave (GtkWidget* widget, GdkDragContext* context, guint time_);

void
gtksharp_widget_base_drag_leave (GtkWidget* widget, GdkDragContext* context, guint time_)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->drag_leave)
		(* klass->drag_leave) (widget, context, time_);
}
void gtksharp_widget_override_window_state_event (GType gtype, gpointer cb);

void
gtksharp_widget_override_window_state_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->window_state_event = cb;
}

gboolean gtksharp_widget_base_window_state_event (GtkWidget* widget, GdkEventWindowState* evnt);

gboolean
gtksharp_widget_base_window_state_event (GtkWidget* widget, GdkEventWindowState* evnt)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->window_state_event)
		return (* klass->window_state_event) (widget, evnt);
	return FALSE;
}
void gtksharp_widget_override_screen_changed (GType gtype, gpointer cb);

void
gtksharp_widget_override_screen_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->screen_changed = cb;
}

void gtksharp_widget_base_screen_changed (GtkWidget* widget, GdkScreen* previous_screen);

void
gtksharp_widget_base_screen_changed (GtkWidget* widget, GdkScreen* previous_screen)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->screen_changed)
		(* klass->screen_changed) (widget, previous_screen);
}
void gtksharp_widget_override_style_set (GType gtype, gpointer cb);

void
gtksharp_widget_override_style_set (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->style_set = cb;
}

void gtksharp_widget_base_style_set (GtkWidget* widget, GtkStyle* previous_style);

void
gtksharp_widget_base_style_set (GtkWidget* widget, GtkStyle* previous_style)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->style_set)
		(* klass->style_set) (widget, previous_style);
}
void gtksharp_widget_override_unrealize (GType gtype, gpointer cb);

void
gtksharp_widget_override_unrealize (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->unrealize = cb;
}

void gtksharp_widget_base_unrealize (GtkWidget* widget);

void
gtksharp_widget_base_unrealize (GtkWidget* widget)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->unrealize)
		(* klass->unrealize) (widget);
}
void gtksharp_widget_override_drag_motion (GType gtype, gpointer cb);

void
gtksharp_widget_override_drag_motion (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->drag_motion = cb;
}

gboolean gtksharp_widget_base_drag_motion (GtkWidget* widget, GdkDragContext* context, gint x, gint y, guint time_);

gboolean
gtksharp_widget_base_drag_motion (GtkWidget* widget, GdkDragContext* context, gint x, gint y, guint time_)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->drag_motion)
		return (* klass->drag_motion) (widget, context, x, y, time_);
	return FALSE;
}
void gtksharp_widget_override_selection_received (GType gtype, gpointer cb);

void
gtksharp_widget_override_selection_received (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWidgetClass *)klass)->selection_received = cb;
}

void gtksharp_widget_base_selection_received (GtkWidget* widget, GtkSelectionData* selection_data, guint time_);

void
gtksharp_widget_base_selection_received (GtkWidget* widget, GtkSelectionData* selection_data, guint time_)
{
	GtkWidgetClass *klass = (GtkWidgetClass *) get_threshold_class (G_OBJECT (widget));
	if (klass->selection_received)
		(* klass->selection_received) (widget, selection_data, time_);
}
void gtksharp_window_override_set_focus (GType gtype, gpointer cb);

void
gtksharp_window_override_set_focus (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWindowClass *)klass)->set_focus = cb;
}

void gtksharp_window_base_set_focus (GtkWindow* window, GtkWidget* focus);

void
gtksharp_window_base_set_focus (GtkWindow* window, GtkWidget* focus)
{
	GtkWindowClass *klass = (GtkWindowClass *) get_threshold_class (G_OBJECT (window));
	if (klass->set_focus)
		(* klass->set_focus) (window, focus);
}
void gtksharp_window_override_activate_focus (GType gtype, gpointer cb);

void
gtksharp_window_override_activate_focus (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWindowClass *)klass)->activate_focus = cb;
}

void gtksharp_window_base_activate_focus (GtkWindow* window);

void
gtksharp_window_base_activate_focus (GtkWindow* window)
{
	GtkWindowClass *klass = (GtkWindowClass *) get_threshold_class (G_OBJECT (window));
	if (klass->activate_focus)
		(* klass->activate_focus) (window);
}
void gtksharp_window_override_activate_default (GType gtype, gpointer cb);

void
gtksharp_window_override_activate_default (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWindowClass *)klass)->activate_default = cb;
}

void gtksharp_window_base_activate_default (GtkWindow* window);

void
gtksharp_window_base_activate_default (GtkWindow* window)
{
	GtkWindowClass *klass = (GtkWindowClass *) get_threshold_class (G_OBJECT (window));
	if (klass->activate_default)
		(* klass->activate_default) (window);
}
void gtksharp_window_override_keys_changed (GType gtype, gpointer cb);

void
gtksharp_window_override_keys_changed (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWindowClass *)klass)->keys_changed = cb;
}

void gtksharp_window_base_keys_changed (GtkWindow* window);

void
gtksharp_window_base_keys_changed (GtkWindow* window)
{
	GtkWindowClass *klass = (GtkWindowClass *) get_threshold_class (G_OBJECT (window));
	if (klass->keys_changed)
		(* klass->keys_changed) (window);
}
void gtksharp_window_override_frame_event (GType gtype, gpointer cb);

void
gtksharp_window_override_frame_event (GType gtype, gpointer cb)
{
	GObjectClass *klass = g_type_class_peek (gtype);
	if (klass == NULL)
		klass = g_type_class_ref (gtype);
	((GtkWindowClass *)klass)->frame_event = cb;
}

gboolean gtksharp_window_base_frame_event (GtkWindow* window, GdkEvent* evnt);

gboolean
gtksharp_window_base_frame_event (GtkWindow* window, GdkEvent* evnt)
{
	GtkWindowClass *klass = (GtkWindowClass *) get_threshold_class (G_OBJECT (window));
	if (klass->frame_event)
		return (* klass->frame_event) (window, evnt);
	return FALSE;
}
GtkAccelFlags gtksharp_gtk_accelkey_get_accel_flags (GtkAccelKey *accelkey);
void gtksharp_gtk_accelkey_set_accel_flags (GtkAccelKey *accelkey, GtkAccelFlags value);

GtkAccelFlags
gtksharp_gtk_accelkey_get_accel_flags (GtkAccelKey *accelkey)
{
	return (GtkAccelFlags)accelkey->accel_flags;
}

void
gtksharp_gtk_accelkey_set_accel_flags (GtkAccelKey *accelkey, GtkAccelFlags value)
{
	accelkey->accel_flags = (GtkAccelFlags)value;
}

guint gtksharp_gtk_selectiondata_get_type_offset (void);

guint
gtksharp_gtk_selectiondata_get_type_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkSelectionData, type);
}

guint gtksharp_gtk_selectiondata_get_length_offset (void);

guint
gtksharp_gtk_selectiondata_get_length_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkSelectionData, length);
}

guint gtksharp_gtk_selectiondata_get_target_offset (void);

guint
gtksharp_gtk_selectiondata_get_target_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkSelectionData, target);
}

guint gtksharp_gtk_selectiondata_get_format_offset (void);

guint
gtksharp_gtk_selectiondata_get_format_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkSelectionData, format);
}

guint gtksharp_gtk_selectiondata_get_selection_offset (void);

guint
gtksharp_gtk_selectiondata_get_selection_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkSelectionData, selection);
}

PangoUnderline gtksharp_gtk_textappearance_get_underline (GtkTextAppearance *textappearance);
void gtksharp_gtk_textappearance_set_underline (GtkTextAppearance *textappearance, PangoUnderline value);

PangoUnderline
gtksharp_gtk_textappearance_get_underline (GtkTextAppearance *textappearance)
{
	return (PangoUnderline)textappearance->underline;
}

void
gtksharp_gtk_textappearance_set_underline (GtkTextAppearance *textappearance, PangoUnderline value)
{
	textappearance->underline = (PangoUnderline)value;
}

gboolean gtksharp_gtk_textappearance_get_strikethrough (GtkTextAppearance *textappearance);
void gtksharp_gtk_textappearance_set_strikethrough (GtkTextAppearance *textappearance, gboolean value);

gboolean
gtksharp_gtk_textappearance_get_strikethrough (GtkTextAppearance *textappearance)
{
	return (gboolean)textappearance->strikethrough;
}

void
gtksharp_gtk_textappearance_set_strikethrough (GtkTextAppearance *textappearance, gboolean value)
{
	textappearance->strikethrough = (gboolean)value;
}

guint gtksharp_gtk_textattributes_get_indent_offset (void);

guint
gtksharp_gtk_textattributes_get_indent_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, indent);
}

guint gtksharp_gtk_textattributes_get_font_offset (void);

guint
gtksharp_gtk_textattributes_get_font_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, font);
}

guint gtksharp_gtk_textattributes_get_right_margin_offset (void);

guint
gtksharp_gtk_textattributes_get_right_margin_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, right_margin);
}

guint gtksharp_gtk_textattributes_get_pixels_below_lines_offset (void);

guint
gtksharp_gtk_textattributes_get_pixels_below_lines_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, pixels_below_lines);
}

guint gtksharp_gtk_textattributes_get_wrap_mode_offset (void);

guint
gtksharp_gtk_textattributes_get_wrap_mode_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, wrap_mode);
}

gboolean gtksharp_gtk_textattributes_get_realized (GtkTextAttributes *textattributes);
void gtksharp_gtk_textattributes_set_realized (GtkTextAttributes *textattributes, gboolean value);

gboolean
gtksharp_gtk_textattributes_get_realized (GtkTextAttributes *textattributes)
{
	return (gboolean)textattributes->realized;
}

void
gtksharp_gtk_textattributes_set_realized (GtkTextAttributes *textattributes, gboolean value)
{
	textattributes->realized = (gboolean)value;
}

guint gtksharp_gtk_textattributes_get_appearance_offset (void);

guint
gtksharp_gtk_textattributes_get_appearance_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, appearance);
}

guint gtksharp_gtk_textattributes_get_language_offset (void);

guint
gtksharp_gtk_textattributes_get_language_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, language);
}

gboolean gtksharp_gtk_textattributes_get_invisible (GtkTextAttributes *textattributes);
void gtksharp_gtk_textattributes_set_invisible (GtkTextAttributes *textattributes, gboolean value);

gboolean
gtksharp_gtk_textattributes_get_invisible (GtkTextAttributes *textattributes)
{
	return (gboolean)textattributes->invisible;
}

void
gtksharp_gtk_textattributes_set_invisible (GtkTextAttributes *textattributes, gboolean value)
{
	textattributes->invisible = (gboolean)value;
}

gboolean gtksharp_gtk_textattributes_get_editable (GtkTextAttributes *textattributes);
void gtksharp_gtk_textattributes_set_editable (GtkTextAttributes *textattributes, gboolean value);

gboolean
gtksharp_gtk_textattributes_get_editable (GtkTextAttributes *textattributes)
{
	return (gboolean)textattributes->editable;
}

void
gtksharp_gtk_textattributes_set_editable (GtkTextAttributes *textattributes, gboolean value)
{
	textattributes->editable = (gboolean)value;
}

guint gtksharp_gtk_textattributes_get_justification_offset (void);

guint
gtksharp_gtk_textattributes_get_justification_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, justification);
}

guint gtksharp_gtk_textattributes_get_pixels_above_lines_offset (void);

guint
gtksharp_gtk_textattributes_get_pixels_above_lines_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, pixels_above_lines);
}

guint gtksharp_gtk_textattributes_get_left_margin_offset (void);

guint
gtksharp_gtk_textattributes_get_left_margin_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, left_margin);
}

guint gtksharp_gtk_textattributes_get_direction_offset (void);

guint
gtksharp_gtk_textattributes_get_direction_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, direction);
}

guint gtksharp_gtk_textattributes_get_pixels_inside_wrap_offset (void);

guint
gtksharp_gtk_textattributes_get_pixels_inside_wrap_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, pixels_inside_wrap);
}

guint gtksharp_gtk_textattributes_get_tabs_offset (void);

guint
gtksharp_gtk_textattributes_get_tabs_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, tabs);
}

guint gtksharp_gtk_textattributes_get_font_scale_offset (void);

guint
gtksharp_gtk_textattributes_get_font_scale_offset (void)
{
	return (guint)G_STRUCT_OFFSET (GtkTextAttributes, font_scale);
}

gboolean gtksharp_gtk_textattributes_get_bg_full_height (GtkTextAttributes *textattributes);
void gtksharp_gtk_textattributes_set_bg_full_height (GtkTextAttributes *textattributes, gboolean value);

gboolean
gtksharp_gtk_textattributes_get_bg_full_height (GtkTextAttributes *textattributes)
{
	return (gboolean)textattributes->bg_full_height;
}

void
gtksharp_gtk_textattributes_set_bg_full_height (GtkTextAttributes *textattributes, gboolean value)
{
	textattributes->bg_full_height = (gboolean)value;
}

