// Automatically-generated SDPGTK wrappers for Gtk+ events
//
// This file was generated with 'awk -f sdpgtkevents.cpp.awk sdpgtkevents.data > source/sdpgtkevents.cpp'
// Do not edit this file by hand!  Alter sdpgtkevents.cpp.awk or sdpgtkevents.data!


#include "sdpgtkevents.h"

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventAdjustmentChanged ('changed')

sdpGtkEventAdjustmentChanged::sdpGtkEventAdjustmentChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventAdjustmentChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventAdjustmentChanged::Event(GtkAdjustment* Adjustment) { m_Adjustment = Adjustment; m_EventContainer->OnEvent(this); }
void sdpGtkEventAdjustmentChanged::RawEvent(GtkAdjustment* Adjustment, gpointer EventData) { ((sdpGtkEventAdjustmentChanged*)EventData)->Event(Adjustment); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventAdjustmentValueChanged ('value-changed')

sdpGtkEventAdjustmentValueChanged::sdpGtkEventAdjustmentValueChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventAdjustmentValueChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventAdjustmentValueChanged::Event(GtkAdjustment* Adjustment) { m_Adjustment = Adjustment; m_EventContainer->OnEvent(this); }
void sdpGtkEventAdjustmentValueChanged::RawEvent(GtkAdjustment* Adjustment, gpointer EventData) { ((sdpGtkEventAdjustmentValueChanged*)EventData)->Event(Adjustment); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventButtonClicked ('clicked')

sdpGtkEventButtonClicked::sdpGtkEventButtonClicked(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventButtonClicked::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventButtonClicked::Event(GtkButton* Button) { m_Button = Button; m_EventContainer->OnEvent(this); }
void sdpGtkEventButtonClicked::RawEvent(GtkButton* Button, gpointer EventData) { ((sdpGtkEventButtonClicked*)EventData)->Event(Button); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventButtonEnter ('enter')

sdpGtkEventButtonEnter::sdpGtkEventButtonEnter(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventButtonEnter::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventButtonEnter::Event(GtkButton* Button) { m_Button = Button; m_EventContainer->OnEvent(this); }
void sdpGtkEventButtonEnter::RawEvent(GtkButton* Button, gpointer EventData) { ((sdpGtkEventButtonEnter*)EventData)->Event(Button); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventButtonLeave ('leave')

sdpGtkEventButtonLeave::sdpGtkEventButtonLeave(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventButtonLeave::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventButtonLeave::Event(GtkButton* Button) { m_Button = Button; m_EventContainer->OnEvent(this); }
void sdpGtkEventButtonLeave::RawEvent(GtkButton* Button, gpointer EventData) { ((sdpGtkEventButtonLeave*)EventData)->Event(Button); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventButtonPressed ('pressed')

sdpGtkEventButtonPressed::sdpGtkEventButtonPressed(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventButtonPressed::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventButtonPressed::Event(GtkButton* Button) { m_Button = Button; m_EventContainer->OnEvent(this); }
void sdpGtkEventButtonPressed::RawEvent(GtkButton* Button, gpointer EventData) { ((sdpGtkEventButtonPressed*)EventData)->Event(Button); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventButtonReleased ('released')

sdpGtkEventButtonReleased::sdpGtkEventButtonReleased(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventButtonReleased::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventButtonReleased::Event(GtkButton* Button) { m_Button = Button; m_EventContainer->OnEvent(this); }
void sdpGtkEventButtonReleased::RawEvent(GtkButton* Button, gpointer EventData) { ((sdpGtkEventButtonReleased*)EventData)->Event(Button); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCalendarDaySelected ('day-selected')

sdpGtkEventCalendarDaySelected::sdpGtkEventCalendarDaySelected(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCalendarDaySelected::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCalendarDaySelected::Event(GtkCalendar* Calendar) { m_Calendar = Calendar; m_EventContainer->OnEvent(this); }
void sdpGtkEventCalendarDaySelected::RawEvent(GtkCalendar* Calendar, gpointer EventData) { ((sdpGtkEventCalendarDaySelected*)EventData)->Event(Calendar); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCalendarDaySelectedDoubleClick ('day-selected-gdouble-click')

sdpGtkEventCalendarDaySelectedDoubleClick::sdpGtkEventCalendarDaySelectedDoubleClick(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCalendarDaySelectedDoubleClick::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCalendarDaySelectedDoubleClick::Event(GtkCalendar* Calendar) { m_Calendar = Calendar; m_EventContainer->OnEvent(this); }
void sdpGtkEventCalendarDaySelectedDoubleClick::RawEvent(GtkCalendar* Calendar, gpointer EventData) { ((sdpGtkEventCalendarDaySelectedDoubleClick*)EventData)->Event(Calendar); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCalendarMonthChanged ('month-changed')

sdpGtkEventCalendarMonthChanged::sdpGtkEventCalendarMonthChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCalendarMonthChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCalendarMonthChanged::Event(GtkCalendar* Calendar) { m_Calendar = Calendar; m_EventContainer->OnEvent(this); }
void sdpGtkEventCalendarMonthChanged::RawEvent(GtkCalendar* Calendar, gpointer EventData) { ((sdpGtkEventCalendarMonthChanged*)EventData)->Event(Calendar); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCalendarNextMonth ('next-month')

sdpGtkEventCalendarNextMonth::sdpGtkEventCalendarNextMonth(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCalendarNextMonth::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCalendarNextMonth::Event(GtkCalendar* Calendar) { m_Calendar = Calendar; m_EventContainer->OnEvent(this); }
void sdpGtkEventCalendarNextMonth::RawEvent(GtkCalendar* Calendar, gpointer EventData) { ((sdpGtkEventCalendarNextMonth*)EventData)->Event(Calendar); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCalendarNextYear ('next-year')

sdpGtkEventCalendarNextYear::sdpGtkEventCalendarNextYear(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCalendarNextYear::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCalendarNextYear::Event(GtkCalendar* Calendar) { m_Calendar = Calendar; m_EventContainer->OnEvent(this); }
void sdpGtkEventCalendarNextYear::RawEvent(GtkCalendar* Calendar, gpointer EventData) { ((sdpGtkEventCalendarNextYear*)EventData)->Event(Calendar); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCalendarPrevMonth ('prev-month')

sdpGtkEventCalendarPrevMonth::sdpGtkEventCalendarPrevMonth(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCalendarPrevMonth::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCalendarPrevMonth::Event(GtkCalendar* Calendar) { m_Calendar = Calendar; m_EventContainer->OnEvent(this); }
void sdpGtkEventCalendarPrevMonth::RawEvent(GtkCalendar* Calendar, gpointer EventData) { ((sdpGtkEventCalendarPrevMonth*)EventData)->Event(Calendar); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCalendarPrevYear ('prev-year')

sdpGtkEventCalendarPrevYear::sdpGtkEventCalendarPrevYear(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCalendarPrevYear::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCalendarPrevYear::Event(GtkCalendar* Calendar) { m_Calendar = Calendar; m_EventContainer->OnEvent(this); }
void sdpGtkEventCalendarPrevYear::RawEvent(GtkCalendar* Calendar, gpointer EventData) { ((sdpGtkEventCalendarPrevYear*)EventData)->Event(Calendar); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCheckMenuItemToggled ('toggled')

sdpGtkEventCheckMenuItemToggled::sdpGtkEventCheckMenuItemToggled(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCheckMenuItemToggled::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCheckMenuItemToggled::Event(GtkCheckMenuItem* MenuItem) { m_MenuItem = MenuItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventCheckMenuItemToggled::RawEvent(GtkCheckMenuItem* MenuItem, gpointer EventData) { ((sdpGtkEventCheckMenuItemToggled*)EventData)->Event(MenuItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListAbortColumnResize ('abort-column-resize')

sdpGtkEventCListAbortColumnResize::sdpGtkEventCListAbortColumnResize(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListAbortColumnResize::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListAbortColumnResize::Event(GtkCList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListAbortColumnResize::RawEvent(GtkCList* List, gpointer EventData) { ((sdpGtkEventCListAbortColumnResize*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListClickColumn ('click-column')

sdpGtkEventCListClickColumn::sdpGtkEventCListClickColumn(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListClickColumn::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListClickColumn::Event(GtkCList* List, gint Column) { m_List = List; m_Column = Column; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListClickColumn::RawEvent(GtkCList* List, gint Column, gpointer EventData) { ((sdpGtkEventCListClickColumn*)EventData)->Event(List, Column); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListEndSelection ('end-selection')

sdpGtkEventCListEndSelection::sdpGtkEventCListEndSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListEndSelection::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListEndSelection::Event(GtkCList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListEndSelection::RawEvent(GtkCList* List, gpointer EventData) { ((sdpGtkEventCListEndSelection*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListExtendSelection ('extend-selection')

sdpGtkEventCListExtendSelection::sdpGtkEventCListExtendSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListExtendSelection::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListExtendSelection::Event(GtkCList* List, GtkScrollType ScrollType, gfloat Position, gboolean AutoStartSelection) { m_List = List; m_ScrollType = ScrollType; m_Position = Position; m_AutoStartSelection = AutoStartSelection; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListExtendSelection::RawEvent(GtkCList* List, GtkScrollType ScrollType, gfloat Position, gboolean AutoStartSelection, gpointer EventData) { ((sdpGtkEventCListExtendSelection*)EventData)->Event(List, ScrollType, Position, AutoStartSelection); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListResizeColumn ('resize-column')

sdpGtkEventCListResizeColumn::sdpGtkEventCListResizeColumn(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListResizeColumn::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListResizeColumn::Event(GtkCList* List, gint Column, gint Width) { m_List = List; m_Column = Column; m_Width = Width; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListResizeColumn::RawEvent(GtkCList* List, gint Column, gint Width, gpointer EventData) { ((sdpGtkEventCListResizeColumn*)EventData)->Event(List, Column, Width); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListRowMove ('row-move')

sdpGtkEventCListRowMove::sdpGtkEventCListRowMove(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListRowMove::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListRowMove::Event(GtkCList* List, gint SourceRow, gint DestinationRow) { m_List = List; m_SourceRow = SourceRow; m_DestinationRow = DestinationRow; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListRowMove::RawEvent(GtkCList* List, gint SourceRow, gint DestinationRow, gpointer EventData) { ((sdpGtkEventCListRowMove*)EventData)->Event(List, SourceRow, DestinationRow); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListScrollHorizontal ('scroll-horizontal')

sdpGtkEventCListScrollHorizontal::sdpGtkEventCListScrollHorizontal(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListScrollHorizontal::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListScrollHorizontal::Event(GtkCList* List, GtkScrollType ScrollType, gfloat Position) { m_List = List; m_ScrollType = ScrollType; m_Position = Position; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListScrollHorizontal::RawEvent(GtkCList* List, GtkScrollType ScrollType, gfloat Position, gpointer EventData) { ((sdpGtkEventCListScrollHorizontal*)EventData)->Event(List, ScrollType, Position); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListScrollVertical ('scroll-vertical')

sdpGtkEventCListScrollVertical::sdpGtkEventCListScrollVertical(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListScrollVertical::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListScrollVertical::Event(GtkCList* List, GtkScrollType ScrollType, gfloat Position) { m_List = List; m_ScrollType = ScrollType; m_Position = Position; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListScrollVertical::RawEvent(GtkCList* List, GtkScrollType ScrollType, gfloat Position, gpointer EventData) { ((sdpGtkEventCListScrollVertical*)EventData)->Event(List, ScrollType, Position); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListSelectAll ('select-all')

sdpGtkEventCListSelectAll::sdpGtkEventCListSelectAll(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListSelectAll::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListSelectAll::Event(GtkCList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListSelectAll::RawEvent(GtkCList* List, gpointer EventData) { ((sdpGtkEventCListSelectAll*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListSelectRow ('select-row')

sdpGtkEventCListSelectRow::sdpGtkEventCListSelectRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListSelectRow::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListSelectRow::Event(GtkCList* List, gint Row, gint Column, GdkEvent* Event) { m_List = List; m_Row = Row; m_Column = Column; m_Event = Event; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListSelectRow::RawEvent(GtkCList* List, gint Row, gint Column, GdkEvent* Event, gpointer EventData) { ((sdpGtkEventCListSelectRow*)EventData)->Event(List, Row, Column, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListStartSelection ('start-selection')

sdpGtkEventCListStartSelection::sdpGtkEventCListStartSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListStartSelection::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListStartSelection::Event(GtkCList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListStartSelection::RawEvent(GtkCList* List, gpointer EventData) { ((sdpGtkEventCListStartSelection*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListToggleAddMode ('toggle-add-mode')

sdpGtkEventCListToggleAddMode::sdpGtkEventCListToggleAddMode(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListToggleAddMode::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListToggleAddMode::Event(GtkCList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListToggleAddMode::RawEvent(GtkCList* List, gpointer EventData) { ((sdpGtkEventCListToggleAddMode*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListToggleFocusRow ('toggle-focus-row')

sdpGtkEventCListToggleFocusRow::sdpGtkEventCListToggleFocusRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListToggleFocusRow::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListToggleFocusRow::Event(GtkCList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListToggleFocusRow::RawEvent(GtkCList* List, gpointer EventData) { ((sdpGtkEventCListToggleFocusRow*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListUndoSelection ('undo-selection')

sdpGtkEventCListUndoSelection::sdpGtkEventCListUndoSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListUndoSelection::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListUndoSelection::Event(GtkCList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListUndoSelection::RawEvent(GtkCList* List, gpointer EventData) { ((sdpGtkEventCListUndoSelection*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListUnselectAll ('unselect-all')

sdpGtkEventCListUnselectAll::sdpGtkEventCListUnselectAll(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListUnselectAll::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListUnselectAll::Event(GtkCList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListUnselectAll::RawEvent(GtkCList* List, gpointer EventData) { ((sdpGtkEventCListUnselectAll*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCListUnselectRow ('unselect-row')

sdpGtkEventCListUnselectRow::sdpGtkEventCListUnselectRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCListUnselectRow::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCListUnselectRow::Event(GtkCList* List, gint Row, gint Column, GdkEvent* Event) { m_List = List; m_Row = Row; m_Column = Column; m_Event = Event; m_EventContainer->OnEvent(this); }
void sdpGtkEventCListUnselectRow::RawEvent(GtkCList* List, gint Row, gint Column, GdkEvent* Event, gpointer EventData) { ((sdpGtkEventCListUnselectRow*)EventData)->Event(List, Row, Column, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventColorSelectionColorChanged ('color-changed')

sdpGtkEventColorSelectionColorChanged::sdpGtkEventColorSelectionColorChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventColorSelectionColorChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventColorSelectionColorChanged::Event(GtkColorSelection* ColorSelection) { m_ColorSelection = ColorSelection; m_EventContainer->OnEvent(this); }
void sdpGtkEventColorSelectionColorChanged::RawEvent(GtkColorSelection* ColorSelection, gpointer EventData) { ((sdpGtkEventColorSelectionColorChanged*)EventData)->Event(ColorSelection); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventContainerAdd ('add')

sdpGtkEventContainerAdd::sdpGtkEventContainerAdd(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventContainerAdd::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventContainerAdd::Event(GtkContainer* Container, GtkWidget* Widget) { m_Container = Container; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventContainerAdd::RawEvent(GtkContainer* Container, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventContainerAdd*)EventData)->Event(Container, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventContainerCheckResize ('check-resize')

sdpGtkEventContainerCheckResize::sdpGtkEventContainerCheckResize(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventContainerCheckResize::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventContainerCheckResize::Event(GtkContainer* Container) { m_Container = Container; m_EventContainer->OnEvent(this); }
void sdpGtkEventContainerCheckResize::RawEvent(GtkContainer* Container, gpointer EventData) { ((sdpGtkEventContainerCheckResize*)EventData)->Event(Container); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventContainerFocus ('focus')

sdpGtkEventContainerFocus::sdpGtkEventContainerFocus(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventContainerFocus::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
GtkDirectionType sdpGtkEventContainerFocus::Event(GtkContainer* Container, GtkDirectionType DirectionType) { m_Container = Container; m_DirectionType = DirectionType; m_EventContainer->OnEvent(this); return m_Result; }
GtkDirectionType sdpGtkEventContainerFocus::RawEvent(GtkContainer* Container, GtkDirectionType DirectionType, gpointer EventData) { return ((sdpGtkEventContainerFocus*)EventData)->Event(Container, DirectionType); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventContainerRemove ('remove')

sdpGtkEventContainerRemove::sdpGtkEventContainerRemove(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventContainerRemove::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventContainerRemove::Event(GtkContainer* Container, GtkWidget* Widget) { m_Container = Container; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventContainerRemove::RawEvent(GtkContainer* Container, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventContainerRemove*)EventData)->Event(Container, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventContainerSetFocusChild ('set-focus-child')

sdpGtkEventContainerSetFocusChild::sdpGtkEventContainerSetFocusChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventContainerSetFocusChild::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventContainerSetFocusChild::Event(GtkContainer* Container, GtkWidget* Widget) { m_Container = Container; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventContainerSetFocusChild::RawEvent(GtkContainer* Container, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventContainerSetFocusChild*)EventData)->Event(Container, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCTreeChangeFocusRowExpansion ('change-focus-row-expansion')

sdpGtkEventCTreeChangeFocusRowExpansion::sdpGtkEventCTreeChangeFocusRowExpansion(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCTreeChangeFocusRowExpansion::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCTreeChangeFocusRowExpansion::Event(GtkCTree* Tree, GtkCTreeExpansionType ExpansionType) { m_Tree = Tree; m_ExpansionType = ExpansionType; m_EventContainer->OnEvent(this); }
void sdpGtkEventCTreeChangeFocusRowExpansion::RawEvent(GtkCTree* Tree, GtkCTreeExpansionType ExpansionType, gpointer EventData) { ((sdpGtkEventCTreeChangeFocusRowExpansion*)EventData)->Event(Tree, ExpansionType); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCTreeTreeCollapse ('tree-collapse')

sdpGtkEventCTreeTreeCollapse::sdpGtkEventCTreeTreeCollapse(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCTreeTreeCollapse::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCTreeTreeCollapse::Event(GtkCTree* Tree, GtkCTreeNode* Node) { m_Tree = Tree; m_Node = Node; m_EventContainer->OnEvent(this); }
void sdpGtkEventCTreeTreeCollapse::RawEvent(GtkCTree* Tree, GtkCTreeNode* Node, gpointer EventData) { ((sdpGtkEventCTreeTreeCollapse*)EventData)->Event(Tree, Node); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCTreeTreeExpand ('tree-expand')

sdpGtkEventCTreeTreeExpand::sdpGtkEventCTreeTreeExpand(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCTreeTreeExpand::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCTreeTreeExpand::Event(GtkCTree* Tree, GtkCTreeNode* Node) { m_Tree = Tree; m_Node = Node; m_EventContainer->OnEvent(this); }
void sdpGtkEventCTreeTreeExpand::RawEvent(GtkCTree* Tree, GtkCTreeNode* Node, gpointer EventData) { ((sdpGtkEventCTreeTreeExpand*)EventData)->Event(Tree, Node); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCTreeTreeMove ('tree-move')

sdpGtkEventCTreeTreeMove::sdpGtkEventCTreeTreeMove(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCTreeTreeMove::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCTreeTreeMove::Event(GtkCTree* Tree, GtkCTreeNode* Node, GtkCTreeNode* NewParent, GtkCTreeNode* NewSibling) { m_Tree = Tree; m_Node = Node; m_NewParent = NewParent; m_NewSibling = NewSibling; m_EventContainer->OnEvent(this); }
void sdpGtkEventCTreeTreeMove::RawEvent(GtkCTree* Tree, GtkCTreeNode* Node, GtkCTreeNode* NewParent, GtkCTreeNode* NewSibling, gpointer EventData) { ((sdpGtkEventCTreeTreeMove*)EventData)->Event(Tree, Node, NewParent, NewSibling); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCTreeTreeSelectRow ('tree-select-row')

sdpGtkEventCTreeTreeSelectRow::sdpGtkEventCTreeTreeSelectRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCTreeTreeSelectRow::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCTreeTreeSelectRow::Event(GtkCTree* Tree, GtkCTreeNode* Row, gint Column) { m_Tree = Tree; m_Row = Row; m_Column = Column; m_EventContainer->OnEvent(this); }
void sdpGtkEventCTreeTreeSelectRow::RawEvent(GtkCTree* Tree, GtkCTreeNode* Row, gint Column, gpointer EventData) { ((sdpGtkEventCTreeTreeSelectRow*)EventData)->Event(Tree, Row, Column); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCTreeTreeUnselectRow ('tree-unselect-row')

sdpGtkEventCTreeTreeUnselectRow::sdpGtkEventCTreeTreeUnselectRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCTreeTreeUnselectRow::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCTreeTreeUnselectRow::Event(GtkCTree* Tree, GtkCTreeNode* Row, gint Column) { m_Tree = Tree; m_Row = Row; m_Column = Column; m_EventContainer->OnEvent(this); }
void sdpGtkEventCTreeTreeUnselectRow::RawEvent(GtkCTree* Tree, GtkCTreeNode* Row, gint Column, gpointer EventData) { ((sdpGtkEventCTreeTreeUnselectRow*)EventData)->Event(Tree, Row, Column); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventCurveCurveTypeChanged ('curve-type-changed')

sdpGtkEventCurveCurveTypeChanged::sdpGtkEventCurveCurveTypeChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventCurveCurveTypeChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventCurveCurveTypeChanged::Event(GtkCurve* Curve) { m_Curve = Curve; m_EventContainer->OnEvent(this); }
void sdpGtkEventCurveCurveTypeChanged::RawEvent(GtkCurve* Curve, gpointer EventData) { ((sdpGtkEventCurveCurveTypeChanged*)EventData)->Event(Curve); }

#ifndef K3D_HAVE_GTK2

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventDataDisconnect ('disconnect')

sdpGtkEventDataDisconnect::sdpGtkEventDataDisconnect(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventDataDisconnect::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventDataDisconnect::Event(GtkData* Data) { m_Data = Data; m_EventContainer->OnEvent(this); }
void sdpGtkEventDataDisconnect::RawEvent(GtkData* Data, gpointer EventData) { ((sdpGtkEventDataDisconnect*)EventData)->Event(Data); }

#endif // !K3D_HAVE_GTK2

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableActivate ('activate')

sdpGtkEventEditableActivate::sdpGtkEventEditableActivate(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableActivate::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableActivate::Event(GtkEditable* Editable) { m_Editable = Editable; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableActivate::RawEvent(GtkEditable* Editable, gpointer EventData) { ((sdpGtkEventEditableActivate*)EventData)->Event(Editable); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableChanged ('changed')

sdpGtkEventEditableChanged::sdpGtkEventEditableChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableChanged::Event(GtkEditable* Editable) { m_Editable = Editable; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableChanged::RawEvent(GtkEditable* Editable, gpointer EventData) { ((sdpGtkEventEditableChanged*)EventData)->Event(Editable); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableCopyClipboard ('copy-clipboard')

sdpGtkEventEditableCopyClipboard::sdpGtkEventEditableCopyClipboard(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableCopyClipboard::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableCopyClipboard::Event(GtkEditable* Editable) { m_Editable = Editable; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableCopyClipboard::RawEvent(GtkEditable* Editable, gpointer EventData) { ((sdpGtkEventEditableCopyClipboard*)EventData)->Event(Editable); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableCutClipboard ('cut-clipboard')

sdpGtkEventEditableCutClipboard::sdpGtkEventEditableCutClipboard(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableCutClipboard::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableCutClipboard::Event(GtkEditable* Editable) { m_Editable = Editable; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableCutClipboard::RawEvent(GtkEditable* Editable, gpointer EventData) { ((sdpGtkEventEditableCutClipboard*)EventData)->Event(Editable); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableDeleteText ('delete-text')

sdpGtkEventEditableDeleteText::sdpGtkEventEditableDeleteText(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableDeleteText::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableDeleteText::Event(GtkEditable* Editable, gint Start, gint End) { m_Editable = Editable; m_Start = Start; m_End = End; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableDeleteText::RawEvent(GtkEditable* Editable, gint Start, gint End, gpointer EventData) { ((sdpGtkEventEditableDeleteText*)EventData)->Event(Editable, Start, End); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableInsertText ('insert-text')

sdpGtkEventEditableInsertText::sdpGtkEventEditableInsertText(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableInsertText::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableInsertText::Event(GtkEditable* Editable, gchar* Text, gint TextLength, gint* Position) { m_Editable = Editable; m_Text = Text; m_TextLength = TextLength; m_Position = Position; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableInsertText::RawEvent(GtkEditable* Editable, gchar* Text, gint TextLength, gint* Position, gpointer EventData) { ((sdpGtkEventEditableInsertText*)EventData)->Event(Editable, Text, TextLength, Position); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableKillChar ('kill-gchar')

sdpGtkEventEditableKillChar::sdpGtkEventEditableKillChar(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableKillChar::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableKillChar::Event(GtkEditable* Editable, gint Direction) { m_Editable = Editable; m_Direction = Direction; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableKillChar::RawEvent(GtkEditable* Editable, gint Direction, gpointer EventData) { ((sdpGtkEventEditableKillChar*)EventData)->Event(Editable, Direction); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableKillLine ('kill-line')

sdpGtkEventEditableKillLine::sdpGtkEventEditableKillLine(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableKillLine::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableKillLine::Event(GtkEditable* Editable, gint Direction) { m_Editable = Editable; m_Direction = Direction; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableKillLine::RawEvent(GtkEditable* Editable, gint Direction, gpointer EventData) { ((sdpGtkEventEditableKillLine*)EventData)->Event(Editable, Direction); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableKillWord ('kill-word')

sdpGtkEventEditableKillWord::sdpGtkEventEditableKillWord(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableKillWord::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableKillWord::Event(GtkEditable* Editable, gint Direction) { m_Editable = Editable; m_Direction = Direction; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableKillWord::RawEvent(GtkEditable* Editable, gint Direction, gpointer EventData) { ((sdpGtkEventEditableKillWord*)EventData)->Event(Editable, Direction); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableMoveCursor ('move-cursor')

sdpGtkEventEditableMoveCursor::sdpGtkEventEditableMoveCursor(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableMoveCursor::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableMoveCursor::Event(GtkEditable* Editable, gint X, gint Y) { m_Editable = Editable; m_X = X; m_Y = Y; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableMoveCursor::RawEvent(GtkEditable* Editable, gint X, gint Y, gpointer EventData) { ((sdpGtkEventEditableMoveCursor*)EventData)->Event(Editable, X, Y); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableMovePage ('move-page')

sdpGtkEventEditableMovePage::sdpGtkEventEditableMovePage(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableMovePage::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableMovePage::Event(GtkEditable* Editable, gint X, gint Y) { m_Editable = Editable; m_X = X; m_Y = Y; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableMovePage::RawEvent(GtkEditable* Editable, gint X, gint Y, gpointer EventData) { ((sdpGtkEventEditableMovePage*)EventData)->Event(Editable, X, Y); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableMoveToColumn ('move-to-column')

sdpGtkEventEditableMoveToColumn::sdpGtkEventEditableMoveToColumn(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableMoveToColumn::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableMoveToColumn::Event(GtkEditable* Editable, gint Column) { m_Editable = Editable; m_Column = Column; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableMoveToColumn::RawEvent(GtkEditable* Editable, gint Column, gpointer EventData) { ((sdpGtkEventEditableMoveToColumn*)EventData)->Event(Editable, Column); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableMoveToRow ('move-to-row')

sdpGtkEventEditableMoveToRow::sdpGtkEventEditableMoveToRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableMoveToRow::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableMoveToRow::Event(GtkEditable* Editable, gint Row) { m_Editable = Editable; m_Row = Row; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableMoveToRow::RawEvent(GtkEditable* Editable, gint Row, gpointer EventData) { ((sdpGtkEventEditableMoveToRow*)EventData)->Event(Editable, Row); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableMoveWord ('move-word')

sdpGtkEventEditableMoveWord::sdpGtkEventEditableMoveWord(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableMoveWord::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableMoveWord::Event(GtkEditable* Editable, gint Direction) { m_Editable = Editable; m_Direction = Direction; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableMoveWord::RawEvent(GtkEditable* Editable, gint Direction, gpointer EventData) { ((sdpGtkEventEditableMoveWord*)EventData)->Event(Editable, Direction); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditablePasteClipboard ('paste-clipboard')

sdpGtkEventEditablePasteClipboard::sdpGtkEventEditablePasteClipboard(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditablePasteClipboard::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditablePasteClipboard::Event(GtkEditable* Editable) { m_Editable = Editable; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditablePasteClipboard::RawEvent(GtkEditable* Editable, gpointer EventData) { ((sdpGtkEventEditablePasteClipboard*)EventData)->Event(Editable); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventEditableSetEditable ('set-editable')

sdpGtkEventEditableSetEditable::sdpGtkEventEditableSetEditable(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventEditableSetEditable::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventEditableSetEditable::Event(GtkEditable* Editable, gboolean IsEditable) { m_Editable = Editable; m_IsEditable = IsEditable; m_EventContainer->OnEvent(this); }
void sdpGtkEventEditableSetEditable::RawEvent(GtkEditable* Editable, gboolean IsEditable, gpointer EventData) { ((sdpGtkEventEditableSetEditable*)EventData)->Event(Editable, IsEditable); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventHandleBoxChildAttached ('child-attached')

sdpGtkEventHandleBoxChildAttached::sdpGtkEventHandleBoxChildAttached(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventHandleBoxChildAttached::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventHandleBoxChildAttached::Event(GtkHandleBox* HandleBox, GtkWidget* Widget) { m_HandleBox = HandleBox; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventHandleBoxChildAttached::RawEvent(GtkHandleBox* HandleBox, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventHandleBoxChildAttached*)EventData)->Event(HandleBox, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventHandleBoxChildDetached ('child-detached')

sdpGtkEventHandleBoxChildDetached::sdpGtkEventHandleBoxChildDetached(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventHandleBoxChildDetached::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventHandleBoxChildDetached::Event(GtkHandleBox* HandleBox, GtkWidget* Widget) { m_HandleBox = HandleBox; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventHandleBoxChildDetached::RawEvent(GtkHandleBox* HandleBox, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventHandleBoxChildDetached*)EventData)->Event(HandleBox, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventInputDialogDisableDevice ('disable-device')

sdpGtkEventInputDialogDisableDevice::sdpGtkEventInputDialogDisableDevice(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventInputDialogDisableDevice::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventInputDialogDisableDevice::Event(GtkInputDialog* InputDialog, guint32 DeviceID) { m_InputDialog = InputDialog; m_DeviceID = DeviceID; m_EventContainer->OnEvent(this); }
void sdpGtkEventInputDialogDisableDevice::RawEvent(GtkInputDialog* InputDialog, guint32 DeviceID, gpointer EventData) { ((sdpGtkEventInputDialogDisableDevice*)EventData)->Event(InputDialog, DeviceID); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventInputDialogEnableDevice ('enable-device')

sdpGtkEventInputDialogEnableDevice::sdpGtkEventInputDialogEnableDevice(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventInputDialogEnableDevice::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventInputDialogEnableDevice::Event(GtkInputDialog* InputDialog, guint32 DeviceID) { m_InputDialog = InputDialog; m_DeviceID = DeviceID; m_EventContainer->OnEvent(this); }
void sdpGtkEventInputDialogEnableDevice::RawEvent(GtkInputDialog* InputDialog, guint32 DeviceID, gpointer EventData) { ((sdpGtkEventInputDialogEnableDevice*)EventData)->Event(InputDialog, DeviceID); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventItemDeselect ('deselect')

sdpGtkEventItemDeselect::sdpGtkEventItemDeselect(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventItemDeselect::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventItemDeselect::Event(GtkItem* Item) { m_Item = Item; m_EventContainer->OnEvent(this); }
void sdpGtkEventItemDeselect::RawEvent(GtkItem* Item, gpointer EventData) { ((sdpGtkEventItemDeselect*)EventData)->Event(Item); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventItemSelect ('select')

sdpGtkEventItemSelect::sdpGtkEventItemSelect(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventItemSelect::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventItemSelect::Event(GtkItem* Item) { m_Item = Item; m_EventContainer->OnEvent(this); }
void sdpGtkEventItemSelect::RawEvent(GtkItem* Item, gpointer EventData) { ((sdpGtkEventItemSelect*)EventData)->Event(Item); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventItemToggle ('toggle')

sdpGtkEventItemToggle::sdpGtkEventItemToggle(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventItemToggle::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventItemToggle::Event(GtkItem* Item) { m_Item = Item; m_EventContainer->OnEvent(this); }
void sdpGtkEventItemToggle::RawEvent(GtkItem* Item, gpointer EventData) { ((sdpGtkEventItemToggle*)EventData)->Event(Item); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemEndSelection ('end-selection')

sdpGtkEventListItemEndSelection::sdpGtkEventListItemEndSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemEndSelection::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemEndSelection::Event(GtkListItem* ListItem) { m_ListItem = ListItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemEndSelection::RawEvent(GtkListItem* ListItem, gpointer EventData) { ((sdpGtkEventListItemEndSelection*)EventData)->Event(ListItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemExtendSelection ('extend-selection')

sdpGtkEventListItemExtendSelection::sdpGtkEventListItemExtendSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemExtendSelection::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemExtendSelection::Event(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position, gboolean AutoStartSelection) { m_ListItem = ListItem; m_ScrollType = ScrollType; m_Position = Position; m_AutoStartSelection = AutoStartSelection; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemExtendSelection::RawEvent(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position, gboolean AutoStartSelection, gpointer EventData) { ((sdpGtkEventListItemExtendSelection*)EventData)->Event(ListItem, ScrollType, Position, AutoStartSelection); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemScrollHorizontal ('scroll-horizontal')

sdpGtkEventListItemScrollHorizontal::sdpGtkEventListItemScrollHorizontal(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemScrollHorizontal::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemScrollHorizontal::Event(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position) { m_ListItem = ListItem; m_ScrollType = ScrollType; m_Position = Position; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemScrollHorizontal::RawEvent(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position, gpointer EventData) { ((sdpGtkEventListItemScrollHorizontal*)EventData)->Event(ListItem, ScrollType, Position); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemScrollVertical ('scroll-vertical')

sdpGtkEventListItemScrollVertical::sdpGtkEventListItemScrollVertical(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemScrollVertical::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemScrollVertical::Event(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position) { m_ListItem = ListItem; m_ScrollType = ScrollType; m_Position = Position; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemScrollVertical::RawEvent(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position, gpointer EventData) { ((sdpGtkEventListItemScrollVertical*)EventData)->Event(ListItem, ScrollType, Position); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemSelectAll ('select-all')

sdpGtkEventListItemSelectAll::sdpGtkEventListItemSelectAll(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemSelectAll::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemSelectAll::Event(GtkListItem* ListItem) { m_ListItem = ListItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemSelectAll::RawEvent(GtkListItem* ListItem, gpointer EventData) { ((sdpGtkEventListItemSelectAll*)EventData)->Event(ListItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemStartSelection ('start-selection')

sdpGtkEventListItemStartSelection::sdpGtkEventListItemStartSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemStartSelection::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemStartSelection::Event(GtkListItem* ListItem) { m_ListItem = ListItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemStartSelection::RawEvent(GtkListItem* ListItem, gpointer EventData) { ((sdpGtkEventListItemStartSelection*)EventData)->Event(ListItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemToggleAddMode ('toggle-add-mode')

sdpGtkEventListItemToggleAddMode::sdpGtkEventListItemToggleAddMode(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemToggleAddMode::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemToggleAddMode::Event(GtkListItem* ListItem) { m_ListItem = ListItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemToggleAddMode::RawEvent(GtkListItem* ListItem, gpointer EventData) { ((sdpGtkEventListItemToggleAddMode*)EventData)->Event(ListItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemToggleFocusRow ('toggle-focus-row')

sdpGtkEventListItemToggleFocusRow::sdpGtkEventListItemToggleFocusRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemToggleFocusRow::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemToggleFocusRow::Event(GtkListItem* ListItem) { m_ListItem = ListItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemToggleFocusRow::RawEvent(GtkListItem* ListItem, gpointer EventData) { ((sdpGtkEventListItemToggleFocusRow*)EventData)->Event(ListItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemUndoSelection ('undo-selection')

sdpGtkEventListItemUndoSelection::sdpGtkEventListItemUndoSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemUndoSelection::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemUndoSelection::Event(GtkListItem* ListItem) { m_ListItem = ListItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemUndoSelection::RawEvent(GtkListItem* ListItem, gpointer EventData) { ((sdpGtkEventListItemUndoSelection*)EventData)->Event(ListItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListItemUnselectAll ('unselect-all')

sdpGtkEventListItemUnselectAll::sdpGtkEventListItemUnselectAll(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListItemUnselectAll::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListItemUnselectAll::Event(GtkListItem* ListItem) { m_ListItem = ListItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventListItemUnselectAll::RawEvent(GtkListItem* ListItem, gpointer EventData) { ((sdpGtkEventListItemUnselectAll*)EventData)->Event(ListItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListSelectChild ('select-child')

sdpGtkEventListSelectChild::sdpGtkEventListSelectChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListSelectChild::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListSelectChild::Event(GtkList* List, GtkWidget* Widget) { m_List = List; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventListSelectChild::RawEvent(GtkList* List, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventListSelectChild*)EventData)->Event(List, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListSelectionChanged ('selection-changed')

sdpGtkEventListSelectionChanged::sdpGtkEventListSelectionChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListSelectionChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListSelectionChanged::Event(GtkList* List) { m_List = List; m_EventContainer->OnEvent(this); }
void sdpGtkEventListSelectionChanged::RawEvent(GtkList* List, gpointer EventData) { ((sdpGtkEventListSelectionChanged*)EventData)->Event(List); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventListUnselectChild ('unselect-child')

sdpGtkEventListUnselectChild::sdpGtkEventListUnselectChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventListUnselectChild::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventListUnselectChild::Event(GtkList* List, GtkWidget* Widget) { m_List = List; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventListUnselectChild::RawEvent(GtkList* List, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventListUnselectChild*)EventData)->Event(List, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventMenuItemActivate ('activate')

sdpGtkEventMenuItemActivate::sdpGtkEventMenuItemActivate(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventMenuItemActivate::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventMenuItemActivate::Event(GtkMenuItem* MenuItem) { m_MenuItem = MenuItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventMenuItemActivate::RawEvent(GtkMenuItem* MenuItem, gpointer EventData) { ((sdpGtkEventMenuItemActivate*)EventData)->Event(MenuItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventMenuItemActivateItem ('activate-item')

sdpGtkEventMenuItemActivateItem::sdpGtkEventMenuItemActivateItem(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventMenuItemActivateItem::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventMenuItemActivateItem::Event(GtkMenuItem* MenuItem) { m_MenuItem = MenuItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventMenuItemActivateItem::RawEvent(GtkMenuItem* MenuItem, gpointer EventData) { ((sdpGtkEventMenuItemActivateItem*)EventData)->Event(MenuItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventMenuShellActivateCurrent ('activate-current')

sdpGtkEventMenuShellActivateCurrent::sdpGtkEventMenuShellActivateCurrent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventMenuShellActivateCurrent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventMenuShellActivateCurrent::Event(GtkMenuShell* MenuShell, gboolean ForceHide) { m_MenuShell = MenuShell; m_ForceHide = ForceHide; m_EventContainer->OnEvent(this); }
void sdpGtkEventMenuShellActivateCurrent::RawEvent(GtkMenuShell* MenuShell, gboolean ForceHide, gpointer EventData) { ((sdpGtkEventMenuShellActivateCurrent*)EventData)->Event(MenuShell, ForceHide); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventMenuShellCancel ('cancel')

sdpGtkEventMenuShellCancel::sdpGtkEventMenuShellCancel(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventMenuShellCancel::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventMenuShellCancel::Event(GtkMenuShell* MenuShell) { m_MenuShell = MenuShell; m_EventContainer->OnEvent(this); }
void sdpGtkEventMenuShellCancel::RawEvent(GtkMenuShell* MenuShell, gpointer EventData) { ((sdpGtkEventMenuShellCancel*)EventData)->Event(MenuShell); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventMenuShellDeactivate ('deactivate')

sdpGtkEventMenuShellDeactivate::sdpGtkEventMenuShellDeactivate(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventMenuShellDeactivate::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventMenuShellDeactivate::Event(GtkMenuShell* MenuShell) { m_MenuShell = MenuShell; m_EventContainer->OnEvent(this); }
void sdpGtkEventMenuShellDeactivate::RawEvent(GtkMenuShell* MenuShell, gpointer EventData) { ((sdpGtkEventMenuShellDeactivate*)EventData)->Event(MenuShell); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventMenuShellMoveCurrent ('move-current')

sdpGtkEventMenuShellMoveCurrent::sdpGtkEventMenuShellMoveCurrent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventMenuShellMoveCurrent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventMenuShellMoveCurrent::Event(GtkMenuShell* MenuShell, GtkMenuDirectionType Direction) { m_MenuShell = MenuShell; m_Direction = Direction; m_EventContainer->OnEvent(this); }
void sdpGtkEventMenuShellMoveCurrent::RawEvent(GtkMenuShell* MenuShell, GtkMenuDirectionType Direction, gpointer EventData) { ((sdpGtkEventMenuShellMoveCurrent*)EventData)->Event(MenuShell, Direction); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventMenuShellSelectionDone ('selection-done')

sdpGtkEventMenuShellSelectionDone::sdpGtkEventMenuShellSelectionDone(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventMenuShellSelectionDone::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventMenuShellSelectionDone::Event(GtkMenuShell* MenuShell) { m_MenuShell = MenuShell; m_EventContainer->OnEvent(this); }
void sdpGtkEventMenuShellSelectionDone::RawEvent(GtkMenuShell* MenuShell, gpointer EventData) { ((sdpGtkEventMenuShellSelectionDone*)EventData)->Event(MenuShell); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventNotebookSwitchPage ('switch-page')

sdpGtkEventNotebookSwitchPage::sdpGtkEventNotebookSwitchPage(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventNotebookSwitchPage::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventNotebookSwitchPage::Event(GtkNotebook* Notebook, GtkNotebookPage* Page, guint PageNumber) { m_Notebook = Notebook; m_Page = Page; m_PageNumber = PageNumber; m_EventContainer->OnEvent(this); }
void sdpGtkEventNotebookSwitchPage::RawEvent(GtkNotebook* Notebook, GtkNotebookPage* Page, guint PageNumber, gpointer EventData) { ((sdpGtkEventNotebookSwitchPage*)EventData)->Event(Notebook, Page, PageNumber); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventObjectDestroy ('destroy')

sdpGtkEventObjectDestroy::sdpGtkEventObjectDestroy(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventObjectDestroy::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventObjectDestroy::Event(GtkObject* Object) { m_Object = Object; m_EventContainer->OnEvent(this); }
void sdpGtkEventObjectDestroy::RawEvent(GtkObject* Object, gpointer EventData) { ((sdpGtkEventObjectDestroy*)EventData)->Event(Object); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventStatusbarTextPopped ('text-popped')

sdpGtkEventStatusbarTextPopped::sdpGtkEventStatusbarTextPopped(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventStatusbarTextPopped::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventStatusbarTextPopped::Event(GtkStatusbar* Statusbar, guint ContextID, gchar* Text) { m_Statusbar = Statusbar; m_ContextID = ContextID; m_Text = Text; m_EventContainer->OnEvent(this); }
void sdpGtkEventStatusbarTextPopped::RawEvent(GtkStatusbar* Statusbar, guint ContextID, gchar* Text, gpointer EventData) { ((sdpGtkEventStatusbarTextPopped*)EventData)->Event(Statusbar, ContextID, Text); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventStatusbarTextPushed ('text-pushed')

sdpGtkEventStatusbarTextPushed::sdpGtkEventStatusbarTextPushed(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventStatusbarTextPushed::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventStatusbarTextPushed::Event(GtkStatusbar* Statusbar, guint ContextID, gchar* Text) { m_Statusbar = Statusbar; m_ContextID = ContextID; m_Text = Text; m_EventContainer->OnEvent(this); }
void sdpGtkEventStatusbarTextPushed::RawEvent(GtkStatusbar* Statusbar, guint ContextID, gchar* Text, gpointer EventData) { ((sdpGtkEventStatusbarTextPushed*)EventData)->Event(Statusbar, ContextID, Text); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTipsQueryStartQuery ('start-query')

sdpGtkEventTipsQueryStartQuery::sdpGtkEventTipsQueryStartQuery(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTipsQueryStartQuery::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventTipsQueryStartQuery::Event(GtkTipsQuery* TipsQuery) { m_TipsQuery = TipsQuery; m_EventContainer->OnEvent(this); }
void sdpGtkEventTipsQueryStartQuery::RawEvent(GtkTipsQuery* TipsQuery, gpointer EventData) { ((sdpGtkEventTipsQueryStartQuery*)EventData)->Event(TipsQuery); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTipsQueryStopQuery ('stop-query')

sdpGtkEventTipsQueryStopQuery::sdpGtkEventTipsQueryStopQuery(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTipsQueryStopQuery::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventTipsQueryStopQuery::Event(GtkTipsQuery* TipsQuery) { m_TipsQuery = TipsQuery; m_EventContainer->OnEvent(this); }
void sdpGtkEventTipsQueryStopQuery::RawEvent(GtkTipsQuery* TipsQuery, gpointer EventData) { ((sdpGtkEventTipsQueryStopQuery*)EventData)->Event(TipsQuery); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTipsQueryWidgetEntered ('widget-entered')

sdpGtkEventTipsQueryWidgetEntered::sdpGtkEventTipsQueryWidgetEntered(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTipsQueryWidgetEntered::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventTipsQueryWidgetEntered::Event(GtkTipsQuery* TipsQuery, GtkWidget* Widget, gchar* TipText, gchar* TipPrivate) { m_TipsQuery = TipsQuery; m_Widget = Widget; m_TipText = TipText; m_TipPrivate = TipPrivate; m_EventContainer->OnEvent(this); }
void sdpGtkEventTipsQueryWidgetEntered::RawEvent(GtkTipsQuery* TipsQuery, GtkWidget* Widget, gchar* TipText, gchar* TipPrivate, gpointer EventData) { ((sdpGtkEventTipsQueryWidgetEntered*)EventData)->Event(TipsQuery, Widget, TipText, TipPrivate); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTipsQueryWidgetSelected ('widget-selected')

sdpGtkEventTipsQueryWidgetSelected::sdpGtkEventTipsQueryWidgetSelected(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTipsQueryWidgetSelected::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventTipsQueryWidgetSelected::Event(GtkTipsQuery* TipsQuery, GtkWidget* Widget, gchar* TipText, gchar* TipPrivate, GdkEvent* Event) { m_TipsQuery = TipsQuery; m_Widget = Widget; m_TipText = TipText; m_TipPrivate = TipPrivate; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventTipsQueryWidgetSelected::RawEvent(GtkTipsQuery* TipsQuery, GtkWidget* Widget, gchar* TipText, gchar* TipPrivate, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventTipsQueryWidgetSelected*)EventData)->Event(TipsQuery, Widget, TipText, TipPrivate, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventToggleButtonToggled ('toggled')

sdpGtkEventToggleButtonToggled::sdpGtkEventToggleButtonToggled(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventToggleButtonToggled::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventToggleButtonToggled::Event(GtkToggleButton* ToggleButton) { m_ToggleButton = ToggleButton; m_EventContainer->OnEvent(this); }
void sdpGtkEventToggleButtonToggled::RawEvent(GtkToggleButton* ToggleButton, gpointer EventData) { ((sdpGtkEventToggleButtonToggled*)EventData)->Event(ToggleButton); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventToolbarOrientationChanged ('orientation-changed')

sdpGtkEventToolbarOrientationChanged::sdpGtkEventToolbarOrientationChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventToolbarOrientationChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventToolbarOrientationChanged::Event(GtkToolbar* Toolbar, GtkOrientation Orientation) { m_Toolbar = Toolbar; m_Orientation = Orientation; m_EventContainer->OnEvent(this); }
void sdpGtkEventToolbarOrientationChanged::RawEvent(GtkToolbar* Toolbar, GtkOrientation Orientation, gpointer EventData) { ((sdpGtkEventToolbarOrientationChanged*)EventData)->Event(Toolbar, Orientation); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventToolbarStyleChanged ('style-changed')

sdpGtkEventToolbarStyleChanged::sdpGtkEventToolbarStyleChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventToolbarStyleChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventToolbarStyleChanged::Event(GtkToolbar* Toolbar, GtkToolbarStyle Style) { m_Toolbar = Toolbar; m_Style = Style; m_EventContainer->OnEvent(this); }
void sdpGtkEventToolbarStyleChanged::RawEvent(GtkToolbar* Toolbar, GtkToolbarStyle Style, gpointer EventData) { ((sdpGtkEventToolbarStyleChanged*)EventData)->Event(Toolbar, Style); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTreeItemCollapse ('collapse')

sdpGtkEventTreeItemCollapse::sdpGtkEventTreeItemCollapse(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTreeItemCollapse::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventTreeItemCollapse::Event(GtkTreeItem* TreeItem) { m_TreeItem = TreeItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventTreeItemCollapse::RawEvent(GtkTreeItem* TreeItem, gpointer EventData) { ((sdpGtkEventTreeItemCollapse*)EventData)->Event(TreeItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTreeItemExpand ('expand')

sdpGtkEventTreeItemExpand::sdpGtkEventTreeItemExpand(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTreeItemExpand::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventTreeItemExpand::Event(GtkTreeItem* TreeItem) { m_TreeItem = TreeItem; m_EventContainer->OnEvent(this); }
void sdpGtkEventTreeItemExpand::RawEvent(GtkTreeItem* TreeItem, gpointer EventData) { ((sdpGtkEventTreeItemExpand*)EventData)->Event(TreeItem); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTreeSelectChild ('select-child')

sdpGtkEventTreeSelectChild::sdpGtkEventTreeSelectChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTreeSelectChild::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventTreeSelectChild::Event(GtkTree* Tree, GtkWidget* Widget) { m_Tree = Tree; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventTreeSelectChild::RawEvent(GtkTree* Tree, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventTreeSelectChild*)EventData)->Event(Tree, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTreeSelectionChanged ('selection-changed')

sdpGtkEventTreeSelectionChanged::sdpGtkEventTreeSelectionChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTreeSelectionChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventTreeSelectionChanged::Event(GtkTree* Tree) { m_Tree = Tree; m_EventContainer->OnEvent(this); }
void sdpGtkEventTreeSelectionChanged::RawEvent(GtkTree* Tree, gpointer EventData) { ((sdpGtkEventTreeSelectionChanged*)EventData)->Event(Tree); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventTreeUnselectChild ('unselect-child')

sdpGtkEventTreeUnselectChild::sdpGtkEventTreeUnselectChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventTreeUnselectChild::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventTreeUnselectChild::Event(GtkTree* Tree, GtkWidget* Widget) { m_Tree = Tree; m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventTreeUnselectChild::RawEvent(GtkTree* Tree, GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventTreeUnselectChild*)EventData)->Event(Tree, Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetAddAccelerator ('add-accelerator')

sdpGtkEventWidgetAddAccelerator::sdpGtkEventWidgetAddAccelerator(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetAddAccelerator::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetAddAccelerator::Event(GtkWidget* Widget, guint SignalID, GtkAccelGroup* Group, guint Key, GdkModifierType Modifier, GtkAccelFlags Flags) { m_Widget = Widget; m_SignalID = SignalID; m_Group = Group; m_Key = Key; m_Modifier = Modifier; m_Flags = Flags; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetAddAccelerator::RawEvent(GtkWidget* Widget, guint SignalID, GtkAccelGroup* Group, guint Key, GdkModifierType Modifier, GtkAccelFlags Flags, gpointer EventData) { ((sdpGtkEventWidgetAddAccelerator*)EventData)->Event(Widget, SignalID, Group, Key, Modifier, Flags); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetButtonPressEvent ('button-press-event')

sdpGtkEventWidgetButtonPressEvent::sdpGtkEventWidgetButtonPressEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetButtonPressEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetButtonPressEvent::Event(GtkWidget* Widget, GdkEventButton* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetButtonPressEvent::RawEvent(GtkWidget* Widget, GdkEventButton* Event, gpointer EventData) { return ((sdpGtkEventWidgetButtonPressEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetButtonReleaseEvent ('button-release-event')

sdpGtkEventWidgetButtonReleaseEvent::sdpGtkEventWidgetButtonReleaseEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetButtonReleaseEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetButtonReleaseEvent::Event(GtkWidget* Widget, GdkEventButton* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetButtonReleaseEvent::RawEvent(GtkWidget* Widget, GdkEventButton* Event, gpointer EventData) { return ((sdpGtkEventWidgetButtonReleaseEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetClientEvent ('client-event')

sdpGtkEventWidgetClientEvent::sdpGtkEventWidgetClientEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetClientEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetClientEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetClientEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetClientEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetConfigureEvent ('configure-event')

sdpGtkEventWidgetConfigureEvent::sdpGtkEventWidgetConfigureEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetConfigureEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetConfigureEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetConfigureEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetConfigureEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDebugMsg ('debug-msg')

sdpGtkEventWidgetDebugMsg::sdpGtkEventWidgetDebugMsg(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDebugMsg::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDebugMsg::Event(GtkWidget* Widget, gchar* String) { m_Widget = Widget; m_String = String; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDebugMsg::RawEvent(GtkWidget* Widget, gchar* String, gpointer EventData) { ((sdpGtkEventWidgetDebugMsg*)EventData)->Event(Widget, String); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDeleteEvent ('delete-event')

sdpGtkEventWidgetDeleteEvent::sdpGtkEventWidgetDeleteEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDeleteEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetDeleteEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetDeleteEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetDeleteEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDestroyEvent ('destroy-event')

sdpGtkEventWidgetDestroyEvent::sdpGtkEventWidgetDestroyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDestroyEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetDestroyEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetDestroyEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetDestroyEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDragBegin ('drag-begin')

sdpGtkEventWidgetDragBegin::sdpGtkEventWidgetDragBegin(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDragBegin::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDragBegin::Event(GtkWidget* Widget, GdkDragContext* DragContext) { m_Widget = Widget; m_DragContext = DragContext; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDragBegin::RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gpointer EventData) { ((sdpGtkEventWidgetDragBegin*)EventData)->Event(Widget, DragContext); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDragDataDelete ('drag-data-delete')

sdpGtkEventWidgetDragDataDelete::sdpGtkEventWidgetDragDataDelete(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDragDataDelete::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDragDataDelete::Event(GtkWidget* Widget, GdkDragContext* DragContext) { m_Widget = Widget; m_DragContext = DragContext; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDragDataDelete::RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gpointer EventData) { ((sdpGtkEventWidgetDragDataDelete*)EventData)->Event(Widget, DragContext); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDragDataGet ('drag-data-get')

sdpGtkEventWidgetDragDataGet::sdpGtkEventWidgetDragDataGet(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDragDataGet::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDragDataGet::Event(GtkWidget* Widget, GdkDragContext* DragContext, GtkSelectionData* Selection, guint MouseX, guint MouseY) { m_Widget = Widget; m_DragContext = DragContext; m_Selection = Selection; m_MouseX = MouseX; m_MouseY = MouseY; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDragDataGet::RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, GtkSelectionData* Selection, guint MouseX, guint MouseY, gpointer EventData) { ((sdpGtkEventWidgetDragDataGet*)EventData)->Event(Widget, DragContext, Selection, MouseX, MouseY); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDragDataReceived ('drag-data-received')

sdpGtkEventWidgetDragDataReceived::sdpGtkEventWidgetDragDataReceived(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDragDataReceived::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDragDataReceived::Event(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, GtkSelectionData* Selection, guint Info, guint Time) { m_Widget = Widget; m_DragContext = DragContext; m_MouseX = MouseX; m_MouseY = MouseY; m_Selection = Selection; m_Info = Info; m_Time = Time; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDragDataReceived::RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, GtkSelectionData* Selection, guint Info, guint Time, gpointer EventData) { ((sdpGtkEventWidgetDragDataReceived*)EventData)->Event(Widget, DragContext, MouseX, MouseY, Selection, Info, Time); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDragDrop ('drag-drop')

sdpGtkEventWidgetDragDrop::sdpGtkEventWidgetDragDrop(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDragDrop::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetDragDrop::Event(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, guint Time) { m_Widget = Widget; m_DragContext = DragContext; m_MouseX = MouseX; m_MouseY = MouseY; m_Time = Time; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetDragDrop::RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, guint Time, gpointer EventData) { return ((sdpGtkEventWidgetDragDrop*)EventData)->Event(Widget, DragContext, MouseX, MouseY, Time); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDragEnd ('drag-end')

sdpGtkEventWidgetDragEnd::sdpGtkEventWidgetDragEnd(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDragEnd::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDragEnd::Event(GtkWidget* Widget, GdkDragContext* DragContext) { m_Widget = Widget; m_DragContext = DragContext; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDragEnd::RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gpointer EventData) { ((sdpGtkEventWidgetDragEnd*)EventData)->Event(Widget, DragContext); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDragLeave ('drag-leave')

sdpGtkEventWidgetDragLeave::sdpGtkEventWidgetDragLeave(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDragLeave::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDragLeave::Event(GtkWidget* Widget, GdkDragContext* DragContext, guint Time) { m_Widget = Widget; m_DragContext = DragContext; m_Time = Time; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDragLeave::RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, guint Time, gpointer EventData) { ((sdpGtkEventWidgetDragLeave*)EventData)->Event(Widget, DragContext, Time); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDragMotion ('drag-motion')

sdpGtkEventWidgetDragMotion::sdpGtkEventWidgetDragMotion(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDragMotion::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetDragMotion::Event(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, guint Time) { m_Widget = Widget; m_DragContext = DragContext; m_MouseX = MouseX; m_MouseY = MouseY; m_Time = Time; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetDragMotion::RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, guint Time, gpointer EventData) { return ((sdpGtkEventWidgetDragMotion*)EventData)->Event(Widget, DragContext, MouseX, MouseY, Time); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDraw ('draw')

sdpGtkEventWidgetDraw::sdpGtkEventWidgetDraw(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDraw::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDraw::Event(GtkWidget* Widget, GdkRectangle* Area) { m_Widget = Widget; m_Area = Area; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDraw::RawEvent(GtkWidget* Widget, GdkRectangle* Area, gpointer EventData) { ((sdpGtkEventWidgetDraw*)EventData)->Event(Widget, Area); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDrawDefault ('draw-default')

sdpGtkEventWidgetDrawDefault::sdpGtkEventWidgetDrawDefault(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDrawDefault::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDrawDefault::Event(GtkWidget* Widget) { m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDrawDefault::RawEvent(GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventWidgetDrawDefault*)EventData)->Event(Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetDrawFocus ('draw-focus')

sdpGtkEventWidgetDrawFocus::sdpGtkEventWidgetDrawFocus(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetDrawFocus::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetDrawFocus::Event(GtkWidget* Widget) { m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetDrawFocus::RawEvent(GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventWidgetDrawFocus*)EventData)->Event(Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetEnterNotifyEvent ('enter-notify-event')

sdpGtkEventWidgetEnterNotifyEvent::sdpGtkEventWidgetEnterNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetEnterNotifyEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetEnterNotifyEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetEnterNotifyEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetEnterNotifyEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetEvent ('event')

sdpGtkEventWidgetEvent::sdpGtkEventWidgetEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetExposeEvent ('expose-event')

sdpGtkEventWidgetExposeEvent::sdpGtkEventWidgetExposeEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetExposeEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetExposeEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetExposeEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetExposeEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetFocusInEvent ('focus-in-event')

sdpGtkEventWidgetFocusInEvent::sdpGtkEventWidgetFocusInEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetFocusInEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetFocusInEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetFocusInEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetFocusInEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetFocusOutEvent ('focus-out-event')

sdpGtkEventWidgetFocusOutEvent::sdpGtkEventWidgetFocusOutEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetFocusOutEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetFocusOutEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetFocusOutEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetFocusOutEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetHide ('hide')

sdpGtkEventWidgetHide::sdpGtkEventWidgetHide(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetHide::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetHide::Event(GtkWidget* Widget) { m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetHide::RawEvent(GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventWidgetHide*)EventData)->Event(Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetKeyPressEvent ('key-press-event')

sdpGtkEventWidgetKeyPressEvent::sdpGtkEventWidgetKeyPressEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetKeyPressEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetKeyPressEvent::Event(GtkWidget* Widget, GdkEventKey* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetKeyPressEvent::RawEvent(GtkWidget* Widget, GdkEventKey* Event, gpointer EventData) { return ((sdpGtkEventWidgetKeyPressEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetKeyReleaseEvent ('key-release-event')

sdpGtkEventWidgetKeyReleaseEvent::sdpGtkEventWidgetKeyReleaseEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetKeyReleaseEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetKeyReleaseEvent::Event(GtkWidget* Widget, GdkEventKey* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetKeyReleaseEvent::RawEvent(GtkWidget* Widget, GdkEventKey* Event, gpointer EventData) { return ((sdpGtkEventWidgetKeyReleaseEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetLeaveNotifyEvent ('leave-notify-event')

sdpGtkEventWidgetLeaveNotifyEvent::sdpGtkEventWidgetLeaveNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetLeaveNotifyEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetLeaveNotifyEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetLeaveNotifyEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetLeaveNotifyEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetMap ('map')

sdpGtkEventWidgetMap::sdpGtkEventWidgetMap(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetMap::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetMap::Event(GtkWidget* Widget) { m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetMap::RawEvent(GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventWidgetMap*)EventData)->Event(Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetMapEvent ('map-event')

sdpGtkEventWidgetMapEvent::sdpGtkEventWidgetMapEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetMapEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetMapEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetMapEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetMapEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetMotionNotifyEvent ('motion-notify-event')

sdpGtkEventWidgetMotionNotifyEvent::sdpGtkEventWidgetMotionNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetMotionNotifyEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetMotionNotifyEvent::Event(GtkWidget* Widget, GdkEventMotion* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetMotionNotifyEvent::RawEvent(GtkWidget* Widget, GdkEventMotion* Event, gpointer EventData) { return ((sdpGtkEventWidgetMotionNotifyEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetNoExposeEvent ('no-expose-event')

sdpGtkEventWidgetNoExposeEvent::sdpGtkEventWidgetNoExposeEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetNoExposeEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetNoExposeEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetNoExposeEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetNoExposeEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetParentSet ('parent-set')

sdpGtkEventWidgetParentSet::sdpGtkEventWidgetParentSet(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetParentSet::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetParentSet::Event(GtkWidget* Widget, GtkWidget* PreviousParent) { m_Widget = Widget; m_PreviousParent = PreviousParent; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetParentSet::RawEvent(GtkWidget* Widget, GtkWidget* PreviousParent, gpointer EventData) { ((sdpGtkEventWidgetParentSet*)EventData)->Event(Widget, PreviousParent); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetPropertyNotifyEvent ('property-notify-event')

sdpGtkEventWidgetPropertyNotifyEvent::sdpGtkEventWidgetPropertyNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetPropertyNotifyEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetPropertyNotifyEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetPropertyNotifyEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetPropertyNotifyEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetProximityInEvent ('proximity-in-event')

sdpGtkEventWidgetProximityInEvent::sdpGtkEventWidgetProximityInEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetProximityInEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetProximityInEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetProximityInEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetProximityInEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetProximityOutEvent ('proximity-out-event')

sdpGtkEventWidgetProximityOutEvent::sdpGtkEventWidgetProximityOutEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetProximityOutEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetProximityOutEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetProximityOutEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetProximityOutEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetRealize ('realize')

sdpGtkEventWidgetRealize::sdpGtkEventWidgetRealize(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetRealize::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetRealize::Event(GtkWidget* Widget) { m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetRealize::RawEvent(GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventWidgetRealize*)EventData)->Event(Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetRemoveAccelerator ('remove-accelerator')

sdpGtkEventWidgetRemoveAccelerator::sdpGtkEventWidgetRemoveAccelerator(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetRemoveAccelerator::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetRemoveAccelerator::Event(GtkWidget* Widget, GtkAccelGroup* Group, guint Key, GdkModifierType Modifiers) { m_Widget = Widget; m_Group = Group; m_Key = Key; m_Modifiers = Modifiers; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetRemoveAccelerator::RawEvent(GtkWidget* Widget, GtkAccelGroup* Group, guint Key, GdkModifierType Modifiers, gpointer EventData) { ((sdpGtkEventWidgetRemoveAccelerator*)EventData)->Event(Widget, Group, Key, Modifiers); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetSelectionClearEvent ('selection-clear-event')

sdpGtkEventWidgetSelectionClearEvent::sdpGtkEventWidgetSelectionClearEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetSelectionClearEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetSelectionClearEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetSelectionClearEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetSelectionClearEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetSelectionGet ('selection-get')

sdpGtkEventWidgetSelectionGet::sdpGtkEventWidgetSelectionGet(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetSelectionGet::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetSelectionGet::Event(GtkWidget* Widget, GtkSelectionData* Selection, guint Info, guint Time) { m_Widget = Widget; m_Selection = Selection; m_Info = Info; m_Time = Time; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetSelectionGet::RawEvent(GtkWidget* Widget, GtkSelectionData* Selection, guint Info, guint Time, gpointer EventData) { ((sdpGtkEventWidgetSelectionGet*)EventData)->Event(Widget, Selection, Info, Time); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetSelectionNotifyEvent ('selection-notify-event')

sdpGtkEventWidgetSelectionNotifyEvent::sdpGtkEventWidgetSelectionNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetSelectionNotifyEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetSelectionNotifyEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetSelectionNotifyEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetSelectionNotifyEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetSelectionReceived ('selection-received')

sdpGtkEventWidgetSelectionReceived::sdpGtkEventWidgetSelectionReceived(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetSelectionReceived::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetSelectionReceived::Event(GtkWidget* Widget, GtkSelectionData* Selection, guint Time) { m_Widget = Widget; m_Selection = Selection; m_Time = Time; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetSelectionReceived::RawEvent(GtkWidget* Widget, GtkSelectionData* Selection, guint Time, gpointer EventData) { ((sdpGtkEventWidgetSelectionReceived*)EventData)->Event(Widget, Selection, Time); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetSelectionRequestEvent ('selection-request-event')

sdpGtkEventWidgetSelectionRequestEvent::sdpGtkEventWidgetSelectionRequestEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetSelectionRequestEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetSelectionRequestEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetSelectionRequestEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetSelectionRequestEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetShow ('show')

sdpGtkEventWidgetShow::sdpGtkEventWidgetShow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetShow::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetShow::Event(GtkWidget* Widget) { m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetShow::RawEvent(GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventWidgetShow*)EventData)->Event(Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetSizeAllocate ('size-allocate')

sdpGtkEventWidgetSizeAllocate::sdpGtkEventWidgetSizeAllocate(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetSizeAllocate::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetSizeAllocate::Event(GtkWidget* Widget, GtkAllocation* Allocation) { m_Widget = Widget; m_Allocation = Allocation; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetSizeAllocate::RawEvent(GtkWidget* Widget, GtkAllocation* Allocation, gpointer EventData) { ((sdpGtkEventWidgetSizeAllocate*)EventData)->Event(Widget, Allocation); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetSizeRequest ('size-request')

sdpGtkEventWidgetSizeRequest::sdpGtkEventWidgetSizeRequest(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetSizeRequest::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetSizeRequest::Event(GtkWidget* Widget, GtkRequisition* Requisition) { m_Widget = Widget; m_Requisition = Requisition; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetSizeRequest::RawEvent(GtkWidget* Widget, GtkRequisition* Requisition, gpointer EventData) { ((sdpGtkEventWidgetSizeRequest*)EventData)->Event(Widget, Requisition); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetStateChanged ('state-changed')

sdpGtkEventWidgetStateChanged::sdpGtkEventWidgetStateChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetStateChanged::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetStateChanged::Event(GtkWidget* Widget, GtkStateType PreviousState) { m_Widget = Widget; m_PreviousState = PreviousState; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetStateChanged::RawEvent(GtkWidget* Widget, GtkStateType PreviousState, gpointer EventData) { ((sdpGtkEventWidgetStateChanged*)EventData)->Event(Widget, PreviousState); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetStyleSet ('style-set')

sdpGtkEventWidgetStyleSet::sdpGtkEventWidgetStyleSet(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetStyleSet::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetStyleSet::Event(GtkWidget* Widget, GtkStyle* PreviousStyle) { m_Widget = Widget; m_PreviousStyle = PreviousStyle; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetStyleSet::RawEvent(GtkWidget* Widget, GtkStyle* PreviousStyle, gpointer EventData) { ((sdpGtkEventWidgetStyleSet*)EventData)->Event(Widget, PreviousStyle); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetUnmap ('unmap')

sdpGtkEventWidgetUnmap::sdpGtkEventWidgetUnmap(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetUnmap::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetUnmap::Event(GtkWidget* Widget) { m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetUnmap::RawEvent(GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventWidgetUnmap*)EventData)->Event(Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetUnmapEvent ('unmap-event')

sdpGtkEventWidgetUnmapEvent::sdpGtkEventWidgetUnmapEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetUnmapEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetUnmapEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetUnmapEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetUnmapEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetUnrealize ('unrealize')

sdpGtkEventWidgetUnrealize::sdpGtkEventWidgetUnrealize(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetUnrealize::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWidgetUnrealize::Event(GtkWidget* Widget) { m_Widget = Widget; m_EventContainer->OnEvent(this); }
void sdpGtkEventWidgetUnrealize::RawEvent(GtkWidget* Widget, gpointer EventData) { ((sdpGtkEventWidgetUnrealize*)EventData)->Event(Widget); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWidgetVisibilityNotifyEvent ('visibility-notify-event')

sdpGtkEventWidgetVisibilityNotifyEvent::sdpGtkEventWidgetVisibilityNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWidgetVisibilityNotifyEvent::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
gboolean sdpGtkEventWidgetVisibilityNotifyEvent::Event(GtkWidget* Widget, GdkEvent* Event) { m_Widget = Widget; m_Event = Event; m_EventContainer->OnEvent(this); return m_Result; }
gboolean sdpGtkEventWidgetVisibilityNotifyEvent::RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData) { return ((sdpGtkEventWidgetVisibilityNotifyEvent*)EventData)->Event(Widget, Event); }

///////////////////////////////////////////////////////////////////////////////
// sdpGtkEventWindowSetFocus ('set-focus')

sdpGtkEventWindowSetFocus::sdpGtkEventWindowSetFocus(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject) : sdpGtkObjectEvent(EventSignal, EventName, After, EventContainer, EventObject) {}
void sdpGtkEventWindowSetFocus::Connect() { m_EventHandler = m_After ? gtk_signal_connect_after(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)) : gtk_signal_connect(m_EventObject, m_EventSignal, GtkSignalFunc(RawEvent), gpointer(this)); }
void sdpGtkEventWindowSetFocus::Event(GtkWindow* Window, GtkWidget* Focus) { m_Window = Window; m_Focus = Focus; m_EventContainer->OnEvent(this); }
void sdpGtkEventWindowSetFocus::RawEvent(GtkWindow* Window, GtkWidget* Focus, gpointer EventData) { ((sdpGtkEventWindowSetFocus*)EventData)->Event(Window, Focus); }

