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


#include "sdpgtkevent.h"

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

class sdpGtkEventAdjustmentChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventAdjustmentChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkAdjustment* Adjustment);
  static void RawEvent(GtkAdjustment* Adjustment, gpointer EventData);
  inline void SetAdjustment(GtkAdjustment* Adjustment) { m_Adjustment = Adjustment; }
  inline GtkAdjustment* Adjustment() { return m_Adjustment; }
protected:
  GtkAdjustment* m_Adjustment;
};

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

class sdpGtkEventAdjustmentValueChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventAdjustmentValueChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkAdjustment* Adjustment);
  static void RawEvent(GtkAdjustment* Adjustment, gpointer EventData);
  inline void SetAdjustment(GtkAdjustment* Adjustment) { m_Adjustment = Adjustment; }
  inline GtkAdjustment* Adjustment() { return m_Adjustment; }
protected:
  GtkAdjustment* m_Adjustment;
};

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

class sdpGtkEventButtonClicked : public sdpGtkObjectEvent
{
public:
  sdpGtkEventButtonClicked(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkButton* Button);
  static void RawEvent(GtkButton* Button, gpointer EventData);
  inline void SetButton(GtkButton* Button) { m_Button = Button; }
  inline GtkButton* Button() { return m_Button; }
protected:
  GtkButton* m_Button;
};

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

class sdpGtkEventButtonEnter : public sdpGtkObjectEvent
{
public:
  sdpGtkEventButtonEnter(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkButton* Button);
  static void RawEvent(GtkButton* Button, gpointer EventData);
  inline void SetButton(GtkButton* Button) { m_Button = Button; }
  inline GtkButton* Button() { return m_Button; }
protected:
  GtkButton* m_Button;
};

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

class sdpGtkEventButtonLeave : public sdpGtkObjectEvent
{
public:
  sdpGtkEventButtonLeave(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkButton* Button);
  static void RawEvent(GtkButton* Button, gpointer EventData);
  inline void SetButton(GtkButton* Button) { m_Button = Button; }
  inline GtkButton* Button() { return m_Button; }
protected:
  GtkButton* m_Button;
};

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

class sdpGtkEventButtonPressed : public sdpGtkObjectEvent
{
public:
  sdpGtkEventButtonPressed(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkButton* Button);
  static void RawEvent(GtkButton* Button, gpointer EventData);
  inline void SetButton(GtkButton* Button) { m_Button = Button; }
  inline GtkButton* Button() { return m_Button; }
protected:
  GtkButton* m_Button;
};

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

class sdpGtkEventButtonReleased : public sdpGtkObjectEvent
{
public:
  sdpGtkEventButtonReleased(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkButton* Button);
  static void RawEvent(GtkButton* Button, gpointer EventData);
  inline void SetButton(GtkButton* Button) { m_Button = Button; }
  inline GtkButton* Button() { return m_Button; }
protected:
  GtkButton* m_Button;
};

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

class sdpGtkEventCalendarDaySelected : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCalendarDaySelected(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCalendar* Calendar);
  static void RawEvent(GtkCalendar* Calendar, gpointer EventData);
  inline void SetCalendar(GtkCalendar* Calendar) { m_Calendar = Calendar; }
  inline GtkCalendar* Calendar() { return m_Calendar; }
protected:
  GtkCalendar* m_Calendar;
};

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

class sdpGtkEventCalendarDaySelectedDoubleClick : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCalendarDaySelectedDoubleClick(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCalendar* Calendar);
  static void RawEvent(GtkCalendar* Calendar, gpointer EventData);
  inline void SetCalendar(GtkCalendar* Calendar) { m_Calendar = Calendar; }
  inline GtkCalendar* Calendar() { return m_Calendar; }
protected:
  GtkCalendar* m_Calendar;
};

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

class sdpGtkEventCalendarMonthChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCalendarMonthChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCalendar* Calendar);
  static void RawEvent(GtkCalendar* Calendar, gpointer EventData);
  inline void SetCalendar(GtkCalendar* Calendar) { m_Calendar = Calendar; }
  inline GtkCalendar* Calendar() { return m_Calendar; }
protected:
  GtkCalendar* m_Calendar;
};

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

class sdpGtkEventCalendarNextMonth : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCalendarNextMonth(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCalendar* Calendar);
  static void RawEvent(GtkCalendar* Calendar, gpointer EventData);
  inline void SetCalendar(GtkCalendar* Calendar) { m_Calendar = Calendar; }
  inline GtkCalendar* Calendar() { return m_Calendar; }
protected:
  GtkCalendar* m_Calendar;
};

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

class sdpGtkEventCalendarNextYear : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCalendarNextYear(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCalendar* Calendar);
  static void RawEvent(GtkCalendar* Calendar, gpointer EventData);
  inline void SetCalendar(GtkCalendar* Calendar) { m_Calendar = Calendar; }
  inline GtkCalendar* Calendar() { return m_Calendar; }
protected:
  GtkCalendar* m_Calendar;
};

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

class sdpGtkEventCalendarPrevMonth : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCalendarPrevMonth(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCalendar* Calendar);
  static void RawEvent(GtkCalendar* Calendar, gpointer EventData);
  inline void SetCalendar(GtkCalendar* Calendar) { m_Calendar = Calendar; }
  inline GtkCalendar* Calendar() { return m_Calendar; }
protected:
  GtkCalendar* m_Calendar;
};

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

class sdpGtkEventCalendarPrevYear : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCalendarPrevYear(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCalendar* Calendar);
  static void RawEvent(GtkCalendar* Calendar, gpointer EventData);
  inline void SetCalendar(GtkCalendar* Calendar) { m_Calendar = Calendar; }
  inline GtkCalendar* Calendar() { return m_Calendar; }
protected:
  GtkCalendar* m_Calendar;
};

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

class sdpGtkEventCheckMenuItemToggled : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCheckMenuItemToggled(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCheckMenuItem* MenuItem);
  static void RawEvent(GtkCheckMenuItem* MenuItem, gpointer EventData);
  inline void SetMenuItem(GtkCheckMenuItem* MenuItem) { m_MenuItem = MenuItem; }
  inline GtkCheckMenuItem* MenuItem() { return m_MenuItem; }
protected:
  GtkCheckMenuItem* m_MenuItem;
};

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

class sdpGtkEventCListAbortColumnResize : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListAbortColumnResize(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List);
  static void RawEvent(GtkCList* List, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline GtkCList* List() { return m_List; }
protected:
  GtkCList* m_List;
};

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

class sdpGtkEventCListClickColumn : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListClickColumn(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List, gint Column);
  static void RawEvent(GtkCList* List, gint Column, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline void SetColumn(gint Column) { m_Column = Column; }
  inline GtkCList* List() { return m_List; }
  inline gint Column() { return m_Column; }
protected:
  GtkCList* m_List;
  gint m_Column;
};

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

class sdpGtkEventCListEndSelection : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListEndSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List);
  static void RawEvent(GtkCList* List, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline GtkCList* List() { return m_List; }
protected:
  GtkCList* m_List;
};

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

class sdpGtkEventCListExtendSelection : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListExtendSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List, GtkScrollType ScrollType, gfloat Position, gboolean AutoStartSelection);
  static void RawEvent(GtkCList* List, GtkScrollType ScrollType, gfloat Position, gboolean AutoStartSelection, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline void SetScrollType(GtkScrollType ScrollType) { m_ScrollType = ScrollType; }
  inline void SetPosition(gfloat Position) { m_Position = Position; }
  inline void SetAutoStartSelection(gboolean AutoStartSelection) { m_AutoStartSelection = AutoStartSelection; }
  inline GtkCList* List() { return m_List; }
  inline GtkScrollType ScrollType() { return m_ScrollType; }
  inline gfloat Position() { return m_Position; }
  inline gboolean AutoStartSelection() { return m_AutoStartSelection; }
protected:
  GtkCList* m_List;
  GtkScrollType m_ScrollType;
  gfloat m_Position;
  gboolean m_AutoStartSelection;
};

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

