wxPython/src/_event.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _event.i
   3 // Purpose:     SWIG interface for common event classes and event binders
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     24-May-1998
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2003 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // Not a %module
  14
  15
  16 //---------------------------------------------------------------------------
  17 // Include some extra python code here
  18 %pythoncode "_event_ex.py"
  19
  20 //---------------------------------------------------------------------------
  21 %newgroup;
  22
  23 // the predefined constants for the number of times we propagate event
  24 // upwards window child-parent chain
  25 enum Propagation_state
  26 {
  27     // don't propagate it at all
  28     wxEVENT_PROPAGATE_NONE = 0,
  29
  30     // propagate it until it is processed
  31     wxEVENT_PROPAGATE_MAX = INT_MAX
  32 };
  33
  34
  35 //---------------------------------------------------------------------------
  36 // Event types
  37
  38 wxEventType wxNewEventType();
  39
  40
  41 %constant wxEventType wxEVT_NULL;
  42 %constant wxEventType wxEVT_FIRST;
  43 %constant wxEventType wxEVT_USER_FIRST;
  44
  45 %constant wxEventType wxEVT_COMMAND_BUTTON_CLICKED;
  46 %constant wxEventType wxEVT_COMMAND_CHECKBOX_CLICKED;
  47 %constant wxEventType wxEVT_COMMAND_CHOICE_SELECTED;
  48 %constant wxEventType wxEVT_COMMAND_LISTBOX_SELECTED;
  49 %constant wxEventType wxEVT_COMMAND_LISTBOX_DOUBLECLICKED;
  50 %constant wxEventType wxEVT_COMMAND_CHECKLISTBOX_TOGGLED;
  51
  52 %constant wxEventType wxEVT_COMMAND_MENU_SELECTED;
  53 %constant wxEventType wxEVT_COMMAND_TOOL_CLICKED;
  54 %constant wxEventType wxEVT_COMMAND_SLIDER_UPDATED;
  55 %constant wxEventType wxEVT_COMMAND_RADIOBOX_SELECTED;
  56 %constant wxEventType wxEVT_COMMAND_RADIOBUTTON_SELECTED;
  57
  58 %constant wxEventType wxEVT_COMMAND_SCROLLBAR_UPDATED;
  59 %constant wxEventType wxEVT_COMMAND_VLBOX_SELECTED;
  60 %constant wxEventType wxEVT_COMMAND_COMBOBOX_SELECTED;
  61 %constant wxEventType wxEVT_COMMAND_TOOL_RCLICKED;
  62 %constant wxEventType wxEVT_COMMAND_TOOL_ENTER;
  63
  64 // Mouse event types
  65 %constant wxEventType wxEVT_LEFT_DOWN;
  66 %constant wxEventType wxEVT_LEFT_UP;
  67 %constant wxEventType wxEVT_MIDDLE_DOWN;
  68 %constant wxEventType wxEVT_MIDDLE_UP;
  69 %constant wxEventType wxEVT_RIGHT_DOWN;
  70 %constant wxEventType wxEVT_RIGHT_UP;
  71 %constant wxEventType wxEVT_MOTION;
  72 %constant wxEventType wxEVT_ENTER_WINDOW;
  73 %constant wxEventType wxEVT_LEAVE_WINDOW;
  74 %constant wxEventType wxEVT_LEFT_DCLICK;
  75 %constant wxEventType wxEVT_MIDDLE_DCLICK;
  76 %constant wxEventType wxEVT_RIGHT_DCLICK;
  77 %constant wxEventType wxEVT_SET_FOCUS;
  78 %constant wxEventType wxEVT_KILL_FOCUS;
  79 %constant wxEventType wxEVT_CHILD_FOCUS;
  80 %constant wxEventType wxEVT_MOUSEWHEEL;
  81
  82 // Non-client mouse events
  83 %constant wxEventType wxEVT_NC_LEFT_DOWN;
  84 %constant wxEventType wxEVT_NC_LEFT_UP;
  85 %constant wxEventType wxEVT_NC_MIDDLE_DOWN;
  86 %constant wxEventType wxEVT_NC_MIDDLE_UP;
  87 %constant wxEventType wxEVT_NC_RIGHT_DOWN;
  88 %constant wxEventType wxEVT_NC_RIGHT_UP;
  89 %constant wxEventType wxEVT_NC_MOTION;
  90 %constant wxEventType wxEVT_NC_ENTER_WINDOW;
  91 %constant wxEventType wxEVT_NC_LEAVE_WINDOW;
  92 %constant wxEventType wxEVT_NC_LEFT_DCLICK;
  93 %constant wxEventType wxEVT_NC_MIDDLE_DCLICK;
  94 %constant wxEventType wxEVT_NC_RIGHT_DCLICK;
  95
  96 // Character input event type
  97 %constant wxEventType wxEVT_CHAR;
  98 %constant wxEventType wxEVT_CHAR_HOOK;
  99 %constant wxEventType wxEVT_NAVIGATION_KEY;
 100 %constant wxEventType wxEVT_KEY_DOWN;
 101 %constant wxEventType wxEVT_KEY_UP;
 102 %constant wxEventType wxEVT_HOTKEY;
 103
 104 // Set cursor event
 105 %constant wxEventType wxEVT_SET_CURSOR;
 106
 107 // wxScrollBar and wxSlider event identifiers
 108 %constant wxEventType wxEVT_SCROLL_TOP;
 109 %constant wxEventType wxEVT_SCROLL_BOTTOM;
 110 %constant wxEventType wxEVT_SCROLL_LINEUP;
 111 %constant wxEventType wxEVT_SCROLL_LINEDOWN;
 112 %constant wxEventType wxEVT_SCROLL_PAGEUP;
 113 %constant wxEventType wxEVT_SCROLL_PAGEDOWN;
 114 %constant wxEventType wxEVT_SCROLL_THUMBTRACK;
 115 %constant wxEventType wxEVT_SCROLL_THUMBRELEASE;
 116 %constant wxEventType wxEVT_SCROLL_ENDSCROLL;
 117
 118 // Scroll events from wxWindow
 119 %constant wxEventType wxEVT_SCROLLWIN_TOP;
 120 %constant wxEventType wxEVT_SCROLLWIN_BOTTOM;
 121 %constant wxEventType wxEVT_SCROLLWIN_LINEUP;
 122 %constant wxEventType wxEVT_SCROLLWIN_LINEDOWN;
 123 %constant wxEventType wxEVT_SCROLLWIN_PAGEUP;
 124 %constant wxEventType wxEVT_SCROLLWIN_PAGEDOWN;
 125 %constant wxEventType wxEVT_SCROLLWIN_THUMBTRACK;
 126 %constant wxEventType wxEVT_SCROLLWIN_THUMBRELEASE;
 127
 128 // System events
 129 %constant wxEventType wxEVT_SIZE;
 130 %constant wxEventType wxEVT_MOVE;
 131 %constant wxEventType wxEVT_CLOSE_WINDOW;
 132 %constant wxEventType wxEVT_END_SESSION;
 133 %constant wxEventType wxEVT_QUERY_END_SESSION;
 134 %constant wxEventType wxEVT_ACTIVATE_APP;
 135 %constant wxEventType wxEVT_POWER;
 136 %constant wxEventType wxEVT_ACTIVATE;
 137 %constant wxEventType wxEVT_CREATE;
 138 %constant wxEventType wxEVT_DESTROY;
 139 %constant wxEventType wxEVT_SHOW;
 140 %constant wxEventType wxEVT_ICONIZE;
 141 %constant wxEventType wxEVT_MAXIMIZE;
 142 %constant wxEventType wxEVT_MOUSE_CAPTURE_CHANGED;
 143 %constant wxEventType wxEVT_PAINT;
 144 %constant wxEventType wxEVT_ERASE_BACKGROUND;
 145 %constant wxEventType wxEVT_NC_PAINT;
 146 %constant wxEventType wxEVT_PAINT_ICON;
 147 %constant wxEventType wxEVT_MENU_OPEN;
 148 %constant wxEventType wxEVT_MENU_CLOSE;
 149 %constant wxEventType wxEVT_MENU_HIGHLIGHT;
 150
 151 %constant wxEventType wxEVT_CONTEXT_MENU;
 152 %constant wxEventType wxEVT_SYS_COLOUR_CHANGED;
 153 %constant wxEventType wxEVT_DISPLAY_CHANGED;
 154 %constant wxEventType wxEVT_SETTING_CHANGED;
 155 %constant wxEventType wxEVT_QUERY_NEW_PALETTE;
 156 %constant wxEventType wxEVT_PALETTE_CHANGED;
 157 %constant wxEventType wxEVT_DROP_FILES;
 158 %constant wxEventType wxEVT_DRAW_ITEM;
 159 %constant wxEventType wxEVT_MEASURE_ITEM;
 160 %constant wxEventType wxEVT_COMPARE_ITEM;
 161 %constant wxEventType wxEVT_INIT_DIALOG;
 162 %constant wxEventType wxEVT_IDLE;
 163 %constant wxEventType wxEVT_UPDATE_UI;
 164 %constant wxEventType wxEVT_SIZING;
 165 %constant wxEventType wxEVT_MOVING;
 166
 167 // Generic command events
 168 // Note: a click is a higher-level event than button down/up
 169 %constant wxEventType wxEVT_COMMAND_LEFT_CLICK;
 170 %constant wxEventType wxEVT_COMMAND_LEFT_DCLICK;
 171 %constant wxEventType wxEVT_COMMAND_RIGHT_CLICK;
 172 %constant wxEventType wxEVT_COMMAND_RIGHT_DCLICK;
 173 %constant wxEventType wxEVT_COMMAND_SET_FOCUS;
 174 %constant wxEventType wxEVT_COMMAND_KILL_FOCUS;
 175 %constant wxEventType wxEVT_COMMAND_ENTER;
 176
 177
 178
 179 %pythoncode {
 180 %#
 181 %# Create some event binders
 182 EVT_SIZE = wx.PyEventBinder( wxEVT_SIZE )
 183 EVT_SIZING = wx.PyEventBinder( wxEVT_SIZING )
 184 EVT_MOVE = wx.PyEventBinder( wxEVT_MOVE )
 185 EVT_MOVING = wx.PyEventBinder( wxEVT_MOVING )
 186 EVT_CLOSE = wx.PyEventBinder( wxEVT_CLOSE_WINDOW )
 187 EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
 188 EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
 189 EVT_PAINT = wx.PyEventBinder( wxEVT_PAINT )
 190 EVT_NC_PAINT = wx.PyEventBinder( wxEVT_NC_PAINT )
 191 EVT_ERASE_BACKGROUND = wx.PyEventBinder( wxEVT_ERASE_BACKGROUND )
 192 EVT_CHAR = wx.PyEventBinder( wxEVT_CHAR )
 193 EVT_KEY_DOWN = wx.PyEventBinder( wxEVT_KEY_DOWN )
 194 EVT_KEY_UP = wx.PyEventBinder( wxEVT_KEY_UP )
 195 EVT_HOTKEY = wx.PyEventBinder( wxEVT_HOTKEY, 1)
 196 EVT_CHAR_HOOK = wx.PyEventBinder( wxEVT_CHAR_HOOK )
 197 EVT_MENU_OPEN = wx.PyEventBinder( wxEVT_MENU_OPEN )
 198 EVT_MENU_CLOSE = wx.PyEventBinder( wxEVT_MENU_CLOSE )
 199 EVT_MENU_HIGHLIGHT = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT, 1)
 200 EVT_MENU_HIGHLIGHT_ALL = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT )
 201 EVT_SET_FOCUS = wx.PyEventBinder( wxEVT_SET_FOCUS )
 202 EVT_KILL_FOCUS = wx.PyEventBinder( wxEVT_KILL_FOCUS )
 203 EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS )
 204 EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE )
 205 EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP )
 206 EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
 207 EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
 208 EVT_DROP_FILES = wx.PyEventBinder( wxEVT_DROP_FILES )
 209 EVT_INIT_DIALOG = wx.PyEventBinder( wxEVT_INIT_DIALOG )
 210 EVT_SYS_COLOUR_CHANGED = wx.PyEventBinder( wxEVT_SYS_COLOUR_CHANGED )
 211 EVT_DISPLAY_CHANGED = wx.PyEventBinder( wxEVT_DISPLAY_CHANGED )
 212 EVT_SHOW = wx.PyEventBinder( wxEVT_SHOW )
 213 EVT_MAXIMIZE = wx.PyEventBinder( wxEVT_MAXIMIZE )
 214 EVT_ICONIZE = wx.PyEventBinder( wxEVT_ICONIZE )
 215 EVT_NAVIGATION_KEY = wx.PyEventBinder( wxEVT_NAVIGATION_KEY )
 216 EVT_PALETTE_CHANGED = wx.PyEventBinder( wxEVT_PALETTE_CHANGED )
 217 EVT_QUERY_NEW_PALETTE = wx.PyEventBinder( wxEVT_QUERY_NEW_PALETTE )
 218 EVT_WINDOW_CREATE = wx.PyEventBinder( wxEVT_CREATE )
 219 EVT_WINDOW_DESTROY = wx.PyEventBinder( wxEVT_DESTROY )
 220 EVT_SET_CURSOR = wx.PyEventBinder( wxEVT_SET_CURSOR )
 221 EVT_MOUSE_CAPTURE_CHANGED = wx.PyEventBinder( wxEVT_MOUSE_CAPTURE_CHANGED )
 222
 223 EVT_LEFT_DOWN = wx.PyEventBinder( wxEVT_LEFT_DOWN )
 224 EVT_LEFT_UP = wx.PyEventBinder( wxEVT_LEFT_UP )
 225 EVT_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_MIDDLE_DOWN )
 226 EVT_MIDDLE_UP = wx.PyEventBinder( wxEVT_MIDDLE_UP )
 227 EVT_RIGHT_DOWN = wx.PyEventBinder( wxEVT_RIGHT_DOWN )
 228 EVT_RIGHT_UP = wx.PyEventBinder( wxEVT_RIGHT_UP )
 229 EVT_MOTION = wx.PyEventBinder( wxEVT_MOTION )
 230 EVT_LEFT_DCLICK = wx.PyEventBinder( wxEVT_LEFT_DCLICK )
 231 EVT_MIDDLE_DCLICK = wx.PyEventBinder( wxEVT_MIDDLE_DCLICK )
 232 EVT_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_RIGHT_DCLICK )
 233 EVT_LEAVE_WINDOW = wx.PyEventBinder( wxEVT_LEAVE_WINDOW )
 234 EVT_ENTER_WINDOW = wx.PyEventBinder( wxEVT_ENTER_WINDOW )
 235 EVT_MOUSEWHEEL = wx.PyEventBinder( wxEVT_MOUSEWHEEL )
 236
 237 EVT_MOUSE_EVENTS = wx.PyEventBinder([ wxEVT_LEFT_DOWN,
 238                                      wxEVT_LEFT_UP,
 239                                      wxEVT_MIDDLE_DOWN,
 240                                      wxEVT_MIDDLE_UP,
 241                                      wxEVT_RIGHT_DOWN,
 242                                      wxEVT_RIGHT_UP,
 243                                      wxEVT_MOTION,
 244                                      wxEVT_LEFT_DCLICK,
 245                                      wxEVT_MIDDLE_DCLICK,
 246                                      wxEVT_RIGHT_DCLICK,
 247                                      wxEVT_ENTER_WINDOW,
 248                                      wxEVT_LEAVE_WINDOW,
 249                                      wxEVT_MOUSEWHEEL
 250                                      ])
 251
 252
 253 %# Scrolling from wxWindow (sent to wxScrolledWindow)
 254 EVT_SCROLLWIN = wx.PyEventBinder([ wxEVT_SCROLLWIN_TOP,
 255                                   wxEVT_SCROLLWIN_BOTTOM,
 256                                   wxEVT_SCROLLWIN_LINEUP,
 257                                   wxEVT_SCROLLWIN_LINEDOWN,
 258                                   wxEVT_SCROLLWIN_PAGEUP,
 259                                   wxEVT_SCROLLWIN_PAGEDOWN,
 260                                   wxEVT_SCROLLWIN_THUMBTRACK,
 261                                   wxEVT_SCROLLWIN_THUMBRELEASE,
 262                                   ])
 263
 264 EVT_SCROLLWIN_TOP = wx.PyEventBinder( wxEVT_SCROLLWIN_TOP )
 265 EVT_SCROLLWIN_BOTTOM = wx.PyEventBinder( wxEVT_SCROLLWIN_BOTTOM )
 266 EVT_SCROLLWIN_LINEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEUP )
 267 EVT_SCROLLWIN_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEDOWN )
 268 EVT_SCROLLWIN_PAGEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEUP )
 269 EVT_SCROLLWIN_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEDOWN )
 270 EVT_SCROLLWIN_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBTRACK )
 271 EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE )
 272
 273 %# Scrolling from wxSlider and wxScrollBar
 274 EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
 275                                wxEVT_SCROLL_BOTTOM,
 276                                wxEVT_SCROLL_LINEUP,
 277                                wxEVT_SCROLL_LINEDOWN,
 278                                wxEVT_SCROLL_PAGEUP,
 279                                wxEVT_SCROLL_PAGEDOWN,
 280                                wxEVT_SCROLL_THUMBTRACK,
 281                                wxEVT_SCROLL_THUMBRELEASE,
 282                                wxEVT_SCROLL_ENDSCROLL,
 283                                ])
 284
 285 EVT_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP )
 286 EVT_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM )
 287 EVT_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP )
 288 EVT_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN )
 289 EVT_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP )
 290 EVT_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN )
 291 EVT_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK )
 292 EVT_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE )
 293 EVT_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL )
 294
 295 %# Scrolling from wxSlider and wxScrollBar, with an id
 296 EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
 297                                        wxEVT_SCROLL_BOTTOM,
 298                                        wxEVT_SCROLL_LINEUP,
 299                                        wxEVT_SCROLL_LINEDOWN,
 300                                        wxEVT_SCROLL_PAGEUP,
 301                                        wxEVT_SCROLL_PAGEDOWN,
 302                                        wxEVT_SCROLL_THUMBTRACK,
 303                                        wxEVT_SCROLL_THUMBRELEASE,
 304                                        wxEVT_SCROLL_ENDSCROLL,
 305                                        ], 1)
 306
 307 EVT_COMMAND_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP, 1)
 308 EVT_COMMAND_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM, 1)
 309 EVT_COMMAND_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP, 1)
 310 EVT_COMMAND_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN, 1)
 311 EVT_COMMAND_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP, 1)
 312 EVT_COMMAND_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN, 1)
 313 EVT_COMMAND_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1)
 314 EVT_COMMAND_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE, 1)
 315 EVT_COMMAND_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL, 1)
 316
 317 EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1)
 318 EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1)
 319 EVT_CHOICE = wx.PyEventBinder( wxEVT_COMMAND_CHOICE_SELECTED, 1)
 320 EVT_LISTBOX = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_SELECTED, 1)
 321 EVT_LISTBOX_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, 1)
 322 EVT_MENU = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 1)
 323 EVT_MENU_RANGE = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 2)
 324 EVT_SLIDER = wx.PyEventBinder( wxEVT_COMMAND_SLIDER_UPDATED, 1)
 325 EVT_RADIOBOX = wx.PyEventBinder( wxEVT_COMMAND_RADIOBOX_SELECTED, 1)
 326 EVT_RADIOBUTTON = wx.PyEventBinder( wxEVT_COMMAND_RADIOBUTTON_SELECTED, 1)
 327
 328 EVT_SCROLLBAR = wx.PyEventBinder( wxEVT_COMMAND_SCROLLBAR_UPDATED, 1)
 329 EVT_VLBOX = wx.PyEventBinder( wxEVT_COMMAND_VLBOX_SELECTED, 1)
 330 EVT_COMBOBOX = wx.PyEventBinder( wxEVT_COMMAND_COMBOBOX_SELECTED, 1)
 331 EVT_TOOL = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 1)
 332 EVT_TOOL_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 2)
 333 EVT_TOOL_RCLICKED = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 1)
 334 EVT_TOOL_RCLICKED_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 2)
 335 EVT_TOOL_ENTER = wx.PyEventBinder( wxEVT_COMMAND_TOOL_ENTER, 1)
 336 EVT_CHECKLISTBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, 1)
 337
 338
 339 EVT_COMMAND_LEFT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_CLICK, 1)
 340 EVT_COMMAND_LEFT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_DCLICK, 1)
 341 EVT_COMMAND_RIGHT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_CLICK, 1)
 342 EVT_COMMAND_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_DCLICK, 1)
 343 EVT_COMMAND_SET_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_SET_FOCUS, 1)
 344 EVT_COMMAND_KILL_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_KILL_FOCUS, 1)
 345 EVT_COMMAND_ENTER = wx.PyEventBinder( wxEVT_COMMAND_ENTER, 1)
 346
 347 EVT_IDLE = wx.PyEventBinder( wxEVT_IDLE )
 348
 349 EVT_UPDATE_UI = wx.PyEventBinder( wxEVT_UPDATE_UI, 1)
 350 EVT_UPDATE_UI_RANGE = wx.PyEventBinder( wxEVT_UPDATE_UI, 2)
 351
 352 EVT_CONTEXT_MENU = wx.PyEventBinder( wxEVT_CONTEXT_MENU )
 353
 354
 355 }
 356
 357 //---------------------------------------------------------------------------
 358 %newgroup;
 359
 360 class wxEvent : public wxObject {
 361 public:
 362     // wxEvent(int winid = 0, wxEventType commandType = wxEVT_NULL);     // *** This class is now an ABC
 363     ~wxEvent();
 364
 365     void SetEventType(wxEventType typ);
 366     wxEventType GetEventType() const;
 367     wxObject *GetEventObject() const;
 368     void SetEventObject(wxObject *obj);
 369     long GetTimestamp() const;
 370     void SetTimestamp(long ts = 0);
 371     int  GetId() const;
 372     void SetId(int Id);
 373
 374
 375     bool IsCommandEvent() const;
 376
 377     DocDeclStr(
 378         void , Skip(bool skip = true),
 379         "Called by an event handler, it controls whether additional event
 380 handlers bound to this event will be called after the current event
 381 handler returns.  Skip(false) (the default setting) will prevent
 382 additional event handlers from being called and control will be
 383 returned to the sender of the event immediately after the current
 384 handler has finished.  Skip(True) will cause the event processing
 385 system to continue searching for a handler function for this event.
 386 ", "");
 387
 388     bool GetSkipped() const;
 389
 390     // Determine if this event should be propagating to the parent window.
 391     bool ShouldPropagate() const;
 392
 393     // Stop an event from propagating to its parent window, returns the old
 394     // propagation level value
 395     int StopPropagation();
 396
 397     // Resume the event propagation by restoring the propagation level
 398     // (returned by StopPropagation())
 399     void ResumePropagation(int propagationLevel);
 400
 401     // this function is used to create a copy of the event polymorphically and
 402     // all derived classes must implement it because otherwise wxPostEvent()
 403     // for them wouldn't work (it needs to do a copy of the event)
 404     virtual wxEvent *Clone() /* =0*/;
 405 };
 406
 407
 408 //---------------------------------------------------------------------------
 409 %newgroup;
 410
 411 // Helper class to temporarily change an event not to propagate.
 412 class  wxPropagationDisabler
 413 {
 414 public:
 415     wxPropagationDisabler(wxEvent& event);
 416     ~wxPropagationDisabler();
 417 };
 418
 419
 420 // Another one to temporarily lower propagation level.
 421 class  wxPropagateOnce
 422 {
 423 public:
 424     wxPropagateOnce(wxEvent& event);
 425     ~wxPropagateOnce();
 426 };
 427
 428 //---------------------------------------------------------------------------
 429 %newgroup;
 430
 431 class wxCommandEvent : public wxEvent
 432 {
 433 public:
 434     wxCommandEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
 435
 436
 437 //     // Set/Get client data from controls
 438 //     void SetClientData(void* clientData) { m_clientData = clientData; }
 439 //     void *GetClientData() const { return m_clientData; }
 440
 441 //     // Set/Get client object from controls
 442 //     void SetClientObject(wxClientData* clientObject) { m_clientObject = clientObject; }
 443 //     void *GetClientObject() const { return m_clientObject; }
 444
 445
 446     // Get listbox selection if single-choice
 447     int GetSelection() const;
 448
 449     // Set/Get listbox/choice selection string
 450     void SetString(const wxString& s);
 451     wxString GetString() const;
 452
 453     // Get checkbox value
 454     bool IsChecked() const;
 455     %pythoncode { Checked = IsChecked }
 456
 457     // True if the listbox event was a selection.
 458     bool IsSelection() const;
 459
 460     void SetExtraLong(long extraLong);
 461     long GetExtraLong() const;
 462
 463     void SetInt(int i);
 464     long GetInt() const;
 465
 466     virtual wxEvent *Clone() const;
 467
 468 };
 469
 470 //---------------------------------------------------------------------------
 471 %newgroup;
 472
 473 // this class adds a possibility to react (from the user) code to a control
 474 // notification: allow or veto the operation being reported.
 475 class wxNotifyEvent : public wxCommandEvent
 476 {
 477 public:
 478     wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
 479
 480     // veto the operation (usually it's allowed by default)
 481     void Veto();
 482
 483     // allow the operation if it was disabled by default
 484     void Allow();
 485
 486     // for implementation code only: is the operation allowed?
 487     bool IsAllowed();
 488 };
 489
 490
 491 //---------------------------------------------------------------------------
 492 %newgroup;
 493
 494 // Scroll event class, derived form wxCommandEvent. wxScrollEvents are
 495 // sent by wxSlider and wxScrollBar.
 496 class  wxScrollEvent : public wxCommandEvent
 497 {
 498 public:
 499     wxScrollEvent(wxEventType commandType = wxEVT_NULL,
 500                   int winid = 0, int pos = 0, int orient = 0);
 501
 502     int GetOrientation() const;
 503     int GetPosition() const;
 504     void SetOrientation(int orient);
 505     void SetPosition(int pos);
 506 };
 507
 508
 509 //---------------------------------------------------------------------------
 510 %newgroup;
 511
 512 // ScrollWin event class, derived fom wxEvent. wxScrollWinEvents
 513 // are sent by wxWindow.
 514 class wxScrollWinEvent : public wxEvent
 515 {
 516 public:
 517     wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
 518                      int pos = 0, int orient = 0);
 519
 520     int GetOrientation() const;
 521     int GetPosition() const;
 522     void SetOrientation(int orient);
 523     void SetPosition(int pos);
 524 };
 525
 526 //---------------------------------------------------------------------------
 527 %newgroup;
 528
 529 // the symbolic names for the mouse buttons
 530 enum
 531 {
 532     wxMOUSE_BTN_ANY     = -1,
 533     wxMOUSE_BTN_NONE    = -1,
 534     wxMOUSE_BTN_LEFT    = 0,
 535     wxMOUSE_BTN_MIDDLE  = 1,
 536     wxMOUSE_BTN_RIGHT   = 2
 537 };
 538
 539
 540 // Mouse event class
 541 class  wxMouseEvent : public wxEvent
 542 {
 543 public:
 544     wxMouseEvent(wxEventType mouseType = wxEVT_NULL);
 545
 546     // Was it a button event? (*doesn't* mean: is any button *down*?)
 547     bool IsButton() const;
 548
 549     // Was it a down event from this (or any) button?
 550     bool ButtonDown(int but = wxMOUSE_BTN_ANY) const;
 551
 552     // Was it a dclick event from this (or any) button?
 553     bool ButtonDClick(int but = wxMOUSE_BTN_ANY) const;
 554
 555     // Was it a up event from this (or any) button?
 556     bool ButtonUp(int but = wxMOUSE_BTN_ANY) const;
 557
 558     // Was the given button changing state?
 559     bool Button(int but) const;
 560
 561     // Was the given button in Down state?
 562     bool ButtonIsDown(int but) const;
 563
 564     // Get the button which is changing state (wxMOUSE_BTN_NONE if none)
 565     int GetButton() const;
 566
 567     // Find state of shift/control keys
 568     bool ControlDown() const;
 569     bool MetaDown() const;
 570     bool AltDown() const;
 571     bool ShiftDown() const;
 572
 573     DocDeclStr(
 574         bool , CmdDown() const,
 575         "\"Cmd\" is a pseudo key which is the same as Control for PC and Unix
 576 platforms but the special \"Apple\" (a.k.a as \"Command\") key on
 577 Macs: it makes often sense to use it instead of, say, `ControlDown`
 578 because Cmd key is used for the same thing under Mac as Ctrl
 579 elsewhere. The Ctrl still exists, it's just not used for this
 580 purpose. So for non-Mac platforms this is the same as `ControlDown`
 581 and Macs this is the same as `MetaDown`.", "");
 582
 583     // Find which event was just generated
 584     bool LeftDown() const;
 585     bool MiddleDown() const;
 586     bool RightDown() const;
 587
 588     bool LeftUp() const;
 589     bool MiddleUp() const;
 590     bool RightUp() const;
 591
 592     bool LeftDClick() const;
 593     bool MiddleDClick() const;
 594     bool RightDClick() const;
 595
 596     // Find the current state of the mouse buttons (regardless
 597     // of current event type)
 598     bool LeftIsDown();
 599     bool MiddleIsDown();
 600     bool RightIsDown();
 601
 602     // True if a button is down and the mouse is moving
 603     bool Dragging() const;
 604
 605     // True if the mouse is moving, and no button is down
 606     bool Moving() const;
 607
 608     // True if the mouse is just entering the window
 609     bool Entering() const;
 610
 611     // True if the mouse is just leaving the window
 612     bool Leaving() const;
 613
 614
 615     DocStr(GetPosition,   // sets the docstring for both
 616            "Returns the position of the mouse in window coordinates when the event
 617 happened.", "");
 618     wxPoint GetPosition();
 619
 620     DocDeclAName(
 621         void, GetPosition(long *OUTPUT, long *OUTPUT),
 622         "GetPositionTuple() -> (x,y)",
 623         GetPositionTuple);
 624
 625     // Find the logical position of the event given the DC
 626     wxPoint GetLogicalPosition(const wxDC& dc) const;
 627
 628     // Get X position
 629     wxCoord GetX() const;
 630
 631     // Get Y position
 632     wxCoord GetY() const;
 633
 634     // Get wheel rotation, positive or negative indicates direction of
 635     // rotation.  Current devices all send an event when rotation is equal to
 636     // +/-WheelDelta, but this allows for finer resolution devices to be
 637     // created in the future.  Because of this you shouldn't assume that one
 638     // event is equal to 1 line or whatever, but you should be able to either
 639     // do partial line scrolling or wait until +/-WheelDelta rotation values
 640     // have been accumulated before scrolling.
 641     int GetWheelRotation() const;
 642
 643     // Get wheel delta, normally 120.  This is the threshold for action to be
 644     // taken, and one such action (for example, scrolling one increment)
 645     // should occur for each delta.
 646     int GetWheelDelta() const;
 647
 648     // Returns the configured number of lines (or whatever) to be scrolled per
 649     // wheel action.  Defaults to one.
 650     int GetLinesPerAction() const;
 651
 652     // Is the system set to do page scrolling?
 653     bool IsPageScroll() const;
 654
 655 public:
 656     wxCoord m_x, m_y;
 657
 658     bool          m_leftDown;
 659     bool          m_middleDown;
 660     bool          m_rightDown;
 661
 662     bool          m_controlDown;
 663     bool          m_shiftDown;
 664     bool          m_altDown;
 665     bool          m_metaDown;
 666
 667     int           m_wheelRotation;
 668     int           m_wheelDelta;
 669     int           m_linesPerAction;
 670 };
 671
 672 //---------------------------------------------------------------------------
 673 %newgroup;
 674
 675 // Cursor set event
 676 class wxSetCursorEvent : public wxEvent
 677 {
 678 public:
 679     wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0);
 680
 681     wxCoord GetX() const;
 682     wxCoord GetY() const;
 683
 684     void SetCursor(const wxCursor& cursor);
 685     const wxCursor& GetCursor() const;
 686     bool HasCursor() const;
 687 };
 688
 689 //---------------------------------------------------------------------------
 690 %newgroup;
 691
 692 // Keyboard input event class
 693
 694 class wxKeyEvent : public wxEvent
 695 {
 696 public:
 697     wxKeyEvent(wxEventType keyType = wxEVT_NULL);
 698
 699     // Find state of shift/control keys
 700     bool ControlDown() const;
 701     bool MetaDown() const;
 702     bool AltDown() const;
 703     bool ShiftDown() const;
 704
 705     DocDeclStr(
 706         bool , CmdDown() const,
 707         "\"Cmd\" is a pseudo key which is the same as Control for PC and Unix
 708 platforms but the special \"Apple\" (a.k.a as \"Command\") key on
 709 Macs: it makes often sense to use it instead of, say, `ControlDown`
 710 because Cmd key is used for the same thing under Mac as Ctrl
 711 elsewhere. The Ctrl still exists, it's just not used for this
 712 purpose. So for non-Mac platforms this is the same as `ControlDown`
 713 and Macs this is the same as `MetaDown`.", "");
 714
 715
 716
 717     // exclude MetaDown() from HasModifiers() because NumLock under X is often
 718     // configured as mod2 modifier, yet the key events even when it is pressed
 719     // should be processed normally, not like Ctrl- or Alt-key
 720     bool HasModifiers() const;
 721
 722     // get the key code: an ASCII7 char or an element of wxKeyCode enum
 723     int GetKeyCode() const;
 724     %pythoncode { KeyCode = GetKeyCode }
 725
 726     %extend {
 727         int GetUnicodeKey() {
 728         %#if wxUSE_UNICODE
 729             return self->GetUnicodeKey();
 730         %#else
 731             return 0;
 732         %#endif
 733         }
 734     }
 735     %pythoncode { GetUniChar = GetUnicodeKey }
 736
 737
 738     // get the raw key code (platform-dependent)
 739     wxUint32 GetRawKeyCode() const;
 740
 741     // get the raw key flags (platform-dependent)
 742     wxUint32 GetRawKeyFlags() const;
 743
 744
 745     DocStr(GetPosition,   // sets the docstring for both
 746            "Find the position of the event.", "");
 747     wxPoint GetPosition();
 748
 749     DocDeclAName(
 750         void, GetPosition(long *OUTPUT, long *OUTPUT),
 751         "GetPositionTuple() -> (x,y)",
 752         GetPositionTuple);
 753
 754     // Get X position
 755     wxCoord GetX() const;
 756
 757     // Get Y position
 758     wxCoord GetY() const;
 759
 760 public:
 761     wxCoord       m_x, m_y;
 762
 763     long          m_keyCode;
 764
 765     bool          m_controlDown;
 766     bool          m_shiftDown;
 767     bool          m_altDown;
 768     bool          m_metaDown;
 769     bool          m_scanCode;
 770
 771     // these fields contain the platform-specific information about
 772     // key that was pressed
 773     wxUint32      m_rawCode;
 774     wxUint32      m_rawFlags;
 775 };
 776
 777 //---------------------------------------------------------------------------
 778 %newgroup;
 779
 780 // Size event class
 781 class wxSizeEvent : public wxEvent
 782 {
 783 public:
 784     wxSizeEvent(const wxSize& sz=wxDefaultSize, int winid = 0);
 785
 786     wxSize GetSize() const;
 787     wxRect GetRect() const;
 788     void SetRect(wxRect rect);
 789     %extend {
 790         void SetSize(wxSize size) {
 791             self->m_size = size;
 792         }
 793     }
 794
 795 public:
 796     wxSize m_size;
 797     wxRect m_rect; // Used for wxEVT_SIZING
 798 };
 799
 800
 801 //---------------------------------------------------------------------------
 802 %newgroup;
 803
 804 // Move event class
 805 class wxMoveEvent : public wxEvent
 806 {
 807 public:
 808     wxMoveEvent(const wxPoint& pos=wxDefaultPosition, int winid = 0);
 809
 810     wxPoint GetPosition() const;
 811     wxRect GetRect() const;
 812     void SetRect(const wxRect& rect);
 813     void SetPosition(const wxPoint& pos);
 814
 815     %pythoncode {
 816         m_pos =  property(GetPosition, SetPosition)
 817         m_rect = property(GetRect, SetRect)
 818     }
 819 };
 820
 821 //---------------------------------------------------------------------------
 822 %newgroup;
 823
 824 // Paint event class
 825 class wxPaintEvent : public wxEvent
 826 {
 827 public:
 828     wxPaintEvent(int Id = 0);
 829 };
 830
 831
 832 class wxNcPaintEvent : public wxEvent
 833 {
 834 public:
 835     wxNcPaintEvent(int winid = 0);
 836 };
 837
 838 //---------------------------------------------------------------------------
 839 %newgroup;
 840
 841 class wxEraseEvent : public wxEvent
 842 {
 843 public:
 844     wxEraseEvent(int Id = 0, wxDC *dc = (wxDC *) NULL);
 845
 846     wxDC *GetDC() const;
 847 };
 848
 849
 850 //---------------------------------------------------------------------------
 851 %newgroup;
 852
 853 class wxFocusEvent : public wxEvent
 854 {
 855 public:
 856     wxFocusEvent(wxEventType type = wxEVT_NULL, int winid = 0);
 857
 858     // The window associated with this event is the window which had focus
 859     // before for SET event and the window which will have focus for the KILL
 860     // one. NB: it may be NULL in both cases!
 861     wxWindow *GetWindow() const;
 862     void SetWindow(wxWindow *win);
 863 };
 864
 865 //---------------------------------------------------------------------------
 866 %newgroup;
 867
 868 // wxChildFocusEvent notifies the parent that a child has got the focus: unlike
 869 // wxFocusEvent it is propagated upwards the window chain
 870 class wxChildFocusEvent : public wxCommandEvent
 871 {
 872 public:
 873     wxChildFocusEvent(wxWindow *win = NULL);
 874
 875     wxWindow *GetWindow() const;
 876 };
 877
 878 //---------------------------------------------------------------------------
 879 %newgroup;
 880
 881 class wxActivateEvent : public wxEvent
 882 {
 883 public:
 884     wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = true, int Id = 0);
 885     bool GetActive() const;
 886 };
 887
 888
 889 //---------------------------------------------------------------------------
 890 %newgroup;
 891
 892 class wxInitDialogEvent : public wxEvent
 893 {
 894 public:
 895     wxInitDialogEvent(int Id = 0);
 896 };
 897
 898
 899 //---------------------------------------------------------------------------
 900 %newgroup;
 901
 902 class wxMenuEvent : public wxEvent
 903 {
 904 public:
 905     wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0, wxMenu* menu = NULL);
 906
 907     // only for wxEVT_MENU_HIGHLIGHT
 908     int GetMenuId() const;
 909
 910     // only for wxEVT_MENU_OPEN/CLOSE
 911     bool IsPopup() const;
 912
 913     // only for wxEVT_MENU_OPEN/CLOSE
 914     wxMenu* GetMenu() const;
 915 };
 916
 917 //---------------------------------------------------------------------------
 918 %newgroup;
 919
 920 // Window close or session close event class
 921 class wxCloseEvent : public wxEvent
 922 {
 923 public:
 924     wxCloseEvent(wxEventType type = wxEVT_NULL, int winid = 0);
 925
 926     void SetLoggingOff(bool logOff);
 927     bool GetLoggingOff() const;
 928
 929     void Veto(bool veto = true);
 930     void SetCanVeto(bool canVeto);
 931
 932     bool CanVeto() const;
 933     bool GetVeto() const;
 934 };
 935
 936
 937 //---------------------------------------------------------------------------
 938 %newgroup;
 939
 940 class wxShowEvent : public wxEvent
 941 {
 942 public:
 943     wxShowEvent(int winid = 0, bool show = false);
 944
 945     void SetShow(bool show);
 946     bool GetShow() const;
 947
 948 };
 949
 950
 951 //---------------------------------------------------------------------------
 952 %newgroup;
 953
 954 class wxIconizeEvent: public wxEvent
 955 {
 956 public:
 957     wxIconizeEvent(int id = 0, bool iconized = true);
 958     bool Iconized();
 959 };
 960
 961
 962 //---------------------------------------------------------------------------
 963 %newgroup;
 964
 965 class wxMaximizeEvent: public wxEvent
 966 {
 967 public:
 968     wxMaximizeEvent(int id = 0);
 969 };
 970
 971 //---------------------------------------------------------------------------
 972 %newgroup;
 973
 974 class wxDropFilesEvent: public wxEvent
 975 {
 976 public:
 977     wxPoint GetPosition();
 978     int GetNumberOfFiles();
 979
 980     %extend {
 981         PyObject* GetFiles() {
 982             int         count = self->GetNumberOfFiles();
 983             wxString*   files = self->GetFiles();
 984             PyObject*   list  = PyList_New(count);
 985
 986             if (!list) {
 987                 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
 988                 return NULL;
 989             }
 990
 991             for (int i=0; i<count; i++) {
 992                 PyList_SetItem(list, i, wx2PyString(files[i]));
 993             }
 994             return list;
 995         }
 996     }
 997 };
 998
 999
