]> git.saurik.com Git - wxWidgets.git/blob - src/common/event.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Sorry, needed to fix typo in previous commit.
[wxWidgets.git] / src / common / event.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/event.cpp
3 // Purpose: Event classes
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/event.h"
28 #include "wx/evtloop.h"
29
30 #ifndef WX_PRECOMP
31 #include "wx/list.h"
32 #include "wx/log.h"
33 #include "wx/app.h"
34 #include "wx/utils.h"
35 #include "wx/stopwatch.h"
36 #include "wx/module.h"
37
38 #if wxUSE_GUI
39 #include "wx/window.h"
40 #include "wx/control.h"
41 #include "wx/dc.h"
42 #include "wx/spinbutt.h"
43 #include "wx/textctrl.h"
44 #include "wx/validate.h"
45 #endif // wxUSE_GUI
46 #endif
47
48 #include "wx/thread.h"
49
50 #if wxUSE_BASE
51 #include "wx/scopedptr.h"
52
53 wxDECLARE_SCOPED_PTR(wxEvent, wxEventPtr)
54 wxDEFINE_SCOPED_PTR(wxEvent, wxEventPtr)
55 #endif // wxUSE_BASE
56
57 // ----------------------------------------------------------------------------
58 // wxWin macros
59 // ----------------------------------------------------------------------------
60
61 #if wxUSE_BASE
62 IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
63 IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
64 IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
65 #endif // wxUSE_BASE
66
67 #if wxUSE_GUI
68 IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
69 IMPLEMENT_DYNAMIC_CLASS(wxThreadEvent, wxCommandEvent)
70 IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent, wxCommandEvent)
71 IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
72 IMPLEMENT_DYNAMIC_CLASS(wxScrollWinEvent, wxEvent)
73 IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent, wxEvent)
74 IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent, wxEvent)
75 IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent, wxEvent)
76 IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent, wxEvent)
77 IMPLEMENT_DYNAMIC_CLASS(wxNcPaintEvent, wxEvent)
78 IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent, wxEvent)
79 IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent, wxEvent)
80 IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent, wxEvent)
81 IMPLEMENT_DYNAMIC_CLASS(wxChildFocusEvent, wxCommandEvent)
82 IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent, wxEvent)
83 IMPLEMENT_DYNAMIC_CLASS(wxShowEvent, wxEvent)
84 IMPLEMENT_DYNAMIC_CLASS(wxMaximizeEvent, wxEvent)
85 IMPLEMENT_DYNAMIC_CLASS(wxIconizeEvent, wxEvent)
86 IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent, wxEvent)
87 IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent, wxEvent)
88 IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent, wxEvent)
89 IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent, wxEvent)
90 IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent, wxEvent)
91 IMPLEMENT_DYNAMIC_CLASS(wxSetCursorEvent, wxEvent)
92 IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
93 IMPLEMENT_DYNAMIC_CLASS(wxDisplayChangedEvent, wxEvent)
94 IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxCommandEvent)
95 IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent, wxEvent)
96 IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent, wxEvent)
97 IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent, wxEvent)
98 IMPLEMENT_DYNAMIC_CLASS(wxWindowCreateEvent, wxEvent)
99 IMPLEMENT_DYNAMIC_CLASS(wxWindowDestroyEvent, wxEvent)
100 IMPLEMENT_DYNAMIC_CLASS(wxHelpEvent, wxCommandEvent)
101 IMPLEMENT_DYNAMIC_CLASS(wxContextMenuEvent, wxCommandEvent)
102 IMPLEMENT_DYNAMIC_CLASS(wxMouseCaptureChangedEvent, wxEvent)
103 IMPLEMENT_DYNAMIC_CLASS(wxMouseCaptureLostEvent, wxEvent)
104 IMPLEMENT_DYNAMIC_CLASS(wxClipboardTextEvent, wxCommandEvent)
105 #endif // wxUSE_GUI
106
107 #if wxUSE_BASE
108
109 const wxEventTable *wxEvtHandler::GetEventTable() const
110 { return &wxEvtHandler::sm_eventTable; }
111
112 const wxEventTable wxEvtHandler::sm_eventTable =
113 { (const wxEventTable *)NULL, &wxEvtHandler::sm_eventTableEntries[0] };
114
115 wxEventHashTable &wxEvtHandler::GetEventHashTable() const
116 { return wxEvtHandler::sm_eventHashTable; }
117
118 wxEventHashTable wxEvtHandler::sm_eventHashTable(wxEvtHandler::sm_eventTable);
119
120 const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
121 { DECLARE_EVENT_TABLE_TERMINATOR() };
122
123
124 // wxUSE_MEMORY_TRACING considers memory freed from the static objects dtors
125 // leaked, so we need to manually clean up all event tables before checking for
126 // the memory leaks when using it, however this breaks re-initializing the
127 // library (i.e. repeated calls to wxInitialize/wxUninitialize) because the
128 // event tables won't be rebuilt the next time, so disable this by default
129 #if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
130
131 class wxEventTableEntryModule: public wxModule
132 {
133 public:
134 wxEventTableEntryModule() { }
135 virtual bool OnInit() { return true; }
136 virtual void OnExit() { wxEventHashTable::ClearAll(); }
137
138 DECLARE_DYNAMIC_CLASS(wxEventTableEntryModule)
139 };
140
141 IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
142
143 #endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
144
145 // ----------------------------------------------------------------------------
146 // global variables
147 // ----------------------------------------------------------------------------
148
149 // common event types are defined here, other event types are defined by the
150 // components which use them
151
152 const wxEventType wxEVT_FIRST = 10000;
153 const wxEventType wxEVT_USER_FIRST = wxEVT_FIRST + 2000;
154
155 DEFINE_EVENT_TYPE(wxEVT_NULL)
156 wxDEFINE_EVENT( wxEVT_IDLE, wxIdleEvent );
157
158 #endif // wxUSE_BASE
159
160 #if wxUSE_GUI
161
162 wxDEFINE_EVENT( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEvent );
163 wxDEFINE_EVENT( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEvent );
164 wxDEFINE_EVENT( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEvent );
165 wxDEFINE_EVENT( wxEVT_COMMAND_LISTBOX_SELECTED, wxCommandEvent );
166 wxDEFINE_EVENT( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEvent );
167 wxDEFINE_EVENT( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, wxCommandEvent );
168 wxDEFINE_EVENT( wxEVT_COMMAND_MENU_SELECTED, wxCommandEvent );
169 wxDEFINE_EVENT( wxEVT_COMMAND_SLIDER_UPDATED, wxCommandEvent );
170 wxDEFINE_EVENT( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEvent );
171 wxDEFINE_EVENT( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEvent );
172 wxDEFINE_EVENT( wxEVT_COMMAND_SCROLLBAR_UPDATED, wxCommandEvent );
173 wxDEFINE_EVENT( wxEVT_COMMAND_VLBOX_SELECTED, wxCommandEvent );
174 wxDEFINE_EVENT( wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEvent );
175 wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_RCLICKED, wxCommandEvent );
176 wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_ENTER, wxCommandEvent );
177 wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEvent );
178 wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, wxCommandEvent );
179 wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, wxCommandEvent );
180
181 // Mouse event types
182 wxDEFINE_EVENT( wxEVT_LEFT_DOWN, wxMouseEvent );
183 wxDEFINE_EVENT( wxEVT_LEFT_UP, wxMouseEvent );
184 wxDEFINE_EVENT( wxEVT_MIDDLE_DOWN, wxMouseEvent );
185 wxDEFINE_EVENT( wxEVT_MIDDLE_UP, wxMouseEvent );
186 wxDEFINE_EVENT( wxEVT_RIGHT_DOWN, wxMouseEvent );
187 wxDEFINE_EVENT( wxEVT_RIGHT_UP, wxMouseEvent );
188 wxDEFINE_EVENT( wxEVT_MOTION, wxMouseEvent );
189 wxDEFINE_EVENT( wxEVT_ENTER_WINDOW, wxMouseEvent );
190 wxDEFINE_EVENT( wxEVT_LEAVE_WINDOW, wxMouseEvent );
191 wxDEFINE_EVENT( wxEVT_LEFT_DCLICK, wxMouseEvent );
192 wxDEFINE_EVENT( wxEVT_MIDDLE_DCLICK, wxMouseEvent );
193 wxDEFINE_EVENT( wxEVT_RIGHT_DCLICK, wxMouseEvent );
194 wxDEFINE_EVENT( wxEVT_SET_FOCUS, wxFocusEvent );
195 wxDEFINE_EVENT( wxEVT_KILL_FOCUS, wxFocusEvent );
196 wxDEFINE_EVENT( wxEVT_CHILD_FOCUS, wxChildFocusEvent );
197 wxDEFINE_EVENT( wxEVT_MOUSEWHEEL, wxMouseEvent );
198 wxDEFINE_EVENT( wxEVT_AUX1_DOWN, wxMouseEvent );
199 wxDEFINE_EVENT( wxEVT_AUX1_UP, wxMouseEvent );
200 wxDEFINE_EVENT( wxEVT_AUX1_DCLICK, wxMouseEvent );
201 wxDEFINE_EVENT( wxEVT_AUX2_DOWN, wxMouseEvent );
202 wxDEFINE_EVENT( wxEVT_AUX2_UP, wxMouseEvent );
203 wxDEFINE_EVENT( wxEVT_AUX2_DCLICK, wxMouseEvent );
204
205 // Character input event type
206 wxDEFINE_EVENT( wxEVT_CHAR, wxKeyEvent );
207 wxDEFINE_EVENT( wxEVT_CHAR_HOOK, wxKeyEvent );
208 wxDEFINE_EVENT( wxEVT_NAVIGATION_KEY, wxNavigationKeyEvent );
209 wxDEFINE_EVENT( wxEVT_KEY_DOWN, wxKeyEvent );
210 wxDEFINE_EVENT( wxEVT_KEY_UP, wxKeyEvent );
211 #if wxUSE_HOTKEY
212 wxDEFINE_EVENT( wxEVT_HOTKEY, wxKeyEvent );
213 #endif
214
215 // Set cursor event
216 wxDEFINE_EVENT( wxEVT_SET_CURSOR, wxSetCursorEvent );
217
218 // wxScrollbar and wxSlider event identifiers
219 wxDEFINE_EVENT( wxEVT_SCROLL_TOP, wxScrollEvent );
220 wxDEFINE_EVENT( wxEVT_SCROLL_BOTTOM, wxScrollEvent );
221 wxDEFINE_EVENT( wxEVT_SCROLL_LINEUP, wxScrollEvent );
222 wxDEFINE_EVENT( wxEVT_SCROLL_LINEDOWN, wxScrollEvent );
223 wxDEFINE_EVENT( wxEVT_SCROLL_PAGEUP, wxScrollEvent );
224 wxDEFINE_EVENT( wxEVT_SCROLL_PAGEDOWN, wxScrollEvent );
225 wxDEFINE_EVENT( wxEVT_SCROLL_THUMBTRACK, wxScrollEvent );
226 wxDEFINE_EVENT( wxEVT_SCROLL_THUMBRELEASE, wxScrollEvent );
227 wxDEFINE_EVENT( wxEVT_SCROLL_CHANGED, wxScrollEvent );
228
229 // Due to a bug in older wx versions, wxSpinEvents were being sent with type of
230 // wxEVT_SCROLL_LINEUP, wxEVT_SCROLL_LINEDOWN and wxEVT_SCROLL_THUMBTRACK. But
231 // with the type-safe events in place, these event types are associated with
232 // wxScrollEvent. To allow handling of spin events, new event types have been
233 // defined in spinbutt.h/spinnbuttcmn.cpp. To maintain backward compatibility
234 // the spin event types are being initialized with the scroll event types.
235
236 #if wxUSE_SPINBTN
237
238 wxDEFINE_EVENT_ALIAS( wxEVT_SPIN_UP, wxSpinEvent, wxEVT_SCROLL_LINEUP );
239 wxDEFINE_EVENT_ALIAS( wxEVT_SPIN_DOWN, wxSpinEvent, wxEVT_SCROLL_LINEDOWN );
240 wxDEFINE_EVENT_ALIAS( wxEVT_SPIN, wxSpinEvent, wxEVT_SCROLL_THUMBTRACK );
241
242 #endif // wxUSE_SPINBTN
243
244 // Scroll events from wxWindow
245 wxDEFINE_EVENT( wxEVT_SCROLLWIN_TOP, wxScrollWinEvent );
246 wxDEFINE_EVENT( wxEVT_SCROLLWIN_BOTTOM, wxScrollWinEvent );
247 wxDEFINE_EVENT( wxEVT_SCROLLWIN_LINEUP, wxScrollWinEvent );
248 wxDEFINE_EVENT( wxEVT_SCROLLWIN_LINEDOWN, wxScrollWinEvent );
249 wxDEFINE_EVENT( wxEVT_SCROLLWIN_PAGEUP, wxScrollWinEvent );
250 wxDEFINE_EVENT( wxEVT_SCROLLWIN_PAGEDOWN, wxScrollWinEvent );
251 wxDEFINE_EVENT( wxEVT_SCROLLWIN_THUMBTRACK, wxScrollWinEvent );
252 wxDEFINE_EVENT( wxEVT_SCROLLWIN_THUMBRELEASE, wxScrollWinEvent );
253
254 // System events
255 wxDEFINE_EVENT( wxEVT_SIZE, wxSizeEvent );
256 wxDEFINE_EVENT( wxEVT_SIZING, wxSizeEvent );
257 wxDEFINE_EVENT( wxEVT_MOVE, wxMoveEvent );
258 wxDEFINE_EVENT( wxEVT_MOVING, wxMoveEvent );
259 wxDEFINE_EVENT( wxEVT_MOVE_START, wxMoveEvent );
260 wxDEFINE_EVENT( wxEVT_MOVE_END, wxMoveEvent );
261 wxDEFINE_EVENT( wxEVT_CLOSE_WINDOW, wxCloseEvent );
262 wxDEFINE_EVENT( wxEVT_END_SESSION, wxCloseEvent );
263 wxDEFINE_EVENT( wxEVT_QUERY_END_SESSION, wxCloseEvent );
264 wxDEFINE_EVENT( wxEVT_HIBERNATE, wxActivateEvent );
265 wxDEFINE_EVENT( wxEVT_ACTIVATE_APP, wxActivateEvent );
266 wxDEFINE_EVENT( wxEVT_ACTIVATE, wxActivateEvent );
267 wxDEFINE_EVENT( wxEVT_CREATE, wxWindowCreateEvent );
268 wxDEFINE_EVENT( wxEVT_DESTROY, wxWindowDestroyEvent );
269 wxDEFINE_EVENT( wxEVT_SHOW, wxShowEvent );
270 wxDEFINE_EVENT( wxEVT_ICONIZE, wxIconizeEvent );
271 wxDEFINE_EVENT( wxEVT_MAXIMIZE, wxMaximizeEvent );
272 wxDEFINE_EVENT( wxEVT_MOUSE_CAPTURE_CHANGED, wxMouseCaptureChangedEvent );
273 wxDEFINE_EVENT( wxEVT_MOUSE_CAPTURE_LOST, wxMouseCaptureLostEvent );
274 wxDEFINE_EVENT( wxEVT_PAINT, wxPaintEvent );
275 wxDEFINE_EVENT( wxEVT_ERASE_BACKGROUND, wxEraseEvent );
276 wxDEFINE_EVENT( wxEVT_NC_PAINT, wxNcPaintEvent );
277 wxDEFINE_EVENT( wxEVT_MENU_OPEN, wxMenuEvent );
278 wxDEFINE_EVENT( wxEVT_MENU_CLOSE, wxMenuEvent );
279 wxDEFINE_EVENT( wxEVT_MENU_HIGHLIGHT, wxMenuEvent );
280 wxDEFINE_EVENT( wxEVT_CONTEXT_MENU, wxContextMenuEvent );
281 wxDEFINE_EVENT( wxEVT_SYS_COLOUR_CHANGED, wxSysColourChangedEvent );
282 wxDEFINE_EVENT( wxEVT_DISPLAY_CHANGED, wxDisplayChangedEvent );
283 wxDEFINE_EVENT( wxEVT_QUERY_NEW_PALETTE, wxQueryNewPaletteEvent );
284 wxDEFINE_EVENT( wxEVT_PALETTE_CHANGED, wxPaletteChangedEvent );
285 wxDEFINE_EVENT( wxEVT_JOY_BUTTON_DOWN, wxJoystickEvent );
286 wxDEFINE_EVENT( wxEVT_JOY_BUTTON_UP, wxJoystickEvent );
287 wxDEFINE_EVENT( wxEVT_JOY_MOVE, wxJoystickEvent );
288 wxDEFINE_EVENT( wxEVT_JOY_ZMOVE, wxJoystickEvent );
289 wxDEFINE_EVENT( wxEVT_DROP_FILES, wxDropFilesEvent );
290 wxDEFINE_EVENT( wxEVT_INIT_DIALOG, wxInitDialogEvent );
291 wxDEFINE_EVENT( wxEVT_UPDATE_UI, wxUpdateUIEvent );
292
293 // Clipboard events
294 wxDEFINE_EVENT( wxEVT_COMMAND_TEXT_COPY, wxClipboardTextEvent );
295 wxDEFINE_EVENT( wxEVT_COMMAND_TEXT_CUT, wxClipboardTextEvent );
296 wxDEFINE_EVENT( wxEVT_COMMAND_TEXT_PASTE, wxClipboardTextEvent );
297
298 // Generic command events
299 // Note: a click is a higher-level event than button down/up
300 wxDEFINE_EVENT( wxEVT_COMMAND_LEFT_CLICK, wxCommandEvent );
301 wxDEFINE_EVENT( wxEVT_COMMAND_LEFT_DCLICK, wxCommandEvent );
302 wxDEFINE_EVENT( wxEVT_COMMAND_RIGHT_CLICK, wxCommandEvent );
303 wxDEFINE_EVENT( wxEVT_COMMAND_RIGHT_DCLICK, wxCommandEvent );
304 wxDEFINE_EVENT( wxEVT_COMMAND_SET_FOCUS, wxCommandEvent );
305 wxDEFINE_EVENT( wxEVT_COMMAND_KILL_FOCUS, wxCommandEvent );
306 wxDEFINE_EVENT( wxEVT_COMMAND_ENTER, wxCommandEvent );
307
308 // Help events
309 wxDEFINE_EVENT( wxEVT_HELP, wxHelpEvent );
310 wxDEFINE_EVENT( wxEVT_DETAILED_HELP, wxHelpEvent );
311
312 // Thread event
313 wxDEFINE_EVENT( wxEVT_COMMAND_THREAD, wxThreadEvent );
314
315 #endif // wxUSE_GUI
316
317 #if wxUSE_BASE
318
319 wxIdleMode wxIdleEvent::sm_idleMode = wxIDLE_PROCESS_ALL;
320
321 // ============================================================================
322 // implementation
323 // ============================================================================
324
325 // ----------------------------------------------------------------------------
326 // event initialization
327 // ----------------------------------------------------------------------------
328
329 int wxNewEventType()
330 {
331 // MT-FIXME
332 static int s_lastUsedEventType = wxEVT_FIRST;
333
334 return s_lastUsedEventType++;
335 }
336 // ----------------------------------------------------------------------------
337 // wxEventFunctor
338 // ----------------------------------------------------------------------------
339
340 wxEventFunctor::~wxEventFunctor()
341 {
342 }
343
344 // ----------------------------------------------------------------------------
345 // wxEvent
346 // ----------------------------------------------------------------------------
347
348 /*
349 * General wxWidgets events, covering all interesting things that might happen
350 * (button clicking, resizing, setting text in widgets, etc.).
351 *
352 * For each completely new event type, derive a new event class.
353 *
354 */
355
356 wxEvent::wxEvent(int theId, wxEventType commandType)
357 {
358 m_eventType = commandType;
359 m_eventObject = NULL;
360 m_timeStamp = 0;
361 m_id = theId;
362 m_skipped = false;
363 m_callbackUserData = NULL;
364 m_isCommandEvent = false;
365 m_propagationLevel = wxEVENT_PROPAGATE_NONE;
366 m_wasProcessed = false;
367 }
368
369 wxEvent::wxEvent(const wxEvent& src)
370 : wxObject(src)
371 , m_eventObject(src.m_eventObject)
372 , m_eventType(src.m_eventType)
373 , m_timeStamp(src.m_timeStamp)
374 , m_id(src.m_id)
375 , m_callbackUserData(src.m_callbackUserData)
376 , m_propagationLevel(src.m_propagationLevel)
377 , m_skipped(src.m_skipped)
378 , m_isCommandEvent(src.m_isCommandEvent)
379 , m_wasProcessed(false)
380 {
381 }
382
383 wxEvent& wxEvent::operator=(const wxEvent& src)
384 {
385 wxObject::operator=(src);
386
387 m_eventObject = src.m_eventObject;
388 m_eventType = src.m_eventType;
389 m_timeStamp = src.m_timeStamp;
390 m_id = src.m_id;
391 m_callbackUserData = src.m_callbackUserData;
392 m_propagationLevel = src.m_propagationLevel;
393 m_skipped = src.m_skipped;
394 m_isCommandEvent = src.m_isCommandEvent;
395
396 // don't change m_wasProcessed
397
398 return *this;
399 }
400
401 #endif // wxUSE_BASE
402
403 #if wxUSE_GUI
404
405 // ----------------------------------------------------------------------------
406 // wxCommandEvent
407 // ----------------------------------------------------------------------------
408
409 #ifdef __VISUALC__
410 // 'this' : used in base member initializer list (for m_commandString)
411 #pragma warning(disable:4355)
412 #endif
413
414 wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
415 : wxEvent(theId, commandType)
416 {
417 m_clientData = NULL;
418 m_clientObject = NULL;
419 m_extraLong = 0;
420 m_commandInt = 0;
421 m_isCommandEvent = true;
422
423 // the command events are propagated upwards by default
424 m_propagationLevel = wxEVENT_PROPAGATE_MAX;
425 }
426
427 #ifdef __VISUALC__
428 #pragma warning(default:4355)
429 #endif
430
431 wxString wxCommandEvent::GetString() const
432 {
433 if (m_eventType != wxEVT_COMMAND_TEXT_UPDATED || !m_eventObject)
434 {
435 return m_cmdString;
436 }
437 else
438 {
439 #if wxUSE_TEXTCTRL
440 wxTextCtrl *txt = wxDynamicCast(m_eventObject, wxTextCtrl);
441 if ( txt )
442 return txt->GetValue();
443 else
444 #endif // wxUSE_TEXTCTRL
445 return m_cmdString;
446 }
447 }
448
449 // ----------------------------------------------------------------------------
450 // wxUpdateUIEvent
451 // ----------------------------------------------------------------------------
452
453 #if wxUSE_LONGLONG
454 wxLongLong wxUpdateUIEvent::sm_lastUpdate = 0;
455 #endif
456
457 long wxUpdateUIEvent::sm_updateInterval = 0;
458
459 wxUpdateUIMode wxUpdateUIEvent::sm_updateMode = wxUPDATE_UI_PROCESS_ALL;
460
461 // Can we update?
462 bool wxUpdateUIEvent::CanUpdate(wxWindowBase *win)
463 {
464 // Don't update if we've switched global updating off
465 // and this window doesn't support updates.
466 if (win &&
467 (GetMode() == wxUPDATE_UI_PROCESS_SPECIFIED &&
468 ((win->GetExtraStyle() & wxWS_EX_PROCESS_UI_UPDATES) == 0)))
469 return false;
470
471 if (sm_updateInterval == -1)
472 return false;
473
474 if (sm_updateInterval == 0)
475 return true;
476
477 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
478 wxLongLong now = wxGetLocalTimeMillis();
479 if (now > (sm_lastUpdate + sm_updateInterval))
480 {
481 return true;
482 }
483
484 return false;
485 #else
486 // If we don't have wxStopWatch or wxLongLong, we
487 // should err on the safe side and update now anyway.
488 return true;
489 #endif
490 }
491
492 // Reset the update time to provide a delay until the next
493 // time we should update
494 void wxUpdateUIEvent::ResetUpdateTime()
495 {
496 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
497 if (sm_updateInterval > 0)
498 {
499 wxLongLong now = wxGetLocalTimeMillis();
500 if (now > (sm_lastUpdate + sm_updateInterval))
501 {
502 sm_lastUpdate = now;
503 }
504 }
505 #endif
506 }
507
508 // ----------------------------------------------------------------------------
509 // wxScrollEvent
510 // ----------------------------------------------------------------------------
511
512 wxScrollEvent::wxScrollEvent(wxEventType commandType,
513 int id,
514 int pos,
515 int orient)
516 : wxCommandEvent(commandType, id)
517 {
518 m_extraLong = orient;
519 m_commandInt = pos;
520 }
521
522 // ----------------------------------------------------------------------------
523 // wxScrollWinEvent
524 // ----------------------------------------------------------------------------
525
526 wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
527 int pos,
528 int orient)
529 {
530 m_eventType = commandType;
531 m_extraLong = orient;
532 m_commandInt = pos;
533 }
534
535 // ----------------------------------------------------------------------------
536 // wxMouseEvent
537 // ----------------------------------------------------------------------------
538
539 wxMouseEvent::wxMouseEvent(wxEventType commandType)
540 {
541 m_eventType = commandType;
542
543 m_x = 0;
544 m_y = 0;
545
546 m_leftDown = false;
547 m_middleDown = false;
548 m_rightDown = false;
549 m_aux1Down = false;
550 m_aux2Down = false;
551
552 m_clickCount = -1;
553
554 m_wheelRotation = 0;
555 m_wheelDelta = 0;
556 m_linesPerAction = 0;
557 m_wheelAxis = 0;
558 }
559
560 void wxMouseEvent::Assign(const wxMouseEvent& event)
561 {
562 wxEvent::operator=(event);
563
564 // Borland C++ 5.82 doesn't compile an explicit call to an implicitly
565 // defined operator=() so need to do it this way:
566 *static_cast<wxMouseState *>(this) = event;
567
568 m_x = event.m_x;
569 m_y = event.m_y;
570
571 m_leftDown = event.m_leftDown;
572 m_middleDown = event.m_middleDown;
573 m_rightDown = event.m_rightDown;
574 m_aux1Down = event.m_aux1Down;
575 m_aux2Down = event.m_aux2Down;
576
577 m_wheelRotation = event.m_wheelRotation;
578 m_wheelDelta = event.m_wheelDelta;
579 m_linesPerAction = event.m_linesPerAction;
580 m_wheelAxis = event.m_wheelAxis;
581 }
582
583 // return true if was a button dclick event
584 bool wxMouseEvent::ButtonDClick(int but) const
585 {
586 switch (but)
587 {
588 default:
589 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDClick"));
590 // fall through
591
592 case wxMOUSE_BTN_ANY:
593 return (LeftDClick() || MiddleDClick() || RightDClick() ||
594 Aux1DClick() || Aux2DClick());
595
596 case wxMOUSE_BTN_LEFT:
597 return LeftDClick();
598
599 case wxMOUSE_BTN_MIDDLE:
600 return MiddleDClick();
601
602 case wxMOUSE_BTN_RIGHT:
603 return RightDClick();
604
605 case wxMOUSE_BTN_AUX1:
606 return Aux1DClick();
607
608 case wxMOUSE_BTN_AUX2:
609 return Aux2DClick();
610 }
611 }
612
613 // return true if was a button down event
614 bool wxMouseEvent::ButtonDown(int but) const
615 {
616 switch (but)
617 {
618 default:
619 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDown"));
620 // fall through
621
622 case wxMOUSE_BTN_ANY:
623 return (LeftDown() || MiddleDown() || RightDown() ||
624 Aux1Down() || Aux2Down());
625
626 case wxMOUSE_BTN_LEFT:
627 return LeftDown();
628
629 case wxMOUSE_BTN_MIDDLE:
630 return MiddleDown();
631
632 case wxMOUSE_BTN_RIGHT:
633 return RightDown();
634
635 case wxMOUSE_BTN_AUX1:
636 return Aux1Down();
637
638 case wxMOUSE_BTN_AUX2:
639 return Aux2Down();
640 }
641 }
642
643 // return true if was a button up event
644 bool wxMouseEvent::ButtonUp(int but) const
645 {
646 switch (but)
647 {
648 default:
649 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonUp"));
650 // fall through
651
652 case wxMOUSE_BTN_ANY:
653 return (LeftUp() || MiddleUp() || RightUp() ||
654 Aux1Up() || Aux2Up());
655
656 case wxMOUSE_BTN_LEFT:
657 return LeftUp();
658
659 case wxMOUSE_BTN_MIDDLE:
660 return MiddleUp();
661
662 case wxMOUSE_BTN_RIGHT:
663 return RightUp();
664
665 case wxMOUSE_BTN_AUX1:
666 return Aux1Up();
667
668 case wxMOUSE_BTN_AUX2:
669 return Aux2Up();
670 }
671 }
672
673 // return true if the given button is currently changing state
674 bool wxMouseEvent::Button(int but) const
675 {
676 switch (but)
677 {
678 default:
679 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::Button"));
680 // fall through
681
682 case wxMOUSE_BTN_ANY:
683 return ButtonUp(wxMOUSE_BTN_ANY) ||
684 ButtonDown(wxMOUSE_BTN_ANY) ||
685 ButtonDClick(wxMOUSE_BTN_ANY);
686
687 case wxMOUSE_BTN_LEFT:
688 return LeftDown() || LeftUp() || LeftDClick();
689
690 case wxMOUSE_BTN_MIDDLE:
691 return MiddleDown() || MiddleUp() || MiddleDClick();
692
693 case wxMOUSE_BTN_RIGHT:
694 return RightDown() || RightUp() || RightDClick();
695
696 case wxMOUSE_BTN_AUX1:
697 return Aux1Down() || Aux1Up() || Aux1DClick();
698
699 case wxMOUSE_BTN_AUX2:
700 return Aux2Down() || Aux2Up() || Aux2DClick();
701 }
702 }
703
704 bool wxMouseEvent::ButtonIsDown(int but) const
705 {
706 switch (but)
707 {
708 default:
709 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonIsDown"));
710 // fall through
711
712 case wxMOUSE_BTN_ANY:
713 return LeftIsDown() || MiddleIsDown() || RightIsDown() || Aux1Down() || Aux2Down();
714
715 case wxMOUSE_BTN_LEFT:
716 return LeftIsDown();
717
718 case wxMOUSE_BTN_MIDDLE:
719 return MiddleIsDown();
720
721 case wxMOUSE_BTN_RIGHT:
722 return RightIsDown();
723
724 case wxMOUSE_BTN_AUX1:
725 return Aux1IsDown();
726
727 case wxMOUSE_BTN_AUX2:
728 return Aux2IsDown();
729 }
730 }
731
732 int wxMouseEvent::GetButton() const
733 {
734 for ( int i = 1; i < wxMOUSE_BTN_MAX; i++ )
735 {
736 if ( Button(i) )
737 {
738 return i;
739 }
740 }
741
742 return wxMOUSE_BTN_NONE;
743 }
744
745 // Find the logical position of the event given the DC
746 wxPoint wxMouseEvent::GetLogicalPosition(const wxDC& dc) const
747 {
748 wxPoint pt(dc.DeviceToLogicalX(m_x), dc.DeviceToLogicalY(m_y));
749 return pt;
750 }
751
752 // ----------------------------------------------------------------------------
753 // wxKeyEvent
754 // ----------------------------------------------------------------------------
755
756 wxKeyEvent::wxKeyEvent(wxEventType type)
757 {
758 m_eventType = type;
759 m_keyCode = 0;
760 #if wxUSE_UNICODE
761 m_uniChar = 0;
762 #endif
763 }
764
765 wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)
766 : wxEvent(evt),
767 wxKeyboardState(evt)
768 {
769 m_x = evt.m_x;
770 m_y = evt.m_y;
771
772 m_keyCode = evt.m_keyCode;
773 m_rawCode = evt.m_rawCode;
774 m_rawFlags = evt.m_rawFlags;
775
776 #if wxUSE_UNICODE
777 m_uniChar = evt.m_uniChar;
778 #endif
779 }
780
781 // ----------------------------------------------------------------------------
782 // wxWindowCreateEvent
783 // ----------------------------------------------------------------------------
784
785 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
786 {
787 SetEventType(wxEVT_CREATE);
788 SetEventObject(win);
789 }
790
791 // ----------------------------------------------------------------------------
792 // wxWindowDestroyEvent
793 // ----------------------------------------------------------------------------
794
795 wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win)
796 {
797 SetEventType(wxEVT_DESTROY);
798 SetEventObject(win);
799 }
800
801 // ----------------------------------------------------------------------------
802 // wxChildFocusEvent
803 // ----------------------------------------------------------------------------
804
805 wxChildFocusEvent::wxChildFocusEvent(wxWindow *win)
806 : wxCommandEvent(wxEVT_CHILD_FOCUS)
807 {
808 SetEventObject(win);
809 }
810
811 // ----------------------------------------------------------------------------
812 // wxHelpEvent
813 // ----------------------------------------------------------------------------
814
815 /* static */
816 wxHelpEvent::Origin wxHelpEvent::GuessOrigin(Origin origin)
817 {
818 if ( origin == Origin_Unknown )
819 {
820 // assume that the event comes from the help button if it's not from
821 // keyboard and that pressing F1 always results in the help event
822 origin = wxGetKeyState(WXK_F1) ? Origin_Keyboard : Origin_HelpButton;
823 }
824
825 return origin;
826 }
827
828 #endif // wxUSE_GUI
829
830
831 #if wxUSE_BASE
832
833 // ----------------------------------------------------------------------------
834 // wxEventHashTable
835 // ----------------------------------------------------------------------------
836
837 static const int EVENT_TYPE_TABLE_INIT_SIZE = 31; // Not too big not too small...
838
839 wxEventHashTable* wxEventHashTable::sm_first = NULL;
840
841 wxEventHashTable::wxEventHashTable(const wxEventTable &table)
842 : m_table(table),
843 m_rebuildHash(true)
844 {
845 AllocEventTypeTable(EVENT_TYPE_TABLE_INIT_SIZE);
846
847 m_next = sm_first;
848 if (m_next)
849 m_next->m_previous = this;
850 sm_first = this;
851 }
852
853 wxEventHashTable::~wxEventHashTable()
854 {
855 if (m_next)
856 m_next->m_previous = m_previous;
857 if (m_previous)
858 m_previous->m_next = m_next;
859 if (sm_first == this)
860 sm_first = m_next;
861
862 Clear();
863 }
864
865 void wxEventHashTable::Clear()
866 {
867 for ( size_t i = 0; i < m_size; i++ )
868 {
869 EventTypeTablePointer eTTnode = m_eventTypeTable[i];
870 delete eTTnode;
871 }
872
873 delete[] m_eventTypeTable;
874 m_eventTypeTable = NULL;
875
876 m_size = 0;
877 }
878
879 #if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
880
881 // Clear all tables
882 void wxEventHashTable::ClearAll()
883 {
884 wxEventHashTable* table = sm_first;
885 while (table)
886 {
887 table->Clear();
888 table = table->m_next;
889 }
890 }
891
892 #endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
893
894 bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
895 {
896 if (m_rebuildHash)
897 {
898 InitHashTable();
899 m_rebuildHash = false;
900 }
901
902 if (!m_eventTypeTable)
903 return false;
904
905 // Find all entries for the given event type.
906 wxEventType eventType = event.GetEventType();
907 const EventTypeTablePointer eTTnode = m_eventTypeTable[eventType % m_size];
908 if (eTTnode && eTTnode->eventType == eventType)
909 {
910 // Now start the search for an event handler
911 // that can handle an event with the given ID.
912 const wxEventTableEntryPointerArray&
913 eventEntryTable = eTTnode->eventEntryTable;
914
915 const size_t count = eventEntryTable.GetCount();
916 for (size_t n = 0; n < count; n++)
917 {
918 const wxEventTableEntry& entry = *eventEntryTable[n];
919 if ( wxEvtHandler::ProcessEventIfMatchesId(entry, self, event) )
920 return true;
921 }
922 }
923
924 return false;
925 }
926
927 void wxEventHashTable::InitHashTable()
928 {
929 // Loop over the event tables and all its base tables.
930 const wxEventTable *table = &m_table;
931 while (table)
932 {
933 // Retrieve all valid event handler entries
934 const wxEventTableEntry *entry = table->entries;
935 while (entry->m_fn != 0)
936 {
937 // Add the event entry in the Hash.
938 AddEntry(*entry);
939
940 entry++;
941 }
942
943 table = table->baseTable;
944 }
945
946 // Lets free some memory.
947 size_t i;
948 for(i = 0; i < m_size; i++)
949 {
950 EventTypeTablePointer eTTnode = m_eventTypeTable[i];
951 if (eTTnode)
952 {
953 eTTnode->eventEntryTable.Shrink();
954 }
955 }
956 }
957
958 void wxEventHashTable::AddEntry(const wxEventTableEntry &entry)
959 {
960 // This might happen 'accidentally' as the app is exiting
961 if (!m_eventTypeTable)
962 return;
963
964 EventTypeTablePointer *peTTnode = &m_eventTypeTable[entry.m_eventType % m_size];
965 EventTypeTablePointer eTTnode = *peTTnode;
966
967 if (eTTnode)
968 {
969 if (eTTnode->eventType != entry.m_eventType)
970 {
971 // Resize the table!
972 GrowEventTypeTable();
973 // Try again to add it.
974 AddEntry(entry);
975 return;
976 }
977 }
978 else
979 {
980 eTTnode = new EventTypeTable;
981 eTTnode->eventType = entry.m_eventType;
982 *peTTnode = eTTnode;
983 }
984
985 // Fill all hash entries between entry.m_id and entry.m_lastId...
986 eTTnode->eventEntryTable.Add(&entry);
987 }
988
989 void wxEventHashTable::AllocEventTypeTable(size_t size)
990 {
991 m_eventTypeTable = new EventTypeTablePointer[size];
992 memset((void *)m_eventTypeTable, 0, sizeof(EventTypeTablePointer)*size);
993 m_size = size;
994 }
995
996 void wxEventHashTable::GrowEventTypeTable()
997 {
998 size_t oldSize = m_size;
999 EventTypeTablePointer *oldEventTypeTable = m_eventTypeTable;
1000
1001 // TODO: Search the most optimal grow sequence
1002 AllocEventTypeTable(/* GetNextPrime(oldSize) */oldSize*2+1);
1003
1004 for ( size_t i = 0; i < oldSize; /* */ )
1005 {
1006 EventTypeTablePointer eTToldNode = oldEventTypeTable[i];
1007 if (eTToldNode)
1008 {
1009 EventTypeTablePointer *peTTnode = &m_eventTypeTable[eTToldNode->eventType % m_size];
1010 EventTypeTablePointer eTTnode = *peTTnode;
1011
1012 // Check for collision, we don't want any.
1013 if (eTTnode)
1014 {
1015 GrowEventTypeTable();
1016 continue; // Don't increment the counter,
1017 // as we still need to add this element.
1018 }
1019 else
1020 {
1021 // Get the old value and put it in the new table.
1022 *peTTnode = oldEventTypeTable[i];
1023 }
1024 }
1025
1026 i++;
1027 }
1028
1029 delete[] oldEventTypeTable;
1030 }
1031
1032 // ----------------------------------------------------------------------------
1033 // wxEvtHandler
1034 // ----------------------------------------------------------------------------
1035
1036 wxEvtHandler::wxEvtHandler()
1037 {
1038 m_nextHandler = NULL;
1039 m_previousHandler = NULL;
1040 m_enabled = true;
1041 m_dynamicEvents = NULL;
1042 m_pendingEvents = NULL;
1043
1044 // no client data (yet)
1045 m_clientData = NULL;
1046 m_clientDataType = wxClientData_None;
1047 }
1048
1049 wxEvtHandler::~wxEvtHandler()
1050 {
1051 Unlink();
1052
1053 if (m_dynamicEvents)
1054 {
1055 for ( wxList::iterator it = m_dynamicEvents->begin(),
1056 end = m_dynamicEvents->end();
1057 it != end;
1058 ++it )
1059 {
1060 wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)*it;
1061
1062 // Remove ourselves from sink destructor notifications
1063 // (this has usually been done, in wxTrackable destructor)
1064 wxEvtHandler *eventSink = entry->m_fn->GetEvtHandler();
1065 if ( eventSink )
1066 {
1067 wxEventConnectionRef * const
1068 evtConnRef = FindRefInTrackerList(eventSink);
1069 if ( evtConnRef )
1070 {
1071 eventSink->RemoveNode(evtConnRef);
1072 delete evtConnRef;
1073 }
1074 }
1075
1076 delete entry->m_callbackUserData;
1077 delete entry;
1078 }
1079 delete m_dynamicEvents;
1080 }
1081
1082 // Remove us from the list of the pending events if necessary.
1083 if (wxTheApp)
1084 wxTheApp->RemovePendingEventHandler(this);
1085
1086 DeletePendingEvents();
1087
1088 // we only delete object data, not untyped
1089 if ( m_clientDataType == wxClientData_Object )
1090 delete m_clientObject;
1091 }
1092
1093 void wxEvtHandler::Unlink()
1094 {
1095 // this event handler must take itself out of the chain of handlers:
1096
1097 if (m_previousHandler)
1098 m_previousHandler->SetNextHandler(m_nextHandler);
1099
1100 if (m_nextHandler)
1101 m_nextHandler->SetPreviousHandler(m_previousHandler);
1102
1103 m_nextHandler = NULL;
1104 m_previousHandler = NULL;
1105 }
1106
1107 bool wxEvtHandler::IsUnlinked() const
1108 {
1109 return m_previousHandler == NULL &&
1110 m_nextHandler == NULL;
1111 }
1112
1113 #if wxUSE_THREADS
1114
1115 bool wxEvtHandler::ProcessThreadEvent(const wxEvent& event)
1116 {
1117 // check that we are really in a child thread
1118 wxASSERT_MSG( !wxThread::IsMain(),
1119 wxT("use ProcessEvent() in main thread") );
1120
1121 AddPendingEvent(event);
1122
1123 return true;
1124 }
1125
1126 #endif // wxUSE_THREADS
1127
1128 void wxEvtHandler::QueueEvent(wxEvent *event)
1129 {
1130 wxCHECK_RET( event, "NULL event can't be posted" );
1131
1132 if (!wxTheApp)
1133 {
1134 // we need an event loop which manages the list of event handlers with
1135 // pending events... cannot proceed without it!
1136 wxLogDebug("No application object! Cannot queue this event!");
1137
1138 // anyway delete the given event to avoid memory leaks
1139 delete event;
1140
1141 return;
1142 }
1143
1144 // 1) Add this event to our list of pending events
1145 wxENTER_CRIT_SECT( m_pendingEventsLock );
1146
1147 if ( !m_pendingEvents )
1148 m_pendingEvents = new wxList;
1149
1150 m_pendingEvents->Append(event);
1151
1152 // 2) Add this event handler to list of event handlers that
1153 // have pending events.
1154
1155 wxTheApp->AppendPendingEventHandler(this);
1156
1157 // only release m_pendingEventsLock now because otherwise there is a race
1158 // condition as described in the ticket #9093: we could process the event
1159 // just added to m_pendingEvents in our ProcessPendingEvents() below before
1160 // we had time to append this pointer to wxHandlersWithPendingEvents list; thus
1161 // breaking the invariant that a handler should be in the list iff it has
1162 // any pending events to process
1163 wxLEAVE_CRIT_SECT( m_pendingEventsLock );
1164
1165 // 3) Inform the system that new pending events are somewhere,
1166 // and that these should be processed in idle time.
1167 wxWakeUpIdle();
1168 }
1169
1170 void wxEvtHandler::DeletePendingEvents()
1171 {
1172 if (m_pendingEvents)
1173 m_pendingEvents->DeleteContents(true);
1174 wxDELETE(m_pendingEvents);
1175 }
1176
1177 void wxEvtHandler::ProcessPendingEvents()
1178 {
1179 if (!wxTheApp)
1180 {
1181 // we need an event loop which manages the list of event handlers with
1182 // pending events... cannot proceed without it!
1183 wxLogDebug("No application object! Cannot process pending events!");
1184 return;
1185 }
1186
1187 // we need to process only a single pending event in this call because
1188 // each call to ProcessEvent() could result in the destruction of this
1189 // same event handler (see the comment at the end of this function)
1190
1191 wxENTER_CRIT_SECT( m_pendingEventsLock );
1192
1193 // this method is only called by wxApp if this handler does have
1194 // pending events
1195 wxCHECK_RET( m_pendingEvents && !m_pendingEvents->IsEmpty(),
1196 "should have pending events if called" );
1197
1198 wxList::compatibility_iterator node = m_pendingEvents->GetFirst();
1199 wxEvent* pEvent = static_cast<wxEvent *>(node->GetData());
1200
1201 // find the first event which can be processed now:
1202 wxEventLoopBase* evtLoop = wxEventLoopBase::GetActive();
1203 if (evtLoop && evtLoop->IsYielding())
1204 {
1205 while (node && pEvent && !evtLoop->IsEventAllowedInsideYield(pEvent->GetEventCategory()))
1206 {
1207 node = node->GetNext();
1208 pEvent = node ? static_cast<wxEvent *>(node->GetData()) : NULL;
1209 }
1210
1211 if (!node)
1212 {
1213 // all our events are NOT processable now... signal this:
1214 wxTheApp->DelayPendingEventHandler(this);
1215
1216 // see the comment at the beginning of evtloop.h header for the
1217 // logic behind YieldFor() and behind DelayPendingEventHandler()
1218
1219 wxLEAVE_CRIT_SECT( m_pendingEventsLock );
1220
1221 return;
1222 }
1223 }
1224
1225 wxEventPtr event(pEvent);
1226
1227 // it's important we remove event from list before processing it, else a
1228 // nested event loop, for example from a modal dialog, might process the
1229 // same event again.
1230 m_pendingEvents->Erase(node);
1231
1232 if ( m_pendingEvents->IsEmpty() )
1233 {
1234 // if there are no more pending events left, we don't need to
1235 // stay in this list
1236 wxTheApp->RemovePendingEventHandler(this);
1237 }
1238
1239 wxLEAVE_CRIT_SECT( m_pendingEventsLock );
1240
1241 ProcessEvent(*event);
1242
1243 // careful: this object could have been deleted by the event handler
1244 // executed by the above ProcessEvent() call, so we can't access any fields
1245 // of this object any more
1246 }
1247
1248 /* static */
1249 bool wxEvtHandler::ProcessEventIfMatchesId(const wxEventTableEntryBase& entry,
1250 wxEvtHandler *handler,
1251 wxEvent& event)
1252 {
1253 int tableId1 = entry.m_id,
1254 tableId2 = entry.m_lastId;
1255
1256 // match only if the event type is the same and the id is either -1 in
1257 // the event table (meaning "any") or the event id matches the id
1258 // specified in the event table either exactly or by falling into
1259 // range between first and last
1260 if ((tableId1 == wxID_ANY) ||
1261 (tableId2 == wxID_ANY && tableId1 == event.GetId()) ||
1262 (tableId2 != wxID_ANY &&
1263 (event.GetId() >= tableId1 && event.GetId() <= tableId2)))
1264 {
1265 event.Skip(false);
1266 event.m_callbackUserData = entry.m_callbackUserData;
1267
1268 #if wxUSE_EXCEPTIONS
1269 if ( wxTheApp )
1270 {
1271 // call the handler via wxApp method which allows the user to catch
1272 // any exceptions which may be thrown by any handler in the program
1273 // in one place
1274 wxTheApp->CallEventHandler(handler, *entry.m_fn, event);
1275 }
1276 else
1277 #endif // wxUSE_EXCEPTIONS
1278 {
1279 (*entry.m_fn)(handler, event);
1280 }
1281
1282 if (!event.GetSkipped())
1283 return true;
1284 }
1285
1286 return false;
1287 }
1288
1289 bool wxEvtHandler::DoTryApp(wxEvent& event)
1290 {
1291 if ( wxTheApp && (this != wxTheApp) )
1292 {
1293 // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always
1294 // swallow it. wxEVT_IDLE is sent explicitly to wxApp so it will be
1295 // processed appropriately via SearchEventTable.
1296 if ( event.GetEventType() != wxEVT_IDLE )
1297 {
1298 if ( wxTheApp->ProcessEvent(event) )
1299 return true;
1300 }
1301 }
1302
1303 return false;
1304 }
1305
1306 bool wxEvtHandler::TryBefore(wxEvent& event)
1307 {
1308 #ifdef WXWIN_COMPATIBILITY_2_8
1309 // call the old virtual function to keep the code overriding it working
1310 return TryValidator(event);
1311 #else
1312 wxUnusedVar(event);
1313 return false;
1314 #endif
1315 }
1316
1317 bool wxEvtHandler::TryAfter(wxEvent& event)
1318 {
1319 #ifdef WXWIN_COMPATIBILITY_2_8
1320 // as above, call the old virtual function for compatibility
1321 return TryParent(event);
1322 #else
1323 return DoTryApp(event);
1324 #endif
1325 }
1326
1327 bool wxEvtHandler::ProcessEvent(wxEvent& event)
1328 {
1329 // allow the application to hook into event processing
1330 //
1331 // note that we should only do it if we're the first event handler called
1332 // to avoid calling FilterEvent() multiple times as the event goes through
1333 // the event handler chain and possibly upwards the window hierarchy
1334 if ( !event.WasProcessed() )
1335 {
1336 if ( wxTheApp )
1337 {
1338 int rc = wxTheApp->FilterEvent(event);
1339 if ( rc != -1 )
1340 {
1341 wxASSERT_MSG( rc == 1 || rc == 0,
1342 "unexpected wxApp::FilterEvent return value" );
1343
1344 return rc != 0;
1345 }
1346 //else: proceed normally
1347 }
1348 }
1349
1350 if ( ProcessEventHere(event) )
1351 return true;
1352
1353 // pass the event to the next handler, notice that we shouldn't call
1354 // TryAfter() even if it doesn't handle the event as the last handler in
1355 // the chain will do it
1356 if ( GetNextHandler() )
1357 return GetNextHandler()->ProcessEvent(event);
1358
1359 // propagate the event upwards the window chain and/or to the application
1360 // object if it wasn't processed at this level
1361 return TryAfter(event);
1362 }
1363
1364 bool wxEvtHandler::ProcessEventHere(wxEvent& event)
1365 {
1366 // If the event handler is disabled it doesn't process any events
1367 if ( !GetEvtHandlerEnabled() )
1368 return false;
1369
1370 // Try the hooks which should be called before our own handlers
1371 if ( TryBefore(event) )
1372 return true;
1373
1374 // Handle per-instance dynamic event tables first
1375 if ( m_dynamicEvents && SearchDynamicEventTable(event) )
1376 return true;
1377
1378 // Then static per-class event tables
1379 if ( GetEventHashTable().HandleEvent(event, this) )
1380 return true;
1381
1382 // We don't have a handler for this event.
1383 return false;
1384 }
1385
1386 bool wxEvtHandler::SafelyProcessEvent(wxEvent& event)
1387 {
1388 #if wxUSE_EXCEPTIONS
1389 try
1390 {
1391 #endif
1392 return ProcessEvent(event);
1393 #if wxUSE_EXCEPTIONS
1394 }
1395 catch ( ... )
1396 {
1397 // notice that we do it in 2 steps to avoid warnings about possibly
1398 // uninitialized loop variable from some versions of g++ which are not
1399 // smart enough to figure out that GetActive() doesn't throw and so
1400 // that loop will always be initialized
1401 wxEventLoopBase *loop = NULL;
1402 try
1403 {
1404 loop = wxEventLoopBase::GetActive();
1405
1406 if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
1407 {
1408 if ( loop )
1409 loop->Exit();
1410 }
1411 //else: continue running current event loop
1412
1413 return false;
1414 }
1415 catch ( ... )
1416 {
1417 // OnExceptionInMainLoop() threw, possibly rethrowing the same
1418 // exception again: very good, but we still need Exit() to
1419 // be called
1420 if ( loop )
1421 loop->Exit();
1422 throw;
1423 }
1424 }
1425 #endif // wxUSE_EXCEPTIONS
1426 }
1427
1428 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
1429 {
1430 const wxEventType eventType = event.GetEventType();
1431 for ( int i = 0; table.entries[i].m_fn != 0; i++ )
1432 {
1433 const wxEventTableEntry& entry = table.entries[i];
1434 if ( eventType == entry.m_eventType )
1435 {
1436 if ( ProcessEventIfMatchesId(entry, this, event) )
1437 return true;
1438 }
1439 }
1440
1441 return false;
1442 }
1443
1444 void wxEvtHandler::DoConnect(int id,
1445 int lastId,
1446 wxEventType eventType,
1447 wxEventFunctor *func,
1448 wxObject *userData)
1449 {
1450 wxDynamicEventTableEntry *entry =
1451 new wxDynamicEventTableEntry(eventType, id, lastId, func, userData);
1452
1453 if (!m_dynamicEvents)
1454 m_dynamicEvents = new wxList;
1455
1456 // Insert at the front of the list so most recent additions are found first
1457 m_dynamicEvents->Insert( (wxObject*) entry );
1458
1459 // Make sure we get to know when a sink is destroyed
1460 wxEvtHandler *eventSink = func->GetEvtHandler();
1461 if ( eventSink && eventSink != this )
1462 {
1463 wxEventConnectionRef *evtConnRef = FindRefInTrackerList(eventSink);
1464 if ( evtConnRef )
1465 evtConnRef->IncRef( );
1466 else
1467 new wxEventConnectionRef(this, eventSink);
1468 }
1469 }
1470
1471 bool
1472 wxEvtHandler::DoDisconnect(int id,
1473 int lastId,
1474 wxEventType eventType,
1475 const wxEventFunctor& func,
1476 wxObject *userData)
1477 {
1478 if (!m_dynamicEvents)
1479 return false;
1480
1481 // Remove connection from tracker node (wxEventConnectionRef)
1482 wxEvtHandler *eventSink = func.GetEvtHandler();
1483 if ( eventSink && eventSink != this )
1484 {
1485 wxEventConnectionRef *evtConnRef = FindRefInTrackerList(eventSink);
1486 if ( evtConnRef )
1487 evtConnRef->DecRef();
1488 }
1489
1490 wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
1491 while (node)
1492 {
1493 wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
1494
1495 if ((entry->m_id == id) &&
1496 ((entry->m_lastId == lastId) || (lastId == wxID_ANY)) &&
1497 ((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) &&
1498 entry->m_fn->Matches(func) &&
1499 ((entry->m_callbackUserData == userData) || !userData))
1500 {
1501 delete entry->m_callbackUserData;
1502 m_dynamicEvents->Erase( node );
1503 delete entry;
1504 return true;
1505 }
1506 node = node->GetNext();
1507 }
1508 return false;
1509 }
1510
1511 bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
1512 {
1513 wxCHECK_MSG( m_dynamicEvents, false,
1514 wxT("caller should check that we have dynamic events") );
1515
1516 wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
1517 while (node)
1518 {
1519 wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
1520
1521 // get next node before (maybe) calling the event handler as it could
1522 // call Disconnect() invalidating the current node
1523 node = node->GetNext();
1524
1525 if ( event.GetEventType() == entry->m_eventType )
1526 {
1527 wxEvtHandler *handler = entry->m_fn->GetEvtHandler();
1528 if ( !handler )
1529 handler = this;
1530 if ( ProcessEventIfMatchesId(*entry, handler, event) )
1531 return true;
1532 }
1533 }
1534
1535 return false;
1536 }
1537
1538 void wxEvtHandler::DoSetClientObject( wxClientData *data )
1539 {
1540 wxASSERT_MSG( m_clientDataType != wxClientData_Void,
1541 wxT("can't have both object and void client data") );
1542
1543 if ( m_clientObject )
1544 delete m_clientObject;
1545
1546 m_clientObject = data;
1547 m_clientDataType = wxClientData_Object;
1548 }
1549
1550 wxClientData *wxEvtHandler::DoGetClientObject() const
1551 {
1552 // it's not an error to call GetClientObject() on a window which doesn't
1553 // have client data at all - NULL will be returned
1554 wxASSERT_MSG( m_clientDataType != wxClientData_Void,
1555 wxT("this window doesn't have object client data") );
1556
1557 return m_clientObject;
1558 }
1559
1560 void wxEvtHandler::DoSetClientData( void *data )
1561 {
1562 wxASSERT_MSG( m_clientDataType != wxClientData_Object,
1563 wxT("can't have both object and void client data") );
1564
1565 m_clientData = data;
1566 m_clientDataType = wxClientData_Void;
1567 }
1568
1569 void *wxEvtHandler::DoGetClientData() const
1570 {
1571 // it's not an error to call GetClientData() on a window which doesn't have
1572 // client data at all - NULL will be returned
1573 wxASSERT_MSG( m_clientDataType != wxClientData_Object,
1574 wxT("this window doesn't have void client data") );
1575
1576 return m_clientData;
1577 }
1578
1579 // A helper to find an wxEventConnectionRef object
1580 wxEventConnectionRef *
1581 wxEvtHandler::FindRefInTrackerList(wxEvtHandler *eventSink)
1582 {
1583 for ( wxTrackerNode *node = eventSink->GetFirst(); node; node = node->m_nxt )
1584 {
1585 // we only want wxEventConnectionRef nodes here
1586 wxEventConnectionRef *evtConnRef = node->ToEventConnection();
1587 if ( evtConnRef && evtConnRef->m_src == this )
1588 {
1589 wxASSERT( evtConnRef->m_sink==eventSink );
1590 return evtConnRef;
1591 }
1592 }
1593
1594 return NULL;
1595 }
1596
1597 void wxEvtHandler::OnSinkDestroyed( wxEvtHandler *sink )
1598 {
1599 wxASSERT(m_dynamicEvents);
1600
1601 // remove all connections with this sink
1602 wxList::compatibility_iterator node = m_dynamicEvents->GetFirst(), node_nxt;
1603 while (node)
1604 {
1605 wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
1606 node_nxt = node->GetNext();
1607
1608 if ( entry->m_fn->GetEvtHandler() == sink )
1609 {
1610 delete entry->m_callbackUserData;
1611 m_dynamicEvents->Erase( node );
1612 delete entry;
1613 }
1614 node = node_nxt;
1615 }
1616 }
1617
1618 #endif // wxUSE_BASE
1619
1620 #if wxUSE_GUI
1621
1622 // Find a window with the focus, that is also a descendant of the given window.
1623 // This is used to determine the window to initially send commands to.
1624 wxWindow* wxFindFocusDescendant(wxWindow* ancestor)
1625 {
1626 // Process events starting with the window with the focus, if any.
1627 wxWindow* focusWin = wxWindow::FindFocus();
1628 wxWindow* win = focusWin;
1629
1630 // Check if this is a descendant of this frame.
1631 // If not, win will be set to NULL.
1632 while (win)
1633 {
1634 if (win == ancestor)
1635 break;
1636 else
1637 win = win->GetParent();
1638 }
1639 if (win == NULL)
1640 focusWin = NULL;
1641
1642 return focusWin;
1643 }
1644
1645 // ----------------------------------------------------------------------------
1646 // wxEventBlocker
1647 // ----------------------------------------------------------------------------
1648
1649 wxEventBlocker::wxEventBlocker(wxWindow *win, wxEventType type)
1650 {
1651 wxCHECK_RET(win, wxT("Null window given to wxEventBlocker"));
1652
1653 m_window = win;
1654
1655 Block(type);
1656 m_window->PushEventHandler(this);
1657 }
1658
1659 wxEventBlocker::~wxEventBlocker()
1660 {
1661 wxEvtHandler *popped = m_window->PopEventHandler(false);
1662 wxCHECK_RET(popped == this,
1663 wxT("Don't push other event handlers into a window managed by wxEventBlocker!"));
1664 }
1665
1666 bool wxEventBlocker::ProcessEvent(wxEvent& event)
1667 {
1668 // should this event be blocked?
1669 for ( size_t i = 0; i < m_eventsToBlock.size(); i++ )
1670 {
1671 wxEventType t = (wxEventType)m_eventsToBlock[i];
1672 if ( t == wxEVT_ANY || t == event.GetEventType() )
1673 return true; // yes, it should: mark this event as processed
1674 }
1675
1676 return false;
1677 }
1678
1679 #endif // wxUSE_GUI
1680
wxWidgets (Impactor)