class sdpGtkEventCListResizeColumn : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListResizeColumn(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List, gint Column, gint Width);
  static void RawEvent(GtkCList* List, gint Column, gint Width, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline void SetColumn(gint Column) { m_Column = Column; }
  inline void SetWidth(gint Width) { m_Width = Width; }
  inline GtkCList* List() { return m_List; }
  inline gint Column() { return m_Column; }
  inline gint Width() { return m_Width; }
protected:
  GtkCList* m_List;
  gint m_Column;
  gint m_Width;
};

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

class sdpGtkEventCListRowMove : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListRowMove(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List, gint SourceRow, gint DestinationRow);
  static void RawEvent(GtkCList* List, gint SourceRow, gint DestinationRow, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline void SetSourceRow(gint SourceRow) { m_SourceRow = SourceRow; }
  inline void SetDestinationRow(gint DestinationRow) { m_DestinationRow = DestinationRow; }
  inline GtkCList* List() { return m_List; }
  inline gint SourceRow() { return m_SourceRow; }
  inline gint DestinationRow() { return m_DestinationRow; }
protected:
  GtkCList* m_List;
  gint m_SourceRow;
  gint m_DestinationRow;
};

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

class sdpGtkEventCListScrollHorizontal : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListScrollHorizontal(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List, GtkScrollType ScrollType, gfloat Position);
  static void RawEvent(GtkCList* List, GtkScrollType ScrollType, gfloat Position, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline void SetScrollType(GtkScrollType ScrollType) { m_ScrollType = ScrollType; }
  inline void SetPosition(gfloat Position) { m_Position = Position; }
  inline GtkCList* List() { return m_List; }
  inline GtkScrollType ScrollType() { return m_ScrollType; }
  inline gfloat Position() { return m_Position; }
protected:
  GtkCList* m_List;
  GtkScrollType m_ScrollType;
  gfloat m_Position;
};

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

class sdpGtkEventCListScrollVertical : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListScrollVertical(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List, GtkScrollType ScrollType, gfloat Position);
  static void RawEvent(GtkCList* List, GtkScrollType ScrollType, gfloat Position, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline void SetScrollType(GtkScrollType ScrollType) { m_ScrollType = ScrollType; }
  inline void SetPosition(gfloat Position) { m_Position = Position; }
  inline GtkCList* List() { return m_List; }
  inline GtkScrollType ScrollType() { return m_ScrollType; }
  inline gfloat Position() { return m_Position; }
protected:
  GtkCList* m_List;
  GtkScrollType m_ScrollType;
  gfloat m_Position;
};

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

class sdpGtkEventCListSelectAll : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListSelectAll(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List);
  static void RawEvent(GtkCList* List, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline GtkCList* List() { return m_List; }
protected:
  GtkCList* m_List;
};

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

class sdpGtkEventCListSelectRow : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListSelectRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List, gint Row, gint Column, GdkEvent* Event);
  static void RawEvent(GtkCList* List, gint Row, gint Column, GdkEvent* Event, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline void SetRow(gint Row) { m_Row = Row; }
  inline void SetColumn(gint Column) { m_Column = Column; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkCList* List() { return m_List; }
  inline gint Row() { return m_Row; }
  inline gint Column() { return m_Column; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  GtkCList* m_List;
  gint m_Row;
  gint m_Column;
  GdkEvent* m_Event;
};

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

class sdpGtkEventCListStartSelection : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListStartSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List);
  static void RawEvent(GtkCList* List, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline GtkCList* List() { return m_List; }
protected:
  GtkCList* m_List;
};

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

class sdpGtkEventCListToggleAddMode : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListToggleAddMode(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List);
  static void RawEvent(GtkCList* List, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline GtkCList* List() { return m_List; }
protected:
  GtkCList* m_List;
};

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

class sdpGtkEventCListToggleFocusRow : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListToggleFocusRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List);
  static void RawEvent(GtkCList* List, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline GtkCList* List() { return m_List; }
protected:
  GtkCList* m_List;
};

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

class sdpGtkEventCListUndoSelection : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListUndoSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List);
  static void RawEvent(GtkCList* List, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline GtkCList* List() { return m_List; }
protected:
  GtkCList* m_List;
};

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

class sdpGtkEventCListUnselectAll : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListUnselectAll(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List);
  static void RawEvent(GtkCList* List, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline GtkCList* List() { return m_List; }
protected:
  GtkCList* m_List;
};

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

class sdpGtkEventCListUnselectRow : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCListUnselectRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCList* List, gint Row, gint Column, GdkEvent* Event);
  static void RawEvent(GtkCList* List, gint Row, gint Column, GdkEvent* Event, gpointer EventData);
  inline void SetList(GtkCList* List) { m_List = List; }
  inline void SetRow(gint Row) { m_Row = Row; }
  inline void SetColumn(gint Column) { m_Column = Column; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkCList* List() { return m_List; }
  inline gint Row() { return m_Row; }
  inline gint Column() { return m_Column; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  GtkCList* m_List;
  gint m_Row;
  gint m_Column;
  GdkEvent* m_Event;
};

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

class sdpGtkEventColorSelectionColorChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventColorSelectionColorChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkColorSelection* ColorSelection);
  static void RawEvent(GtkColorSelection* ColorSelection, gpointer EventData);
  inline void SetColorSelection(GtkColorSelection* ColorSelection) { m_ColorSelection = ColorSelection; }
  inline GtkColorSelection* ColorSelection() { return m_ColorSelection; }
protected:
  GtkColorSelection* m_ColorSelection;
};

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

