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