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