1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Event classes
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && !defined(__EMX__)
21 // Some older compilers (such as EMX) cannot handle
22 // #pragma interface/implementation correctly, iff
23 // #pragma implementation is used in _two_ translation
24 // units (as created by e.g. event.cpp compiled for
25 // libwx_base and event.cpp compiled for libwx_gui_core).
26 // So we must not use those pragmas for those compilers in
28 #pragma implementation "event.h"
31 // For compilers that support precompilation, includes "wx.h".
32 #include "wx/wxprec.h"
44 #include "wx/control.h"
51 #include "wx/module.h"
54 #include "wx/validate.h"
56 #include "wx/stopwatch.h"
60 // ----------------------------------------------------------------------------
62 // ----------------------------------------------------------------------------
65 IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler
, wxObject
)
66 IMPLEMENT_ABSTRACT_CLASS(wxEvent
, wxObject
)
70 IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent
, wxEvent
)
71 IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent
, wxEvent
)
72 IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent
, wxCommandEvent
)
73 IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent
, wxCommandEvent
)
74 IMPLEMENT_DYNAMIC_CLASS(wxScrollWinEvent
, wxEvent
)
75 IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent
, wxEvent
)
76 IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent
, wxEvent
)
77 IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent
, wxEvent
)
78 IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent
, wxEvent
)
79 IMPLEMENT_DYNAMIC_CLASS(wxNcPaintEvent
, wxEvent
)
80 IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent
, wxEvent
)
81 IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent
, wxEvent
)
82 IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent
, wxEvent
)
83 IMPLEMENT_DYNAMIC_CLASS(wxChildFocusEvent
, wxCommandEvent
)
84 IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent
, wxEvent
)
85 IMPLEMENT_DYNAMIC_CLASS(wxShowEvent
, wxEvent
)
86 IMPLEMENT_DYNAMIC_CLASS(wxMaximizeEvent
, wxEvent
)
87 IMPLEMENT_DYNAMIC_CLASS(wxIconizeEvent
, wxEvent
)
88 IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent
, wxEvent
)
89 IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent
, wxEvent
)
90 IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent
, wxEvent
)
91 IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent
, wxEvent
)
92 IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent
, wxEvent
)
93 IMPLEMENT_DYNAMIC_CLASS(wxSetCursorEvent
, wxEvent
)
94 IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent
, wxEvent
)
95 IMPLEMENT_DYNAMIC_CLASS(wxDisplayChangedEvent
, wxEvent
)
96 IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent
, wxCommandEvent
)
97 IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent
, wxEvent
)
98 IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent
, wxEvent
)
99 IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent
, wxEvent
)
100 IMPLEMENT_DYNAMIC_CLASS(wxWindowCreateEvent
, wxEvent
)
101 IMPLEMENT_DYNAMIC_CLASS(wxWindowDestroyEvent
, wxEvent
)
102 IMPLEMENT_DYNAMIC_CLASS(wxHelpEvent
, wxCommandEvent
)
103 IMPLEMENT_DYNAMIC_CLASS(wxContextMenuEvent
, wxCommandEvent
)
104 IMPLEMENT_DYNAMIC_CLASS(wxMouseCaptureChangedEvent
, wxEvent
)
109 const wxEventTable
*wxEvtHandler
::GetEventTable() const
110 { return &wxEvtHandler
::sm_eventTable
; }
112 const wxEventTable wxEvtHandler
::sm_eventTable
=
113 { (const wxEventTable
*)NULL
, &wxEvtHandler
::sm_eventTableEntries
[0] };
115 wxEventHashTable
&wxEvtHandler
::GetEventHashTable() const
116 { return wxEvtHandler
::sm_eventHashTable
; }
118 wxEventHashTable wxEvtHandler
::sm_eventHashTable(wxEvtHandler
::sm_eventTable
);
120 const wxEventTableEntry wxEvtHandler
::sm_eventTableEntries
[] =
121 { DECLARE_EVENT_TABLE_ENTRY(wxEVT_NULL
, 0, 0, (wxObjectEventFunction
)NULL
, NULL
) };
125 // Clear up event hash table contents or we can get problems
126 // when C++ is cleaning up the static object
127 class wxEventTableEntryModule
: public wxModule
129 DECLARE_DYNAMIC_CLASS(wxEventTableEntryModule
)
131 wxEventTableEntryModule() {}
132 bool OnInit() { return true; }
135 wxEventHashTable
::ClearAll();
138 IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule
, wxModule
)
141 // ----------------------------------------------------------------------------
143 // ----------------------------------------------------------------------------
145 // To put pending event handlers
146 wxList
*wxPendingEvents
= (wxList
*)NULL
;
149 // protects wxPendingEvents list
150 wxCriticalSection
*wxPendingEventsLocker
= (wxCriticalSection
*)NULL
;
153 #if !WXWIN_COMPATIBILITY_EVENT_TYPES
155 // common event types are defined here, other event types are defined by the
156 // components which use them
158 const wxEventType wxEVT_FIRST
= 10000;
159 const wxEventType wxEVT_USER_FIRST
= wxEVT_FIRST
+ 2000;
161 DEFINE_EVENT_TYPE(wxEVT_NULL
)
162 DEFINE_EVENT_TYPE(wxEVT_IDLE
)
163 DEFINE_EVENT_TYPE(wxEVT_SOCKET
)
165 #endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
171 #if !WXWIN_COMPATIBILITY_EVENT_TYPES
173 DEFINE_EVENT_TYPE(wxEVT_COMMAND_BUTTON_CLICKED
)
174 DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHECKBOX_CLICKED
)
175 DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHOICE_SELECTED
)
176 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LISTBOX_SELECTED
)
177 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED
)
178 DEFINE_EVENT_TYPE(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED
)
179 DEFINE_EVENT_TYPE(wxEVT_COMMAND_MENU_SELECTED
)
180 DEFINE_EVENT_TYPE(wxEVT_COMMAND_SLIDER_UPDATED
)
181 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RADIOBOX_SELECTED
)
182 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RADIOBUTTON_SELECTED
)
183 DEFINE_EVENT_TYPE(wxEVT_COMMAND_SCROLLBAR_UPDATED
)
184 DEFINE_EVENT_TYPE(wxEVT_COMMAND_VLBOX_SELECTED
)
185 DEFINE_EVENT_TYPE(wxEVT_COMMAND_COMBOBOX_SELECTED
)
186 DEFINE_EVENT_TYPE(wxEVT_COMMAND_TOOL_RCLICKED
)
187 DEFINE_EVENT_TYPE(wxEVT_COMMAND_TOOL_ENTER
)
188 DEFINE_EVENT_TYPE(wxEVT_COMMAND_SPINCTRL_UPDATED
)
190 // Sockets and timers send events, too
191 DEFINE_EVENT_TYPE(wxEVT_TIMER
)
194 DEFINE_EVENT_TYPE(wxEVT_LEFT_DOWN
)
195 DEFINE_EVENT_TYPE(wxEVT_LEFT_UP
)
196 DEFINE_EVENT_TYPE(wxEVT_MIDDLE_DOWN
)
197 DEFINE_EVENT_TYPE(wxEVT_MIDDLE_UP
)
198 DEFINE_EVENT_TYPE(wxEVT_RIGHT_DOWN
)
199 DEFINE_EVENT_TYPE(wxEVT_RIGHT_UP
)
200 DEFINE_EVENT_TYPE(wxEVT_MOTION
)
201 DEFINE_EVENT_TYPE(wxEVT_ENTER_WINDOW
)
202 DEFINE_EVENT_TYPE(wxEVT_LEAVE_WINDOW
)
203 DEFINE_EVENT_TYPE(wxEVT_LEFT_DCLICK
)
204 DEFINE_EVENT_TYPE(wxEVT_MIDDLE_DCLICK
)
205 DEFINE_EVENT_TYPE(wxEVT_RIGHT_DCLICK
)
206 DEFINE_EVENT_TYPE(wxEVT_SET_FOCUS
)
207 DEFINE_EVENT_TYPE(wxEVT_KILL_FOCUS
)
208 DEFINE_EVENT_TYPE(wxEVT_CHILD_FOCUS
)
209 DEFINE_EVENT_TYPE(wxEVT_MOUSEWHEEL
)
211 // Non-client mouse events
212 DEFINE_EVENT_TYPE(wxEVT_NC_LEFT_DOWN
)
213 DEFINE_EVENT_TYPE(wxEVT_NC_LEFT_UP
)
214 DEFINE_EVENT_TYPE(wxEVT_NC_MIDDLE_DOWN
)
215 DEFINE_EVENT_TYPE(wxEVT_NC_MIDDLE_UP
)
216 DEFINE_EVENT_TYPE(wxEVT_NC_RIGHT_DOWN
)
217 DEFINE_EVENT_TYPE(wxEVT_NC_RIGHT_UP
)
218 DEFINE_EVENT_TYPE(wxEVT_NC_MOTION
)
219 DEFINE_EVENT_TYPE(wxEVT_NC_ENTER_WINDOW
)
220 DEFINE_EVENT_TYPE(wxEVT_NC_LEAVE_WINDOW
)
221 DEFINE_EVENT_TYPE(wxEVT_NC_LEFT_DCLICK
)
222 DEFINE_EVENT_TYPE(wxEVT_NC_MIDDLE_DCLICK
)
223 DEFINE_EVENT_TYPE(wxEVT_NC_RIGHT_DCLICK
)
225 // Character input event type
226 DEFINE_EVENT_TYPE(wxEVT_CHAR
)
227 DEFINE_EVENT_TYPE(wxEVT_CHAR_HOOK
)
228 DEFINE_EVENT_TYPE(wxEVT_NAVIGATION_KEY
)
229 DEFINE_EVENT_TYPE(wxEVT_KEY_DOWN
)
230 DEFINE_EVENT_TYPE(wxEVT_KEY_UP
)
232 DEFINE_EVENT_TYPE(wxEVT_HOTKEY
)
236 DEFINE_EVENT_TYPE(wxEVT_SET_CURSOR
)
238 // wxScrollbar and wxSlider event identifiers
239 DEFINE_EVENT_TYPE(wxEVT_SCROLL_TOP
)
240 DEFINE_EVENT_TYPE(wxEVT_SCROLL_BOTTOM
)
241 DEFINE_EVENT_TYPE(wxEVT_SCROLL_LINEUP
)
242 DEFINE_EVENT_TYPE(wxEVT_SCROLL_LINEDOWN
)
243 DEFINE_EVENT_TYPE(wxEVT_SCROLL_PAGEUP
)
244 DEFINE_EVENT_TYPE(wxEVT_SCROLL_PAGEDOWN
)
245 DEFINE_EVENT_TYPE(wxEVT_SCROLL_THUMBTRACK
)
246 DEFINE_EVENT_TYPE(wxEVT_SCROLL_THUMBRELEASE
)
247 DEFINE_EVENT_TYPE(wxEVT_SCROLL_ENDSCROLL
)
249 // Scroll events from wxWindow
250 DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_TOP
)
251 DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_BOTTOM
)
252 DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_LINEUP
)
253 DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_LINEDOWN
)
254 DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_PAGEUP
)
255 DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_PAGEDOWN
)
256 DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_THUMBTRACK
)
257 DEFINE_EVENT_TYPE(wxEVT_SCROLLWIN_THUMBRELEASE
)
260 DEFINE_EVENT_TYPE(wxEVT_SIZE
)
261 DEFINE_EVENT_TYPE(wxEVT_SIZING
)
262 DEFINE_EVENT_TYPE(wxEVT_MOVE
)
263 DEFINE_EVENT_TYPE(wxEVT_MOVING
)
264 DEFINE_EVENT_TYPE(wxEVT_CLOSE_WINDOW
)
265 DEFINE_EVENT_TYPE(wxEVT_END_SESSION
)
266 DEFINE_EVENT_TYPE(wxEVT_QUERY_END_SESSION
)
267 DEFINE_EVENT_TYPE(wxEVT_ACTIVATE_APP
)
268 DEFINE_EVENT_TYPE(wxEVT_POWER
)
269 DEFINE_EVENT_TYPE(wxEVT_ACTIVATE
)
270 DEFINE_EVENT_TYPE(wxEVT_CREATE
)
271 DEFINE_EVENT_TYPE(wxEVT_DESTROY
)
272 DEFINE_EVENT_TYPE(wxEVT_SHOW
)
273 DEFINE_EVENT_TYPE(wxEVT_ICONIZE
)
274 DEFINE_EVENT_TYPE(wxEVT_MAXIMIZE
)
275 DEFINE_EVENT_TYPE(wxEVT_MOUSE_CAPTURE_CHANGED
)
276 DEFINE_EVENT_TYPE(wxEVT_PAINT
)
277 DEFINE_EVENT_TYPE(wxEVT_ERASE_BACKGROUND
)
278 DEFINE_EVENT_TYPE(wxEVT_NC_PAINT
)
279 DEFINE_EVENT_TYPE(wxEVT_PAINT_ICON
)
280 DEFINE_EVENT_TYPE(wxEVT_MENU_OPEN
)
281 DEFINE_EVENT_TYPE(wxEVT_MENU_CLOSE
)
282 DEFINE_EVENT_TYPE(wxEVT_MENU_HIGHLIGHT
)
283 DEFINE_EVENT_TYPE(wxEVT_CONTEXT_MENU
)
284 DEFINE_EVENT_TYPE(wxEVT_SYS_COLOUR_CHANGED
)
285 DEFINE_EVENT_TYPE(wxEVT_DISPLAY_CHANGED
)
286 DEFINE_EVENT_TYPE(wxEVT_SETTING_CHANGED
)
287 DEFINE_EVENT_TYPE(wxEVT_QUERY_NEW_PALETTE
)
288 DEFINE_EVENT_TYPE(wxEVT_PALETTE_CHANGED
)
289 DEFINE_EVENT_TYPE(wxEVT_JOY_BUTTON_DOWN
)
290 DEFINE_EVENT_TYPE(wxEVT_JOY_BUTTON_UP
)
291 DEFINE_EVENT_TYPE(wxEVT_JOY_MOVE
)
292 DEFINE_EVENT_TYPE(wxEVT_JOY_ZMOVE
)
293 DEFINE_EVENT_TYPE(wxEVT_DROP_FILES
)
294 DEFINE_EVENT_TYPE(wxEVT_DRAW_ITEM
)
295 DEFINE_EVENT_TYPE(wxEVT_MEASURE_ITEM
)
296 DEFINE_EVENT_TYPE(wxEVT_COMPARE_ITEM
)
297 DEFINE_EVENT_TYPE(wxEVT_INIT_DIALOG
)
298 DEFINE_EVENT_TYPE(wxEVT_UPDATE_UI
)
300 // Generic command events
301 // Note: a click is a higher-level event than button down/up
302 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LEFT_CLICK
)
303 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LEFT_DCLICK
)
304 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RIGHT_CLICK
)
305 DEFINE_EVENT_TYPE(wxEVT_COMMAND_RIGHT_DCLICK
)
306 DEFINE_EVENT_TYPE(wxEVT_COMMAND_SET_FOCUS
)
307 DEFINE_EVENT_TYPE(wxEVT_COMMAND_KILL_FOCUS
)
308 DEFINE_EVENT_TYPE(wxEVT_COMMAND_ENTER
)
311 DEFINE_EVENT_TYPE(wxEVT_HELP
)
312 DEFINE_EVENT_TYPE(wxEVT_DETAILED_HELP
)
314 #endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
320 // ============================================================================
322 // ============================================================================
324 // ----------------------------------------------------------------------------
325 // event initialization
326 // ----------------------------------------------------------------------------
331 static int s_lastUsedEventType
= wxEVT_FIRST
;
333 return s_lastUsedEventType
++;
336 // ----------------------------------------------------------------------------
338 // ----------------------------------------------------------------------------
341 * General wxWidgets events, covering
342 * all interesting things that might happen (button clicking, resizing,
343 * setting text in widgets, etc.).
345 * For each completely new event type, derive a new event class.
349 wxEvent
::wxEvent(int theId
, wxEventType commandType
)
351 m_eventType
= commandType
;
352 m_eventObject
= (wxObject
*) NULL
;
356 m_callbackUserData
= (wxObject
*) NULL
;
357 m_isCommandEvent
= false;
358 m_propagationLevel
= wxEVENT_PROPAGATE_NONE
;
361 wxEvent
::wxEvent(const wxEvent
&src
)
363 , m_eventObject(src
.m_eventObject
)
364 , m_eventType(src
.m_eventType
)
365 , m_timeStamp(src
.m_timeStamp
)
367 , m_callbackUserData(src
.m_callbackUserData
)
368 , m_propagationLevel(src
.m_propagationLevel
)
369 , m_skipped(src
.m_skipped
)
370 , m_isCommandEvent(src
.m_isCommandEvent
)
383 wxCommandEvent
::wxCommandEvent(wxEventType commandType
, int theId
)
384 : wxEvent(theId
, commandType
)
385 #if WXWIN_COMPATIBILITY_2_4
386 , m_commandString(this)
389 m_clientData
= (char *) NULL
;
390 m_clientObject
= (wxClientData
*) NULL
;
393 m_isCommandEvent
= true;
395 // the command events are propagated upwards by default
396 m_propagationLevel
= wxEVENT_PROPAGATE_MAX
;
399 wxString wxCommandEvent
::GetString() const
401 if(m_eventType
!= wxEVT_COMMAND_TEXT_UPDATED
|| !m_eventObject
)
405 wxTextCtrl
*txt
= wxDynamicCast(m_eventObject
, wxTextCtrl
);
407 return txt
->GetValue();
418 wxLongLong wxUpdateUIEvent
::sm_lastUpdate
= 0;
421 long wxUpdateUIEvent
::sm_updateInterval
= 0;
423 wxUpdateUIMode wxUpdateUIEvent
::sm_updateMode
= wxUPDATE_UI_PROCESS_ALL
;
426 bool wxUpdateUIEvent
::CanUpdate(wxWindowBase
*win
)
428 // Don't update if we've switched global updating off
429 // and this window doesn't support updates.
431 (GetMode() == wxUPDATE_UI_PROCESS_SPECIFIED
&&
432 ((win
->GetExtraStyle() & wxWS_EX_PROCESS_UI_UPDATES
) == 0)))
435 if (sm_updateInterval
== -1)
438 if (sm_updateInterval
== 0)
441 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
442 wxLongLong now
= wxGetLocalTimeMillis();
443 if (now
> (sm_lastUpdate
+ sm_updateInterval
))
450 // If we don't have wxStopWatch or wxLongLong, we
451 // should err on the safe side and update now anyway.
456 // Reset the update time to provide a delay until the next
457 // time we should update
458 void wxUpdateUIEvent
::ResetUpdateTime()
460 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
461 if (sm_updateInterval
> 0)
463 wxLongLong now
= wxGetLocalTimeMillis();
464 if (now
> (sm_lastUpdate
+ sm_updateInterval
))
476 wxIdleMode wxIdleEvent
::sm_idleMode
= wxIDLE_PROCESS_ALL
;
478 // Can we send an idle event?
479 bool wxIdleEvent
::CanSend(wxWindow
* win
)
481 // Don't update if we've switched global updating off
482 // and this window doesn't support updates.
484 (GetMode() == wxIDLE_PROCESS_SPECIFIED
&&
485 ((win
->GetExtraStyle() & wxWS_EX_PROCESS_IDLE
) == 0)))
495 wxScrollEvent
::wxScrollEvent(wxEventType commandType
,
499 : wxCommandEvent(commandType
, id
)
501 m_extraLong
= orient
;
509 wxScrollWinEvent
::wxScrollWinEvent(wxEventType commandType
,
513 m_eventType
= commandType
;
514 m_extraLong
= orient
;
523 wxMouseEvent
::wxMouseEvent(wxEventType commandType
)
525 m_eventType
= commandType
;
528 m_controlDown
= false;
532 m_middleDown
= false;
537 m_linesPerAction
= 0;
540 void wxMouseEvent
::Assign(const wxMouseEvent
& event
)
542 m_eventType
= event
.m_eventType
;
547 m_leftDown
= event
.m_leftDown
;
548 m_middleDown
= event
.m_middleDown
;
549 m_rightDown
= event
.m_rightDown
;
551 m_controlDown
= event
.m_controlDown
;
552 m_shiftDown
= event
.m_shiftDown
;
553 m_altDown
= event
.m_altDown
;
554 m_metaDown
= event
.m_metaDown
;
556 m_wheelRotation
= event
.m_wheelRotation
;
557 m_wheelDelta
= event
.m_wheelDelta
;
558 m_linesPerAction
= event
.m_linesPerAction
;
561 // return true if was a button dclick event
562 bool wxMouseEvent
::ButtonDClick(int but
) const
567 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDClick"));
570 case wxMOUSE_BTN_ANY
:
571 return (LeftDClick() || MiddleDClick() || RightDClick());
573 case wxMOUSE_BTN_LEFT
:
576 case wxMOUSE_BTN_MIDDLE
:
577 return MiddleDClick();
579 case wxMOUSE_BTN_RIGHT
:
580 return RightDClick();
584 // return true if was a button down event
585 bool wxMouseEvent
::ButtonDown(int but
) const
590 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDown"));
593 case wxMOUSE_BTN_ANY
:
594 return (LeftDown() || MiddleDown() || RightDown());
596 case wxMOUSE_BTN_LEFT
:
599 case wxMOUSE_BTN_MIDDLE
:
602 case wxMOUSE_BTN_RIGHT
:
607 // return true if was a button up event
608 bool wxMouseEvent
::ButtonUp(int but
) const
613 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonUp"));
616 case wxMOUSE_BTN_ANY
:
617 return (LeftUp() || MiddleUp() || RightUp());
619 case wxMOUSE_BTN_LEFT
:
622 case wxMOUSE_BTN_MIDDLE
:
625 case wxMOUSE_BTN_RIGHT
:
630 // return true if the given button is currently changing state
631 bool wxMouseEvent
::Button(int but
) const
636 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::Button"));
639 case wxMOUSE_BTN_ANY
:
640 return ButtonUp(wxMOUSE_BTN_ANY
) ||
641 ButtonDown(wxMOUSE_BTN_ANY
) ||
642 ButtonDClick(wxMOUSE_BTN_ANY
);
644 case wxMOUSE_BTN_LEFT
:
645 return LeftDown() || LeftUp() || LeftDClick();
647 case wxMOUSE_BTN_MIDDLE
:
648 return MiddleDown() || MiddleUp() || MiddleDClick();
650 case wxMOUSE_BTN_RIGHT
:
651 return RightDown() || RightUp() || RightDClick();
655 bool wxMouseEvent
::ButtonIsDown(int but
) const
660 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonIsDown"));
663 case wxMOUSE_BTN_ANY
:
664 return LeftIsDown() || MiddleIsDown() || RightIsDown();
666 case wxMOUSE_BTN_LEFT
:
669 case wxMOUSE_BTN_MIDDLE
:
670 return MiddleIsDown();
672 case wxMOUSE_BTN_RIGHT
:
673 return RightIsDown();
677 int wxMouseEvent
::GetButton() const
679 for ( int i
= 1; i
<= 3; i
++ )
687 return wxMOUSE_BTN_NONE
;
690 // Find the logical position of the event given the DC
691 wxPoint wxMouseEvent
::GetLogicalPosition(const wxDC
& dc
) const
693 wxPoint
pt(dc
.DeviceToLogicalX(m_x
), dc
.DeviceToLogicalY(m_y
));
703 wxKeyEvent
::wxKeyEvent(wxEventType type
)
707 m_controlDown
= false;
717 wxKeyEvent
::wxKeyEvent(const wxKeyEvent
& evt
)
723 m_keyCode
= evt
.m_keyCode
;
725 m_controlDown
= evt
.m_controlDown
;
726 m_shiftDown
= evt
.m_shiftDown
;
727 m_altDown
= evt
.m_altDown
;
728 m_metaDown
= evt
.m_metaDown
;
729 m_scanCode
= evt
.m_scanCode
;
730 m_rawCode
= evt
.m_rawCode
;
731 m_rawFlags
= evt
.m_rawFlags
;
734 m_uniChar
= evt
.m_uniChar
;
738 long wxKeyEvent
::KeyCode() const
743 wxWindowCreateEvent
::wxWindowCreateEvent(wxWindow
*win
)
745 SetEventType(wxEVT_CREATE
);
749 wxWindowDestroyEvent
::wxWindowDestroyEvent(wxWindow
*win
)
751 SetEventType(wxEVT_DESTROY
);
755 wxChildFocusEvent
::wxChildFocusEvent(wxWindow
*win
)
756 : wxCommandEvent(wxEVT_CHILD_FOCUS
)
766 // ----------------------------------------------------------------------------
768 // ----------------------------------------------------------------------------
770 static const int EVENT_TYPE_TABLE_INIT_SIZE
= 31; // Not too big not too small...
772 wxEventHashTable
* wxEventHashTable
::sm_first
= NULL
;
774 wxEventHashTable
::wxEventHashTable(const wxEventTable
&table
)
778 AllocEventTypeTable(EVENT_TYPE_TABLE_INIT_SIZE
);
782 m_next
->m_previous
= this;
786 wxEventHashTable
::~wxEventHashTable()
789 m_next
->m_previous
= m_previous
;
791 m_previous
->m_next
= m_next
;
792 if (sm_first
== this)
798 void wxEventHashTable
::Clear()
801 for(i
= 0; i
< m_size
; i
++)
803 EventTypeTablePointer eTTnode
= m_eventTypeTable
[i
];
810 // Necessary in order to not invoke the
811 // overloaded delete operator when statics are cleaned up
812 if (m_eventTypeTable
)
813 delete[] m_eventTypeTable
;
815 m_eventTypeTable
= NULL
;
820 void wxEventHashTable
::ClearAll()
822 wxEventHashTable
* table
= sm_first
;
826 table
= table
->m_next
;
830 bool wxEventHashTable
::HandleEvent(wxEvent
&event
, wxEvtHandler
*self
)
835 m_rebuildHash
= false;
838 if (!m_eventTypeTable
)
841 // Find all entries for the given event type.
842 wxEventType eventType
= event
.GetEventType();
843 const EventTypeTablePointer eTTnode
= m_eventTypeTable
[eventType
% m_size
];
844 if (eTTnode
&& eTTnode
->eventType
== eventType
)
846 // Now start the search for an event handler
847 // that can handle an event with the given ID.
848 const wxEventTableEntryPointerArray
&
849 eventEntryTable
= eTTnode
->eventEntryTable
;
851 const size_t count
= eventEntryTable
.GetCount();
852 for (size_t n
= 0; n
< count
; n
++)
855 ProcessEventIfMatches(*eventEntryTable
[n
], self
, event
) )
865 void wxEventHashTable
::InitHashTable()
867 // Loop over the event tables and all its base tables.
868 const wxEventTable
*table
= &m_table
;
871 // Retrieve all valid event handler entries
872 const wxEventTableEntry
*entry
= table
->entries
;
873 while (entry
->m_fn
!= 0)
875 // Add the event entry in the Hash.
881 table
= table
->baseTable
;
884 // Lets free some memory.
886 for(i
= 0; i
< m_size
; i
++)
888 EventTypeTablePointer eTTnode
= m_eventTypeTable
[i
];
891 eTTnode
->eventEntryTable
.Shrink();
896 void wxEventHashTable
::AddEntry(const wxEventTableEntry
&entry
)
898 // This might happen 'accidentally' as the app is exiting
899 if (!m_eventTypeTable
)
902 EventTypeTablePointer
*peTTnode
= &m_eventTypeTable
[entry
.m_eventType
% m_size
];
903 EventTypeTablePointer eTTnode
= *peTTnode
;
907 if (eTTnode
->eventType
!= entry
.m_eventType
)
910 GrowEventTypeTable();
911 // Try again to add it.
918 eTTnode
= new EventTypeTable
;
919 eTTnode
->eventType
= entry
.m_eventType
;
923 // Fill all hash entries between entry.m_id and entry.m_lastId...
924 eTTnode
->eventEntryTable
.Add(&entry
);
927 void wxEventHashTable
::AllocEventTypeTable(size_t size
)
929 m_eventTypeTable
= new EventTypeTablePointer
[size
];
930 memset((void *)m_eventTypeTable
, 0, sizeof(EventTypeTablePointer
)*size
);
934 void wxEventHashTable
::GrowEventTypeTable()
936 size_t oldSize
= m_size
;
937 EventTypeTablePointer
*oldEventTypeTable
= m_eventTypeTable
;
939 // TODO: Search the most optimal grow sequence
940 AllocEventTypeTable(/* GetNextPrime(oldSize) */oldSize
*2+1);
942 for ( size_t i
= 0; i
< oldSize
; /* */ )
944 EventTypeTablePointer eTToldNode
= oldEventTypeTable
[i
];
947 EventTypeTablePointer
*peTTnode
= &m_eventTypeTable
[eTToldNode
->eventType
% m_size
];
948 EventTypeTablePointer eTTnode
= *peTTnode
;
950 // Check for collision, we don't want any.
953 GrowEventTypeTable();
954 continue; // Don't increment the counter,
955 // as we still need to add this element.
959 // Get the old value and put it in the new table.
960 *peTTnode
= oldEventTypeTable
[i
];
967 delete[] oldEventTypeTable
;
971 // ----------------------------------------------------------------------------
973 // ----------------------------------------------------------------------------
979 wxEvtHandler
::wxEvtHandler()
981 m_nextHandler
= (wxEvtHandler
*) NULL
;
982 m_previousHandler
= (wxEvtHandler
*) NULL
;
984 m_dynamicEvents
= (wxList
*) NULL
;
985 m_pendingEvents
= (wxList
*) NULL
;
987 # if !defined(__VISAGECPP__)
988 m_eventsLocker
= new wxCriticalSection
;
991 // no client data (yet)
993 m_clientDataType
= wxClientData_None
;
996 wxEvtHandler
::~wxEvtHandler()
998 // Takes itself out of the list of handlers
999 if (m_previousHandler
)
1000 m_previousHandler
->m_nextHandler
= m_nextHandler
;
1003 m_nextHandler
->m_previousHandler
= m_previousHandler
;
1005 if (m_dynamicEvents
)
1007 wxList
::iterator it
= m_dynamicEvents
->begin(),
1008 en
= m_dynamicEvents
->end();
1009 for (;it
!= en
; ++it
)
1011 #if WXWIN_COMPATIBILITY_EVENT_TYPES
1012 wxEventTableEntry
*entry
= (wxEventTableEntry
*)*it
;
1013 #else // !WXWIN_COMPATIBILITY_EVENT_TYPES
1014 wxDynamicEventTableEntry
*entry
= (wxDynamicEventTableEntry
*)*it
;
1015 #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
1017 if (entry
->m_callbackUserData
)
1018 delete entry
->m_callbackUserData
;
1021 delete m_dynamicEvents
;
1024 delete m_pendingEvents
;
1027 # if !defined(__VISAGECPP__)
1028 delete m_eventsLocker
;
1031 // Remove us from wxPendingEvents if necessary.
1032 if(wxPendingEventsLocker
)
1033 wxENTER_CRIT_SECT(*wxPendingEventsLocker
);
1034 if ( wxPendingEvents
) {
1035 wxPendingEvents
->DeleteObject(this);
1037 if(wxPendingEventsLocker
)
1038 wxLEAVE_CRIT_SECT(*wxPendingEventsLocker
);
1041 // we only delete object data, not untyped
1042 if ( m_clientDataType
== wxClientData_Object
)
1043 delete m_clientObject
;
1048 bool wxEvtHandler
::ProcessThreadEvent(wxEvent
& event
)
1050 // check that we are really in a child thread
1051 wxASSERT_MSG( !wxThread
::IsMain(),
1052 wxT("use ProcessEvent() in main thread") );
1054 AddPendingEvent(event
);
1059 void wxEvtHandler
::ClearEventLocker()
1061 #if !defined(__VISAGECPP__)
1062 delete m_eventsLocker
;
1063 m_eventsLocker
= NULL
;
1067 #endif // wxUSE_THREADS
1069 void wxEvtHandler
::AddPendingEvent(wxEvent
& event
)
1071 // 1) Add event to list of pending events of this event handler
1073 wxEvent
*eventCopy
= event
.Clone();
1075 // we must be able to copy the events here so the event class must
1076 // implement Clone() properly instead of just providing a NULL stab for it
1077 wxCHECK_RET( eventCopy
,
1078 _T("events of this type aren't supposed to be posted") );
1080 #if defined(__VISAGECPP__)
1081 wxENTER_CRIT_SECT( m_eventsLocker
);
1083 wxENTER_CRIT_SECT( *m_eventsLocker
);
1086 if ( !m_pendingEvents
)
1087 m_pendingEvents
= new wxList
;
1089 m_pendingEvents
->Append(eventCopy
);
1091 #if defined(__VISAGECPP__)
1092 wxLEAVE_CRIT_SECT( m_eventsLocker
);
1094 wxLEAVE_CRIT_SECT( *m_eventsLocker
);
1097 // 2) Add this event handler to list of event handlers that
1098 // have pending events.
1100 wxENTER_CRIT_SECT(*wxPendingEventsLocker
);
1102 if ( !wxPendingEvents
)
1103 wxPendingEvents
= new wxList
;
1104 wxPendingEvents
->Append(this);
1106 wxLEAVE_CRIT_SECT(*wxPendingEventsLocker
);
1108 // 3) Inform the system that new pending events are somwehere,
1109 // and that these should be processed in idle time.
1113 void wxEvtHandler
::ProcessPendingEvents()
1115 // this method is only called by wxApp if this handler does have pending
1117 wxCHECK_RET( m_pendingEvents
,
1118 wxT("Please call wxApp::ProcessPendingEvents() instead") );
1120 #if defined(__VISAGECPP__)
1121 wxENTER_CRIT_SECT( m_eventsLocker
);
1123 wxENTER_CRIT_SECT( *m_eventsLocker
);
1126 // remember last event to process during this iteration
1127 wxList
::compatibility_iterator lastPendingNode
= m_pendingEvents
->GetLast();
1129 wxList
::compatibility_iterator node
= m_pendingEvents
->GetFirst();
1132 wxEvent
*event
= (wxEvent
*)node
->GetData();
1133 m_pendingEvents
->Erase(node
);
1135 // In ProcessEvent, new events might get added and
1136 // we can safely leave the crtical section here.
1137 #if defined(__VISAGECPP__)
1138 wxLEAVE_CRIT_SECT( m_eventsLocker
);
1140 wxLEAVE_CRIT_SECT( *m_eventsLocker
);
1142 ProcessEvent(*event
);
1144 #if defined(__VISAGECPP__)
1145 wxENTER_CRIT_SECT( m_eventsLocker
);
1147 wxENTER_CRIT_SECT( *m_eventsLocker
);
1150 // leave the loop once we have processed all events that were present
1151 // at the start of ProcessPendingEvents because otherwise we could get
1152 // into infinite loop if the pending event handler execution resulted
1153 // in another event being posted
1154 if ( node
== lastPendingNode
)
1157 node
= m_pendingEvents
->GetFirst();
1160 #if defined(__VISAGECPP__)
1161 wxLEAVE_CRIT_SECT( m_eventsLocker
);
1163 wxLEAVE_CRIT_SECT( *m_eventsLocker
);
1171 wxEvtHandler
::ProcessEventIfMatches(const wxEventTableEntryBase
& entry
,
1172 wxEvtHandler
*handler
,
1175 int tableId1
= entry
.m_id
,
1176 tableId2
= entry
.m_lastId
;
1178 // match only if the event type is the same and the id is either -1 in
1179 // the event table (meaning "any") or the event id matches the id
1180 // specified in the event table either exactly or by falling into
1181 // range between first and last
1182 if ((tableId1
== wxID_ANY
) ||
1183 (tableId2
== wxID_ANY
&& tableId1
== event
.GetId()) ||
1184 (tableId2
!= wxID_ANY
&&
1185 (event
.GetId() >= tableId1
&& event
.GetId() <= tableId2
)))
1188 event
.m_callbackUserData
= entry
.m_callbackUserData
;
1190 #if wxUSE_EXCEPTIONS
1193 // call the handler via wxApp method which allows the user to catch
1194 // any exceptions which may be thrown by any handler in the program
1196 wxTheApp
->HandleEvent(handler
, (wxEventFunction
)entry
.m_fn
, event
);
1199 #endif // wxUSE_EXCEPTIONS
1201 // no need for an extra virtual function call
1202 (handler
->*((wxEventFunction
) (entry
.m_fn
)))(event
);
1205 if (!event
.GetSkipped())
1212 bool wxEvtHandler
::TryParent(wxEvent
& event
)
1214 if ( wxTheApp
&& (this != wxTheApp
) )
1216 // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always
1217 // swallow it. wxEVT_IDLE is sent explicitly to wxApp so it will be
1218 // processed appropriately via SearchEventTable.
1219 if ( event
.GetEventType() != wxEVT_IDLE
)
1221 if ( wxTheApp
->ProcessEvent(event
) )
1229 bool wxEvtHandler
::ProcessEvent(wxEvent
& event
)
1231 // allow the application to hook into event processing
1234 int rc
= wxTheApp
->FilterEvent(event
);
1237 wxASSERT_MSG( rc
== 1 || rc
== 0,
1238 _T("unexpected wxApp::FilterEvent return value") );
1242 //else: proceed normally
1245 // An event handler can be enabled or disabled
1246 if ( GetEvtHandlerEnabled() )
1248 // if we have a validator, it has higher priority than our own event
1250 if ( TryValidator(event
) )
1253 // Handle per-instance dynamic event tables first
1254 if ( m_dynamicEvents
&& SearchDynamicEventTable(event
) )
1257 // Then static per-class event tables
1258 if ( GetEventHashTable().HandleEvent(event
, this) )
1262 // Try going down the event handler chain
1263 if ( GetNextHandler() )
1265 if ( GetNextHandler()->ProcessEvent(event
) )
1269 // Finally propagate the event upwards the window chain and/or to the
1270 // application object as necessary
1271 return TryParent(event
);
1275 bool wxEvtHandler
::SearchEventTable(wxEventTable
& table
, wxEvent
& event
)
1277 const wxEventType eventType
= event
.GetEventType();
1278 for ( int i
= 0; table
.entries
[i
].m_fn
!= 0; i
++ )
1280 const wxEventTableEntry
& entry
= table
.entries
[i
];
1281 if ( eventType
== entry
.m_eventType
)
1283 if ( ProcessEventIfMatches(entry
, this, event
) )
1291 void wxEvtHandler
::Connect( int id
, int lastId
,
1293 wxObjectEventFunction func
,
1295 wxEvtHandler
* eventSink
)
1297 #if WXWIN_COMPATIBILITY_EVENT_TYPES
1298 wxEventTableEntry
*entry
= new wxEventTableEntry
;
1299 entry
->m_eventType
= eventType
;
1301 entry
->m_lastId
= lastId
;
1303 entry
->m_callbackUserData
= userData
;
1304 #else // !WXWIN_COMPATIBILITY_EVENT_TYPES
1305 wxDynamicEventTableEntry
*entry
=
1306 new wxDynamicEventTableEntry(eventType
, id
, lastId
, func
, userData
, eventSink
);
1307 #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
1309 if (!m_dynamicEvents
)
1310 m_dynamicEvents
= new wxList
;
1312 // Insert at the front of the list so most recent additions are found first
1313 m_dynamicEvents
->Insert( (wxObject
*) entry
);
1316 bool wxEvtHandler
::Disconnect( int id
, int lastId
, wxEventType eventType
,
1317 wxObjectEventFunction func
,
1319 wxEvtHandler
* eventSink
)
1321 if (!m_dynamicEvents
)
1324 wxList
::compatibility_iterator node
= m_dynamicEvents
->GetFirst();
1327 #if WXWIN_COMPATIBILITY_EVENT_TYPES
1328 wxEventTableEntry
*entry
= (wxEventTableEntry
*)node
->GetData();
1329 #else // !WXWIN_COMPATIBILITY_EVENT_TYPES
1330 wxDynamicEventTableEntry
*entry
= (wxDynamicEventTableEntry
*)node
->GetData();
1331 #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
1333 if ((entry
->m_id
== id
) &&
1334 ((entry
->m_lastId
== lastId
) || (lastId
== wxID_ANY
)) &&
1335 ((entry
->m_eventType
== eventType
) || (eventType
== wxEVT_NULL
)) &&
1336 ((entry
->m_fn
== func
) || (func
== (wxObjectEventFunction
)NULL
)) &&
1337 ((entry
->m_eventSink
== eventSink
) || (eventSink
== (wxEvtHandler
*)NULL
)) &&
1338 ((entry
->m_callbackUserData
== userData
) || (userData
== (wxObject
*)NULL
)))
1340 if (entry
->m_callbackUserData
)
1341 delete entry
->m_callbackUserData
;
1342 m_dynamicEvents
->Erase( node
);
1346 node
= node
->GetNext();
1351 bool wxEvtHandler
::SearchDynamicEventTable( wxEvent
& event
)
1353 wxCHECK_MSG( m_dynamicEvents
, false,
1354 wxT("caller should check that we have dynamic events") );
1356 wxList
::compatibility_iterator node
= m_dynamicEvents
->GetFirst();
1359 #if WXWIN_COMPATIBILITY_EVENT_TYPES
1360 wxEventTableEntry
*entry
= (wxEventTableEntry
*)node
->GetData();
1361 #else // !WXWIN_COMPATIBILITY_EVENT_TYPES
1362 wxDynamicEventTableEntry
*entry
= (wxDynamicEventTableEntry
*)node
->GetData();
1363 #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
1365 if ((event
.GetEventType() == entry
->m_eventType
) && (entry
->m_fn
!= 0))
1367 wxEvtHandler
*handler
=
1368 #if !WXWIN_COMPATIBILITY_EVENT_TYPES
1369 entry
->m_eventSink ? entry
->m_eventSink
1374 if ( ProcessEventIfMatches(*entry
, handler
, event
) )
1380 node
= node
->GetNext();
1386 void wxEvtHandler
::DoSetClientObject( wxClientData
*data
)
1388 wxASSERT_MSG( m_clientDataType
!= wxClientData_Void
,
1389 wxT("can't have both object and void client data") );
1391 if ( m_clientObject
)
1392 delete m_clientObject
;
1394 m_clientObject
= data
;
1395 m_clientDataType
= wxClientData_Object
;
1398 wxClientData
*wxEvtHandler
::DoGetClientObject() const
1400 // it's not an error to call GetClientObject() on a window which doesn't
1401 // have client data at all - NULL will be returned
1402 wxASSERT_MSG( m_clientDataType
!= wxClientData_Void
,
1403 wxT("this window doesn't have object client data") );
1405 return m_clientObject
;
1408 void wxEvtHandler
::DoSetClientData( void *data
)
1410 wxASSERT_MSG( m_clientDataType
!= wxClientData_Object
,
1411 wxT("can't have both object and void client data") );
1413 m_clientData
= data
;
1414 m_clientDataType
= wxClientData_Void
;
1417 void *wxEvtHandler
::DoGetClientData() const
1419 // it's not an error to call GetClientData() on a window which doesn't have
1420 // client data at all - NULL will be returned
1421 wxASSERT_MSG( m_clientDataType
!= wxClientData_Object
,
1422 wxT("this window doesn't have void client data") );
1424 return m_clientData
;
1427 #endif // wxUSE_BASE
1431 // Find a window with the focus, that is also a descendant of the given window.
1432 // This is used to determine the window to initially send commands to.
1433 wxWindow
* wxFindFocusDescendant(wxWindow
* ancestor
)
1435 // Process events starting with the window with the focus, if any.
1436 wxWindow
* focusWin
= wxWindow
::FindFocus();
1437 wxWindow
* win
= focusWin
;
1439 // Check if this is a descendant of this frame.
1440 // If not, win will be set to NULL.
1443 if (win
== ancestor
)
1446 win
= win
->GetParent();
1448 if (win
== (wxWindow
*) NULL
)
1449 focusWin
= (wxWindow
*) NULL
;