class sdpGtkEventContainerAdd : public sdpGtkObjectEvent
{
public:
  sdpGtkEventContainerAdd(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkContainer* Container, GtkWidget* Widget);
  static void RawEvent(GtkContainer* Container, GtkWidget* Widget, gpointer EventData);
  inline void SetContainer(GtkContainer* Container) { m_Container = Container; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkContainer* Container() { return m_Container; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkContainer* m_Container;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventContainerCheckResize : public sdpGtkObjectEvent
{
public:
  sdpGtkEventContainerCheckResize(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkContainer* Container);
  static void RawEvent(GtkContainer* Container, gpointer EventData);
  inline void SetContainer(GtkContainer* Container) { m_Container = Container; }
  inline GtkContainer* Container() { return m_Container; }
protected:
  GtkContainer* m_Container;
};

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

class sdpGtkEventContainerFocus : public sdpGtkObjectEvent
{
public:
  sdpGtkEventContainerFocus(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  GtkDirectionType Event(GtkContainer* Container, GtkDirectionType DirectionType);
  static GtkDirectionType RawEvent(GtkContainer* Container, GtkDirectionType DirectionType, gpointer EventData);
  inline void SetResult(GtkDirectionType Result) { m_Result = Result; }
  inline GtkDirectionType Result() { return m_Result; }
  inline void SetContainer(GtkContainer* Container) { m_Container = Container; }
  inline void SetDirectionType(GtkDirectionType DirectionType) { m_DirectionType = DirectionType; }
  inline GtkContainer* Container() { return m_Container; }
  inline GtkDirectionType DirectionType() { return m_DirectionType; }
protected:
  GtkDirectionType m_Result;
  GtkContainer* m_Container;
  GtkDirectionType m_DirectionType;
};

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

class sdpGtkEventContainerRemove : public sdpGtkObjectEvent
{
public:
  sdpGtkEventContainerRemove(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkContainer* Container, GtkWidget* Widget);
  static void RawEvent(GtkContainer* Container, GtkWidget* Widget, gpointer EventData);
  inline void SetContainer(GtkContainer* Container) { m_Container = Container; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkContainer* Container() { return m_Container; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkContainer* m_Container;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventContainerSetFocusChild : public sdpGtkObjectEvent
{
public:
  sdpGtkEventContainerSetFocusChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkContainer* Container, GtkWidget* Widget);
  static void RawEvent(GtkContainer* Container, GtkWidget* Widget, gpointer EventData);
  inline void SetContainer(GtkContainer* Container) { m_Container = Container; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkContainer* Container() { return m_Container; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkContainer* m_Container;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventCTreeChangeFocusRowExpansion : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCTreeChangeFocusRowExpansion(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCTree* Tree, GtkCTreeExpansionType ExpansionType);
  static void RawEvent(GtkCTree* Tree, GtkCTreeExpansionType ExpansionType, gpointer EventData);
  inline void SetTree(GtkCTree* Tree) { m_Tree = Tree; }
  inline void SetExpansionType(GtkCTreeExpansionType ExpansionType) { m_ExpansionType = ExpansionType; }
  inline GtkCTree* Tree() { return m_Tree; }
  inline GtkCTreeExpansionType ExpansionType() { return m_ExpansionType; }
protected:
  GtkCTree* m_Tree;
  GtkCTreeExpansionType m_ExpansionType;
};

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

class sdpGtkEventCTreeTreeCollapse : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCTreeTreeCollapse(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCTree* Tree, GtkCTreeNode* Node);
  static void RawEvent(GtkCTree* Tree, GtkCTreeNode* Node, gpointer EventData);
  inline void SetTree(GtkCTree* Tree) { m_Tree = Tree; }
  inline void SetNode(GtkCTreeNode* Node) { m_Node = Node; }
  inline GtkCTree* Tree() { return m_Tree; }
  inline GtkCTreeNode* Node() { return m_Node; }
protected:
  GtkCTree* m_Tree;
  GtkCTreeNode* m_Node;
};

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

class sdpGtkEventCTreeTreeExpand : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCTreeTreeExpand(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCTree* Tree, GtkCTreeNode* Node);
  static void RawEvent(GtkCTree* Tree, GtkCTreeNode* Node, gpointer EventData);
  inline void SetTree(GtkCTree* Tree) { m_Tree = Tree; }
  inline void SetNode(GtkCTreeNode* Node) { m_Node = Node; }
  inline GtkCTree* Tree() { return m_Tree; }
  inline GtkCTreeNode* Node() { return m_Node; }
protected:
  GtkCTree* m_Tree;
  GtkCTreeNode* m_Node;
};

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

class sdpGtkEventCTreeTreeMove : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCTreeTreeMove(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCTree* Tree, GtkCTreeNode* Node, GtkCTreeNode* NewParent, GtkCTreeNode* NewSibling);
  static void RawEvent(GtkCTree* Tree, GtkCTreeNode* Node, GtkCTreeNode* NewParent, GtkCTreeNode* NewSibling, gpointer EventData);
  inline void SetTree(GtkCTree* Tree) { m_Tree = Tree; }
  inline void SetNode(GtkCTreeNode* Node) { m_Node = Node; }
  inline void SetNewParent(GtkCTreeNode* NewParent) { m_NewParent = NewParent; }
  inline void SetNewSibling(GtkCTreeNode* NewSibling) { m_NewSibling = NewSibling; }
  inline GtkCTree* Tree() { return m_Tree; }
  inline GtkCTreeNode* Node() { return m_Node; }
  inline GtkCTreeNode* NewParent() { return m_NewParent; }
  inline GtkCTreeNode* NewSibling() { return m_NewSibling; }
protected:
  GtkCTree* m_Tree;
  GtkCTreeNode* m_Node;
  GtkCTreeNode* m_NewParent;
  GtkCTreeNode* m_NewSibling;
};

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

class sdpGtkEventCTreeTreeSelectRow : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCTreeTreeSelectRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCTree* Tree, GtkCTreeNode* Row, gint Column);
  static void RawEvent(GtkCTree* Tree, GtkCTreeNode* Row, gint Column, gpointer EventData);
  inline void SetTree(GtkCTree* Tree) { m_Tree = Tree; }
  inline void SetRow(GtkCTreeNode* Row) { m_Row = Row; }
  inline void SetColumn(gint Column) { m_Column = Column; }
  inline GtkCTree* Tree() { return m_Tree; }
  inline GtkCTreeNode* Row() { return m_Row; }
  inline gint Column() { return m_Column; }
protected:
  GtkCTree* m_Tree;
  GtkCTreeNode* m_Row;
  gint m_Column;
};

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

class sdpGtkEventCTreeTreeUnselectRow : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCTreeTreeUnselectRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCTree* Tree, GtkCTreeNode* Row, gint Column);
  static void RawEvent(GtkCTree* Tree, GtkCTreeNode* Row, gint Column, gpointer EventData);
  inline void SetTree(GtkCTree* Tree) { m_Tree = Tree; }
  inline void SetRow(GtkCTreeNode* Row) { m_Row = Row; }
  inline void SetColumn(gint Column) { m_Column = Column; }
  inline GtkCTree* Tree() { return m_Tree; }
  inline GtkCTreeNode* Row() { return m_Row; }
  inline gint Column() { return m_Column; }
protected:
  GtkCTree* m_Tree;
  GtkCTreeNode* m_Row;
  gint m_Column;
};

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

class sdpGtkEventCurveCurveTypeChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventCurveCurveTypeChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkCurve* Curve);
  static void RawEvent(GtkCurve* Curve, gpointer EventData);
  inline void SetCurve(GtkCurve* Curve) { m_Curve = Curve; }
  inline GtkCurve* Curve() { return m_Curve; }
protected:
  GtkCurve* m_Curve;
};

#ifndef K3D_HAVE_GTK2

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

class sdpGtkEventDataDisconnect : public sdpGtkObjectEvent
{
public:
  sdpGtkEventDataDisconnect(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkData* Data);
  static void RawEvent(GtkData* Data, gpointer EventData);
  inline void SetData(GtkData* Data) { m_Data = Data; }
  inline GtkData* Data() { return m_Data; }
protected:
  GtkData* m_Data;
};

#endif

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

class sdpGtkEventEditableActivate : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableActivate(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable);
  static void RawEvent(GtkEditable* Editable, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline GtkEditable* Editable() { return m_Editable; }
protected:
  GtkEditable* m_Editable;
};

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

class sdpGtkEventEditableChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable);
  static void RawEvent(GtkEditable* Editable, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline GtkEditable* Editable() { return m_Editable; }
protected:
  GtkEditable* m_Editable;
};

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

class sdpGtkEventEditableCopyClipboard : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableCopyClipboard(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable);
  static void RawEvent(GtkEditable* Editable, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline GtkEditable* Editable() { return m_Editable; }
protected:
  GtkEditable* m_Editable;
};

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

class sdpGtkEventEditableCutClipboard : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableCutClipboard(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable);
  static void RawEvent(GtkEditable* Editable, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline GtkEditable* Editable() { return m_Editable; }
protected:
  GtkEditable* m_Editable;
};

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

