wxPython/src/_event.i

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