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