class sdpGtkEventEditableDeleteText : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableDeleteText(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint Start, gint End);
  static void RawEvent(GtkEditable* Editable, gint Start, gint End, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetStart(gint Start) { m_Start = Start; }
  inline void SetEnd(gint End) { m_End = End; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint Start() { return m_Start; }
  inline gint End() { return m_End; }
protected:
  GtkEditable* m_Editable;
  gint m_Start;
  gint m_End;
};

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

class sdpGtkEventEditableInsertText : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableInsertText(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gchar* Text, gint TextLength, gint* Position);
  static void RawEvent(GtkEditable* Editable, gchar* Text, gint TextLength, gint* Position, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetText(gchar* Text) { m_Text = Text; }
  inline void SetTextLength(gint TextLength) { m_TextLength = TextLength; }
  inline void SetPosition(gint* Position) { m_Position = Position; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gchar* Text() { return m_Text; }
  inline gint TextLength() { return m_TextLength; }
  inline gint* Position() { return m_Position; }
protected:
  GtkEditable* m_Editable;
  gchar* m_Text;
  gint m_TextLength;
  gint* m_Position;
};

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

class sdpGtkEventEditableKillChar : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableKillChar(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint Direction);
  static void RawEvent(GtkEditable* Editable, gint Direction, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetDirection(gint Direction) { m_Direction = Direction; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint Direction() { return m_Direction; }
protected:
  GtkEditable* m_Editable;
  gint m_Direction;
};

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

class sdpGtkEventEditableKillLine : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableKillLine(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint Direction);
  static void RawEvent(GtkEditable* Editable, gint Direction, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetDirection(gint Direction) { m_Direction = Direction; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint Direction() { return m_Direction; }
protected:
  GtkEditable* m_Editable;
  gint m_Direction;
};

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

class sdpGtkEventEditableKillWord : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableKillWord(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint Direction);
  static void RawEvent(GtkEditable* Editable, gint Direction, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetDirection(gint Direction) { m_Direction = Direction; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint Direction() { return m_Direction; }
protected:
  GtkEditable* m_Editable;
  gint m_Direction;
};

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

class sdpGtkEventEditableMoveCursor : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableMoveCursor(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint X, gint Y);
  static void RawEvent(GtkEditable* Editable, gint X, gint Y, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetX(gint X) { m_X = X; }
  inline void SetY(gint Y) { m_Y = Y; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint X() { return m_X; }
  inline gint Y() { return m_Y; }
protected:
  GtkEditable* m_Editable;
  gint m_X;
  gint m_Y;
};

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

class sdpGtkEventEditableMovePage : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableMovePage(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint X, gint Y);
  static void RawEvent(GtkEditable* Editable, gint X, gint Y, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetX(gint X) { m_X = X; }
  inline void SetY(gint Y) { m_Y = Y; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint X() { return m_X; }
  inline gint Y() { return m_Y; }
protected:
  GtkEditable* m_Editable;
  gint m_X;
  gint m_Y;
};

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

class sdpGtkEventEditableMoveToColumn : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableMoveToColumn(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint Column);
  static void RawEvent(GtkEditable* Editable, gint Column, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetColumn(gint Column) { m_Column = Column; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint Column() { return m_Column; }
protected:
  GtkEditable* m_Editable;
  gint m_Column;
};

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

class sdpGtkEventEditableMoveToRow : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableMoveToRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint Row);
  static void RawEvent(GtkEditable* Editable, gint Row, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetRow(gint Row) { m_Row = Row; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint Row() { return m_Row; }
protected:
  GtkEditable* m_Editable;
  gint m_Row;
};

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

class sdpGtkEventEditableMoveWord : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableMoveWord(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gint Direction);
  static void RawEvent(GtkEditable* Editable, gint Direction, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetDirection(gint Direction) { m_Direction = Direction; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gint Direction() { return m_Direction; }
protected:
  GtkEditable* m_Editable;
  gint m_Direction;
};

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

class sdpGtkEventEditablePasteClipboard : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditablePasteClipboard(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable);
  static void RawEvent(GtkEditable* Editable, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline GtkEditable* Editable() { return m_Editable; }
protected:
  GtkEditable* m_Editable;
};

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

class sdpGtkEventEditableSetEditable : public sdpGtkObjectEvent
{
public:
  sdpGtkEventEditableSetEditable(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkEditable* Editable, gboolean IsEditable);
  static void RawEvent(GtkEditable* Editable, gboolean IsEditable, gpointer EventData);
  inline void SetEditable(GtkEditable* Editable) { m_Editable = Editable; }
  inline void SetIsEditable(gboolean IsEditable) { m_IsEditable = IsEditable; }
  inline GtkEditable* Editable() { return m_Editable; }
  inline gboolean IsEditable() { return m_IsEditable; }
protected:
  GtkEditable* m_Editable;
  gboolean m_IsEditable;
};

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

class sdpGtkEventHandleBoxChildAttached : public sdpGtkObjectEvent
{
public:
  sdpGtkEventHandleBoxChildAttached(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkHandleBox* HandleBox, GtkWidget* Widget);
  static void RawEvent(GtkHandleBox* HandleBox, GtkWidget* Widget, gpointer EventData);
  inline void SetHandleBox(GtkHandleBox* HandleBox) { m_HandleBox = HandleBox; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkHandleBox* HandleBox() { return m_HandleBox; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkHandleBox* m_HandleBox;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventHandleBoxChildDetached : public sdpGtkObjectEvent
{
public:
  sdpGtkEventHandleBoxChildDetached(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkHandleBox* HandleBox, GtkWidget* Widget);
  static void RawEvent(GtkHandleBox* HandleBox, GtkWidget* Widget, gpointer EventData);
  inline void SetHandleBox(GtkHandleBox* HandleBox) { m_HandleBox = HandleBox; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkHandleBox* HandleBox() { return m_HandleBox; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkHandleBox* m_HandleBox;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventInputDialogDisableDevice : public sdpGtkObjectEvent
{
public:
  sdpGtkEventInputDialogDisableDevice(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkInputDialog* InputDialog, guint32 DeviceID);
  static void RawEvent(GtkInputDialog* InputDialog, guint32 DeviceID, gpointer EventData);
  inline void SetInputDialog(GtkInputDialog* InputDialog) { m_InputDialog = InputDialog; }
  inline void SetDeviceID(guint32 DeviceID) { m_DeviceID = DeviceID; }
  inline GtkInputDialog* InputDialog() { return m_InputDialog; }
  inline guint32 DeviceID() { return m_DeviceID; }
protected:
  GtkInputDialog* m_InputDialog;
  guint32 m_DeviceID;
};

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

class sdpGtkEventInputDialogEnableDevice : public sdpGtkObjectEvent
{
public:
  sdpGtkEventInputDialogEnableDevice(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkInputDialog* InputDialog, guint32 DeviceID);
  static void RawEvent(GtkInputDialog* InputDialog, guint32 DeviceID, gpointer EventData);
  inline void SetInputDialog(GtkInputDialog* InputDialog) { m_InputDialog = InputDialog; }
  inline void SetDeviceID(guint32 DeviceID) { m_DeviceID = DeviceID; }
  inline GtkInputDialog* InputDialog() { return m_InputDialog; }
  inline guint32 DeviceID() { return m_DeviceID; }
protected:
  GtkInputDialog* m_InputDialog;
  guint32 m_DeviceID;
};

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

class sdpGtkEventItemDeselect : public sdpGtkObjectEvent
{
public:
  sdpGtkEventItemDeselect(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkItem* Item);
  static void RawEvent(GtkItem* Item, gpointer EventData);
  inline void SetItem(GtkItem* Item) { m_Item = Item; }
  inline GtkItem* Item() { return m_Item; }
protected:
  GtkItem* m_Item;
};

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

class sdpGtkEventItemSelect : public sdpGtkObjectEvent
{
public:
  sdpGtkEventItemSelect(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkItem* Item);
  static void RawEvent(GtkItem* Item, gpointer EventData);
  inline void SetItem(GtkItem* Item) { m_Item = Item; }
  inline GtkItem* Item() { return m_Item; }
protected:
  GtkItem* m_Item;
};

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

class sdpGtkEventItemToggle : public sdpGtkObjectEvent
{
public:
  sdpGtkEventItemToggle(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkItem* Item);
  static void RawEvent(GtkItem* Item, gpointer EventData);
  inline void SetItem(GtkItem* Item) { m_Item = Item; }
  inline GtkItem* Item() { return m_Item; }
protected:
  GtkItem* m_Item;
};

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

class sdpGtkEventListItemEndSelection : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemEndSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem);
  static void RawEvent(GtkListItem* ListItem, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline GtkListItem* ListItem() { return m_ListItem; }
protected:
  GtkListItem* m_ListItem;
};

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

class sdpGtkEventListItemExtendSelection : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemExtendSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position, gboolean AutoStartSelection);
  static void RawEvent(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position, gboolean AutoStartSelection, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline void SetScrollType(GtkScrollType ScrollType) { m_ScrollType = ScrollType; }
  inline void SetPosition(gfloat Position) { m_Position = Position; }
  inline void SetAutoStartSelection(gboolean AutoStartSelection) { m_AutoStartSelection = AutoStartSelection; }
  inline GtkListItem* ListItem() { return m_ListItem; }
  inline GtkScrollType ScrollType() { return m_ScrollType; }
  inline gfloat Position() { return m_Position; }
  inline gboolean AutoStartSelection() { return m_AutoStartSelection; }
protected:
  GtkListItem* m_ListItem;
  GtkScrollType m_ScrollType;
  gfloat m_Position;
  gboolean m_AutoStartSelection;
};

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

class sdpGtkEventListItemScrollHorizontal : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemScrollHorizontal(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position);
  static void RawEvent(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline void SetScrollType(GtkScrollType ScrollType) { m_ScrollType = ScrollType; }
  inline void SetPosition(gfloat Position) { m_Position = Position; }
  inline GtkListItem* ListItem() { return m_ListItem; }
  inline GtkScrollType ScrollType() { return m_ScrollType; }
  inline gfloat Position() { return m_Position; }
protected:
  GtkListItem* m_ListItem;
  GtkScrollType m_ScrollType;
  gfloat m_Position;
};

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

class sdpGtkEventListItemScrollVertical : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemScrollVertical(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position);
  static void RawEvent(GtkListItem* ListItem, GtkScrollType ScrollType, gfloat Position, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline void SetScrollType(GtkScrollType ScrollType) { m_ScrollType = ScrollType; }
  inline void SetPosition(gfloat Position) { m_Position = Position; }
  inline GtkListItem* ListItem() { return m_ListItem; }
  inline GtkScrollType ScrollType() { return m_ScrollType; }
  inline gfloat Position() { return m_Position; }
protected:
  GtkListItem* m_ListItem;
  GtkScrollType m_ScrollType;
  gfloat m_Position;
};

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

class sdpGtkEventListItemSelectAll : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemSelectAll(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem);
  static void RawEvent(GtkListItem* ListItem, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline GtkListItem* ListItem() { return m_ListItem; }
protected:
  GtkListItem* m_ListItem;
};

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

class sdpGtkEventListItemStartSelection : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemStartSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem);
  static void RawEvent(GtkListItem* ListItem, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline GtkListItem* ListItem() { return m_ListItem; }
protected:
  GtkListItem* m_ListItem;
};

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

class sdpGtkEventListItemToggleAddMode : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemToggleAddMode(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem);
  static void RawEvent(GtkListItem* ListItem, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline GtkListItem* ListItem() { return m_ListItem; }
protected:
  GtkListItem* m_ListItem;
};

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

class sdpGtkEventListItemToggleFocusRow : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemToggleFocusRow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem);
  static void RawEvent(GtkListItem* ListItem, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline GtkListItem* ListItem() { return m_ListItem; }
protected:
  GtkListItem* m_ListItem;
};

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

class sdpGtkEventListItemUndoSelection : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemUndoSelection(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem);
  static void RawEvent(GtkListItem* ListItem, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline GtkListItem* ListItem() { return m_ListItem; }
protected:
  GtkListItem* m_ListItem;
};

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

class sdpGtkEventListItemUnselectAll : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListItemUnselectAll(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkListItem* ListItem);
  static void RawEvent(GtkListItem* ListItem, gpointer EventData);
  inline void SetListItem(GtkListItem* ListItem) { m_ListItem = ListItem; }
  inline GtkListItem* ListItem() { return m_ListItem; }
protected:
  GtkListItem* m_ListItem;
};

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

class sdpGtkEventListSelectChild : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListSelectChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkList* List, GtkWidget* Widget);
  static void RawEvent(GtkList* List, GtkWidget* Widget, gpointer EventData);
  inline void SetList(GtkList* List) { m_List = List; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkList* List() { return m_List; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkList* m_List;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventListSelectionChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListSelectionChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkList* List);
  static void RawEvent(GtkList* List, gpointer EventData);
  inline void SetList(GtkList* List) { m_List = List; }
  inline GtkList* List() { return m_List; }
protected:
  GtkList* m_List;
};

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

class sdpGtkEventListUnselectChild : public sdpGtkObjectEvent
{
public:
  sdpGtkEventListUnselectChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkList* List, GtkWidget* Widget);
  static void RawEvent(GtkList* List, GtkWidget* Widget, gpointer EventData);
  inline void SetList(GtkList* List) { m_List = List; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkList* List() { return m_List; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkList* m_List;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventMenuItemActivate : public sdpGtkObjectEvent
{
public:
  sdpGtkEventMenuItemActivate(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkMenuItem* MenuItem);
  static void RawEvent(GtkMenuItem* MenuItem, gpointer EventData);
  inline void SetMenuItem(GtkMenuItem* MenuItem) { m_MenuItem = MenuItem; }
  inline GtkMenuItem* MenuItem() { return m_MenuItem; }
protected:
  GtkMenuItem* m_MenuItem;
};

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

class sdpGtkEventMenuItemActivateItem : public sdpGtkObjectEvent
{
public:
  sdpGtkEventMenuItemActivateItem(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkMenuItem* MenuItem);
  static void RawEvent(GtkMenuItem* MenuItem, gpointer EventData);
  inline void SetMenuItem(GtkMenuItem* MenuItem) { m_MenuItem = MenuItem; }
  inline GtkMenuItem* MenuItem() { return m_MenuItem; }
protected:
  GtkMenuItem* m_MenuItem;
};

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

class sdpGtkEventMenuShellActivateCurrent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventMenuShellActivateCurrent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkMenuShell* MenuShell, gboolean ForceHide);
  static void RawEvent(GtkMenuShell* MenuShell, gboolean ForceHide, gpointer EventData);
  inline void SetMenuShell(GtkMenuShell* MenuShell) { m_MenuShell = MenuShell; }
  inline void SetForceHide(gboolean ForceHide) { m_ForceHide = ForceHide; }
  inline GtkMenuShell* MenuShell() { return m_MenuShell; }
  inline gboolean ForceHide() { return m_ForceHide; }
protected:
  GtkMenuShell* m_MenuShell;
  gboolean m_ForceHide;
};

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

class sdpGtkEventMenuShellCancel : public sdpGtkObjectEvent
{
public:
  sdpGtkEventMenuShellCancel(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkMenuShell* MenuShell);
  static void RawEvent(GtkMenuShell* MenuShell, gpointer EventData);
  inline void SetMenuShell(GtkMenuShell* MenuShell) { m_MenuShell = MenuShell; }
  inline GtkMenuShell* MenuShell() { return m_MenuShell; }
protected:
  GtkMenuShell* m_MenuShell;
};

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

class sdpGtkEventMenuShellDeactivate : public sdpGtkObjectEvent
{
public:
  sdpGtkEventMenuShellDeactivate(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkMenuShell* MenuShell);
  static void RawEvent(GtkMenuShell* MenuShell, gpointer EventData);
  inline void SetMenuShell(GtkMenuShell* MenuShell) { m_MenuShell = MenuShell; }
  inline GtkMenuShell* MenuShell() { return m_MenuShell; }
protected:
  GtkMenuShell* m_MenuShell;
};

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

class sdpGtkEventMenuShellMoveCurrent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventMenuShellMoveCurrent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkMenuShell* MenuShell, GtkMenuDirectionType Direction);
  static void RawEvent(GtkMenuShell* MenuShell, GtkMenuDirectionType Direction, gpointer EventData);
  inline void SetMenuShell(GtkMenuShell* MenuShell) { m_MenuShell = MenuShell; }
  inline void SetDirection(GtkMenuDirectionType Direction) { m_Direction = Direction; }
  inline GtkMenuShell* MenuShell() { return m_MenuShell; }
  inline GtkMenuDirectionType Direction() { return m_Direction; }
protected:
  GtkMenuShell* m_MenuShell;
  GtkMenuDirectionType m_Direction;
};

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

class sdpGtkEventMenuShellSelectionDone : public sdpGtkObjectEvent
{
public:
  sdpGtkEventMenuShellSelectionDone(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkMenuShell* MenuShell);
  static void RawEvent(GtkMenuShell* MenuShell, gpointer EventData);
  inline void SetMenuShell(GtkMenuShell* MenuShell) { m_MenuShell = MenuShell; }
  inline GtkMenuShell* MenuShell() { return m_MenuShell; }
protected:
  GtkMenuShell* m_MenuShell;
};

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

class sdpGtkEventNotebookSwitchPage : public sdpGtkObjectEvent
{
public:
  sdpGtkEventNotebookSwitchPage(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkNotebook* Notebook, GtkNotebookPage* Page, guint PageNumber);
  static void RawEvent(GtkNotebook* Notebook, GtkNotebookPage* Page, guint PageNumber, gpointer EventData);
  inline void SetNotebook(GtkNotebook* Notebook) { m_Notebook = Notebook; }
  inline void SetPage(GtkNotebookPage* Page) { m_Page = Page; }
  inline void SetPageNumber(guint PageNumber) { m_PageNumber = PageNumber; }
  inline GtkNotebook* Notebook() { return m_Notebook; }
  inline GtkNotebookPage* Page() { return m_Page; }
  inline guint PageNumber() { return m_PageNumber; }
protected:
  GtkNotebook* m_Notebook;
  GtkNotebookPage* m_Page;
  guint m_PageNumber;
};

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

class sdpGtkEventObjectDestroy : public sdpGtkObjectEvent
{
public:
  sdpGtkEventObjectDestroy(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkObject* Object);
  static void RawEvent(GtkObject* Object, gpointer EventData);
  inline void SetObject(GtkObject* Object) { m_Object = Object; }
  inline GtkObject* Object() { return m_Object; }
protected:
  GtkObject* m_Object;
};

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

class sdpGtkEventStatusbarTextPopped : public sdpGtkObjectEvent
{
public:
  sdpGtkEventStatusbarTextPopped(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkStatusbar* Statusbar, guint ContextID, gchar* Text);
  static void RawEvent(GtkStatusbar* Statusbar, guint ContextID, gchar* Text, gpointer EventData);
  inline void SetStatusbar(GtkStatusbar* Statusbar) { m_Statusbar = Statusbar; }
  inline void SetContextID(guint ContextID) { m_ContextID = ContextID; }
  inline void SetText(gchar* Text) { m_Text = Text; }
  inline GtkStatusbar* Statusbar() { return m_Statusbar; }
  inline guint ContextID() { return m_ContextID; }
  inline gchar* Text() { return m_Text; }
protected:
  GtkStatusbar* m_Statusbar;
  guint m_ContextID;
  gchar* m_Text;
};

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

class sdpGtkEventStatusbarTextPushed : public sdpGtkObjectEvent
{
public:
  sdpGtkEventStatusbarTextPushed(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkStatusbar* Statusbar, guint ContextID, gchar* Text);
  static void RawEvent(GtkStatusbar* Statusbar, guint ContextID, gchar* Text, gpointer EventData);
  inline void SetStatusbar(GtkStatusbar* Statusbar) { m_Statusbar = Statusbar; }
  inline void SetContextID(guint ContextID) { m_ContextID = ContextID; }
  inline void SetText(gchar* Text) { m_Text = Text; }
  inline GtkStatusbar* Statusbar() { return m_Statusbar; }
  inline guint ContextID() { return m_ContextID; }
  inline gchar* Text() { return m_Text; }
protected:
  GtkStatusbar* m_Statusbar;
  guint m_ContextID;
  gchar* m_Text;
};

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

class sdpGtkEventTipsQueryStartQuery : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTipsQueryStartQuery(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkTipsQuery* TipsQuery);
  static void RawEvent(GtkTipsQuery* TipsQuery, gpointer EventData);
  inline void SetTipsQuery(GtkTipsQuery* TipsQuery) { m_TipsQuery = TipsQuery; }
  inline GtkTipsQuery* TipsQuery() { return m_TipsQuery; }
protected:
  GtkTipsQuery* m_TipsQuery;
};

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

class sdpGtkEventTipsQueryStopQuery : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTipsQueryStopQuery(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkTipsQuery* TipsQuery);
  static void RawEvent(GtkTipsQuery* TipsQuery, gpointer EventData);
  inline void SetTipsQuery(GtkTipsQuery* TipsQuery) { m_TipsQuery = TipsQuery; }
  inline GtkTipsQuery* TipsQuery() { return m_TipsQuery; }
protected:
  GtkTipsQuery* m_TipsQuery;
};

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

class sdpGtkEventTipsQueryWidgetEntered : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTipsQueryWidgetEntered(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkTipsQuery* TipsQuery, GtkWidget* Widget, gchar* TipText, gchar* TipPrivate);
  static void RawEvent(GtkTipsQuery* TipsQuery, GtkWidget* Widget, gchar* TipText, gchar* TipPrivate, gpointer EventData);
  inline void SetTipsQuery(GtkTipsQuery* TipsQuery) { m_TipsQuery = TipsQuery; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetTipText(gchar* TipText) { m_TipText = TipText; }
  inline void SetTipPrivate(gchar* TipPrivate) { m_TipPrivate = TipPrivate; }
  inline GtkTipsQuery* TipsQuery() { return m_TipsQuery; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline gchar* TipText() { return m_TipText; }
  inline gchar* TipPrivate() { return m_TipPrivate; }
protected:
  GtkTipsQuery* m_TipsQuery;
  GtkWidget* m_Widget;
  gchar* m_TipText;
  gchar* m_TipPrivate;
};

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

class sdpGtkEventTipsQueryWidgetSelected : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTipsQueryWidgetSelected(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkTipsQuery* TipsQuery, GtkWidget* Widget, gchar* TipText, gchar* TipPrivate, GdkEvent* Event);
  static gboolean RawEvent(GtkTipsQuery* TipsQuery, GtkWidget* Widget, gchar* TipText, gchar* TipPrivate, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetTipsQuery(GtkTipsQuery* TipsQuery) { m_TipsQuery = TipsQuery; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetTipText(gchar* TipText) { m_TipText = TipText; }
  inline void SetTipPrivate(gchar* TipPrivate) { m_TipPrivate = TipPrivate; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkTipsQuery* TipsQuery() { return m_TipsQuery; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline gchar* TipText() { return m_TipText; }
  inline gchar* TipPrivate() { return m_TipPrivate; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkTipsQuery* m_TipsQuery;
  GtkWidget* m_Widget;
  gchar* m_TipText;
  gchar* m_TipPrivate;
  GdkEvent* m_Event;
};

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

class sdpGtkEventToggleButtonToggled : public sdpGtkObjectEvent
{
public:
  sdpGtkEventToggleButtonToggled(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkToggleButton* ToggleButton);
  static void RawEvent(GtkToggleButton* ToggleButton, gpointer EventData);
  inline void SetToggleButton(GtkToggleButton* ToggleButton) { m_ToggleButton = ToggleButton; }
  inline GtkToggleButton* ToggleButton() { return m_ToggleButton; }
protected:
  GtkToggleButton* m_ToggleButton;
};

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

class sdpGtkEventToolbarOrientationChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventToolbarOrientationChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkToolbar* Toolbar, GtkOrientation Orientation);
  static void RawEvent(GtkToolbar* Toolbar, GtkOrientation Orientation, gpointer EventData);
  inline void SetToolbar(GtkToolbar* Toolbar) { m_Toolbar = Toolbar; }
  inline void SetOrientation(GtkOrientation Orientation) { m_Orientation = Orientation; }
  inline GtkToolbar* Toolbar() { return m_Toolbar; }
  inline GtkOrientation Orientation() { return m_Orientation; }
protected:
  GtkToolbar* m_Toolbar;
  GtkOrientation m_Orientation;
};

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

class sdpGtkEventToolbarStyleChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventToolbarStyleChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkToolbar* Toolbar, GtkToolbarStyle Style);
  static void RawEvent(GtkToolbar* Toolbar, GtkToolbarStyle Style, gpointer EventData);
  inline void SetToolbar(GtkToolbar* Toolbar) { m_Toolbar = Toolbar; }
  inline void SetStyle(GtkToolbarStyle Style) { m_Style = Style; }
  inline GtkToolbar* Toolbar() { return m_Toolbar; }
  inline GtkToolbarStyle Style() { return m_Style; }
protected:
  GtkToolbar* m_Toolbar;
  GtkToolbarStyle m_Style;
};

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

class sdpGtkEventTreeItemCollapse : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTreeItemCollapse(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkTreeItem* TreeItem);
  static void RawEvent(GtkTreeItem* TreeItem, gpointer EventData);
  inline void SetTreeItem(GtkTreeItem* TreeItem) { m_TreeItem = TreeItem; }
  inline GtkTreeItem* TreeItem() { return m_TreeItem; }
protected:
  GtkTreeItem* m_TreeItem;
};

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

class sdpGtkEventTreeItemExpand : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTreeItemExpand(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkTreeItem* TreeItem);
  static void RawEvent(GtkTreeItem* TreeItem, gpointer EventData);
  inline void SetTreeItem(GtkTreeItem* TreeItem) { m_TreeItem = TreeItem; }
  inline GtkTreeItem* TreeItem() { return m_TreeItem; }
protected:
  GtkTreeItem* m_TreeItem;
};

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

class sdpGtkEventTreeSelectChild : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTreeSelectChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkTree* Tree, GtkWidget* Widget);
  static void RawEvent(GtkTree* Tree, GtkWidget* Widget, gpointer EventData);
  inline void SetTree(GtkTree* Tree) { m_Tree = Tree; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkTree* Tree() { return m_Tree; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkTree* m_Tree;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventTreeSelectionChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTreeSelectionChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkTree* Tree);
  static void RawEvent(GtkTree* Tree, gpointer EventData);
  inline void SetTree(GtkTree* Tree) { m_Tree = Tree; }
  inline GtkTree* Tree() { return m_Tree; }
protected:
  GtkTree* m_Tree;
};

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

class sdpGtkEventTreeUnselectChild : public sdpGtkObjectEvent
{
public:
  sdpGtkEventTreeUnselectChild(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkTree* Tree, GtkWidget* Widget);
  static void RawEvent(GtkTree* Tree, GtkWidget* Widget, gpointer EventData);
  inline void SetTree(GtkTree* Tree) { m_Tree = Tree; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkTree* Tree() { return m_Tree; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkTree* m_Tree;
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetAddAccelerator : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetAddAccelerator(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, guint SignalID, GtkAccelGroup* Group, guint Key, GdkModifierType Modifier, GtkAccelFlags Flags);
  static void RawEvent(GtkWidget* Widget, guint SignalID, GtkAccelGroup* Group, guint Key, GdkModifierType Modifier, GtkAccelFlags Flags, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetSignalID(guint SignalID) { m_SignalID = SignalID; }
  inline void SetGroup(GtkAccelGroup* Group) { m_Group = Group; }
  inline void SetKey(guint Key) { m_Key = Key; }
  inline void SetModifier(GdkModifierType Modifier) { m_Modifier = Modifier; }
  inline void SetFlags(GtkAccelFlags Flags) { m_Flags = Flags; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline guint SignalID() { return m_SignalID; }
  inline GtkAccelGroup* Group() { return m_Group; }
  inline guint Key() { return m_Key; }
  inline GdkModifierType Modifier() { return m_Modifier; }
  inline GtkAccelFlags Flags() { return m_Flags; }
protected:
  GtkWidget* m_Widget;
  guint m_SignalID;
  GtkAccelGroup* m_Group;
  guint m_Key;
  GdkModifierType m_Modifier;
  GtkAccelFlags m_Flags;
};

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

class sdpGtkEventWidgetButtonPressEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetButtonPressEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEventButton* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEventButton* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEventButton* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEventButton* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEventButton* m_Event;
};

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

class sdpGtkEventWidgetButtonReleaseEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetButtonReleaseEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEventButton* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEventButton* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEventButton* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEventButton* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEventButton* m_Event;
};

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

class sdpGtkEventWidgetClientEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetClientEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetConfigureEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetConfigureEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetDebugMsg : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDebugMsg(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, gchar* String);
  static void RawEvent(GtkWidget* Widget, gchar* String, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetString(gchar* String) { m_String = String; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline gchar* String() { return m_String; }
protected:
  GtkWidget* m_Widget;
  gchar* m_String;
};

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

class sdpGtkEventWidgetDeleteEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDeleteEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetDestroyEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDestroyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetDragBegin : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDragBegin(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GdkDragContext* DragContext);
  static void RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetDragContext(GdkDragContext* DragContext) { m_DragContext = DragContext; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkDragContext* DragContext() { return m_DragContext; }
protected:
  GtkWidget* m_Widget;
  GdkDragContext* m_DragContext;
};

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

class sdpGtkEventWidgetDragDataDelete : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDragDataDelete(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GdkDragContext* DragContext);
  static void RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetDragContext(GdkDragContext* DragContext) { m_DragContext = DragContext; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkDragContext* DragContext() { return m_DragContext; }
protected:
  GtkWidget* m_Widget;
  GdkDragContext* m_DragContext;
};

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

class sdpGtkEventWidgetDragDataGet : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDragDataGet(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GdkDragContext* DragContext, GtkSelectionData* Selection, guint MouseX, guint MouseY);
  static void RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, GtkSelectionData* Selection, guint MouseX, guint MouseY, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetDragContext(GdkDragContext* DragContext) { m_DragContext = DragContext; }
  inline void SetSelection(GtkSelectionData* Selection) { m_Selection = Selection; }
  inline void SetMouseX(guint MouseX) { m_MouseX = MouseX; }
  inline void SetMouseY(guint MouseY) { m_MouseY = MouseY; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkDragContext* DragContext() { return m_DragContext; }
  inline GtkSelectionData* Selection() { return m_Selection; }
  inline guint MouseX() { return m_MouseX; }
  inline guint MouseY() { return m_MouseY; }
protected:
  GtkWidget* m_Widget;
  GdkDragContext* m_DragContext;
  GtkSelectionData* m_Selection;
  guint m_MouseX;
  guint m_MouseY;
};

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

class sdpGtkEventWidgetDragDataReceived : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDragDataReceived(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, GtkSelectionData* Selection, guint Info, guint Time);
  static void RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, GtkSelectionData* Selection, guint Info, guint Time, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetDragContext(GdkDragContext* DragContext) { m_DragContext = DragContext; }
  inline void SetMouseX(gint MouseX) { m_MouseX = MouseX; }
  inline void SetMouseY(gint MouseY) { m_MouseY = MouseY; }
  inline void SetSelection(GtkSelectionData* Selection) { m_Selection = Selection; }
  inline void SetInfo(guint Info) { m_Info = Info; }
  inline void SetTime(guint Time) { m_Time = Time; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkDragContext* DragContext() { return m_DragContext; }
  inline gint MouseX() { return m_MouseX; }
  inline gint MouseY() { return m_MouseY; }
  inline GtkSelectionData* Selection() { return m_Selection; }
  inline guint Info() { return m_Info; }
  inline guint Time() { return m_Time; }
protected:
  GtkWidget* m_Widget;
  GdkDragContext* m_DragContext;
  gint m_MouseX;
  gint m_MouseY;
  GtkSelectionData* m_Selection;
  guint m_Info;
  guint m_Time;
};

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

class sdpGtkEventWidgetDragDrop : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDragDrop(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, guint Time);
  static gboolean RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, guint Time, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetDragContext(GdkDragContext* DragContext) { m_DragContext = DragContext; }
  inline void SetMouseX(gint MouseX) { m_MouseX = MouseX; }
  inline void SetMouseY(gint MouseY) { m_MouseY = MouseY; }
  inline void SetTime(guint Time) { m_Time = Time; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkDragContext* DragContext() { return m_DragContext; }
  inline gint MouseX() { return m_MouseX; }
  inline gint MouseY() { return m_MouseY; }
  inline guint Time() { return m_Time; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkDragContext* m_DragContext;
  gint m_MouseX;
  gint m_MouseY;
  guint m_Time;
};

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

class sdpGtkEventWidgetDragEnd : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDragEnd(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GdkDragContext* DragContext);
  static void RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetDragContext(GdkDragContext* DragContext) { m_DragContext = DragContext; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkDragContext* DragContext() { return m_DragContext; }
protected:
  GtkWidget* m_Widget;
  GdkDragContext* m_DragContext;
};

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

class sdpGtkEventWidgetDragLeave : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDragLeave(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GdkDragContext* DragContext, guint Time);
  static void RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, guint Time, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetDragContext(GdkDragContext* DragContext) { m_DragContext = DragContext; }
  inline void SetTime(guint Time) { m_Time = Time; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkDragContext* DragContext() { return m_DragContext; }
  inline guint Time() { return m_Time; }
protected:
  GtkWidget* m_Widget;
  GdkDragContext* m_DragContext;
  guint m_Time;
};

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

class sdpGtkEventWidgetDragMotion : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDragMotion(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, guint Time);
  static gboolean RawEvent(GtkWidget* Widget, GdkDragContext* DragContext, gint MouseX, gint MouseY, guint Time, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetDragContext(GdkDragContext* DragContext) { m_DragContext = DragContext; }
  inline void SetMouseX(gint MouseX) { m_MouseX = MouseX; }
  inline void SetMouseY(gint MouseY) { m_MouseY = MouseY; }
  inline void SetTime(guint Time) { m_Time = Time; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkDragContext* DragContext() { return m_DragContext; }
  inline gint MouseX() { return m_MouseX; }
  inline gint MouseY() { return m_MouseY; }
  inline guint Time() { return m_Time; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkDragContext* m_DragContext;
  gint m_MouseX;
  gint m_MouseY;
  guint m_Time;
};

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

class sdpGtkEventWidgetDraw : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDraw(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GdkRectangle* Area);
  static void RawEvent(GtkWidget* Widget, GdkRectangle* Area, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetArea(GdkRectangle* Area) { m_Area = Area; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkRectangle* Area() { return m_Area; }
protected:
  GtkWidget* m_Widget;
  GdkRectangle* m_Area;
};

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

class sdpGtkEventWidgetDrawDefault : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDrawDefault(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget);
  static void RawEvent(GtkWidget* Widget, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetDrawFocus : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetDrawFocus(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget);
  static void RawEvent(GtkWidget* Widget, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetEnterNotifyEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetEnterNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetExposeEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetExposeEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetFocusInEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetFocusInEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetFocusOutEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetFocusOutEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetHide : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetHide(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget);
  static void RawEvent(GtkWidget* Widget, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetKeyPressEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetKeyPressEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEventKey* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEventKey* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEventKey* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEventKey* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEventKey* m_Event;
};

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

class sdpGtkEventWidgetKeyReleaseEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetKeyReleaseEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEventKey* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEventKey* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEventKey* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEventKey* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEventKey* m_Event;
};

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

class sdpGtkEventWidgetLeaveNotifyEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetLeaveNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetMap : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetMap(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget);
  static void RawEvent(GtkWidget* Widget, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetMapEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetMapEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetMotionNotifyEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetMotionNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEventMotion* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEventMotion* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEventMotion* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEventMotion* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEventMotion* m_Event;
};

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

class sdpGtkEventWidgetNoExposeEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetNoExposeEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetParentSet : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetParentSet(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GtkWidget* PreviousParent);
  static void RawEvent(GtkWidget* Widget, GtkWidget* PreviousParent, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetPreviousParent(GtkWidget* PreviousParent) { m_PreviousParent = PreviousParent; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GtkWidget* PreviousParent() { return m_PreviousParent; }
protected:
  GtkWidget* m_Widget;
  GtkWidget* m_PreviousParent;
};

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

class sdpGtkEventWidgetPropertyNotifyEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetPropertyNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetProximityInEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetProximityInEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetProximityOutEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetProximityOutEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetRealize : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetRealize(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget);
  static void RawEvent(GtkWidget* Widget, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetRemoveAccelerator : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetRemoveAccelerator(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GtkAccelGroup* Group, guint Key, GdkModifierType Modifiers);
  static void RawEvent(GtkWidget* Widget, GtkAccelGroup* Group, guint Key, GdkModifierType Modifiers, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetGroup(GtkAccelGroup* Group) { m_Group = Group; }
  inline void SetKey(guint Key) { m_Key = Key; }
  inline void SetModifiers(GdkModifierType Modifiers) { m_Modifiers = Modifiers; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GtkAccelGroup* Group() { return m_Group; }
  inline guint Key() { return m_Key; }
  inline GdkModifierType Modifiers() { return m_Modifiers; }
protected:
  GtkWidget* m_Widget;
  GtkAccelGroup* m_Group;
  guint m_Key;
  GdkModifierType m_Modifiers;
};

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

class sdpGtkEventWidgetSelectionClearEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetSelectionClearEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetSelectionGet : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetSelectionGet(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GtkSelectionData* Selection, guint Info, guint Time);
  static void RawEvent(GtkWidget* Widget, GtkSelectionData* Selection, guint Info, guint Time, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetSelection(GtkSelectionData* Selection) { m_Selection = Selection; }
  inline void SetInfo(guint Info) { m_Info = Info; }
  inline void SetTime(guint Time) { m_Time = Time; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GtkSelectionData* Selection() { return m_Selection; }
  inline guint Info() { return m_Info; }
  inline guint Time() { return m_Time; }
protected:
  GtkWidget* m_Widget;
  GtkSelectionData* m_Selection;
  guint m_Info;
  guint m_Time;
};

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

class sdpGtkEventWidgetSelectionNotifyEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetSelectionNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetSelectionReceived : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetSelectionReceived(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GtkSelectionData* Selection, guint Time);
  static void RawEvent(GtkWidget* Widget, GtkSelectionData* Selection, guint Time, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetSelection(GtkSelectionData* Selection) { m_Selection = Selection; }
  inline void SetTime(guint Time) { m_Time = Time; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GtkSelectionData* Selection() { return m_Selection; }
  inline guint Time() { return m_Time; }
protected:
  GtkWidget* m_Widget;
  GtkSelectionData* m_Selection;
  guint m_Time;
};

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

class sdpGtkEventWidgetSelectionRequestEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetSelectionRequestEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetShow : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetShow(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget);
  static void RawEvent(GtkWidget* Widget, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetSizeAllocate : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetSizeAllocate(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GtkAllocation* Allocation);
  static void RawEvent(GtkWidget* Widget, GtkAllocation* Allocation, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetAllocation(GtkAllocation* Allocation) { m_Allocation = Allocation; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GtkAllocation* Allocation() { return m_Allocation; }
protected:
  GtkWidget* m_Widget;
  GtkAllocation* m_Allocation;
};

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

class sdpGtkEventWidgetSizeRequest : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetSizeRequest(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GtkRequisition* Requisition);
  static void RawEvent(GtkWidget* Widget, GtkRequisition* Requisition, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetRequisition(GtkRequisition* Requisition) { m_Requisition = Requisition; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GtkRequisition* Requisition() { return m_Requisition; }
protected:
  GtkWidget* m_Widget;
  GtkRequisition* m_Requisition;
};

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

class sdpGtkEventWidgetStateChanged : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetStateChanged(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GtkStateType PreviousState);
  static void RawEvent(GtkWidget* Widget, GtkStateType PreviousState, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetPreviousState(GtkStateType PreviousState) { m_PreviousState = PreviousState; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GtkStateType PreviousState() { return m_PreviousState; }
protected:
  GtkWidget* m_Widget;
  GtkStateType m_PreviousState;
};

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

class sdpGtkEventWidgetStyleSet : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetStyleSet(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget, GtkStyle* PreviousStyle);
  static void RawEvent(GtkWidget* Widget, GtkStyle* PreviousStyle, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetPreviousStyle(GtkStyle* PreviousStyle) { m_PreviousStyle = PreviousStyle; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GtkStyle* PreviousStyle() { return m_PreviousStyle; }
protected:
  GtkWidget* m_Widget;
  GtkStyle* m_PreviousStyle;
};

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

class sdpGtkEventWidgetUnmap : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetUnmap(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget);
  static void RawEvent(GtkWidget* Widget, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetUnmapEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetUnmapEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWidgetUnrealize : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetUnrealize(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWidget* Widget);
  static void RawEvent(GtkWidget* Widget, gpointer EventData);
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline GtkWidget* Widget() { return m_Widget; }
protected:
  GtkWidget* m_Widget;
};

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

class sdpGtkEventWidgetVisibilityNotifyEvent : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWidgetVisibilityNotifyEvent(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  gboolean Event(GtkWidget* Widget, GdkEvent* Event);
  static gboolean RawEvent(GtkWidget* Widget, GdkEvent* Event, gpointer EventData);
  inline void SetResult(gboolean Result) { m_Result = Result; }
  inline gboolean Result() { return m_Result; }
  inline void SetWidget(GtkWidget* Widget) { m_Widget = Widget; }
  inline void SetEvent(GdkEvent* Event) { m_Event = Event; }
  inline GtkWidget* Widget() { return m_Widget; }
  inline GdkEvent* Event() { return m_Event; }
protected:
  gboolean m_Result;
  GtkWidget* m_Widget;
  GdkEvent* m_Event;
};

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

class sdpGtkEventWindowSetFocus : public sdpGtkObjectEvent
{
public:
  sdpGtkEventWindowSetFocus(SDPCSTRING EventSignal, SDPCSTRING EventName, bool After, sdpGtkObjectContainer* EventContainer, GtkObject* EventObject);
  void Connect();
  void Event(GtkWindow* Window, GtkWidget* Focus);
  static void RawEvent(GtkWindow* Window, GtkWidget* Focus, gpointer EventData);
  inline void SetWindow(GtkWindow* Window) { m_Window = Window; }
  inline void SetFocus(GtkWidget* Focus) { m_Focus = Focus; }
  inline GtkWindow* Window() { return m_Window; }
  inline GtkWidget* Focus() { return m_Focus; }
protected:
  GtkWindow* m_Window;
  GtkWidget* m_Focus;
};

