wxPython/src/_event.i

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