1000
1001 //---------------------------------------------------------------------------
1002 %newgroup;
1003
1004
1005 // Whether to always send update events to windows, or
1006 // to only send update events to those with the
1007 // wxWS_EX_PROCESS_UI_UPDATES style.
1008
1009 enum wxUpdateUIMode
1010 {
1011         // Send UI update events to all windows
1012     wxUPDATE_UI_PROCESS_ALL,
1013
1014         // Send UI update events to windows that have
1015         // the wxWS_EX_PROCESS_UI_UPDATES flag specified
1016     wxUPDATE_UI_PROCESS_SPECIFIED
1017 };
1018
1019
1020
1021 class wxUpdateUIEvent : public wxCommandEvent
1022 {
1023 public:
1024     wxUpdateUIEvent(wxWindowID commandId = 0);
1025
1026     bool GetChecked() const;
1027     bool GetEnabled() const;
1028     wxString GetText() const;
1029     bool GetSetText() const;
1030     bool GetSetChecked() const;
1031     bool GetSetEnabled() const;
1032
1033     void Check(bool check);
1034     void Enable(bool enable);
1035     void SetText(const wxString& text);
1036
1037     // Sets the interval between updates in milliseconds.
1038     // Set to -1 to disable updates, or to 0 to update as frequently as possible.
1039     static void SetUpdateInterval(long updateInterval);
1040
1041     // Returns the current interval between updates in milliseconds
1042     static long GetUpdateInterval();
1043
1044     // Can we update this window?
1045     static bool CanUpdate(wxWindow *win);
1046
1047     // Reset the update time to provide a delay until the next
1048     // time we should update
1049     static void ResetUpdateTime();
1050
1051     // Specify how wxWindows will send update events: to
1052     // all windows, or only to those which specify that they
1053     // will process the events.
1054     static void SetMode(wxUpdateUIMode mode);
1055
1056     // Returns the UI update mode
1057     static wxUpdateUIMode GetMode();
1058 };
1059
1060 //---------------------------------------------------------------------------
1061 %newgroup;
1062
1063 class wxSysColourChangedEvent: public wxEvent {
1064 public:
1065     wxSysColourChangedEvent();
1066 };
1067
1068 //---------------------------------------------------------------------------
1069 %newgroup;
1070
1071
1072 //  wxEVT_MOUSE_CAPTURE_CHANGED
1073 //  The window losing the capture receives this message
1074 //  (even if it released the capture itself).
1075 class wxMouseCaptureChangedEvent : public wxEvent
1076 {
1077 public:
1078     wxMouseCaptureChangedEvent(wxWindowID winid = 0, wxWindow* gainedCapture = NULL);
1079
1080     wxWindow* GetCapturedWindow() const;
1081 };
1082
1083 //---------------------------------------------------------------------------
1084 %newgroup;
1085
1086 class wxDisplayChangedEvent : public wxEvent
1087 {
1088 public:
1089     wxDisplayChangedEvent();
1090 };
1091
1092 //---------------------------------------------------------------------------
1093 %newgroup;
1094
1095 class  wxPaletteChangedEvent : public wxEvent
1096 {
1097 public:
1098     wxPaletteChangedEvent(wxWindowID id = 0);
1099
1100     void SetChangedWindow(wxWindow* win);
1101     wxWindow* GetChangedWindow();
1102
1103 };
1104
1105 //---------------------------------------------------------------------------
1106 %newgroup;
1107
1108
1109 //  wxEVT_QUERY_NEW_PALETTE
1110 //  Indicates the window is getting keyboard focus and should re-do its palette.
1111 class wxQueryNewPaletteEvent : public wxEvent
1112 {
1113 public:
1114     wxQueryNewPaletteEvent(wxWindowID winid = 0);
1115
1116     // App sets this if it changes the palette.
1117     void SetPaletteRealized(bool realized);
1118     bool GetPaletteRealized() const;
1119 };
1120
1121 //---------------------------------------------------------------------------
1122 %newgroup;
1123
1124
1125 //  Event generated by dialog navigation keys
1126 //  wxEVT_NAVIGATION_KEY
1127
1128 class wxNavigationKeyEvent : public wxEvent
1129 {
1130 public:
1131     wxNavigationKeyEvent();
1132
1133     // direction: forward (True) or backward (False)
1134     bool GetDirection() const;
1135     void SetDirection(bool forward);
1136
1137     // it may be a window change event (MDI, notebook pages...) or a control
1138     // change event
1139     bool IsWindowChange() const;
1140     void SetWindowChange(bool ischange);
1141
1142     // Set to true under MSW if the event was generated using the tab key.
1143     // This is required for proper navogation over radio buttons
1144     bool IsFromTab() const;
1145     void SetFromTab(bool bIs);
1146
1147     void SetFlags(long flags);
1148
1149     // the child which has the focus currently (may be NULL - use
1150     // wxWindow::FindFocus then)
1151     wxWindow* GetCurrentFocus() const;
1152     void SetCurrentFocus(wxWindow *win);
1153
1154     enum {
1155         IsBackward,
1156         IsForward,
1157         WinChange,
1158         FromTab
1159     };
1160 };
1161
1162
1163 //---------------------------------------------------------------------------
1164 %newgroup;
1165
1166 // Window creation/destruction events: the first is sent as soon as window is
1167 // created (i.e. the underlying GUI object exists), but when the C++ object is
1168 // fully initialized (so virtual functions may be called). The second,
1169 // wxEVT_DESTROY, is sent right before the window is destroyed - again, it's
1170 // still safe to call virtual functions at this moment
1171
1172 class wxWindowCreateEvent : public wxCommandEvent
1173 {
1174 public:
1175     wxWindowCreateEvent(wxWindow *win = NULL);
1176     wxWindow *GetWindow() const;
1177 };
1178
1179 class wxWindowDestroyEvent : public wxCommandEvent
1180 {
1181 public:
1182     wxWindowDestroyEvent(wxWindow *win = NULL);
1183     wxWindow *GetWindow() const;
1184 };
1185
1186
1187 //---------------------------------------------------------------------------
1188 %newgroup;
1189
1190 // A Context event is sent when the user right clicks on a window or
1191 // presses Shift-F10
1192 // NOTE : Under windows this is a repackaged WM_CONTETXMENU message
1193 //        Under other systems it may have to be generated from a right click event
1194 /*
1195  wxEVT_CONTEXT_MENU
1196 */
1197
1198 class wxContextMenuEvent : public wxCommandEvent
1199 {
1200 public:
1201     wxContextMenuEvent(wxEventType type = wxEVT_NULL,
1202                        wxWindowID winid = 0,
1203                        const wxPoint& pt = wxDefaultPosition);
1204
1205     // Position of event (in screen coordinates)
1206     const wxPoint& GetPosition() const;
1207     void SetPosition(const wxPoint& pos);
1208 };
1209
1210 //---------------------------------------------------------------------------
1211 %newgroup;
1212
1213 // Whether to always send idle events to windows, or
1214 // to only send update events to those with the
1215 // wxWS_EX_PROCESS_IDLE style.
1216
1217 enum wxIdleMode
1218 {
1219         // Send idle events to all windows
1220     wxIDLE_PROCESS_ALL,
1221
1222         // Send idle events to windows that have
1223         // the wxWS_EX_PROCESS_IDLE flag specified
1224     wxIDLE_PROCESS_SPECIFIED
1225 };
1226
1227
1228 class wxIdleEvent : public wxEvent
1229 {
1230 public:
1231     wxIdleEvent();
1232
1233     void RequestMore(bool needMore = true);
1234     bool MoreRequested() const;
1235
1236     // Specify how wxWindows will send idle events: to
1237     // all windows, or only to those which specify that they
1238     // will process the events.
1239     static void SetMode(wxIdleMode mode);
1240
1241     // Returns the idle event mode
1242     static wxIdleMode GetMode();
1243
1244     // Can we send an idle event?
1245     static bool CanSend(wxWindow* win);
1246 };
1247
1248 //---------------------------------------------------------------------------
1249 %newgroup;
1250
1251 // These classes can be derived from in Python and passed through the event
1252 // system without loosing anything.  They do this by keeping a reference to
1253 // themselves and some special case handling in wxPyCallback::EventThunker.
1254
1255 class wxPyEvent : public wxEvent {
1256 public:
1257     %pythonAppend wxPyEvent     "self.SetSelf(self)"
1258     wxPyEvent(int winid=0, wxEventType commandType = wxEVT_NULL );
1259     ~wxPyEvent();
1260
1261
1262     void SetSelf(PyObject* self);
1263     PyObject* GetSelf();
1264 };
1265
1266
1267 class wxPyCommandEvent : public wxCommandEvent {
1268 public:
1269     %pythonAppend wxPyCommandEvent     "self.SetSelf(self)"
1270     wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0);
1271     ~wxPyCommandEvent();
1272
1273     void SetSelf(PyObject* self);
1274     PyObject* GetSelf();
1275 };
1276
1277
1278
1279 //---------------------------------------------------------------------------
1280
1281
1282 class wxDateEvent : public wxCommandEvent
1283 {
1284 public:
1285     wxDateEvent(wxWindow *win, const wxDateTime& dt, wxEventType type);
1286
1287     const wxDateTime& GetDate() const;
1288     void SetDate(const wxDateTime &date);
1289
1290 };
1291
1292
1293 %constant wxEventType wxEVT_DATE_CHANGED;
1294
1295 %pythoncode {
1296     EVT_DATE_CHANGED = wx.PyEventBinder( wxEVT_DATE_CHANGED, 1 )
1297 }
1298
1299
1300 //---------------------------------------------------------------------------