]> git.saurik.com Git - wxWidgets.git/blame - wxPython/src/_event.i
reSWIGged
[wxWidgets.git] / wxPython / src / _event.i
CommitLineData
d14a1e28
RD
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
25enum 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
38wxEventType wxNewEventType();
39
40
41%constant wxEventType wxEVT_NULL;
42%constant wxEventType wxEVT_FIRST;
43%constant wxEventType wxEVT_USER_FIRST;
44
45%constant wxEventType wxEVT_COMMAND_BUTTON_CLICKED;
46%constant wxEventType wxEVT_COMMAND_CHECKBOX_CLICKED;
47%constant wxEventType wxEVT_COMMAND_CHOICE_SELECTED;
48%constant wxEventType wxEVT_COMMAND_LISTBOX_SELECTED;
49%constant wxEventType wxEVT_COMMAND_LISTBOX_DOUBLECLICKED;
50%constant wxEventType wxEVT_COMMAND_CHECKLISTBOX_TOGGLED;
51
52%constant wxEventType wxEVT_COMMAND_MENU_SELECTED;
53%constant wxEventType wxEVT_COMMAND_TOOL_CLICKED;
54%constant wxEventType wxEVT_COMMAND_SLIDER_UPDATED;
55%constant wxEventType wxEVT_COMMAND_RADIOBOX_SELECTED;
56%constant wxEventType wxEVT_COMMAND_RADIOBUTTON_SELECTED;
57
58%constant wxEventType wxEVT_COMMAND_SCROLLBAR_UPDATED;
59%constant wxEventType wxEVT_COMMAND_VLBOX_SELECTED;
60%constant wxEventType wxEVT_COMMAND_COMBOBOX_SELECTED;
61%constant wxEventType wxEVT_COMMAND_TOOL_RCLICKED;
62%constant wxEventType wxEVT_COMMAND_TOOL_ENTER;
63
64// Mouse event types
65%constant wxEventType wxEVT_LEFT_DOWN;
66%constant wxEventType wxEVT_LEFT_UP;
67%constant wxEventType wxEVT_MIDDLE_DOWN;
68%constant wxEventType wxEVT_MIDDLE_UP;
69%constant wxEventType wxEVT_RIGHT_DOWN;
70%constant wxEventType wxEVT_RIGHT_UP;
71%constant wxEventType wxEVT_MOTION;
72%constant wxEventType wxEVT_ENTER_WINDOW;
73%constant wxEventType wxEVT_LEAVE_WINDOW;
74%constant wxEventType wxEVT_LEFT_DCLICK;
75%constant wxEventType wxEVT_MIDDLE_DCLICK;
76%constant wxEventType wxEVT_RIGHT_DCLICK;
77%constant wxEventType wxEVT_SET_FOCUS;
78%constant wxEventType wxEVT_KILL_FOCUS;
79%constant wxEventType wxEVT_CHILD_FOCUS;
80%constant wxEventType wxEVT_MOUSEWHEEL;
81
82// Non-client mouse events
83%constant wxEventType wxEVT_NC_LEFT_DOWN;
84%constant wxEventType wxEVT_NC_LEFT_UP;
85%constant wxEventType wxEVT_NC_MIDDLE_DOWN;
86%constant wxEventType wxEVT_NC_MIDDLE_UP;
87%constant wxEventType wxEVT_NC_RIGHT_DOWN;
88%constant wxEventType wxEVT_NC_RIGHT_UP;
89%constant wxEventType wxEVT_NC_MOTION;
90%constant wxEventType wxEVT_NC_ENTER_WINDOW;
91%constant wxEventType wxEVT_NC_LEAVE_WINDOW;
92%constant wxEventType wxEVT_NC_LEFT_DCLICK;
93%constant wxEventType wxEVT_NC_MIDDLE_DCLICK;
94%constant wxEventType wxEVT_NC_RIGHT_DCLICK;
95
96// Character input event type
97%constant wxEventType wxEVT_CHAR;
98%constant wxEventType wxEVT_CHAR_HOOK;
99%constant wxEventType wxEVT_NAVIGATION_KEY;
100%constant wxEventType wxEVT_KEY_DOWN;
101%constant wxEventType wxEVT_KEY_UP;
102%constant wxEventType wxEVT_HOTKEY;
103
104// Set cursor event
105%constant wxEventType wxEVT_SET_CURSOR;
106
107// wxScrollBar and wxSlider event identifiers
108%constant wxEventType wxEVT_SCROLL_TOP;
109%constant wxEventType wxEVT_SCROLL_BOTTOM;
110%constant wxEventType wxEVT_SCROLL_LINEUP;
111%constant wxEventType wxEVT_SCROLL_LINEDOWN;
112%constant wxEventType wxEVT_SCROLL_PAGEUP;
113%constant wxEventType wxEVT_SCROLL_PAGEDOWN;
114%constant wxEventType wxEVT_SCROLL_THUMBTRACK;
115%constant wxEventType wxEVT_SCROLL_THUMBRELEASE;
116%constant wxEventType wxEVT_SCROLL_ENDSCROLL;
117
118// Scroll events from wxWindow
119%constant wxEventType wxEVT_SCROLLWIN_TOP;
120%constant wxEventType wxEVT_SCROLLWIN_BOTTOM;
121%constant wxEventType wxEVT_SCROLLWIN_LINEUP;
122%constant wxEventType wxEVT_SCROLLWIN_LINEDOWN;
123%constant wxEventType wxEVT_SCROLLWIN_PAGEUP;
124%constant wxEventType wxEVT_SCROLLWIN_PAGEDOWN;
125%constant wxEventType wxEVT_SCROLLWIN_THUMBTRACK;
126%constant wxEventType wxEVT_SCROLLWIN_THUMBRELEASE;
127
128// System events
129%constant wxEventType wxEVT_SIZE;
130%constant wxEventType wxEVT_MOVE;
131%constant wxEventType wxEVT_CLOSE_WINDOW;
132%constant wxEventType wxEVT_END_SESSION;
133%constant wxEventType wxEVT_QUERY_END_SESSION;
134%constant wxEventType wxEVT_ACTIVATE_APP;
135%constant wxEventType wxEVT_POWER;
136%constant wxEventType wxEVT_ACTIVATE;
137%constant wxEventType wxEVT_CREATE;
138%constant wxEventType wxEVT_DESTROY;
139%constant wxEventType wxEVT_SHOW;
140%constant wxEventType wxEVT_ICONIZE;
141%constant wxEventType wxEVT_MAXIMIZE;
142%constant wxEventType wxEVT_MOUSE_CAPTURE_CHANGED;
143%constant wxEventType wxEVT_PAINT;
144%constant wxEventType wxEVT_ERASE_BACKGROUND;
145%constant wxEventType wxEVT_NC_PAINT;
146%constant wxEventType wxEVT_PAINT_ICON;
147%constant wxEventType wxEVT_MENU_OPEN;
148%constant wxEventType wxEVT_MENU_CLOSE;
149%constant wxEventType wxEVT_MENU_HIGHLIGHT;
150
151%constant wxEventType wxEVT_CONTEXT_MENU;
152%constant wxEventType wxEVT_SYS_COLOUR_CHANGED;
153%constant wxEventType wxEVT_DISPLAY_CHANGED;
154%constant wxEventType wxEVT_SETTING_CHANGED;
155%constant wxEventType wxEVT_QUERY_NEW_PALETTE;
156%constant wxEventType wxEVT_PALETTE_CHANGED;
157%constant wxEventType wxEVT_DROP_FILES;
158%constant wxEventType wxEVT_DRAW_ITEM;
159%constant wxEventType wxEVT_MEASURE_ITEM;
160%constant wxEventType wxEVT_COMPARE_ITEM;
161%constant wxEventType wxEVT_INIT_DIALOG;
162%constant wxEventType wxEVT_IDLE;
163%constant wxEventType wxEVT_UPDATE_UI;
164%constant wxEventType wxEVT_SIZING;
165%constant wxEventType wxEVT_MOVING;
166
167// Generic command events
168// Note: a click is a higher-level event than button down/up
169%constant wxEventType wxEVT_COMMAND_LEFT_CLICK;
170%constant wxEventType wxEVT_COMMAND_LEFT_DCLICK;
171%constant wxEventType wxEVT_COMMAND_RIGHT_CLICK;
172%constant wxEventType wxEVT_COMMAND_RIGHT_DCLICK;
173%constant wxEventType wxEVT_COMMAND_SET_FOCUS;
174%constant wxEventType wxEVT_COMMAND_KILL_FOCUS;
175%constant wxEventType wxEVT_COMMAND_ENTER;
176
177
178
179%pythoncode {
180%#
181%# Create some event binders
182EVT_SIZE = wx.PyEventBinder( wxEVT_SIZE )
183EVT_SIZING = wx.PyEventBinder( wxEVT_SIZING )
184EVT_MOVE = wx.PyEventBinder( wxEVT_MOVE )
185EVT_MOVING = wx.PyEventBinder( wxEVT_MOVING )
186EVT_CLOSE = wx.PyEventBinder( wxEVT_CLOSE_WINDOW )
187EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
188EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
189EVT_PAINT = wx.PyEventBinder( wxEVT_PAINT )
190EVT_NC_PAINT = wx.PyEventBinder( wxEVT_NC_PAINT )
191EVT_ERASE_BACKGROUND = wx.PyEventBinder( wxEVT_ERASE_BACKGROUND )
192EVT_CHAR = wx.PyEventBinder( wxEVT_CHAR )
193EVT_KEY_DOWN = wx.PyEventBinder( wxEVT_KEY_DOWN )
194EVT_KEY_UP = wx.PyEventBinder( wxEVT_KEY_UP )
195EVT_HOTKEY = wx.PyEventBinder( wxEVT_HOTKEY, 1)
196EVT_CHAR_HOOK = wx.PyEventBinder( wxEVT_CHAR_HOOK )
197EVT_MENU_OPEN = wx.PyEventBinder( wxEVT_MENU_OPEN )
198EVT_MENU_CLOSE = wx.PyEventBinder( wxEVT_MENU_CLOSE )
199EVT_MENU_HIGHLIGHT = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT, 1)
200EVT_MENU_HIGHLIGHT_ALL = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT )
201EVT_SET_FOCUS = wx.PyEventBinder( wxEVT_SET_FOCUS )
202EVT_KILL_FOCUS = wx.PyEventBinder( wxEVT_KILL_FOCUS )
203EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS )
204EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE )
205EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP )
206EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
207EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
208EVT_DROP_FILES = wx.PyEventBinder( wxEVT_DROP_FILES )
209EVT_INIT_DIALOG = wx.PyEventBinder( wxEVT_INIT_DIALOG )
210EVT_SYS_COLOUR_CHANGED = wx.PyEventBinder( wxEVT_SYS_COLOUR_CHANGED )
211EVT_DISPLAY_CHANGED = wx.PyEventBinder( wxEVT_DISPLAY_CHANGED )
212EVT_SHOW = wx.PyEventBinder( wxEVT_SHOW )
213EVT_MAXIMIZE = wx.PyEventBinder( wxEVT_MAXIMIZE )
214EVT_ICONIZE = wx.PyEventBinder( wxEVT_ICONIZE )
215EVT_NAVIGATION_KEY = wx.PyEventBinder( wxEVT_NAVIGATION_KEY )
216EVT_PALETTE_CHANGED = wx.PyEventBinder( wxEVT_PALETTE_CHANGED )
217EVT_QUERY_NEW_PALETTE = wx.PyEventBinder( wxEVT_QUERY_NEW_PALETTE )
218EVT_WINDOW_CREATE = wx.PyEventBinder( wxEVT_CREATE )
219EVT_WINDOW_DESTROY = wx.PyEventBinder( wxEVT_DESTROY )
220EVT_SET_CURSOR = wx.PyEventBinder( wxEVT_SET_CURSOR )
221EVT_MOUSE_CAPTURE_CHANGED = wx.PyEventBinder( wxEVT_MOUSE_CAPTURE_CHANGED )
222
223EVT_LEFT_DOWN = wx.PyEventBinder( wxEVT_LEFT_DOWN )
224EVT_LEFT_UP = wx.PyEventBinder( wxEVT_LEFT_UP )
225EVT_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_MIDDLE_DOWN )
226EVT_MIDDLE_UP = wx.PyEventBinder( wxEVT_MIDDLE_UP )
227EVT_RIGHT_DOWN = wx.PyEventBinder( wxEVT_RIGHT_DOWN )
228EVT_RIGHT_UP = wx.PyEventBinder( wxEVT_RIGHT_UP )
229EVT_MOTION = wx.PyEventBinder( wxEVT_MOTION )
230EVT_LEFT_DCLICK = wx.PyEventBinder( wxEVT_LEFT_DCLICK )
231EVT_MIDDLE_DCLICK = wx.PyEventBinder( wxEVT_MIDDLE_DCLICK )
232EVT_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_RIGHT_DCLICK )
233EVT_LEAVE_WINDOW = wx.PyEventBinder( wxEVT_LEAVE_WINDOW )
234EVT_ENTER_WINDOW = wx.PyEventBinder( wxEVT_ENTER_WINDOW )
235EVT_MOUSEWHEEL = wx.PyEventBinder( wxEVT_MOUSEWHEEL )
236
237EVT_MOUSE_EVENTS = wx.PyEventBinder([ wxEVT_LEFT_DOWN,
238 wxEVT_LEFT_UP,
239 wxEVT_MIDDLE_DOWN,
240 wxEVT_MIDDLE_UP,
241 wxEVT_RIGHT_DOWN,
242 wxEVT_RIGHT_UP,
243 wxEVT_MOTION,
244 wxEVT_LEFT_DCLICK,
245 wxEVT_MIDDLE_DCLICK,
246 wxEVT_RIGHT_DCLICK,
247 wxEVT_ENTER_WINDOW,
248 wxEVT_LEAVE_WINDOW,
249 wxEVT_MOUSEWHEEL
250 ])
251
252
253%# Scrolling from wxWindow (sent to wxScrolledWindow)
254EVT_SCROLLWIN = wx.PyEventBinder([ wxEVT_SCROLLWIN_TOP,
255 wxEVT_SCROLLWIN_BOTTOM,
256 wxEVT_SCROLLWIN_LINEUP,
257 wxEVT_SCROLLWIN_LINEDOWN,
258 wxEVT_SCROLLWIN_PAGEUP,
259 wxEVT_SCROLLWIN_PAGEDOWN,
260 wxEVT_SCROLLWIN_THUMBTRACK,
261 wxEVT_SCROLLWIN_THUMBRELEASE,
262 ])
263
264EVT_SCROLLWIN_TOP = wx.PyEventBinder( wxEVT_SCROLLWIN_TOP )
265EVT_SCROLLWIN_BOTTOM = wx.PyEventBinder( wxEVT_SCROLLWIN_BOTTOM )
266EVT_SCROLLWIN_LINEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEUP )
267EVT_SCROLLWIN_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEDOWN )
268EVT_SCROLLWIN_PAGEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEUP )
269EVT_SCROLLWIN_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEDOWN )
270EVT_SCROLLWIN_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBTRACK )
271EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE )
272
273%# Scrolling from wxSlider and wxScrollBar
274EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
275 wxEVT_SCROLL_BOTTOM,
276 wxEVT_SCROLL_LINEUP,
277 wxEVT_SCROLL_LINEDOWN,
278 wxEVT_SCROLL_PAGEUP,
279 wxEVT_SCROLL_PAGEDOWN,
280 wxEVT_SCROLL_THUMBTRACK,
281 wxEVT_SCROLL_THUMBRELEASE,
282 wxEVT_SCROLL_ENDSCROLL,
283 ])
284
285EVT_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP )
286EVT_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM )
287EVT_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP )
288EVT_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN )
289EVT_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP )
290EVT_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN )
291EVT_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK )
292EVT_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE )
293EVT_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL )
294
295%# Scrolling from wxSlider and wxScrollBar, with an id
296EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
297 wxEVT_SCROLL_BOTTOM,
298 wxEVT_SCROLL_LINEUP,
299 wxEVT_SCROLL_LINEDOWN,
300 wxEVT_SCROLL_PAGEUP,
301 wxEVT_SCROLL_PAGEDOWN,
302 wxEVT_SCROLL_THUMBTRACK,
303 wxEVT_SCROLL_THUMBRELEASE,
304 wxEVT_SCROLL_ENDSCROLL,
305 ], 1)
306
307EVT_COMMAND_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP, 1)
308EVT_COMMAND_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM, 1)
309EVT_COMMAND_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP, 1)
310EVT_COMMAND_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN, 1)
311EVT_COMMAND_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP, 1)
312EVT_COMMAND_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN, 1)
313EVT_COMMAND_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1)
314EVT_COMMAND_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE, 1)
315EVT_COMMAND_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL, 1)
316
d14a1e28
RD
317EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1)
318EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1)
319EVT_CHOICE = wx.PyEventBinder( wxEVT_COMMAND_CHOICE_SELECTED, 1)
320EVT_LISTBOX = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_SELECTED, 1)
321EVT_LISTBOX_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, 1)
322EVT_MENU = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 1)
323EVT_MENU_RANGE = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 2)
324EVT_SLIDER = wx.PyEventBinder( wxEVT_COMMAND_SLIDER_UPDATED, 1)
325EVT_RADIOBOX = wx.PyEventBinder( wxEVT_COMMAND_RADIOBOX_SELECTED, 1)
326EVT_RADIOBUTTON = wx.PyEventBinder( wxEVT_COMMAND_RADIOBUTTON_SELECTED, 1)
327
328EVT_SCROLLBAR = wx.PyEventBinder( wxEVT_COMMAND_SCROLLBAR_UPDATED, 1)
329EVT_VLBOX = wx.PyEventBinder( wxEVT_COMMAND_VLBOX_SELECTED, 1)
330EVT_COMBOBOX = wx.PyEventBinder( wxEVT_COMMAND_COMBOBOX_SELECTED, 1)
331EVT_TOOL = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 1)
332EVT_TOOL_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 2)
333EVT_TOOL_RCLICKED = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 1)
334EVT_TOOL_RCLICKED_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 2)
335EVT_TOOL_ENTER = wx.PyEventBinder( wxEVT_COMMAND_TOOL_ENTER, 1)
336EVT_CHECKLISTBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, 1)
337
338
339EVT_COMMAND_LEFT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_CLICK, 1)
340EVT_COMMAND_LEFT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_DCLICK, 1)
341EVT_COMMAND_RIGHT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_CLICK, 1)
342EVT_COMMAND_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_DCLICK, 1)
343EVT_COMMAND_SET_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_SET_FOCUS, 1)
344EVT_COMMAND_KILL_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_KILL_FOCUS, 1)
345EVT_COMMAND_ENTER = wx.PyEventBinder( wxEVT_COMMAND_ENTER, 1)
346
347EVT_IDLE = wx.PyEventBinder( wxEVT_IDLE )
348
349EVT_UPDATE_UI = wx.PyEventBinder( wxEVT_UPDATE_UI, 1)
350EVT_UPDATE_UI_RANGE = wx.PyEventBinder( wxEVT_UPDATE_UI, 2)
351
352EVT_CONTEXT_MENU = wx.PyEventBinder( wxEVT_CONTEXT_MENU )
353
354
355}
356
357//---------------------------------------------------------------------------
358%newgroup;
359
360class wxEvent : public wxObject {
361public:
362 // wxEvent(int winid = 0, wxEventType commandType = wxEVT_NULL); // *** This class is now an ABC
363 ~wxEvent();
364
365 void SetEventType(wxEventType typ);
366 wxEventType GetEventType() const;
367 wxObject *GetEventObject() const;
368 void SetEventObject(wxObject *obj);
369 long GetTimestamp() const;
370 void SetTimestamp(long ts = 0);
371 int GetId() const;
372 void SetId(int Id);
373
374
375 bool IsCommandEvent() const;
376
377 // Can instruct event processor that we wish to ignore this event
378 // (treat as if the event table entry had not been found): this must be done
379 // to allow the event processing by the base classes (calling event.Skip()
380 // is the analog of calling the base class verstion of a virtual function)
dd9f7fea 381 void Skip(bool skip = True);
d14a1e28
RD
382 bool GetSkipped() const;
383
384 // Determine if this event should be propagating to the parent window.
385 bool ShouldPropagate() const;
386
387 // Stop an event from propagating to its parent window, returns the old
388 // propagation level value
389 int StopPropagation();
390
391 // Resume the event propagation by restoring the propagation level
392 // (returned by StopPropagation())
393 void ResumePropagation(int propagationLevel);
394
395 // this function is used to create a copy of the event polymorphically and
396 // all derived classes must implement it because otherwise wxPostEvent()
397 // for them wouldn't work (it needs to do a copy of the event)
398 virtual wxEvent *Clone() /* =0*/;
399};
400
401
402//---------------------------------------------------------------------------
403%newgroup;
404
405// Helper class to temporarily change an event not to propagate.
406class wxPropagationDisabler
407{
408public:
409 wxPropagationDisabler(wxEvent& event);
410 ~wxPropagationDisabler();
411};
412
413
414// Another one to temporarily lower propagation level.
415class wxPropagateOnce
416{
417public:
418 wxPropagateOnce(wxEvent& event);
419 ~wxPropagateOnce();
420};
421
422//---------------------------------------------------------------------------
423%newgroup;
424
425class wxCommandEvent : public wxEvent
426{
427public:
428 wxCommandEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
429
430
431// // Set/Get client data from controls
432// void SetClientData(void* clientData) { m_clientData = clientData; }
433// void *GetClientData() const { return m_clientData; }
434
435// // Set/Get client object from controls
436// void SetClientObject(wxClientData* clientObject) { m_clientObject = clientObject; }
437// void *GetClientObject() const { return m_clientObject; }
438
439
440 // Get listbox selection if single-choice
441 int GetSelection() const;
442
443 // Set/Get listbox/choice selection string
444 void SetString(const wxString& s);
445 wxString GetString() const;
446
447 // Get checkbox value
448 bool IsChecked() const;
61c5a8ac
RD
449 %pythoncode { Checked = IsChecked }
450
dd9f7fea 451 // True if the listbox event was a selection.
d14a1e28
RD
452 bool IsSelection() const;
453
454 void SetExtraLong(long extraLong);
455 long GetExtraLong() const;
456
457 void SetInt(int i);
458 long GetInt() const;
459
460 virtual wxEvent *Clone() const;
461
462};
463
464//---------------------------------------------------------------------------
465%newgroup;
466
467// this class adds a possibility to react (from the user) code to a control
468// notification: allow or veto the operation being reported.
469class wxNotifyEvent : public wxCommandEvent
470{
471public:
472 wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
473
474 // veto the operation (usually it's allowed by default)
475 void Veto();
476
477 // allow the operation if it was disabled by default
478 void Allow();
479
480 // for implementation code only: is the operation allowed?
481 bool IsAllowed();
482};
483
484
485//---------------------------------------------------------------------------
486%newgroup;
487
488// Scroll event class, derived form wxCommandEvent. wxScrollEvents are
489// sent by wxSlider and wxScrollBar.
490class wxScrollEvent : public wxCommandEvent
491{
492public:
493 wxScrollEvent(wxEventType commandType = wxEVT_NULL,
494 int winid = 0, int pos = 0, int orient = 0);
495
496 int GetOrientation() const;
497 int GetPosition() const;
498 void SetOrientation(int orient);
499 void SetPosition(int pos);
500};
501
502
503//---------------------------------------------------------------------------
504%newgroup;
505
506// ScrollWin event class, derived fom wxEvent. wxScrollWinEvents
507// are sent by wxWindow.
508class wxScrollWinEvent : public wxEvent
509{
510public:
511 wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
512 int pos = 0, int orient = 0);
513
514 int GetOrientation() const;
515 int GetPosition() const;
516 void SetOrientation(int orient);
517 void SetPosition(int pos);
518};
519
520//---------------------------------------------------------------------------
521%newgroup;
522
523// the symbolic names for the mouse buttons
524enum
525{
526 wxMOUSE_BTN_ANY = -1,
527 wxMOUSE_BTN_NONE = -1,
528 wxMOUSE_BTN_LEFT = 0,
529 wxMOUSE_BTN_MIDDLE = 1,
530 wxMOUSE_BTN_RIGHT = 2
531};
532
533
534// Mouse event class
535class wxMouseEvent : public wxEvent
536{
537public:
538 wxMouseEvent(wxEventType mouseType = wxEVT_NULL);
539
540 // Was it a button event? (*doesn't* mean: is any button *down*?)
541 bool IsButton() const;
542
543 // Was it a down event from this (or any) button?
544 bool ButtonDown(int but = wxMOUSE_BTN_ANY) const;
545
546 // Was it a dclick event from this (or any) button?
547 bool ButtonDClick(int but = wxMOUSE_BTN_ANY) const;
548
549 // Was it a up event from this (or any) button?
550 bool ButtonUp(int but = wxMOUSE_BTN_ANY) const;
551
552 // Was the given button changing state?
553 bool Button(int but) const;
554
555 // Was the given button in Down state?
556 bool ButtonIsDown(int but) const;
557
558 // Get the button which is changing state (wxMOUSE_BTN_NONE if none)
559 int GetButton() const;
560
561 // Find state of shift/control keys
562 bool ControlDown() const;
563 bool MetaDown() const;
564 bool AltDown() const;
565 bool ShiftDown() const;
566
567 // Find which event was just generated
568 bool LeftDown() const;
569 bool MiddleDown() const;
570 bool RightDown() const;
571
572 bool LeftUp() const;
573 bool MiddleUp() const;
574 bool RightUp() const;
575
576 bool LeftDClick() const;
577 bool MiddleDClick() const;
578 bool RightDClick() const;
579
580 // Find the current state of the mouse buttons (regardless
581 // of current event type)
582 bool LeftIsDown();
583 bool MiddleIsDown();
584 bool RightIsDown();
585
586 // True if a button is down and the mouse is moving
587 bool Dragging() const;
588
589 // True if the mouse is moving, and no button is down
590 bool Moving() const;
591
592 // True if the mouse is just entering the window
593 bool Entering() const;
594
595 // True if the mouse is just leaving the window
596 bool Leaving() const;
597
dd9f7fea
RD
598
599 DocStr(GetPosition, // sets the docstring for both
d07d2bc9
RD
600 "Returns the position of the mouse in window coordinates when the event
601happened.", "");
d14a1e28 602 wxPoint GetPosition();
d14a1e28 603
dd9f7fea
RD
604 DocDeclAName(
605 void, GetPosition(long *OUTPUT, long *OUTPUT),
606 "GetPositionTuple() -> (x,y)",
607 GetPositionTuple);
608
d14a1e28
RD
609 // Find the logical position of the event given the DC
610 wxPoint GetLogicalPosition(const wxDC& dc) const;
611
612 // Get X position
613 wxCoord GetX() const;
614
615 // Get Y position
616 wxCoord GetY() const;
617
618 // Get wheel rotation, positive or negative indicates direction of
619 // rotation. Current devices all send an event when rotation is equal to
620 // +/-WheelDelta, but this allows for finer resolution devices to be
621 // created in the future. Because of this you shouldn't assume that one
622 // event is equal to 1 line or whatever, but you should be able to either
623 // do partial line scrolling or wait until +/-WheelDelta rotation values
624 // have been accumulated before scrolling.
625 int GetWheelRotation() const;
626
627 // Get wheel delta, normally 120. This is the threshold for action to be
628 // taken, and one such action (for example, scrolling one increment)
629 // should occur for each delta.
630 int GetWheelDelta() const;
631
632 // Returns the configured number of lines (or whatever) to be scrolled per
633 // wheel action. Defaults to one.
634 int GetLinesPerAction() const;
635
636 // Is the system set to do page scrolling?
637 bool IsPageScroll() const;
638
639public:
640 wxCoord m_x, m_y;
641
642 bool m_leftDown;
643 bool m_middleDown;
644 bool m_rightDown;
645
646 bool m_controlDown;
647 bool m_shiftDown;
648 bool m_altDown;
649 bool m_metaDown;
650
651 int m_wheelRotation;
652 int m_wheelDelta;
653 int m_linesPerAction;
654};
655
656//---------------------------------------------------------------------------
657%newgroup;
658
659// Cursor set event
660class wxSetCursorEvent : public wxEvent
661{
662public:
663 wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0);
664
665 wxCoord GetX() const;
666 wxCoord GetY() const;
667
668 void SetCursor(const wxCursor& cursor);
669 const wxCursor& GetCursor() const;
670 bool HasCursor() const;
671};
672
673//---------------------------------------------------------------------------
674%newgroup;
675
676// Keyboard input event class
677
678class wxKeyEvent : public wxEvent
679{
680public:
681 wxKeyEvent(wxEventType keyType = wxEVT_NULL);
682
683 // Find state of shift/control keys
684 bool ControlDown() const;
685 bool MetaDown() const;
686 bool AltDown() const;
687 bool ShiftDown() const;
688
689 // exclude MetaDown() from HasModifiers() because NumLock under X is often
690 // configured as mod2 modifier, yet the key events even when it is pressed
691 // should be processed normally, not like Ctrl- or Alt-key
692 bool HasModifiers() const;
693
694 // get the key code: an ASCII7 char or an element of wxKeyCode enum
695 int GetKeyCode() const;
696 %pythoncode { KeyCode = GetKeyCode }
697
698 %extend {
699 int GetUniChar() {
3b7224dc 700 %#if wxUSE_UNICODE
d14a1e28 701 return self->m_uniChar;
3b7224dc 702 %#else
d14a1e28 703 return 0;
3b7224dc 704 %#endif
d14a1e28
RD
705 }
706 }
707
708 // get the raw key code (platform-dependent)
709 wxUint32 GetRawKeyCode() const;
710
711 // get the raw key flags (platform-dependent)
712 wxUint32 GetRawKeyFlags() const;
713
dd9f7fea
RD
714
715 DocStr(GetPosition, // sets the docstring for both
d07d2bc9 716 "Find the position of the event.", "");
d14a1e28 717 wxPoint GetPosition();
dd9f7fea
RD
718
719 DocDeclAName(
720 void, GetPosition(long *OUTPUT, long *OUTPUT),
721 "GetPositionTuple() -> (x,y)",
722 GetPositionTuple);
d14a1e28
RD
723
724 // Get X position
725 wxCoord GetX() const;
726
727 // Get Y position
728 wxCoord GetY() const;
729
730public:
731 wxCoord m_x, m_y;
732
733 long m_keyCode;
734
735 bool m_controlDown;
736 bool m_shiftDown;
737 bool m_altDown;
738 bool m_metaDown;
739 bool m_scanCode;
740
741 // these fields contain the platform-specific information about
742 // key that was pressed
743 wxUint32 m_rawCode;
744 wxUint32 m_rawFlags;
745};
746
747//---------------------------------------------------------------------------
748%newgroup;
749
750// Size event class
751class wxSizeEvent : public wxEvent
752{
753public:
754 wxSizeEvent(const wxSize& sz=wxDefaultSize, int winid = 0);
755
756 wxSize GetSize() const;
757 wxRect GetRect() const;
758 void SetRect(wxRect rect);
759 %extend {
760 void SetSize(wxSize size) {
761 self->m_size = size;
762 }
763 }
764
765public:
766 wxSize m_size;
767 wxRect m_rect; // Used for wxEVT_SIZING
768};
769
770
771//---------------------------------------------------------------------------
772%newgroup;
773
774// Move event class
775class wxMoveEvent : public wxEvent
776{
777public:
778 wxMoveEvent(const wxPoint& pos=wxDefaultPosition, int winid = 0);
779
780 wxPoint GetPosition() const;
781 wxRect GetRect() const;
782 void SetRect(wxRect rect);
783 %extend {
784 void SetPosition(wxPoint pos) {
785 self->m_pos = pos;
786 }
787 }
788
789 wxPoint m_pos;
790 wxRect m_rect;
791};
792
793//---------------------------------------------------------------------------
794%newgroup;
795
796// Paint event class
797class wxPaintEvent : public wxEvent
798{
799public:
800 wxPaintEvent(int Id = 0);
801};
802
803
804class wxNcPaintEvent : public wxEvent
805{
806public:
807 wxNcPaintEvent(int winid = 0);
808};
809
810//---------------------------------------------------------------------------
811%newgroup;
812
813class wxEraseEvent : public wxEvent
814{
815public:
816 wxEraseEvent(int Id = 0, wxDC *dc = (wxDC *) NULL);
817
818 wxDC *GetDC() const;
819};
820
821
822//---------------------------------------------------------------------------
823%newgroup;
824
825class wxFocusEvent : public wxEvent
826{
827public:
828 wxFocusEvent(wxEventType type = wxEVT_NULL, int winid = 0);
829
830 // The window associated with this event is the window which had focus
831 // before for SET event and the window which will have focus for the KILL
832 // one. NB: it may be NULL in both cases!
833 wxWindow *GetWindow() const;
834 void SetWindow(wxWindow *win);
835};
836
837//---------------------------------------------------------------------------
838%newgroup;
839
840// wxChildFocusEvent notifies the parent that a child has got the focus: unlike
841// wxFocusEvent it is propagated upwards the window chain
842class wxChildFocusEvent : public wxCommandEvent
843{
844public:
845 wxChildFocusEvent(wxWindow *win = NULL);
846
847 wxWindow *GetWindow() const;
848};
849
850//---------------------------------------------------------------------------
851%newgroup;
852
853class wxActivateEvent : public wxEvent
854{
855public:
dd9f7fea 856 wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = True, int Id = 0);
d14a1e28
RD
857 bool GetActive() const;
858};
859
860
861//---------------------------------------------------------------------------
862%newgroup;
863
864class wxInitDialogEvent : public wxEvent
865{
866public:
867 wxInitDialogEvent(int Id = 0);
868};
869
870
871//---------------------------------------------------------------------------
872%newgroup;
873
874class wxMenuEvent : public wxEvent
875{
876public:
877 wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0, wxMenu* menu = NULL);
878
879 // only for wxEVT_MENU_HIGHLIGHT
880 int GetMenuId() const;
881
882 // only for wxEVT_MENU_OPEN/CLOSE
883 bool IsPopup() const;
884
885 // only for wxEVT_MENU_OPEN/CLOSE
886 wxMenu* GetMenu() const;
887};
888
889//---------------------------------------------------------------------------
890%newgroup;
891
892// Window close or session close event class
893class wxCloseEvent : public wxEvent
894{
895public:
896 wxCloseEvent(wxEventType type = wxEVT_NULL, int winid = 0);
897
898 void SetLoggingOff(bool logOff);
899 bool GetLoggingOff() const;
900
dd9f7fea 901 void Veto(bool veto = True);
d14a1e28
RD
902 void SetCanVeto(bool canVeto);
903
904 bool CanVeto() const;
905 bool GetVeto() const;
906};
907
908
909//---------------------------------------------------------------------------
910%newgroup;
911
912class wxShowEvent : public wxEvent
913{
914public:
dd9f7fea 915 wxShowEvent(int winid = 0, bool show = False);
d14a1e28
RD
916
917 void SetShow(bool show);
918 bool GetShow() const;
919
920};
921
922
923//---------------------------------------------------------------------------
924%newgroup;
925
926class wxIconizeEvent: public wxEvent
927{
928public:
dd9f7fea 929 wxIconizeEvent(int id = 0, bool iconized = True);
d14a1e28
RD
930 bool Iconized();
931};
932
933
934//---------------------------------------------------------------------------
935%newgroup;
936
937class wxMaximizeEvent: public wxEvent
938{
939public:
940 wxMaximizeEvent(int id = 0);
941};
942
943//---------------------------------------------------------------------------
944%newgroup;
945
946class wxDropFilesEvent: public wxEvent
947{
948public:
949 wxPoint GetPosition();
950 int GetNumberOfFiles();
951
952 %extend {
953 PyObject* GetFiles() {
954 int count = self->GetNumberOfFiles();
955 wxString* files = self->GetFiles();
956 PyObject* list = PyList_New(count);
957
958 if (!list) {
959 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
960 return NULL;
961 }
962
963 for (int i=0; i<count; i++) {
1fc9204a 964 PyList_SetItem(list, i, wx2PyString(files[i]));
d14a1e28
RD
965 }
966 return list;
967 }
968 }
969};
970
971
972
973//---------------------------------------------------------------------------
974%newgroup;
975
976
977// Whether to always send update events to windows, or
978// to only send update events to those with the
979// wxWS_EX_PROCESS_UI_UPDATES style.
980
981enum wxUpdateUIMode
982{
983 // Send UI update events to all windows
984 wxUPDATE_UI_PROCESS_ALL,
985
986 // Send UI update events to windows that have
987 // the wxWS_EX_PROCESS_UI_UPDATES flag specified
988 wxUPDATE_UI_PROCESS_SPECIFIED
989};
990
64e8a1f0
RD
991
992
d14a1e28
RD
993class wxUpdateUIEvent : public wxCommandEvent
994{
995public:
996 wxUpdateUIEvent(wxWindowID commandId = 0);
997
998 bool GetChecked() const;
999 bool GetEnabled() const;
1000 wxString GetText() const;
1001 bool GetSetText() const;
1002 bool GetSetChecked() const;
1003 bool GetSetEnabled() const;
1004
1005 void Check(bool check);
1006 void Enable(bool enable);
1007 void SetText(const wxString& text);
1008
1009 // Sets the interval between updates in milliseconds.
1010 // Set to -1 to disable updates, or to 0 to update as frequently as possible.
1011 static void SetUpdateInterval(long updateInterval);
1012
1013 // Returns the current interval between updates in milliseconds
1014 static long GetUpdateInterval();
1015
1016 // Can we update this window?
1017 static bool CanUpdate(wxWindow *win);
1018
1019 // Reset the update time to provide a delay until the next
1020 // time we should update
1021 static void ResetUpdateTime();
1022
1023 // Specify how wxWindows will send update events: to
1024 // all windows, or only to those which specify that they
1025 // will process the events.
1026 static void SetMode(wxUpdateUIMode mode);
1027
1028 // Returns the UI update mode
1029 static wxUpdateUIMode GetMode();
1030};
1031
d14a1e28
RD
1032//---------------------------------------------------------------------------
1033%newgroup;
1034
1035class wxSysColourChangedEvent: public wxEvent {
1036public:
1037 wxSysColourChangedEvent();
1038};
1039
1040//---------------------------------------------------------------------------
1041%newgroup;
1042
1043
1044// wxEVT_MOUSE_CAPTURE_CHANGED
1045// The window losing the capture receives this message
1046// (even if it released the capture itself).
1047class wxMouseCaptureChangedEvent : public wxEvent
1048{
1049public:
1050 wxMouseCaptureChangedEvent(wxWindowID winid = 0, wxWindow* gainedCapture = NULL);
1051
1052 wxWindow* GetCapturedWindow() const;
1053};
1054
1055//---------------------------------------------------------------------------
1056%newgroup;
1057
1058class wxDisplayChangedEvent : public wxEvent
1059{
1060public:
1061 wxDisplayChangedEvent();
1062};
1063
1064//---------------------------------------------------------------------------
1065%newgroup;
1066
1067class wxPaletteChangedEvent : public wxEvent
1068{
1069public:
1070 wxPaletteChangedEvent(wxWindowID id = 0);
1071
1072 void SetChangedWindow(wxWindow* win);
1073 wxWindow* GetChangedWindow();
1074
1075};
1076
1077//---------------------------------------------------------------------------
1078%newgroup;
1079
1080
1081// wxEVT_QUERY_NEW_PALETTE
1082// Indicates the window is getting keyboard focus and should re-do its palette.
1083class wxQueryNewPaletteEvent : public wxEvent
1084{
1085public:
1086 wxQueryNewPaletteEvent(wxWindowID winid = 0);
1087
1088 // App sets this if it changes the palette.
1089 void SetPaletteRealized(bool realized);
1090 bool GetPaletteRealized() const;
1091};
1092
1093//---------------------------------------------------------------------------
1094%newgroup;
1095
1096
1097// Event generated by dialog navigation keys
1098// wxEVT_NAVIGATION_KEY
1099
1100class wxNavigationKeyEvent : public wxEvent
1101{
1102public:
1103 wxNavigationKeyEvent();
1104
dd9f7fea 1105 // direction: forward (True) or backward (False)
d14a1e28 1106 bool GetDirection() const;
3b74f194 1107 void SetDirection(bool forward);
d14a1e28
RD
1108
1109 // it may be a window change event (MDI, notebook pages...) or a control
1110 // change event
1111 bool IsWindowChange() const;
3b74f194 1112 void SetWindowChange(bool ischange);
d14a1e28 1113
3b74f194
RD
1114 void SetFlags(long flags);
1115
d14a1e28
RD
1116 // the child which has the focus currently (may be NULL - use
1117 // wxWindow::FindFocus then)
1118 wxWindow* GetCurrentFocus() const;
1119 void SetCurrentFocus(wxWindow *win);
3b74f194
RD
1120
1121 enum {
1122 IsForward,
1123 WinChange
1124 };
d14a1e28
RD
1125};
1126
1127
1128//---------------------------------------------------------------------------
1129%newgroup;
1130
1131// Window creation/destruction events: the first is sent as soon as window is
1132// created (i.e. the underlying GUI object exists), but when the C++ object is
1133// fully initialized (so virtual functions may be called). The second,
1134// wxEVT_DESTROY, is sent right before the window is destroyed - again, it's
1135// still safe to call virtual functions at this moment
1136
1137class wxWindowCreateEvent : public wxCommandEvent
1138{
1139public:
1140 wxWindowCreateEvent(wxWindow *win = NULL);
1141 wxWindow *GetWindow() const;
1142};
1143
1144class wxWindowDestroyEvent : public wxCommandEvent
1145{
1146public:
1147 wxWindowDestroyEvent(wxWindow *win = NULL);
1148 wxWindow *GetWindow() const;
1149};
1150
1151
1152//---------------------------------------------------------------------------
1153%newgroup;
1154
1155// A Context event is sent when the user right clicks on a window or
1156// presses Shift-F10
1157// NOTE : Under windows this is a repackaged WM_CONTETXMENU message
1158// Under other systems it may have to be generated from a right click event
1159/*
1160 wxEVT_CONTEXT_MENU
1161*/
1162
1163class wxContextMenuEvent : public wxCommandEvent
1164{
1165public:
1166 wxContextMenuEvent(wxEventType type = wxEVT_NULL,
1167 wxWindowID winid = 0,
1168 const wxPoint& pt = wxDefaultPosition);
1169
1170 // Position of event (in screen coordinates)
1171 const wxPoint& GetPosition() const;
1172 void SetPosition(const wxPoint& pos);
1173};
1174
1175//---------------------------------------------------------------------------
1176%newgroup;
1177
1178// Whether to always send idle events to windows, or
1179// to only send update events to those with the
1180// wxWS_EX_PROCESS_IDLE style.
1181
1182enum wxIdleMode
1183{
1184 // Send idle events to all windows
1185 wxIDLE_PROCESS_ALL,
1186
1187 // Send idle events to windows that have
1188 // the wxWS_EX_PROCESS_IDLE flag specified
1189 wxIDLE_PROCESS_SPECIFIED
1190};
1191
64e8a1f0 1192
d14a1e28
RD
1193class wxIdleEvent : public wxEvent
1194{
1195public:
1196 wxIdleEvent();
1197
dd9f7fea 1198 void RequestMore(bool needMore = True);
d14a1e28
RD
1199 bool MoreRequested() const;
1200
1201 // Specify how wxWindows will send idle events: to
1202 // all windows, or only to those which specify that they
1203 // will process the events.
1204 static void SetMode(wxIdleMode mode);
1205
1206 // Returns the idle event mode
1207 static wxIdleMode GetMode();
1208
1209 // Can we send an idle event?
1210 static bool CanSend(wxWindow* win);
1211};
1212
1213//---------------------------------------------------------------------------
1214%newgroup;
1215
1216// These classes can be derived from in Python and passed through the event
1217// system without loosing anything. They do this by keeping a reference to
1218// themselves and some special case handling in wxPyCallback::EventThunker.
1219
1220class wxPyEvent : public wxEvent {
1221public:
2b9048c5 1222 %pythonAppend wxPyEvent "self.SetSelf(self)"
d14a1e28
RD
1223 wxPyEvent(int winid=0, wxEventType commandType = wxEVT_NULL );
1224 ~wxPyEvent();
1225
1226
1227 void SetSelf(PyObject* self);
1228 PyObject* GetSelf();
1229};
1230
1231
1232class wxPyCommandEvent : public wxCommandEvent {
1233public:
2b9048c5 1234 %pythonAppend wxPyCommandEvent "self.SetSelf(self)"
d14a1e28
RD
1235 wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0);
1236 ~wxPyCommandEvent();
1237
1238 void SetSelf(PyObject* self);
1239 PyObject* GetSelf();
1240};
1241
1242
1243
1244//---------------------------------------------------------------------------
1245
1246
1247