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 %constant wxEventType wxEVT_HIBERNATE;
 167
 168
 169 // Generic command events
 170 // Note: a click is a higher-level event than button down/up
 171 %constant wxEventType wxEVT_COMMAND_LEFT_CLICK;
 172 %constant wxEventType wxEVT_COMMAND_LEFT_DCLICK;
 173 %constant wxEventType wxEVT_COMMAND_RIGHT_CLICK;
 174 %constant wxEventType wxEVT_COMMAND_RIGHT_DCLICK;
 175 %constant wxEventType wxEVT_COMMAND_SET_FOCUS;
 176 %constant wxEventType wxEVT_COMMAND_KILL_FOCUS;
 177 %constant wxEventType wxEVT_COMMAND_ENTER;
 178
 179
 180
 181 %pythoncode {
 182 %#
 183 %# Create some event binders
 184 EVT_SIZE = wx.PyEventBinder( wxEVT_SIZE )
 185 EVT_SIZING = wx.PyEventBinder( wxEVT_SIZING )
 186 EVT_MOVE = wx.PyEventBinder( wxEVT_MOVE )
 187 EVT_MOVING = wx.PyEventBinder( wxEVT_MOVING )
 188 EVT_CLOSE = wx.PyEventBinder( wxEVT_CLOSE_WINDOW )
 189 EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
 190 EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
 191 EVT_PAINT = wx.PyEventBinder( wxEVT_PAINT )
 192 EVT_NC_PAINT = wx.PyEventBinder( wxEVT_NC_PAINT )
 193 EVT_ERASE_BACKGROUND = wx.PyEventBinder( wxEVT_ERASE_BACKGROUND )
 194 EVT_CHAR = wx.PyEventBinder( wxEVT_CHAR )
 195 EVT_KEY_DOWN = wx.PyEventBinder( wxEVT_KEY_DOWN )
 196 EVT_KEY_UP = wx.PyEventBinder( wxEVT_KEY_UP )
 197 EVT_HOTKEY = wx.PyEventBinder( wxEVT_HOTKEY, 1)
 198 EVT_CHAR_HOOK = wx.PyEventBinder( wxEVT_CHAR_HOOK )
 199 EVT_MENU_OPEN = wx.PyEventBinder( wxEVT_MENU_OPEN )
 200 EVT_MENU_CLOSE = wx.PyEventBinder( wxEVT_MENU_CLOSE )
 201 EVT_MENU_HIGHLIGHT = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT, 1)
 202 EVT_MENU_HIGHLIGHT_ALL = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT )
 203 EVT_SET_FOCUS = wx.PyEventBinder( wxEVT_SET_FOCUS )
 204 EVT_KILL_FOCUS = wx.PyEventBinder( wxEVT_KILL_FOCUS )
 205 EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS )
 206 EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE )
 207 EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP )
 208 EVT_HIBERNATE = wx.PyEventBinder( wxEVT_HIBERNATE )
 209 EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
 210 EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
 211 EVT_DROP_FILES = wx.PyEventBinder( wxEVT_DROP_FILES )
 212 EVT_INIT_DIALOG = wx.PyEventBinder( wxEVT_INIT_DIALOG )
 213 EVT_SYS_COLOUR_CHANGED = wx.PyEventBinder( wxEVT_SYS_COLOUR_CHANGED )
 214 EVT_DISPLAY_CHANGED = wx.PyEventBinder( wxEVT_DISPLAY_CHANGED )
 215 EVT_SHOW = wx.PyEventBinder( wxEVT_SHOW )
 216 EVT_MAXIMIZE = wx.PyEventBinder( wxEVT_MAXIMIZE )
 217 EVT_ICONIZE = wx.PyEventBinder( wxEVT_ICONIZE )
 218 EVT_NAVIGATION_KEY = wx.PyEventBinder( wxEVT_NAVIGATION_KEY )
 219 EVT_PALETTE_CHANGED = wx.PyEventBinder( wxEVT_PALETTE_CHANGED )
 220 EVT_QUERY_NEW_PALETTE = wx.PyEventBinder( wxEVT_QUERY_NEW_PALETTE )
 221 EVT_WINDOW_CREATE = wx.PyEventBinder( wxEVT_CREATE )
 222 EVT_WINDOW_DESTROY = wx.PyEventBinder( wxEVT_DESTROY )
 223 EVT_SET_CURSOR = wx.PyEventBinder( wxEVT_SET_CURSOR )
 224 EVT_MOUSE_CAPTURE_CHANGED = wx.PyEventBinder( wxEVT_MOUSE_CAPTURE_CHANGED )
 225
 226 EVT_LEFT_DOWN = wx.PyEventBinder( wxEVT_LEFT_DOWN )
 227 EVT_LEFT_UP = wx.PyEventBinder( wxEVT_LEFT_UP )
 228 EVT_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_MIDDLE_DOWN )
 229 EVT_MIDDLE_UP = wx.PyEventBinder( wxEVT_MIDDLE_UP )
 230 EVT_RIGHT_DOWN = wx.PyEventBinder( wxEVT_RIGHT_DOWN )
 231 EVT_RIGHT_UP = wx.PyEventBinder( wxEVT_RIGHT_UP )
 232 EVT_MOTION = wx.PyEventBinder( wxEVT_MOTION )
 233 EVT_LEFT_DCLICK = wx.PyEventBinder( wxEVT_LEFT_DCLICK )
 234 EVT_MIDDLE_DCLICK = wx.PyEventBinder( wxEVT_MIDDLE_DCLICK )
 235 EVT_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_RIGHT_DCLICK )
 236 EVT_LEAVE_WINDOW = wx.PyEventBinder( wxEVT_LEAVE_WINDOW )
 237 EVT_ENTER_WINDOW = wx.PyEventBinder( wxEVT_ENTER_WINDOW )
 238 EVT_MOUSEWHEEL = wx.PyEventBinder( wxEVT_MOUSEWHEEL )
 239
 240 EVT_MOUSE_EVENTS = wx.PyEventBinder([ wxEVT_LEFT_DOWN,
 241                                      wxEVT_LEFT_UP,
 242                                      wxEVT_MIDDLE_DOWN,
 243                                      wxEVT_MIDDLE_UP,
 244                                      wxEVT_RIGHT_DOWN,
 245                                      wxEVT_RIGHT_UP,
 246                                      wxEVT_MOTION,
 247                                      wxEVT_LEFT_DCLICK,
 248                                      wxEVT_MIDDLE_DCLICK,
 249                                      wxEVT_RIGHT_DCLICK,
 250                                      wxEVT_ENTER_WINDOW,
 251                                      wxEVT_LEAVE_WINDOW,
 252                                      wxEVT_MOUSEWHEEL
 253                                      ])
 254
 255
 256 %# Scrolling from wxWindow (sent to wxScrolledWindow)
 257 EVT_SCROLLWIN = wx.PyEventBinder([ wxEVT_SCROLLWIN_TOP,
 258                                   wxEVT_SCROLLWIN_BOTTOM,
 259                                   wxEVT_SCROLLWIN_LINEUP,
 260                                   wxEVT_SCROLLWIN_LINEDOWN,
 261                                   wxEVT_SCROLLWIN_PAGEUP,
 262                                   wxEVT_SCROLLWIN_PAGEDOWN,
 263                                   wxEVT_SCROLLWIN_THUMBTRACK,
 264                                   wxEVT_SCROLLWIN_THUMBRELEASE,
 265                                   ])
 266
 267 EVT_SCROLLWIN_TOP = wx.PyEventBinder( wxEVT_SCROLLWIN_TOP )
 268 EVT_SCROLLWIN_BOTTOM = wx.PyEventBinder( wxEVT_SCROLLWIN_BOTTOM )
 269 EVT_SCROLLWIN_LINEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEUP )
 270 EVT_SCROLLWIN_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEDOWN )
 271 EVT_SCROLLWIN_PAGEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEUP )
 272 EVT_SCROLLWIN_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEDOWN )
 273 EVT_SCROLLWIN_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBTRACK )
 274 EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE )
 275
 276 %# Scrolling from wx.Slider and wx.ScrollBar
 277 EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
 278                                wxEVT_SCROLL_BOTTOM,
 279                                wxEVT_SCROLL_LINEUP,
 280                                wxEVT_SCROLL_LINEDOWN,
 281                                wxEVT_SCROLL_PAGEUP,
 282                                wxEVT_SCROLL_PAGEDOWN,
 283                                wxEVT_SCROLL_THUMBTRACK,
 284                                wxEVT_SCROLL_THUMBRELEASE,
 285                                wxEVT_SCROLL_ENDSCROLL,
 286                                ])
 287
 288 EVT_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP )
 289 EVT_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM )
 290 EVT_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP )
 291 EVT_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN )
 292 EVT_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP )
 293 EVT_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN )
 294 EVT_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK )
 295 EVT_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE )
 296 EVT_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL )
 297
 298 %# Scrolling from wx.Slider and wx.ScrollBar, with an id
 299 EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
 300                                        wxEVT_SCROLL_BOTTOM,
 301                                        wxEVT_SCROLL_LINEUP,
 302                                        wxEVT_SCROLL_LINEDOWN,
 303                                        wxEVT_SCROLL_PAGEUP,
 304                                        wxEVT_SCROLL_PAGEDOWN,
 305                                        wxEVT_SCROLL_THUMBTRACK,
 306                                        wxEVT_SCROLL_THUMBRELEASE,
 307                                        wxEVT_SCROLL_ENDSCROLL,
 308                                        ], 1)
 309
 310 EVT_COMMAND_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP, 1)
 311 EVT_COMMAND_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM, 1)
 312 EVT_COMMAND_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP, 1)
 313 EVT_COMMAND_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN, 1)
 314 EVT_COMMAND_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP, 1)
 315 EVT_COMMAND_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN, 1)
 316 EVT_COMMAND_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1)
 317 EVT_COMMAND_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE, 1)
 318 EVT_COMMAND_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL, 1)
 319
 320 EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1)
 321 EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1)
 322 EVT_CHOICE = wx.PyEventBinder( wxEVT_COMMAND_CHOICE_SELECTED, 1)
 323 EVT_LISTBOX = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_SELECTED, 1)
 324 EVT_LISTBOX_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, 1)
 325 EVT_MENU = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 1)
 326 EVT_MENU_RANGE = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 2)
 327 EVT_SLIDER = wx.PyEventBinder( wxEVT_COMMAND_SLIDER_UPDATED, 1)
 328 EVT_RADIOBOX = wx.PyEventBinder( wxEVT_COMMAND_RADIOBOX_SELECTED, 1)
 329 EVT_RADIOBUTTON = wx.PyEventBinder( wxEVT_COMMAND_RADIOBUTTON_SELECTED, 1)
 330
 331 EVT_SCROLLBAR = wx.PyEventBinder( wxEVT_COMMAND_SCROLLBAR_UPDATED, 1)
 332 EVT_VLBOX = wx.PyEventBinder( wxEVT_COMMAND_VLBOX_SELECTED, 1)
 333 EVT_COMBOBOX = wx.PyEventBinder( wxEVT_COMMAND_COMBOBOX_SELECTED, 1)
 334 EVT_TOOL = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 1)
 335 EVT_TOOL_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 2)
 336 EVT_TOOL_RCLICKED = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 1)
 337 EVT_TOOL_RCLICKED_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 2)
 338 EVT_TOOL_ENTER = wx.PyEventBinder( wxEVT_COMMAND_TOOL_ENTER, 1)
 339 EVT_CHECKLISTBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, 1)
 340
 341
 342 EVT_COMMAND_LEFT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_CLICK, 1)
 343 EVT_COMMAND_LEFT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_DCLICK, 1)
 344 EVT_COMMAND_RIGHT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_CLICK, 1)
 345 EVT_COMMAND_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_DCLICK, 1)
 346 EVT_COMMAND_SET_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_SET_FOCUS, 1)
 347 EVT_COMMAND_KILL_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_KILL_FOCUS, 1)
 348 EVT_COMMAND_ENTER = wx.PyEventBinder( wxEVT_COMMAND_ENTER, 1)
 349
 350 EVT_IDLE = wx.PyEventBinder( wxEVT_IDLE )
 351
 352 EVT_UPDATE_UI = wx.PyEventBinder( wxEVT_UPDATE_UI, 1)
 353 EVT_UPDATE_UI_RANGE = wx.PyEventBinder( wxEVT_UPDATE_UI, 2)
 354
 355 EVT_CONTEXT_MENU = wx.PyEventBinder( wxEVT_CONTEXT_MENU )
 356
 357
 358 }
 359
 360 //---------------------------------------------------------------------------
 361 %newgroup;
 362
 363 DocStr(wxEvent,
 364 "An event is a structure holding information about an event passed to a
 365 callback or member function. wx.Event is an abstract base class for
 366 other event classes", "");
 367
 368 class wxEvent : public wxObject {
 369 public:
 370     // wxEvent(int winid = 0, wxEventType commandType = wxEVT_NULL);     // *** This class is now an ABC
 371     ~wxEvent();
 372
 373     DocDeclStr(
 374         void , SetEventType(wxEventType typ),
 375         "Sets the specific type of the event.", "");
 376
 377     DocDeclStr(
 378         wxEventType , GetEventType() const,
 379         "Returns the identifier of the given event type, such as
 380 ``wxEVT_COMMAND_BUTTON_CLICKED``.", "");
 381
 382     DocDeclStr(
 383         wxObject *, GetEventObject() const,
 384         "Returns the object (usually a window) associated with the event, if
 385 any.", "");
 386
 387     DocDeclStr(
 388         void , SetEventObject(wxObject *obj),
 389         "Sets the originating object, or in other words, obj is normally the
 390 object that is sending the event.", "");
 391
 392     long GetTimestamp() const;
 393     void SetTimestamp(long ts = 0);
 394
 395     DocDeclStr(
 396         int  , GetId() const,
 397         "Returns the identifier associated with this event, such as a button
 398 command id.", "");
 399
 400     DocDeclStr(
 401         void , SetId(int Id),
 402         "Set's the ID for the event.  This is usually the ID of the window that
 403 is sending the event, but it can also be a command id from a menu
 404 item, etc.", "");
 405
 406
 407
 408     DocDeclStr(
 409         bool , IsCommandEvent() const,
 410         "Returns true if the event is or is derived from `wx.CommandEvent` else
 411 it returns false. Note: Exists only for optimization purposes.", "");
 412
 413
 414     DocDeclStr(
 415         void , Skip(bool skip = true),
 416         "Called by an event handler, it controls whether additional event
 417 handlers bound to this event will be called after the current event
 418 handler returns.  Skip(false) (the default setting) will prevent
 419 additional event handlers from being called and control will be
 420 returned to the sender of the event immediately after the current
 421 handler has finished.  Skip(True) will cause the event processing
 422 system to continue searching for a handler function for this event.
 423 ", "");
 424
 425     DocDeclStr(
 426         bool , GetSkipped() const,
 427         "Returns true if the event handler should be skipped, false otherwise.
 428 :see: `Skip`", "");
 429
 430
 431     DocDeclStr(
 432         bool , ShouldPropagate() const,
 433         "Test if this event should be propagated to the parent window or not,
 434 i.e. if the propagation level is currently greater than 0.", "");
 435
 436
 437     // Stop an event from propagating to its parent window, returns the old
 438     // propagation level value
 439     DocDeclStr(
 440         int , StopPropagation(),
 441         "Stop the event from propagating to its parent window.  Returns the old
 442 propagation level value which may be later passed to
 443 `ResumePropagation` to allow propagating the event again.", "");
 444
 445
 446     DocDeclStr(
 447         void , ResumePropagation(int propagationLevel),
 448         "Resume the event propagation by restoring the propagation level.  (For
 449 example, you can use the value returned by an earlier call to
 450 `StopPropagation`.)
 451 ", "");
 452
 453
 454     // this function is used to create a copy of the event polymorphically and
 455     // all derived classes must implement it because otherwise wxPostEvent()
 456     // for them wouldn't work (it needs to do a copy of the event)
 457     virtual wxEvent *Clone() /* =0*/;
 458 };
 459
 460
 461 //---------------------------------------------------------------------------
 462 %newgroup;
 463
 464 DocStr(wxPropagationDisabler,
 465 "Helper class to temporarily change an event not to propagate.  Simply
 466 create an instance of this class and then whe it is destroyed the
 467 propogation of the event will be restored.", "");
 468 class  wxPropagationDisabler
 469 {
 470 public:
 471     wxPropagationDisabler(wxEvent& event);
 472     ~wxPropagationDisabler();
 473 };
 474
 475
 476 DocStr( wxPropagateOnce,
 477 "A helper class that will temporarily lower propagation level of an
 478 event.  Simply create an instance of this class and then whe it is
 479 destroyed the propogation of the event will be restored.", "");
 480 class  wxPropagateOnce
 481 {
 482 public:
 483     wxPropagateOnce(wxEvent& event);
 484     ~wxPropagateOnce();
 485 };
 486
 487 //---------------------------------------------------------------------------
 488 %newgroup;
 489
 490 DocStr(wxCommandEvent,
 491 "This event class contains information about command events, which
 492 originate from a variety of simple controls, as well as menus and
 493 toolbars.", "");
 494
 495 class wxCommandEvent : public wxEvent
 496 {
 497 public:
 498     wxCommandEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
 499
 500
 501 //     // Set/Get client data from controls
 502 //     void SetClientData(void* clientData) { m_clientData = clientData; }
 503 //     void *GetClientData() const { return m_clientData; }
 504
 505 //     // Set/Get client object from controls
 506 //     void SetClientObject(wxClientData* clientObject) { m_clientObject = clientObject; }
 507 //     void *GetClientObject() const { return m_clientObject; }
 508
 509
 510     DocDeclStr(
 511         int , GetSelection() const,
 512         "Returns item index for a listbox or choice selection event (not valid
 513 for a deselection).", "");
 514
 515
 516     void SetString(const wxString& s);
 517     DocDeclStr(
 518         wxString , GetString() const,
 519         "Returns item string for a listbox or choice selection event (not valid
 520 for a deselection).", "");
 521
 522
 523     DocDeclStr(
 524         bool , IsChecked() const,
 525         "This method can be used with checkbox and menu events: for the
 526 checkboxes, the method returns true for a selection event and false
 527 for a deselection one. For the menu events, this method indicates if
 528 the menu item just has become checked or unchecked (and thus only
 529 makes sense for checkable menu items).", "");
 530
 531     %pythoncode { Checked = IsChecked }
 532
 533     DocDeclStr(
 534         bool , IsSelection() const,
 535         "For a listbox or similar event, returns true if it is a selection,
 536 false if it is a deselection.", "");
 537
 538
 539     void SetExtraLong(long extraLong);
 540     DocDeclStr(
 541         long , GetExtraLong() const,
 542         "Returns extra information dependant on the event objects type. If the
 543 event comes from a listbox selection, it is a boolean determining
 544 whether the event was a selection (true) or a deselection (false). A
 545 listbox deselection only occurs for multiple-selection boxes, and in
 546 this case the index and string values are indeterminate and the
 547 listbox must be examined by the application.", "");
 548
 549
 550     void SetInt(int i);
 551     DocDeclStr(
 552         long , GetInt() const,
 553         "Returns the integer identifier corresponding to a listbox, choice or
 554 radiobox selection (only if the event was a selection, not a
 555 deselection), or a boolean value representing the value of a checkbox.", "");
 556
 557
 558     virtual wxEvent *Clone() const;
 559
 560 };
 561
 562 //---------------------------------------------------------------------------
 563 %newgroup;
 564
 565 DocStr(wxNotifyEvent,
 566 "An instance of this class (or one of its derived classes) is sent from
 567 a control when the control's state is being changed and the control
 568 allows that change to be prevented from happening.  The event handler
 569 can call `Veto` or `Allow` to tell the control what to do.", "");
 570
 571 class wxNotifyEvent : public wxCommandEvent
 572 {
 573 public:
 574     wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
 575
 576     DocDeclStr(
 577         void , Veto(),
 578         "Prevents the change announced by this event from happening.
 579
 580 It is in general a good idea to notify the user about the reasons for
 581 vetoing the change because otherwise the applications behaviour (which
 582 just refuses to do what the user wants) might be quite surprising.", "");
 583
 584
 585     DocDeclStr(
 586         void , Allow(),
 587         "This is the opposite of `Veto`: it explicitly allows the event to be
 588 processed. For most events it is not necessary to call this method as
 589 the events are allowed anyhow but some are forbidden by default (this
 590 will be mentioned in the corresponding event description).", "");
 591
 592
 593     DocDeclStr(
 594         bool , IsAllowed(),
 595         "Returns true if the change is allowed (`Veto` hasn't been called) or
 596 false otherwise (if it was).", "");
 597
 598 };
 599
 600
 601 //---------------------------------------------------------------------------
 602 %newgroup;
 603
 604 DocStr(wxScrollEvent,
 605 "A scroll event holds information about events sent from stand-alone
 606 scrollbars and sliders. Note that scrolled windows do not send
 607 instnaces of this event class, but send the `wx.ScrollWinEvent`
 608 instead.", "
 609
 610 Events
 611 -------
 612     =======================     ==========================================
 613     EVT_SCROLL                  Used to bind all scroll events
 614     EVT_SCROLL_TOP              scroll-to-top events (minimum position)
 615     EVT_SCROLL_BOTTOM           scroll-to-bottom events (maximum position)
 616     EVT_SCROLL_LINEUP           line up events
 617     EVT_SCROLL_LINEDOWN         line down events
 618     EVT_SCROLL_PAGEUP           page up events
 619     EVT_SCROLL_PAGEDOWN         page down events
 620     EVT_SCROLL_THUMBTRACK       thumbtrack events (frequent events sent
 621                                 as the user drags the 'thumb')
 622     EVT_SCROLL_THUMBRELEASE     thumb release events.
 623     EVT_SCROLL_ENDSCROLL        End of scrolling
 624     =======================     ==========================================
 625
 626 Note
 627 ------
 628     The EVT_SCROLL_THUMBRELEASE event is only emitted when actually
 629     dragging the thumb using the mouse and releasing it (This
 630     EVT_SCROLL_THUMBRELEASE event is also followed by an
 631     EVT_SCROLL_ENDSCROLL event).
 632
 633     The EVT_SCROLL_ENDSCROLL event also occurs when using the keyboard
 634     to change the thumb position, and when clicking next to the thumb
 635     (In all these cases the EVT_SCROLL_THUMBRELEASE event does not
 636     happen).
 637
 638     In short, the EVT_SCROLL_ENDSCROLL event is triggered when
 639     scrolling/ moving has finished. The only exception (unfortunately)
 640     is that changing the thumb position using the mousewheel does give
 641     a EVT_SCROLL_THUMBRELEASE event but NOT an EVT_SCROLL_ENDSCROLL
 642     event.
 643 ");
 644
 645 class  wxScrollEvent : public wxCommandEvent
 646 {
 647 public:
 648     DocCtorStr(
 649         wxScrollEvent(wxEventType commandType = wxEVT_NULL,
 650                       int winid = 0, int pos = 0, int orient = 0),
 651         "", "");
 652
 653     DocDeclStr(
 654         int , GetOrientation() const,
 655         "Returns wx.HORIZONTAL or wx.VERTICAL, depending on the orientation of
 656 the scrollbar.", "");
 657
 658     DocDeclStr(
 659         int , GetPosition() const,
 660         "Returns the position of the scrollbar.", "");
 661
 662     void SetOrientation(int orient);
 663     void SetPosition(int pos);
 664 };
 665
 666
 667 //---------------------------------------------------------------------------
 668 %newgroup;
 669
 670 DocStr(wxScrollWinEvent,
 671 "A wx.ScrollWinEvent holds information about scrolling and is sent from
 672 scrolling windows.", "
 673
 674 Events
 675 -------
 676     ==========================     ==========================================
 677     EVT_SCROLLWIN                  Used to bind all scrolled window scroll events
 678     EVT_SCROLLWIN_TOP              scroll-to-top events (minimum position)
 679     EVT_SCROLLWIN_BOTTOM           scroll-to-bottom events (maximum position)
 680     EVT_SCROLLWIN_LINEUP           line up events
 681     EVT_SCROLLWIN_LINEDOWN         line down events
 682     EVT_SCROLLWIN_PAGEUP           page up events
 683     EVT_SCROLLWIN_PAGEDOWN         page down events
 684     EVT_SCROLLWIN_THUMBTRACK       thumbtrack events (frequent events sent
 685                                    as the user drags the 'thumb')
 686     EVT_SCROLLWIN_THUMBRELEASE     thumb release events.
 687     EVT_SCROLLWIN_ENDSCROLL        End of scrolling
 688     ==========================     ==========================================
 689
 690 :see: `wx.ScrollEvent`
 691 ");
 692
 693 class wxScrollWinEvent : public wxEvent
 694 {
 695 public:
 696     wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
 697                      int pos = 0, int orient = 0);
 698
 699     DocDeclStr(
 700         int , GetOrientation() const,
 701         "Returns wx.HORIZONTAL or wx.VERTICAL, depending on the orientation of
 702 the scrollbar.", "");
 703
 704     DocDeclStr(
 705         int , GetPosition() const,
 706         "Returns the position of the scrollbar for the thumb track and release
 707 events. Note that this field can't be used for the other events, you
 708 need to query the window itself for the current position in that case.", "");
 709
 710     void SetOrientation(int orient);
 711     void SetPosition(int pos);
 712 };
 713
 714 //---------------------------------------------------------------------------
 715 %newgroup;
 716
 717
 718 DocStr(wxMouseEvent,
 719 "This event class contains information about the events generated by
 720 the mouse: they include mouse buttons press and release events and
 721 mouse move events.
 722
 723 All mouse events involving the buttons use ``wx.MOUSE_BTN_LEFT`` for
 724 the left mouse button, ``wx.MOUSE_BTN_MIDDLE`` for the middle one and
 725 ``wx.MOUSE_BTN_RIGHT`` for the right one. Note that not all mice have
 726 a middle button so a portable application should avoid relying on the
 727 events from it.
 728
 729 Note the difference between methods like `LeftDown` and `LeftIsDown`:
 730 the former returns true when the event corresponds to the left mouse
 731 button click while the latter returns true if the left mouse button is
 732 currently being pressed. For example, when the user is dragging the
 733 mouse you can use `LeftIsDown` to test whether the left mouse button
 734 is (still) depressed. Also, by convention, if `LeftDown` returns true,
 735 `LeftIsDown` will also return true in wxWidgets whatever the
 736 underlying GUI behaviour is (which is platform-dependent). The same
 737 applies, of course, to other mouse buttons as well.", "
 738
 739 Events
 740 -------
 741     ==================     ==============================================
 742     EVT_LEFT_DOWN          Left mouse button down event. The handler
 743                            of this event should normally call
 744                            event.Skip() to allow the default processing
 745                            to take place as otherwise the window under
 746                            mouse wouldn't get the focus.
 747     EVT_LEFT_UP            Left mouse button up event
 748     EVT_LEFT_DCLICK        Left mouse button double click event
 749     EVT_MIDDLE_DOWN        Middle mouse button down event
 750     EVT_MIDDLE_UP          Middle mouse button up event
 751     EVT_MIDDLE_DCLICK      Middle mouse button double click event
 752     EVT_RIGHT_DOWN         Right mouse button down event
 753     EVT_RIGHT_UP           Right mouse button up event
 754     EVT_RIGHT_DCLICK       Right mouse button double click event
 755     EVT_MOTION             Event sent when the mouse is moving
 756     EVT_ENTER_WINDOW       Event sent when the mouse enters the
 757                            boundaries of a window.
 758     EVT_LEAVE_WINDOW       Sent when the mouse leaves the window's bounds
 759     EVT_MOUSEWHEEL         Mouse scroll wheel event
 760     EVT_MOUSE_EVENTS       Binds all mouse events at once.
 761     ==================     ==============================================
 762
 763 ");
 764
 765
 766 // the symbolic names for the mouse buttons
 767 enum
 768 {
 769     wxMOUSE_BTN_ANY     = -1,
 770     wxMOUSE_BTN_NONE    = -1,
 771     wxMOUSE_BTN_LEFT    = 0,
 772     wxMOUSE_BTN_MIDDLE  = 1,
 773     wxMOUSE_BTN_RIGHT   = 2
 774 };
 775
 776
 777 // Mouse event class
 778 class  wxMouseEvent : public wxEvent
 779 {
 780 public:
 781     DocCtorStr(
 782         wxMouseEvent(wxEventType mouseType = wxEVT_NULL),
 783 "Constructs a wx.MouseEvent.  Valid event types are:
 784
 785     * wxEVT_ENTER_WINDOW
 786     * wxEVT_LEAVE_WINDOW
 787     * wxEVT_LEFT_DOWN
 788     * wxEVT_LEFT_UP
 789     * wxEVT_LEFT_DCLICK
 790     * wxEVT_MIDDLE_DOWN
 791     * wxEVT_MIDDLE_UP
 792     * wxEVT_MIDDLE_DCLICK
 793     * wxEVT_RIGHT_DOWN
 794     * wxEVT_RIGHT_UP
 795     * wxEVT_RIGHT_DCLICK
 796     * wxEVT_MOTION
 797     * wxEVT_MOUSEWHEEL ", "");
 798
 799
 800     DocDeclStr(
 801         bool , IsButton() const,
 802         "Returns true if the event was a mouse button event (not necessarily a
 803 button down event - that may be tested using `ButtonDown`).", "");
 804
 805
 806     DocDeclStr(
 807         bool , ButtonDown(int but = wxMOUSE_BTN_ANY) const,
 808         "If the argument is omitted, this returns true if the event was any
 809 mouse button down event. Otherwise the argument specifies which
 810 button-down event shold be checked for (see `Button` for the possible
 811 values).", "");
 812
 813
 814     DocDeclStr(
 815         bool , ButtonDClick(int but = wxMOUSE_BTN_ANY) const,
 816         "If the argument is omitted, this returns true if the event was any
 817 mouse double click event. Otherwise the argument specifies which
 818 double click event to check for (see `Button` for the possible
 819 values).", "");
 820
 821
 822     DocDeclStr(
 823         bool , ButtonUp(int but = wxMOUSE_BTN_ANY) const,
 824         "If the argument is omitted, this returns true if the event was any
 825 mouse button up event. Otherwise the argument specifies which button
 826 up event to check for (see `Button` for the possible values).", "");
 827
 828
 829     DocDeclStr(
 830         bool , Button(int button) const,
 831         "Returns true if the identified mouse button is changing state. Valid
 832 values of button are:
 833
 834      ====================      =====================================
 835      wx.MOUSE_BTN_LEFT         check if left button was pressed
 836      wx.MOUSE_BTN_MIDDLE       check if middle button was pressed
 837      wx.MOUSE_BTN_RIGHT        check if right button was pressed
 838      wx.MOUSE_BTN_ANY          check if any button was pressed
 839      ====================      =====================================
 840 ", "");
 841
 842
 843     // Was the given button in Down state?
 844     bool ButtonIsDown(int but) const;
 845
 846     DocDeclStr(
 847         int , GetButton() const,
 848         "Returns the mouse button which generated this event or
 849 wx.MOUSE_BTN_NONE if no button is involved (for mouse move, enter or
 850 leave event, for example). Otherwise wx.MOUSE_BTN_LEFT is returned for
 851 the left button down, up and double click events, wx.MOUSE_BTN_MIDDLE
 852 and wx.MOUSE_BTN_RIGHT for the same events for the middle and the
 853 right buttons respectively.", "");
 854
 855
 856     DocDeclStr(
 857         bool , ControlDown() const,
 858         "Returns true if the control key was down at the time of the event.", "");
 859
 860     DocDeclStr(
 861         bool , MetaDown() const,
 862         "Returns true if the Meta key was down at the time of the event.", "");
 863
 864
 865     DocDeclStr(
 866         bool , AltDown() const,
 867         "Returns true if the Alt key was down at the time of the event.", "");
 868
 869     DocDeclStr(
 870         bool , ShiftDown() const,
 871         "Returns true if the Shift key was down at the time of the event.", "");
 872
 873
 874     DocDeclStr(
 875         bool , CmdDown() const,
 876         "\"Cmd\" is a pseudo key which is the same as Control for PC and Unix
 877 platforms but the special \"Apple\" (a.k.a as \"Command\") key on
 878 Macs. It often makes sense to use it instead of, say, `ControlDown`
 879 because Cmd key is used for the same thing under Mac as Ctrl
 880 elsewhere. The Ctrl key still exists, it's just not used for this
 881 purpose. So for non-Mac platforms this is the same as `ControlDown`
 882 and Macs this is the same as `MetaDown`.", "");
 883
 884
 885     DocDeclStr(
 886         bool , LeftDown() const,
 887         "Returns true if the left mouse button state changed to down.", "");
 888
 889     DocDeclStr(
 890         bool , MiddleDown() const,
 891         "Returns true if the middle mouse button state changed to down.", "");
 892
 893     DocDeclStr(
 894         bool , RightDown() const,
 895         "Returns true if the right mouse button state changed to down.", "");
 896
 897
 898
 899     DocDeclStr(
 900         bool , LeftUp() const,
 901         "Returns true if the left mouse button state changed to up.", "");
 902
 903     DocDeclStr(
 904         bool , MiddleUp() const,
 905         "Returns true if the middle mouse button state changed to up.", "");
 906
 907     DocDeclStr(
 908         bool , RightUp() const,
 909         "Returns true if the right mouse button state changed to up.", "");
 910
 911
 912
 913
 914     DocDeclStr(
 915         bool , LeftDClick() const,
 916         "Returns true if the event was a left button double click.", "");
 917
 918     DocDeclStr(
 919         bool , MiddleDClick() const,
 920         "Returns true if the event was a middle button double click.", "");
 921
 922     DocDeclStr(
 923         bool , RightDClick() const,
 924         "Returns true if the event was a right button double click.", "");
 925
 926
 927
 928     DocDeclStr(
 929         bool , LeftIsDown(),
 930         "Returns true if the left mouse button is currently down, independent
 931 of the current event type.
 932
 933 Please notice that it is not the same as LeftDown which returns true
 934 if the left mouse button was just pressed. Rather, it describes the
 935 state of the mouse button before the event happened.
 936
 937 This event is usually used in the mouse event handlers which process
 938 \"move mouse\" messages to determine whether the user is (still)
 939 dragging the mouse.", "");
 940
 941     DocDeclStr(
 942         bool , MiddleIsDown(),
 943         "Returns true if the middle mouse button is currently down, independent
 944 of the current event type.", "");
 945
 946     DocDeclStr(
 947         bool , RightIsDown(),
 948         "Returns true if the right mouse button is currently down, independent
 949 of the current event type.", "");
 950
 951
 952
 953     DocDeclStr(
 954         bool , Dragging() const,
 955         "Returns true if this was a dragging event (motion while a button is
 956 depressed).", "");
 957
 958
 959     DocDeclStr(
 960         bool , Moving() const,
 961         "Returns true if this was a motion event and no mouse buttons were
 962 pressed. If any mouse button is held pressed, then this method returns
 963 false and Dragging returns true.", "");
 964
 965
 966     DocDeclStr(
 967         bool , Entering() const,
 968         "Returns true if the mouse was entering the window.", "");
 969
 970
 971     DocDeclStr(
 972         bool , Leaving() const,
 973         "Returns true if the mouse was leaving the window.", "");
 974
 975
 976
 977     DocStr(GetPosition,   // sets the docstring for both
 978            "Returns the pixel position of the mouse in window coordinates when the
 979 event happened.", "");
 980     wxPoint GetPosition();
 981
 982     DocDeclAName(
 983         void, GetPosition(long *OUTPUT, long *OUTPUT),
 984         "GetPositionTuple() -> (x,y)",
 985         GetPositionTuple);
 986
 987     DocDeclStr(
 988         wxPoint , GetLogicalPosition(const wxDC& dc) const,
 989         "Returns the logical mouse position in pixels (i.e. translated
 990 according to the translation set for the DC, which usually indicates
 991 that the window has been scrolled).", "");
 992
 993
 994     DocDeclStr(
 995         wxCoord , GetX() const,
 996         "Returns X coordinate of the physical mouse event position.", "");
 997
 998     DocDeclStr(
 999         wxCoord , GetY() const,
1000         "Returns Y coordinate of the physical mouse event position.", "");
1001
1002
1003     DocDeclStr(
1004         int , GetWheelRotation() const,
1005         "Get wheel rotation, positive or negative indicates direction of
1006 rotation. Current devices all send an event when rotation is equal to
1007 +/-WheelDelta, but this allows for finer resolution devices to be
1008 created in the future. Because of this you shouldn't assume that one
1009 event is equal to 1 line or whatever, but you should be able to either
1010 do partial line scrolling or wait until +/-WheelDelta rotation values
1011 have been accumulated before scrolling.", "");
1012
1013
1014     DocDeclStr(
1015         int , GetWheelDelta() const,
1016         "Get wheel delta, normally 120. This is the threshold for action to be
1017 taken, and one such action (for example, scrolling one increment)
1018 should occur for each delta.", "");
1019
1020
1021     DocDeclStr(
1022         int , GetLinesPerAction() const,
1023         "Returns the configured number of lines (or whatever) to be scrolled
1024 per wheel action. Defaults to three.", "");
1025
1026
1027     DocDeclStr(
1028         bool , IsPageScroll() const,
1029         "Returns true if the system has been setup to do page scrolling with
1030 the mouse wheel instead of line scrolling.", "");
1031
1032
1033 public:
1034     wxCoord m_x, m_y;
1035
1036     bool          m_leftDown;
1037     bool          m_middleDown;
1038     bool          m_rightDown;
1039
1040     bool          m_controlDown;
1041     bool          m_shiftDown;
1042     bool          m_altDown;
1043     bool          m_metaDown;
1044
1045     int           m_wheelRotation;
1046     int           m_wheelDelta;
1047     int           m_linesPerAction;
1048 };
1049
1050 //---------------------------------------------------------------------------
1051 %newgroup;
1052
1053 // Cursor set event
1054
1055 DocStr(wxSetCursorEvent,
1056 "A SetCursorEvent is generated when the mouse cursor is about to be set
1057 as a result of mouse motion. This event gives the application the
1058 chance to perform specific mouse cursor processing based on the
1059 current position of the mouse within the window. Use the `SetCursor`
1060 method to specify the cursor you want to be displayed.", "");
1061
1062 class wxSetCursorEvent : public wxEvent
1063 {
1064 public:
1065     DocCtorStr(
1066         wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0),
1067         "Construct a new `wx.SetCursorEvent`.", "");
1068
1069     DocDeclStr(
1070         wxCoord , GetX() const,
1071         "Returns the X coordinate of the mouse in client coordinates.", "");
1072
1073     DocDeclStr(
1074         wxCoord , GetY() const,
1075         "Returns the Y coordinate of the mouse in client coordinates.", "");
1076
1077
1078     DocDeclStr(
1079         void , SetCursor(const wxCursor& cursor),
1080         "Sets the cursor associated with this event.", "");
1081
1082     DocDeclStr(
1083         const wxCursor& , GetCursor() const,
1084         "Returns a reference to the cursor specified by this event.", "");
1085
1086     DocDeclStr(
1087         bool , HasCursor() const,
1088         "Returns true if the cursor specified by this event is a valid cursor.", "");
1089
1090 };
1091
1092 //---------------------------------------------------------------------------
1093 %newgroup;
1094
1095 // Keyboard input event class
1096
1097 DocStr(wxKeyEvent,
1098 "This event class contains information about keypress and character
1099 events.  These events are only sent to the widget that currently has
1100 the keyboard focus.
1101
1102 Notice that there are three different kinds of keyboard events in
1103 wxWidgets: key down and up events and char events. The difference
1104 between the first two is clear - the first corresponds to a key press
1105 and the second to a key release - otherwise they are identical. Just
1106 note that if the key is maintained in a pressed state you will
1107 typically get a lot of (automatically generated) down events but only
1108 one up so it is wrong to assume that there is one up event
1109 corresponding to each down one.
1110
1111 Both key events provide untranslated key codes while the char event
1112 carries the translated one. The untranslated code for alphanumeric
1113 keys is always an upper case value. For the other keys it is one of
1114 WXK_XXX values from the keycodes table. The translated key is, in
1115 general, the character the user expects to appear as the result of the
1116 key combination when typing the text into a text entry zone, for
1117 example.
1118
1119 A few examples to clarify this (all assume that CAPS LOCK is unpressed
1120 and the standard US keyboard): when the 'A' key is pressed, the key
1121 down event key code is equal to ASCII A == 65. But the char event key
1122 code is ASCII a == 97. On the other hand, if you press both SHIFT and
1123 'A' keys simultaneously , the key code in key down event will still be
1124 just 'A' while the char event key code parameter will now be 'A' as
1125 well.
1126
1127 Although in this simple case it is clear that the correct key code
1128 could be found in the key down event handler by checking the value
1129 returned by `ShiftDown`, in general you should use EVT_CHAR for this
1130 as for non alphanumeric keys or non-US keyboard layouts the
1131 translation is keyboard-layout dependent and can only be done properly
1132 by the system itself.
1133
1134 Another kind of translation is done when the control key is pressed:
1135 for example, for CTRL-A key press the key down event still carries the
1136 same key code 'A' as usual but the char event will have key code of 1,
1137 the ASCII value of this key combination.
1138
1139 You may discover how the other keys on your system behave
1140 interactively by running the KeyEvents sample in the wxPython demo and
1141 pressing some keys while the blue box at the top has the keyboard
1142 focus.
1143
1144 **Note**: If a key down event is caught and the event handler does not
1145 call event.Skip() then the coresponding char event will not
1146 happen. This is by design and enables the programs that handle both
1147 types of events to be a bit simpler.
1148
1149 **Note for Windows programmers**: The key and char events in wxWidgets
1150 are similar to but slightly different from Windows WM_KEYDOWN and
1151 WM_CHAR events. In particular, Alt-x combination will generate a char
1152 event in wxWidgets (unless it is used as an accelerator).
1153
1154 **Tip**: be sure to call event.Skip() for events that you don't
1155 process in key event function, otherwise menu shortcuts may cease to
1156 work under Windows.
1157 ", "
1158
1159 Events
1160 ------
1161     ==================     ==============================================
1162     wx.EVT_KEY_DOWN        Sent when a keyboard key has been pressed
1163     wx.EVT_KEY_UP          Sent when a keyboard key has been released
1164     wx.EVT_CHAR            Sent for translated character events.
1165     ==================     ==============================================
1166
1167
1168 Keycode Table
1169 -------------
1170     ===========  ==============  ========  ====================  =================
1171     WXK_BACK     WXK_EXECUTE     WXK_F1    WXK_NUMPAD_SPACE      WXK_WINDOWS_LEFT
1172     WXK_TAB      WXK_SNAPSHOT    WXK_F2    WXK_NUMPAD_TAB        WXK_WINDOWS_RIGHT
1173     WXK_RETURN   WXK_INSERT      WXK_F3    WXK_NUMPAD_ENTER      WXK_WINDOWS_MENU
1174     WXK_ESCAPE   WXK_HELP        WXK_F4    WXK_NUMPAD_F1         WXK_SPECIAL1
1175     WXK_SPACE    WXK_NUMPAD0     WXK_F5    WXK_NUMPAD_F2         WXK_SPECIAL2
1176     WXK_DELETE   WXK_NUMPAD1     WXK_F6    WXK_NUMPAD_F3         WXK_SPECIAL3
1177     WXK_LBUTTON  WXK_NUMPAD2     WXK_F7    WXK_NUMPAD_F4         WXK_SPECIAL4
1178     WXK_RBUTTON  WXK_NUMPAD3     WXK_F8    WXK_NUMPAD_HOME       WXK_SPECIAL5
1179     WXK_CANCEL   WXK_NUMPAD4     WXK_F9    WXK_NUMPAD_LEFT       WXK_SPECIAL6
1180     WXK_MBUTTON  WXK_NUMPAD5     WXK_F10   WXK_NUMPAD_UP         WXK_SPECIAL7
1181     WXK_CLEAR    WXK_NUMPAD6     WXK_F11   WXK_NUMPAD_RIGHT      WXK_SPECIAL8
1182     WXK_SHIFT    WXK_NUMPAD7     WXK_F12   WXK_NUMPAD_DOWN       WXK_SPECIAL9
1183     WXK_ALT      WXK_NUMPAD8     WXK_F13   WXK_NUMPAD_PRIOR      WXK_SPECIAL10
1184     WXK_CONTROL  WXK_NUMPAD9     WXK_F14   WXK_NUMPAD_PAGEUP     WXK_SPECIAL11
1185     WXK_MENU     WXK_MULTIPLY    WXK_F15   WXK_NUMPAD_NEXT       WXK_SPECIAL12
1186     WXK_PAUSE    WXK_ADD         WXK_F16   WXK_NUMPAD_PAGEDOWN   WXK_SPECIAL13
1187     WXK_CAPITAL  WXK_SEPARATOR   WXK_F17   WXK_NUMPAD_END        WXK_SPECIAL14
1188     WXK_PRIOR    WXK_SUBTRACT    WXK_F18   WXK_NUMPAD_BEGIN      WXK_SPECIAL15
1189     WXK_NEXT     WXK_DECIMAL     WXK_F19   WXK_NUMPAD_INSERT     WXK_SPECIAL16
1190     WXK_END      WXK_DIVIDE      WXK_F20   WXK_NUMPAD_DELETE     WXK_SPECIAL17
1191     WXK_HOME     WXK_NUMLOCK     WXK_F21   WXK_NUMPAD_EQUAL      WXK_SPECIAL18
1192     WXK_LEFT     WXK_SCROLL      WXK_F22   WXK_NUMPAD_MULTIPLY   WXK_SPECIAL19
1193     WXK_UP       WXK_PAGEUP      WXK_F23   WXK_NUMPAD_ADD        WXK_SPECIAL20
1194     WXK_RIGHT    WXK_PAGEDOWN    WXK_F24   WXK_NUMPAD_SEPARATOR
1195     WXK_DOWN                               WXK_NUMPAD_SUBTRACT
1196     WXK_SELECT                             WXK_NUMPAD_DECIMAL
1197     WXK_PRINT                              WXK_NUMPAD_DIVIDE
1198     ===========  ==============  ========  ====================  =================
1199 ");
1200
1201 class wxKeyEvent : public wxEvent
1202 {
1203 public:
1204     DocCtorStr(
1205         wxKeyEvent(wxEventType eventType = wxEVT_NULL),
1206         "Construct a new `wx.KeyEvent`.  Valid event types are:
1207     * ", "");
1208
1209
1210     DocDeclStr(
1211         bool , ControlDown() const,
1212         "Returns ``True`` if the Control key was down at the time of the event.", "");
1213
1214     DocDeclStr(
1215         bool , MetaDown() const,
1216         "Returns ``True`` if the Meta key was down at the time of the event.", "");
1217
1218     DocDeclStr(
1219         bool , AltDown() const,
1220         "Returns ``True`` if the Alt key was down at the time of the event.", "");
1221
1222     DocDeclStr(
1223         bool , ShiftDown() const,
1224         "Returns ``True`` if the Shift key was down at the time of the event.", "");
1225
1226
1227     DocDeclStr(
1228         bool , CmdDown() const,
1229         "\"Cmd\" is a pseudo key which is the same as Control for PC and Unix
1230 platforms but the special \"Apple\" (a.k.a as \"Command\") key on
1231 Macs. It makes often sense to use it instead of, say, `ControlDown`
1232 because Cmd key is used for the same thing under Mac as Ctrl
1233 elsewhere. The Ctrl still exists, it's just not used for this
1234 purpose. So for non-Mac platforms this is the same as `ControlDown`
1235 and Macs this is the same as `MetaDown`.", "");
1236
1237
1238
1239     DocDeclStr(
1240         bool , HasModifiers() const,
1241         "Returns true if either CTRL or ALT keys was down at the time of the
1242 key event. Note that this function does not take into account neither
1243 SHIFT nor META key states (the reason for ignoring the latter is that
1244 it is common for NUMLOCK key to be configured as META under X but the
1245 key presses even while NUMLOCK is on should be still processed
1246 normally).", "");
1247
1248
1249     DocDeclStr(
1250         int , GetKeyCode() const,
1251         "Returns the virtual key code. ASCII events return normal ASCII values,
1252 while non-ASCII events return values such as WXK_LEFT for the left
1253 cursor key. See `wx.KeyEvent` for a full list of the virtual key
1254 codes.
1255
1256 Note that in Unicode build, the returned value is meaningful only if
1257 the user entered a character that can be represented in current
1258 locale's default charset. You can obtain the corresponding Unicode
1259 character using `GetUnicodeKey`.", "");
1260     %pythoncode { KeyCode = GetKeyCode }
1261
1262
1263     %extend {
1264         DocStr(
1265             GetUnicodeKey,
1266             "Returns the Unicode character corresponding to this key event.  This
1267 function is only meaningfule in a Unicode build of wxPython.", "");
1268         int GetUnicodeKey() {
1269         %#if wxUSE_UNICODE
1270             return self->GetUnicodeKey();
1271         %#else
1272             return 0;
1273         %#endif
1274         }
1275     }
1276     %pythoncode { GetUniChar = GetUnicodeKey }
1277
1278
1279     DocDeclStr(
1280         wxUint32 , GetRawKeyCode() const,
1281         "Returns the raw key code for this event. This is a platform-dependent
1282 scan code which should only be used in advanced
1283 applications. Currently the raw key codes are not supported by all
1284 ports.", "");
1285
1286
1287     DocDeclStr(
1288         wxUint32 , GetRawKeyFlags() const,
1289         "Returns the low level key flags for this event. The flags are
1290 platform-dependent and should only be used in advanced applications.
1291 Currently the raw key flags are not supported by all ports.", "");
1292
1293
1294
1295     DocStr(GetPosition,   // sets the docstring for both
1296            "Find the position of the event, if applicable.", "");
1297     wxPoint GetPosition();
1298
1299     DocDeclAName(
1300         void, GetPosition(long *OUTPUT, long *OUTPUT),
1301         "GetPositionTuple() -> (x,y)",
1302         GetPositionTuple);
1303
1304
1305     DocDeclStr(
1306         wxCoord , GetX() const,
1307         "Returns the X position (in client coordinates) of the event, if
1308 applicable.", "");
1309
1310
1311     DocDeclStr(
1312         wxCoord , GetY() const,
1313         "Returns the Y position (in client coordinates) of the event, if
1314 applicable.", "");
1315
1316
1317 public:
1318     wxCoord       m_x, m_y;
1319
1320     long          m_keyCode;
1321
1322     bool          m_controlDown;
1323     bool          m_shiftDown;
1324     bool          m_altDown;
1325     bool          m_metaDown;
1326     bool          m_scanCode;
1327
1328     wxUint32      m_rawCode;
1329     wxUint32      m_rawFlags;
1330 };
1331
1332 //---------------------------------------------------------------------------
1333 %newgroup;
1334
1335 // Size event class
1336
1337 DocStr(wxSizeEvent,
1338 "A size event holds information about size change events.  The EVT_SIZE
1339 handler function will be called when the window it is bound to has
1340 been resized.
1341
1342 Note that the size passed is of the whole window: call
1343 `wx.Window.GetClientSize` for the area which may be used by the
1344 application.
1345
1346 When a window is resized, usually only a small part of the window is
1347 damaged and and that area is all that is in the update region for the
1348 next paint event. However, if your drawing depends on the size of the
1349 window, you may need to clear the DC explicitly and repaint the whole
1350 window. In which case, you may need to call `wx.Window.Refresh` to
1351 invalidate the entire window.
1352 ", "");
1353
1354 class wxSizeEvent : public wxEvent
1355 {
1356 public:
1357     DocCtorStr(
1358         wxSizeEvent(const wxSize& sz=wxDefaultSize, int winid = 0),
1359         "Construct a new ``wx.SizeEvent``.", "");
1360
1361     DocDeclStr(
1362         wxSize , GetSize() const,
1363         "Returns the entire size of the window generating the size change
1364 event.", "");
1365
1366     wxRect GetRect() const;
1367     void SetRect(wxRect rect);
1368
1369     %extend {
1370         void SetSize(wxSize size) {
1371             self->m_size = size;
1372         }
1373     }
1374
1375 public:
1376     wxSize m_size;
1377     wxRect m_rect;
1378 };
1379
1380
1381 //---------------------------------------------------------------------------
1382 %newgroup;
1383
1384 DocStr(wxMoveEvent,
1385 "This event object is sent for EVT_MOVE event bindings when a window is
1386 moved to a new position.", "");
1387
1388 class wxMoveEvent : public wxEvent
1389 {
1390 public:
1391     DocCtorStr(
1392         wxMoveEvent(const wxPoint& pos=wxDefaultPosition, int winid = 0),
1393         "Constructor.", "");
1394
1395     DocDeclStr(
1396         wxPoint , GetPosition() const,
1397         "Returns the position of the window generating the move change event.", "");
1398
1399     wxRect GetRect() const;
1400     void SetRect(const wxRect& rect);
1401     void SetPosition(const wxPoint& pos);
1402
1403     %pythoncode {
1404         m_pos =  property(GetPosition, SetPosition)
1405         m_rect = property(GetRect, SetRect)
1406     }
1407 };
1408
1409 //---------------------------------------------------------------------------
1410 %newgroup;
1411
1412 DocStr(wxPaintEvent,
1413 "A paint event is sent when a window's contents needs to be repainted.
1414 Note that in an EVT_PAINT handler the application must *always* create
1415 a `wx.PaintDC` object, even if you do not use it.  Otherwise MS
1416 Windows assumes that the window has not been painted yet and will send
1417 the event again, causing endless refreshes.
1418
1419 You can optimize painting by retrieving the rectangles that have been
1420 damaged using `wx.Window.GetUpdateRegion` and/or `wx.RegionIterator`,
1421 and only repainting these rectangles. The rectangles are in terms of
1422 the client area, and are unscrolled, so you will need to do some
1423 calculations using the current view position to obtain logical,
1424 scrolled units.
1425 ", "");
1426
1427 class wxPaintEvent : public wxEvent
1428 {
1429 public:
1430     DocCtorStr(
1431         wxPaintEvent(int Id = 0),
1432         "", "");
1433 };
1434
1435
1436 class wxNcPaintEvent : public wxEvent
1437 {
1438 public:
1439     wxNcPaintEvent(int winid = 0);
1440 };
1441
1442 //---------------------------------------------------------------------------
1443 %newgroup;
1444
1445 DocStr(wxEraseEvent,
1446 "An erase event is sent whenever the background of a window needs to be
1447 repainted.  To intercept this event use the EVT_ERASE_BACKGROUND event
1448 binder.  On some platforms, such as GTK+, this event is simulated
1449 (simply generated just before the paint event) and may cause flicker.
1450
1451 To paint a custom background use the `GetDC` method and use the returned
1452 device context if it is not ``None``, otherwise create a temporary
1453 `wx.ClientDC` and draw on that.
1454 ", "");
1455
1456 class wxEraseEvent : public wxEvent
1457 {
1458 public:
1459     DocCtorStr(
1460         wxEraseEvent(int Id = 0, wxDC *dc = NULL),
1461         "Constructor", "");
1462
1463     DocDeclStr(
1464         wxDC *, GetDC() const,
1465         "Returns the device context the event handler should draw upon.  If
1466 ``None`` is returned then create a temporary `wx.ClientDC` and use
1467 that instead.", "");
1468 };
1469
1470
1471 //---------------------------------------------------------------------------
1472 %newgroup;
1473
1474 DocStr(wxFocusEvent,
1475 "A focus event is sent when a window's focus changes. The window losing
1476 focus receives an EVT_KILL_FOCUS event while the window gaining it
1477 gets an EVT_SET_FOCUS event.
1478
1479 Notice that the set focus event happens both when the user gives focus
1480 to the window (whether using the mouse or keyboard) and when it is
1481 done from the program itself using `wx.Window.SetFocus`.
1482 ", "");
1483
1484 class wxFocusEvent : public wxEvent
1485 {
1486 public:
1487     DocCtorStr(
1488         wxFocusEvent(wxEventType type = wxEVT_NULL, int winid = 0),
1489         "Constructor", "");
1490
1491     DocDeclStr(
1492         wxWindow *, GetWindow() const,
1493         "Returns the other window associated with this event, that is the
1494 window which had the focus before for the EVT_SET_FOCUS event and the
1495 window which is going to receive focus for the wxEVT_KILL_FOCUS event.
1496
1497 Warning: the window returned may be None!", "");
1498
1499     void SetWindow(wxWindow *win);
1500 };
1501
1502 //---------------------------------------------------------------------------
1503 %newgroup;
1504
1505 DocStr(wxChildFocusEvent,
1506 "wx.ChildFocusEvent notifies the parent that a child has received the
1507 focus.  Unlike `wx.FocusEvent` it is propagated up the window
1508 heirarchy.", "");
1509
1510
1511 class wxChildFocusEvent : public wxCommandEvent
1512 {
1513 public:
1514     DocCtorStr(
1515         wxChildFocusEvent(wxWindow *win = NULL),
1516         "Constructor", "");
1517
1518     DocDeclStr(
1519         wxWindow *, GetWindow() const,
1520         "The window which has just received the focus.", "");
1521
1522 };
1523
1524 //---------------------------------------------------------------------------
1525 %newgroup;
1526
1527 DocStr(wxActivateEvent,
1528 "An activate event is sent when a top-level window or the entire
1529 application is being activated or deactivated.
1530
1531 A top-level window (a dialog or frame) receives an activate event when
1532 is being activated or deactivated. This is indicated visually by the
1533 title bar changing colour, and a subwindow gaining the keyboard focus.
1534 An application is activated or deactivated when one of its frames
1535 becomes activated, or a frame becomes inactivate resulting in all
1536 application frames being inactive.
1537
1538 Please note that usually you should call event.Skip() in your handlers
1539 for these events so the default handlers will still be called, as not
1540 doing so can result in strange effects.
1541 ", "
1542
1543 Events
1544 -------
1545     =======================     ==========================================
1546     wx.EVT_ACTIVATE             Sent to a frame when it has been activated
1547                                 or deactivated.
1548     wx.EVT_ACTIVATE_APP         Sent to the app object when its activation
1549                                 state changes.
1550     =======================     ==========================================
1551 ");
1552
1553
1554 class wxActivateEvent : public wxEvent
1555 {
1556 public:
1557     DocCtorStr(
1558         wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = true, int Id = 0),
1559         "Constructor", "");
1560
1561     DocDeclStr(
1562         bool , GetActive() const,
1563         "Returns true if the application or window is being activated, false
1564 otherwise.", "");
1565
1566 };
1567
1568
1569 //---------------------------------------------------------------------------
1570 %newgroup;
1571
1572 DocStr(wxInitDialogEvent,
1573 "A wx.InitDialogEvent is sent as a dialog is being initialised, or for
1574 any window when `wx.Window.InitDialog` is called.  Handlers for this
1575 event can transfer data to the window, or anything else that should be
1576 done before the user begins editing the form. The default handler
1577 calls `wx.Window.TransferDataToWindow`.", "
1578
1579 Events
1580 -------
1581     =======================     ==========================================
1582     wx.EVT_INIT_DIALOG          Binder for init dialog events.
1583     =======================     ==========================================
1584 ");
1585
1586 class wxInitDialogEvent : public wxEvent
1587 {
1588 public:
1589     DocCtorStr(
1590         wxInitDialogEvent(int Id = 0),
1591         "Constructor", "");
1592 };
1593
1594
1595 //---------------------------------------------------------------------------
1596 %newgroup;
1597
1598 DocStr(wxMenuEvent,
1599 "This class is used for a variety of menu-related events.  Note that
1600 these do not include menu command events, which are handled by sending
1601 `wx.CommandEvent` objects.
1602
1603 The default handler for wx.EVT_MENU_HIGHLIGHT displays menu item help
1604 text in the first field of the status bar.", "
1605
1606 Events
1607 -------
1608     =========================   ==========================================
1609     wx.EVT_MENU_OPEN            A menu is about to be opened. On Windows,
1610                                 this is only sent once for each navigation
1611                                 of the menubar (up until all menus have closed).
1612     wx.EVT_MENU_CLOSE           A menu has been just closed.
1613     wx.EVT_MENU_HIGHLIGHT       Sent when the menu item with the specified id
1614                                 has been highlighted: used by default to show
1615                                 help prompts in the `wx.Frame`'s status bar.
1616     wx.EVT_MENU_HIGHLIGHT_ALL   Can be used to catch the menu highlight
1617                                 event for all menu items.
1618     =========================   ==========================================
1619 ");
1620
1621 class wxMenuEvent : public wxEvent
1622 {
1623 public:
1624     DocCtorStr(
1625         wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0, wxMenu* menu = NULL),
1626         "Constructor", "");
1627
1628     DocDeclStr(
1629         int , GetMenuId() const,
1630         "Returns the menu identifier associated with the event. This method
1631 should be only used with the HIGHLIGHT events.", "");
1632
1633
1634     DocDeclStr(
1635         bool , IsPopup() const,
1636         "Returns ``True`` if the menu which is being opened or closed is a
1637 popup menu, ``False`` if it is a normal one.  This method should only
1638 be used with the OPEN and CLOSE events.", "");
1639
1640
1641     DocDeclStr(
1642         wxMenu* , GetMenu() const,
1643         "Returns the menu which is being opened or closed. This method should
1644 only be used with the OPEN and CLOSE events.", "");
1645
1646 };
1647
1648 //---------------------------------------------------------------------------
1649 %newgroup;
1650
1651 DocStr(wxCloseEvent,
1652 "This event class contains information about window and session close
1653 events.
1654
1655 The handler function for EVT_CLOSE is called when the user has tried
1656 to close a a frame or dialog box using the window manager controls or
1657 the system menu. It can also be invoked by the application itself
1658 programmatically, for example by calling the `wx.Window.Close`
1659 function.
1660
1661 You should check whether the application is forcing the deletion of
1662 the window using `CanVeto`. If it returns ``False``, you must destroy
1663 the window using `wx.Window.Destroy`. If the return value is ``True``,
1664 it is up to you whether you respond by destroying the window or not.
1665 For example you may wish to display a message dialog prompting to save
1666 files or to cancel the close.
1667
1668 If you don't destroy the window, you should call `Veto` to let the
1669 calling code know that you did not destroy the window. This allows the
1670 `wx.Window.Close` function to return ``True`` or ``False`` depending
1671 on whether the close instruction was honored or not.", "
1672
1673 Events
1674 -------
1675     =========================   ==========================================
1676     wx.EVT_CLOSE                This event is sent to a top-level window
1677                                 when it has been requested to close either
1678                                 from the user or programatically.
1679     wx.EVT_QUERY_END_SESSION    This event is sent to the `wx.App` when the
1680                                 system is about to be logged off, giving the
1681                                 app a chance to veto the shutdown.
1682     wx.EVT_END_SESSION          This event is sent to the `wx.App` when the
1683                                 system is being logged off.
1684     =========================   ==========================================
1685 ");
1686
1687 class wxCloseEvent : public wxEvent
1688 {
1689 public:
1690     DocCtorStr(
1691         wxCloseEvent(wxEventType type = wxEVT_NULL, int winid = 0),
1692         "Constructor.", "");
1693
1694     DocDeclStr(
1695         void , SetLoggingOff(bool logOff),
1696         "Sets the 'logging off' flag.", "");
1697
1698     DocDeclStr(
1699         bool , GetLoggingOff() const,
1700         "Returns true if the user is logging off.", "");
1701
1702
1703     DocDeclStr(
1704         void , Veto(bool veto = true),
1705         "Call this from your event handler to veto a system shutdown or to
1706 signal to the calling application that a window close did not happen.
1707
1708 You can only veto a shutdown or close if `CanVeto` returns true.", "");
1709
1710     bool GetVeto() const;
1711
1712     DocDeclStr(
1713         void , SetCanVeto(bool canVeto),
1714         "Sets the 'can veto' flag.", "");
1715
1716     DocDeclStr(
1717         bool , CanVeto() const,
1718         "Returns true if you can veto a system shutdown or a window close
1719 event. Vetoing a window close event is not possible if the calling
1720 code wishes to force the application to exit, and so this function
1721 must be called to check this.", "");
1722
1723 };
1724
1725
1726 //---------------------------------------------------------------------------
1727 %newgroup;
1728
1729 DocStr(wxShowEvent,
1730 "An EVT_SHOW event is sent when a window is shown or hidden.", "");
1731
1732 class wxShowEvent : public wxEvent
1733 {
1734 public:
1735     wxShowEvent(int winid = 0, bool show = false);
1736
1737     void SetShow(bool show);
1738     bool GetShow() const;
1739
1740 };
1741
1742
1743 //---------------------------------------------------------------------------
1744 %newgroup;
1745
1746 DocStr(wxIconizeEvent,
1747 "An EVT_ICONIZE event is sent when a frame is iconized (minimized) or
1748 restored.", "");
1749
1750 class wxIconizeEvent: public wxEvent
1751 {
1752 public:
1753     wxIconizeEvent(int id = 0, bool iconized = true);
1754
1755     DocDeclStr(
1756         bool , Iconized(),
1757         "Returns ``True`` if the frame has been iconized, ``False`` if it has
1758 been restored.", "");
1759
1760 };
1761
1762
1763 //---------------------------------------------------------------------------
1764 %newgroup;
1765
1766 DocStr(wxMaximizeEvent,
1767 "An EVT_MAXIMIZE event is sent when a frame is maximized or restored.", "");
1768
1769 class wxMaximizeEvent: public wxEvent
1770 {
1771 public:
1772     wxMaximizeEvent(int id = 0);
1773 };
1774
1775 //---------------------------------------------------------------------------
1776 %newgroup;
1777
1778 DocStr(wxDropFilesEvent,
1779 "This class is used for drop files events, that is, when files have
1780 been dropped onto the window. This functionality is only available
1781 under Windows. The window must have previously been enabled for
1782 dropping by calling `wx.Window.DragAcceptFiles`.
1783
1784 Important note: this is a separate implementation to the more general
1785 drag and drop implementation using `wx.FileDropTarget`, and etc. This
1786 implementation uses the older, Windows message-based approach of
1787 dropping files.
1788
1789 Use wx.EVT_DROP_FILES to bind an event handler to receive file drop
1790 events.
1791 ", "");
1792
1793 class wxDropFilesEvent: public wxEvent
1794 {
1795 public:
1796
1797     // TODO:  wrap the ctor!
1798
1799
1800     DocDeclStr(
1801         wxPoint , GetPosition(),
1802         "Returns the position at which the files were dropped.", "");
1803
1804     DocDeclStr(
1805         int , GetNumberOfFiles(),
1806         "Returns the number of files dropped.", "");
1807
1808
1809     %extend {
1810         DocStr(
1811             GetFiles,
1812             "Returns a list of the filenames that were dropped.", "");
1813
1814         PyObject* GetFiles() {
1815             int         count = self->GetNumberOfFiles();
1816             wxString*   files = self->GetFiles();
1817             wxPyBlock_t blocked = wxPyBeginBlockThreads();
1818             PyObject*   list  = PyList_New(count);
1819
1820             if (!list) {
1821                 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
1822                 wxPyEndBlockThreads(blocked);
1823                 return NULL;
1824             }
1825
1826             for (int i=0; i<count; i++) {
1827                 PyList_SetItem(list, i, wx2PyString(files[i]));
1828             }
1829             wxPyEndBlockThreads(blocked);
1830             return list;
1831         }
1832     }
1833 };
1834
1835
1836
1837 //---------------------------------------------------------------------------
1838 %newgroup;
1839
1840
1841 enum wxUpdateUIMode
1842 {
1843     wxUPDATE_UI_PROCESS_ALL,
1844     wxUPDATE_UI_PROCESS_SPECIFIED
1845 };
1846
1847
1848 DocStr(wxUpdateUIEvent,
1849 "This class is used for EVT_UPDATE_UI pseudo-events which are sent by
1850 wxWidgets to give an application the chance to update various user
1851 interface elements.
1852
1853 Without update UI events, an application has to work hard to
1854 check/uncheck, enable/disable, and set the text for elements such as
1855 menu items and toolbar buttons. The code for doing this has to be
1856 mixed up with the code that is invoked when an action is invoked for a
1857 menu item or button.
1858
1859 With update UI events, you define an event handler to look at the
1860 state of the application and change UI elements accordingly. wxWidgets
1861 will call your handler functions in idle time, so you don't have to
1862 worry where to call this code. In addition to being a clearer and more
1863 declarative method, it also means you don't have to worry whether
1864 you're updating a toolbar or menubar identifier. The same handler can
1865 update a menu item and toolbar button, if the ID values are the same.
1866
1867 Instead of directly manipulating the menu or button, you call
1868 functions in the event object, such as `Check`. wxWidgets will
1869 determine whether such a call has been made, and which UI element to
1870 update.
1871
1872 These events will work for popup menus as well as menubars. Just
1873 before a menu is popped up, `wx.Menu.UpdateUI` is called to process
1874 any UI events for the window that owns the menu.
1875
1876 If you find that the overhead of UI update processing is affecting
1877 your application, you can do one or both of the following:
1878
1879    1. Call `wx.UpdateUIEvent.SetMode` with a value of
1880       wx.UPDATE_UI_PROCESS_SPECIFIED, and set the extra style
1881       wx.WS_EX_PROCESS_UPDATE_EVENTS for every window that should
1882       receive update events. No other windows will receive update
1883       events.
1884
1885    2. Call `wx.UpdateUIEvent.SetUpdateInterval` with a millisecond
1886       value to set the delay between updates. You may need to call
1887       `wx.Window.UpdateWindowUI` at critical points, for example when
1888       a dialog is about to be shown, in case the user sees a slight
1889       delay before windows are updated.
1890
1891 Note that although events are sent in idle time, defining a EVT_IDLE
1892 handler for a window does not affect this because the events are sent
1893 from an internal idle handler.
1894
1895 wxWidgets tries to optimize update events on some platforms. On
1896 Windows and GTK+, events for menubar items are only sent when the menu
1897 is about to be shown, and not in idle time.
1898 ", "");
1899
1900 class wxUpdateUIEvent : public wxCommandEvent
1901 {
1902 public:
1903     DocCtorStr(
1904         wxUpdateUIEvent(wxWindowID commandId = 0),
1905         "Constructor", "");
1906
1907     DocDeclStr(
1908         bool , GetChecked() const,
1909         "Returns ``True`` if the UI element should be checked.", "");
1910
1911     DocDeclStr(
1912         bool , GetEnabled() const,
1913         "Returns ``True`` if the UI element should be enabled.", "");
1914
1915     DocDeclStr(
1916         wxString , GetText() const,
1917         "Returns the text that should be set for the UI element.", "");
1918
1919     DocDeclStr(
1920         bool , GetSetText() const,
1921         "Returns ``True`` if the application has called `SetText`. For
1922 wxWidgets internal use only.", "");
1923
1924     DocDeclStr(
1925         bool , GetSetChecked() const,
1926         "Returns ``True`` if the application has called `Check`. For wxWidgets
1927 internal use only.", "");
1928
1929     DocDeclStr(
1930         bool , GetSetEnabled() const,
1931         "Returns ``True`` if the application has called `Enable`. For wxWidgets
1932 internal use only.", "");
1933
1934
1935
1936     DocDeclStr(
1937         void , Check(bool check),
1938         "Check or uncheck the UI element.", "");
1939
1940     DocDeclStr(
1941         void , Enable(bool enable),
1942         "Enable or disable the UI element.", "");
1943
1944     DocDeclStr(
1945         void , SetText(const wxString& text),
1946         "Sets the text for this UI element.", "");
1947
1948
1949
1950     DocDeclStr(
1951         static void , SetUpdateInterval(long updateInterval),
1952         "Sets the interval between updates in milliseconds. Set to -1 to
1953 disable updates, or to 0 to update as frequently as possible. The
1954 default is 0.
1955
1956 Use this to reduce the overhead of UI update events if your
1957 application has a lot of windows. If you set the value to -1 or
1958 greater than 0, you may also need to call `wx.Window.UpdateWindowUI`
1959 at appropriate points in your application, such as when a dialog is
1960 about to be shown.", "");
1961
1962
1963     DocDeclStr(
1964         static long , GetUpdateInterval(),
1965         "Returns the current interval between updates in milliseconds. -1
1966 disables updates, 0 updates as frequently as possible.", "");
1967
1968
1969     DocDeclStr(
1970         static bool , CanUpdate(wxWindow *win),
1971         "Returns ``True`` if it is appropriate to update (send UI update events
1972 to) this window.
1973
1974 This function looks at the mode used (see `wx.UpdateUIEvent.SetMode`),
1975 the wx.WS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update
1976 events were last sent in idle time, and the update interval, to
1977 determine whether events should be sent to this window now. By default
1978 this will always return true because the update mode is initially
1979 wx.UPDATE_UI_PROCESS_ALL and the interval is set to 0; so update
1980 events will be sent as often as possible. You can reduce the frequency
1981 that events are sent by changing the mode and/or setting an update
1982 interval.
1983 ", "");
1984
1985
1986     DocDeclStr(
1987         static void , ResetUpdateTime(),
1988         "Used internally to reset the last-updated time to the current time. It
1989 is assumed that update events are normally sent in idle time, so this
1990 is called at the end of idle processing.", "");
1991
1992
1993     DocDeclStr(
1994         static void , SetMode(wxUpdateUIMode mode),
1995         "Specify how wxWidgets will send update events: to all windows, or only
1996 to those which specify that they will process the events.
1997
1998 The mode may be one of the following values:
1999
2000     =============================   ==========================================
2001     wxUPDATE_UI_PROCESS_ALL         Send UI update events to all windows.  This
2002                                     is the default setting.
2003     wxUPDATE_UI_PROCESS_SPECIFIED   Send UI update events only to windows that
2004                                     have the wx.WS_EX_PROCESS_UI_UPDATES extra
2005                                     style set.
2006     =============================   ==========================================
2007 ", "");
2008
2009
2010     DocDeclStr(
2011         static wxUpdateUIMode , GetMode(),
2012         "Returns a value specifying how wxWidgets will send update events: to
2013 all windows, or only to those which specify that they will process the
2014 events.", "");
2015
2016 };
2017
2018 //---------------------------------------------------------------------------
2019 %newgroup;
2020
2021 DocStr(wxSysColourChangedEvent,
2022 "This class is used for EVT_SYS_COLOUR_CHANGED, which are generated
2023 when the user changes the colour settings using the control
2024 panel. This is only applicable under Windows.
2025
2026 The default event handler for this event propagates the event to child
2027 windows, since Windows only sends the events to top-level windows. If
2028 intercepting this event for a top-level window, remember to call
2029 `Skip` so the the base class handler will still be executed, or to
2030 pass the event on to the window's children explicitly.
2031 ", "");
2032
2033 class wxSysColourChangedEvent: public wxEvent {
2034 public:
2035     DocCtorStr(
2036         wxSysColourChangedEvent(),
2037         "Constructor", "");
2038 };
2039
2040 //---------------------------------------------------------------------------
2041 %newgroup;
2042
2043
2044 DocStr(wxMouseCaptureChangedEvent,
2045 "An mouse capture changed event (EVT_MOUSE_CAPTURE_CHANGED) is sent to
2046 a window that loses its mouse capture. This is called even if
2047 `wx.Window.ReleaseMouse` was called by the application code. Handling
2048 this event allows an application to cater for unexpected capture
2049 releases which might otherwise confuse mouse handling code.
2050
2051 This event is implemented under Windows only.", "");
2052
2053 class wxMouseCaptureChangedEvent : public wxEvent
2054 {
2055 public:
2056     DocCtorStr(
2057         wxMouseCaptureChangedEvent(wxWindowID winid = 0, wxWindow* gainedCapture = NULL),
2058         "Constructor", "");
2059
2060     DocDeclStr(
2061         wxWindow* , GetCapturedWindow() const,
2062         "Returns the window that gained the capture, or ``None`` if it was a
2063 non-wxWidgets window.", "");
2064
2065 };
2066
2067 //---------------------------------------------------------------------------
2068 %newgroup;
2069
2070 DocStr(wxDisplayChangedEvent,
2071 "An EVT_DISPLAY_CHANGED event is sent to all windows when the display
2072 resolution has changed.
2073
2074 This event is implemented under Windows only.", "");
2075
2076 class wxDisplayChangedEvent : public wxEvent
2077 {
2078 public:
2079     DocCtorStr(
2080         wxDisplayChangedEvent(),
2081         "", "");
2082 };
2083
2084 //---------------------------------------------------------------------------
2085 %newgroup;
2086
2087 DocStr(wxPaletteChangedEvent,
2088 "An EVT_PALETTE_CHANGED event is sent when the system palette has
2089 changed, thereby giving each window a chance to redo their own to
2090 match.
2091
2092 This event is implemented under Windows only.", "");
2093
2094 class  wxPaletteChangedEvent : public wxEvent
2095 {
2096 public:
2097     wxPaletteChangedEvent(wxWindowID id = 0);
2098
2099     void SetChangedWindow(wxWindow* win);
2100     wxWindow* GetChangedWindow();
2101
2102 };
2103
2104 //---------------------------------------------------------------------------
2105 %newgroup;
2106
2107 DocStr(wxQueryNewPaletteEvent,
2108        "An EVT_QUERY_NEW_PALETE event indicates the window is getting keyboard
2109 focus and should re-do its palette.
2110
2111 This event is implemented under Windows only.", "");
2112
2113 class wxQueryNewPaletteEvent : public wxEvent
2114 {
2115 public:
2116     DocCtorStr(
2117         wxQueryNewPaletteEvent(wxWindowID winid = 0),
2118         "Constructor.", "");
2119
2120     DocDeclStr(
2121         void , SetPaletteRealized(bool realized),
2122         "App should set this if it changes the palette.", "");
2123
2124     bool GetPaletteRealized() const;
2125 };
2126
2127 //---------------------------------------------------------------------------
2128 %newgroup;
2129
2130
2131
2132 DocStr(wxNavigationKeyEvent,
2133 "EVT_NAVIGATION_KEY events are used to control moving the focus between
2134 widgets, otherwise known as tab-traversal.  You woudl normally not
2135 catch navigation events in applications as there are already
2136 appropriate handlers in `wx.Dialog` and `wx.Panel`, but you may find
2137 it useful to send navigation events in certain situations to change
2138 the focus in certain ways, although it's probably easier to just call
2139 `wx.Window.Navigate`.", "");
2140
2141 class wxNavigationKeyEvent : public wxEvent
2142 {
2143 public:
2144     DocCtorStr(
2145         wxNavigationKeyEvent(),
2146         "", "");
2147
2148     DocDeclStr(
2149         bool , GetDirection() const,
2150         "Returns ``True`` if the direction is forward, ``False`` otherwise.", "");
2151
2152     DocDeclStr(
2153         void , SetDirection(bool forward),
2154         "Specify the direction that the navigation should take.  Usually the
2155 difference between using Tab and Shift-Tab.", "");
2156
2157
2158     DocDeclStr(
2159         bool , IsWindowChange() const,
2160         "Returns ``True`` if window change is allowed.", "");
2161
2162     DocDeclStr(
2163         void , SetWindowChange(bool ischange),
2164         "Specify if the navigation should be able to change parent windows.
2165 For example, changing notebook pages, etc. This is usually implemented
2166 by using Control-Tab.", "");
2167
2168
2169     DocDeclStr(
2170         bool , IsFromTab() const,
2171         "Returns ``True`` if the navigation event is originated from the Tab
2172 key.", "");
2173
2174     DocDeclStr(
2175         void , SetFromTab(bool bIs),
2176         "Set to true under MSW if the event was generated using the tab key.
2177 This is required for proper navogation over radio buttons.", "");
2178
2179
2180     DocDeclStr(
2181         void , SetFlags(long flags),
2182         "Set the navigation flags to a combination of the following:
2183
2184     * wx.NavigationKeyEvent.IsBackward
2185     * wx.NavigationKeyEvent.IsForward
2186     * wx.NavigationKeyEvent.WinChange
2187     * wx.NavigationKeyEvent.FromTab
2188 ", "");
2189
2190
2191     DocDeclStr(
2192         wxWindow* , GetCurrentFocus() const,
2193         "Returns the child window which currenty has the focus.  May be
2194 ``None``.", "");
2195
2196     DocDeclStr(
2197         void , SetCurrentFocus(wxWindow *win),
2198         "Set the window that has the focus.", "");
2199
2200
2201     enum {
2202         IsBackward,
2203         IsForward,
2204         WinChange,
2205         FromTab
2206     };
2207 };
2208
2209 //---------------------------------------------------------------------------
2210 %newgroup;
2211
2212
2213 DocStr(wxWindowCreateEvent,
2214        "The EVT_WINDOW_CREATE event is sent as soon as the window object (the
2215 underlying GUI object) exists.", "");
2216
2217 class wxWindowCreateEvent : public wxCommandEvent
2218 {
2219 public:
2220     wxWindowCreateEvent(wxWindow *win = NULL);
2221
2222     DocDeclStr(
2223         wxWindow *, GetWindow() const,
2224         "Returns the window that this event refers to.", "");
2225
2226 };
2227
2228
2229 DocStr(wxWindowDestroyEvent,
2230        "The EVT_WINDOW_DESTROY event is sent right before the window is
2231 destroyed.", "");
2232 class wxWindowDestroyEvent : public wxCommandEvent
2233 {
2234 public:
2235     wxWindowDestroyEvent(wxWindow *win = NULL);
2236
2237     DocDeclStr(
2238         wxWindow *, GetWindow() const,
2239         "Returns the window that this event refers to.", "");
2240 };
2241
2242
2243 //---------------------------------------------------------------------------
2244 %newgroup;
2245
2246
2247 DocStr(wxContextMenuEvent,
2248 "This class is used for context menu events (EVT_CONTECT_MENU,) sent to
2249 give the application a chance to show a context (popup) menu.", "");
2250
2251 class wxContextMenuEvent : public wxCommandEvent
2252 {
2253 public:
2254     DocCtorStr(
2255         wxContextMenuEvent(wxEventType type = wxEVT_NULL,
2256                            wxWindowID winid = 0,
2257                            const wxPoint& pt = wxDefaultPosition),
2258         "Constructor.", "");
2259
2260     // Position of event (in screen coordinates)
2261     DocDeclStr(
2262         const wxPoint& , GetPosition() const,
2263         "Returns the position (in screen coordinants) at which the menu should
2264 be shown.", "");
2265
2266
2267     DocDeclStr(
2268         void , SetPosition(const wxPoint& pos),
2269         "Sets the position at which the menu should be shown.", "");
2270
2271 };
2272
2273 //---------------------------------------------------------------------------
2274 %newgroup;
2275
2276 enum wxIdleMode
2277 {
2278     wxIDLE_PROCESS_ALL,
2279     wxIDLE_PROCESS_SPECIFIED
2280 };
2281
2282
2283 DocStr(wxIdleEvent,
2284 "This class is used for EVT_IDLE events, which are generated and sent
2285 when the application *becomes* idle.  In other words, the when the
2286 event queue becomes empty then idle events are sent to all windows (by
2287 default) and as long as none of them call `RequestMore` then there are
2288 no more idle events until after the system event queue has some normal
2289 events and then becomes empty again.
2290
2291 By default, idle events are sent to all windows. If this is causing a
2292 significant overhead in your application, you can call
2293 `wx.IdleEvent.SetMode` with the value wx.IDLE_PROCESS_SPECIFIED, and
2294 set the wx.WS_EX_PROCESS_IDLE extra window style for every window
2295 which should receive idle events.  Then idle events will only be sent
2296 to those windows and not to any others.", "");
2297
2298 class wxIdleEvent : public wxEvent
2299 {
2300 public:
2301     DocCtorStr(
2302         wxIdleEvent(),
2303         "Constructor", "");
2304
2305
2306     DocDeclStr(
2307         void , RequestMore(bool needMore = true),
2308         "Tells wxWidgets that more processing is required. This function can be
2309 called by an EVT_IDLE handler for a window to indicate that the
2310 application should forward the EVT_IDLE event once more to the
2311 application windows. If no window calls this function during its
2312 EVT_IDLE handler, then the application will remain in a passive event
2313 loop until a new event is posted to the application by the windowing
2314 system.", "");
2315
2316     DocDeclStr(
2317         bool , MoreRequested() const,
2318         "Returns ``True`` if the OnIdle function processing this event
2319 requested more processing time.", "");
2320
2321
2322     DocDeclStr(
2323         static void , SetMode(wxIdleMode mode),
2324         "Static method for specifying how wxWidgets will send idle events: to
2325 all windows, or only to those which specify that they will process the
2326 events.
2327
2328 The mode can be one of the following values:
2329
2330     =========================   ========================================
2331     wx.IDLE_PROCESS_ALL         Send idle events to all windows
2332     wx.IDLE_PROCESS_SPECIFIED   Send idle events only to windows that have
2333                                 the wx.WS_EX_PROCESS_IDLE extra style
2334                                 flag set.
2335     =========================   ========================================
2336 ", "");
2337
2338
2339     DocDeclStr(
2340         static wxIdleMode , GetMode(),
2341         "Static method returning a value specifying how wxWidgets will send
2342 idle events: to all windows, or only to those which specify that they
2343 will process the events.", "");
2344
2345
2346     DocDeclStr(
2347         static bool , CanSend(wxWindow* win),
2348         "Returns ``True`` if it is appropriate to send idle events to this
2349 window.
2350
2351 This function looks at the mode used (see `wx.IdleEvent.SetMode`), and
2352 the wx.WS_EX_PROCESS_IDLE style in window to determine whether idle
2353 events should be sent to this window now. By default this will always
2354 return ``True`` because the update mode is initially
2355 wx.IDLE_PROCESS_ALL. You can change the mode to only send idle events
2356 to windows with the wx.WS_EX_PROCESS_IDLE extra window style set.", "");
2357
2358 };
2359
2360 //---------------------------------------------------------------------------
2361 %newgroup;
2362
2363 // These classes can be derived from in Python and passed through the event
2364 // system without loosing anything.  They do this by keeping a reference to
2365 // themselves and some special case handling in wxPyCallback::EventThunker.
2366
2367 DocStr(wxPyEvent,
2368 "wx.PyEvent can be used as a base class for implementing custom event
2369 types in Python.  You should derived from this class instead of
2370 `wx.Event` because this class is Python-aware and is able to transport
2371 its Python bits safely through the wxWidgets event system and have
2372 them still be there when the event handler is invoked.
2373
2374 :see: `wx.PyCommandEvent`
2375 ", "");
2376
2377 class wxPyEvent : public wxEvent {
2378 public:
2379     %pythonAppend wxPyEvent     "self._SetSelf(self)"
2380     DocCtorStr(
2381         wxPyEvent(int winid=0, wxEventType eventType = wxEVT_NULL ),
2382         "", "");
2383
2384     ~wxPyEvent();
2385
2386
2387     %Rename(_SetSelf, void , SetSelf(PyObject* self));
2388     %Rename(_GetSelf, PyObject* , GetSelf());
2389 };
2390
2391
2392
2393 DocStr(wxPyCommandEvent,
2394 "wx.PyCommandEvent can be used as a base class for implementing custom
2395 event types in Python, where the event shoudl travel up to parent
2396 windows looking for a handler.  You should derived from this class
2397 instead of `wx.CommandEvent` because this class is Python-aware and is
2398 able to transport its Python bits safely through the wxWidgets event
2399 system and have them still be there when the event handler is invoked.
2400
2401 :see: `wx.PyEvent`
2402 ", "");
2403
2404 class wxPyCommandEvent : public wxCommandEvent {
2405 public:
2406     %pythonAppend wxPyCommandEvent     "self._SetSelf(self)"
2407
2408     DocCtorStr(
2409         wxPyCommandEvent(wxEventType eventType = wxEVT_NULL, int id=0),
2410         "", "");
2411
2412     ~wxPyCommandEvent();
2413
2414     %Rename(_SetSelf, void , SetSelf(PyObject* self));
2415     %Rename(_GetSelf, PyObject* , GetSelf());
2416 };
2417
2418
2419
2420 //---------------------------------------------------------------------------
2421
2422
2423 DocStr(wxDateEvent,
2424 "This event class holds information about a date change event and is
2425 used together with `wx.DatePickerCtrl`. It also serves as a base class
2426 for `wx.calendar.CalendarEvent`.  Bind these event types with
2427 EVT_DATE_CHANGED.", "");
2428
2429 class wxDateEvent : public wxCommandEvent
2430 {
2431 public:
2432     DocCtorStr(
2433         wxDateEvent(wxWindow *win, const wxDateTime& dt, wxEventType type),
2434         "", "");
2435
2436     DocDeclStr(
2437         const wxDateTime& , GetDate() const,
2438         "Returns the date.", "");
2439
2440     DocDeclStr(
2441         void , SetDate(const wxDateTime &date),
2442         "Sets the date carried by the event, normally only used by the library
2443 internally.", "");
2444
2445
2446 };
2447
2448
2449 %constant wxEventType wxEVT_DATE_CHANGED;
2450
2451 %pythoncode {
2452     EVT_DATE_CHANGED = wx.PyEventBinder( wxEVT_DATE_CHANGED, 1 )
2453 }
2454
2455
2456 //---------------------------------------------------------------------------