]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: 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 | #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 | |
27 | // such files. | |
28 | #pragma implementation "event.h" | |
29 | #endif | |
30 | ||
31 | // For compilers that support precompilation, includes "wx.h". | |
32 | #include "wx/wxprec.h" | |
33 | ||
34 | #ifdef __BORLANDC__ | |
35 | #pragma hdrstop | |
36 | #endif | |
37 | ||
38 | #ifndef WX_PRECOMP | |
39 | #include "wx/defs.h" | |
40 | #include "wx/app.h" | |
41 | #include "wx/list.h" | |
42 | ||
43 | #if wxUSE_GUI | |
44 | #include "wx/control.h" | |
45 | #include "wx/utils.h" | |
46 | #include "wx/dc.h" | |
47 | #endif // wxUSE_GUI | |
48 | #endif | |
49 | ||
50 | #include "wx/event.h" | |
51 | #include "wx/module.h" | |
52 | ||
53 | #if wxUSE_GUI | |
54 | #include "wx/validate.h" | |
55 | #if wxUSE_STOPWATCH | |
56 | #include "wx/stopwatch.h" | |
57 | #endif | |
58 | #endif // wxUSE_GUI | |
59 | ||
60 | // ---------------------------------------------------------------------------- | |
61 | // wxWin macros | |
62 | // ---------------------------------------------------------------------------- | |
63 | ||
64 | #if wxUSE_BASE | |
65 | IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject) | |
66 | IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject) | |
67 | #endif // wxUSE_BASE | |
68 | ||
69 | #if wxUSE_GUI | |
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) | |
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_ENTRY(wxEVT_NULL, 0, 0, (wxObjectEventFunction)NULL, NULL) }; | |
122 | ||
123 | ||
124 | #ifdef __WXDEBUG__ | |
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 | |
128 | { | |
129 | DECLARE_DYNAMIC_CLASS(wxEventTableEntryModule) | |
130 | public: | |
131 | wxEventTableEntryModule() {} | |
132 | bool OnInit() { return true; } | |
133 | void OnExit() | |
134 | { | |
135 | wxEventHashTable::ClearAll(); | |
136 | } | |
137 | }; | |
138 | IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule) | |
139 | #endif | |
140 | ||
141 | // ---------------------------------------------------------------------------- | |
142 | // global variables | |
143 | // ---------------------------------------------------------------------------- | |
144 | ||
145 | // To put pending event handlers | |
146 | wxList *wxPendingEvents = (wxList *)NULL; | |
147 | ||
148 | #if wxUSE_THREADS | |
149 | // protects wxPendingEvents list | |
150 | wxCriticalSection *wxPendingEventsLocker = (wxCriticalSection *)NULL; | |
151 | #endif | |
152 | ||
153 | #if !WXWIN_COMPATIBILITY_EVENT_TYPES | |
154 | ||
155 | // common event types are defined here, other event types are defined by the | |
156 | // components which use them | |
157 | ||
158 | const wxEventType wxEVT_FIRST = 10000; | |
159 | const wxEventType wxEVT_USER_FIRST = wxEVT_FIRST + 2000; | |
160 | ||
161 | DEFINE_EVENT_TYPE(wxEVT_NULL) | |
162 | DEFINE_EVENT_TYPE(wxEVT_IDLE) | |
163 | DEFINE_EVENT_TYPE(wxEVT_SOCKET) | |
164 | ||
165 | #endif // !WXWIN_COMPATIBILITY_EVENT_TYPES | |
166 | ||
167 | #endif // wxUSE_BASE | |
168 | ||
169 | #if wxUSE_GUI | |
170 | ||
171 | #if !WXWIN_COMPATIBILITY_EVENT_TYPES | |
172 | ||
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) | |
189 | ||
190 | // Sockets and timers send events, too | |
191 | DEFINE_EVENT_TYPE(wxEVT_TIMER) | |
192 | ||
193 | // Mouse event types | |
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) | |
210 | ||
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) | |
224 | ||
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) | |
231 | #if wxUSE_HOTKEY | |
232 | DEFINE_EVENT_TYPE(wxEVT_HOTKEY) | |
233 | #endif | |
234 | ||
235 | // Set cursor event | |
236 | DEFINE_EVENT_TYPE(wxEVT_SET_CURSOR) | |
237 | ||
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) | |
248 | ||
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) | |
258 | ||
259 | // System events | |
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) | |
299 | ||
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) | |
309 | ||
310 | // Help events | |
311 | DEFINE_EVENT_TYPE(wxEVT_HELP) | |
312 | DEFINE_EVENT_TYPE(wxEVT_DETAILED_HELP) | |
313 | ||
314 | #endif // !WXWIN_COMPATIBILITY_EVENT_TYPES | |
315 | ||
316 | #endif // wxUSE_GUI | |
317 | ||
318 | #if wxUSE_BASE | |
319 | ||
320 | // ============================================================================ | |
321 | // implementation | |
322 | // ============================================================================ | |
323 | ||
324 | // ---------------------------------------------------------------------------- | |
325 | // event initialization | |
326 | // ---------------------------------------------------------------------------- | |
327 | ||
328 | int wxNewEventType() | |
329 | { | |
330 | // MT-FIXME | |
331 | static int s_lastUsedEventType = wxEVT_FIRST; | |
332 | ||
333 | return s_lastUsedEventType++; | |
334 | } | |
335 | ||
336 | // ---------------------------------------------------------------------------- | |
337 | // wxEvent | |
338 | // ---------------------------------------------------------------------------- | |
339 | ||
340 | /* | |
341 | * General wxWidgets events, covering | |
342 | * all interesting things that might happen (button clicking, resizing, | |
343 | * setting text in widgets, etc.). | |
344 | * | |
345 | * For each completely new event type, derive a new event class. | |
346 | * | |
347 | */ | |
348 | ||
349 | wxEvent::wxEvent(int theId, wxEventType commandType ) | |
350 | { | |
351 | m_eventType = commandType; | |
352 | m_eventObject = (wxObject *) NULL; | |
353 | m_timeStamp = 0; | |
354 | m_id = theId; | |
355 | m_skipped = false; | |
356 | m_callbackUserData = (wxObject *) NULL; | |
357 | m_isCommandEvent = false; | |
358 | m_propagationLevel = wxEVENT_PROPAGATE_NONE; | |
359 | } | |
360 | ||
361 | wxEvent::wxEvent(const wxEvent &src) | |
362 | : wxObject() | |
363 | , m_eventObject(src.m_eventObject) | |
364 | , m_eventType(src.m_eventType) | |
365 | , m_timeStamp(src.m_timeStamp) | |
366 | , m_id(src.m_id) | |
367 | , m_callbackUserData(src.m_callbackUserData) | |
368 | , m_propagationLevel(src.m_propagationLevel) | |
369 | , m_skipped(src.m_skipped) | |
370 | , m_isCommandEvent(src.m_isCommandEvent) | |
371 | { | |
372 | } | |
373 | ||
374 | #endif // wxUSE_BASE | |
375 | ||
376 | #if wxUSE_GUI | |
377 | ||
378 | /* | |
379 | * Command events | |
380 | * | |
381 | */ | |
382 | ||
383 | wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId) | |
384 | : wxEvent(theId, commandType) | |
385 | { | |
386 | m_clientData = (char *) NULL; | |
387 | m_clientObject = (wxClientData *) NULL; | |
388 | m_extraLong = 0; | |
389 | m_commandInt = 0; | |
390 | m_isCommandEvent = true; | |
391 | ||
392 | // the command events are propagated upwards by default | |
393 | m_propagationLevel = wxEVENT_PROPAGATE_MAX; | |
394 | } | |
395 | ||
396 | /* | |
397 | * UI update events | |
398 | */ | |
399 | ||
400 | #if wxUSE_LONGLONG | |
401 | wxLongLong wxUpdateUIEvent::sm_lastUpdate = 0; | |
402 | #endif | |
403 | ||
404 | long wxUpdateUIEvent::sm_updateInterval = 0; | |
405 | ||
406 | wxUpdateUIMode wxUpdateUIEvent::sm_updateMode = wxUPDATE_UI_PROCESS_ALL; | |
407 | ||
408 | // Can we update? | |
409 | bool wxUpdateUIEvent::CanUpdate(wxWindowBase *win) | |
410 | { | |
411 | // Don't update if we've switched global updating off | |
412 | // and this window doesn't support updates. | |
413 | if (win && | |
414 | (GetMode() == wxUPDATE_UI_PROCESS_SPECIFIED && | |
415 | ((win->GetExtraStyle() & wxWS_EX_PROCESS_UI_UPDATES) == 0))) | |
416 | return false; | |
417 | ||
418 | if (sm_updateInterval == -1) | |
419 | return false; | |
420 | else if (sm_updateInterval == 0) | |
421 | return true; | |
422 | else | |
423 | { | |
424 | #if wxUSE_STOPWATCH && wxUSE_LONGLONG | |
425 | wxLongLong now = wxGetLocalTimeMillis(); | |
426 | if (now > (sm_lastUpdate + sm_updateInterval)) | |
427 | { | |
428 | return true; | |
429 | } | |
430 | #else | |
431 | // If we don't have wxStopWatch or wxLongLong, we | |
432 | // should err on the safe side and update now anyway. | |
433 | return true; | |
434 | #endif | |
435 | } | |
436 | return false; | |
437 | } | |
438 | ||
439 | // Reset the update time to provide a delay until the next | |
440 | // time we should update | |
441 | void wxUpdateUIEvent::ResetUpdateTime() | |
442 | { | |
443 | #if wxUSE_STOPWATCH && wxUSE_LONGLONG | |
444 | if (sm_updateInterval > 0) | |
445 | { | |
446 | wxLongLong now = wxGetLocalTimeMillis(); | |
447 | if (now > (sm_lastUpdate + sm_updateInterval)) | |
448 | { | |
449 | sm_lastUpdate = now; | |
450 | } | |
451 | } | |
452 | #endif | |
453 | } | |
454 | ||
455 | /* | |
456 | * Idle events | |
457 | */ | |
458 | ||
459 | wxIdleMode wxIdleEvent::sm_idleMode = wxIDLE_PROCESS_ALL; | |
460 | ||
461 | // Can we send an idle event? | |
462 | bool wxIdleEvent::CanSend(wxWindow* 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() == wxIDLE_PROCESS_SPECIFIED && | |
468 | ((win->GetExtraStyle() & wxWS_EX_PROCESS_IDLE) == 0))) | |
469 | return false; | |
470 | ||
471 | return true; | |
472 | } | |
473 | ||
474 | /* | |
475 | * Scroll events | |
476 | */ | |
477 | ||
478 | wxScrollEvent::wxScrollEvent(wxEventType commandType, | |
479 | int id, | |
480 | int pos, | |
481 | int orient) | |
482 | : wxCommandEvent(commandType, id) | |
483 | { | |
484 | m_extraLong = orient; | |
485 | m_commandInt = pos; | |
486 | } | |
487 | ||
488 | /* | |
489 | * ScrollWin events | |
490 | */ | |
491 | ||
492 | wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType, | |
493 | int pos, | |
494 | int orient) | |
495 | { | |
496 | m_eventType = commandType; | |
497 | m_extraLong = orient; | |
498 | m_commandInt = pos; | |
499 | } | |
500 | ||
501 | /* | |
502 | * Mouse events | |
503 | * | |
504 | */ | |
505 | ||
506 | wxMouseEvent::wxMouseEvent(wxEventType commandType) | |
507 | { | |
508 | m_eventType = commandType; | |
509 | m_metaDown = false; | |
510 | m_altDown = false; | |
511 | m_controlDown = false; | |
512 | m_shiftDown = false; | |
513 | m_leftDown = false; | |
514 | m_rightDown = false; | |
515 | m_middleDown = false; | |
516 | m_x = 0; | |
517 | m_y = 0; | |
518 | m_wheelRotation = 0; | |
519 | m_wheelDelta = 0; | |
520 | m_linesPerAction = 0; | |
521 | } | |
522 | ||
523 | void wxMouseEvent::Assign(const wxMouseEvent& event) | |
524 | { | |
525 | m_eventType = event.m_eventType; | |
526 | ||
527 | m_x = event.m_x; | |
528 | m_y = event.m_y; | |
529 | ||
530 | m_leftDown = event.m_leftDown; | |
531 | m_middleDown = event.m_middleDown; | |
532 | m_rightDown = event.m_rightDown; | |
533 | ||
534 | m_controlDown = event.m_controlDown; | |
535 | m_shiftDown = event.m_shiftDown; | |
536 | m_altDown = event.m_altDown; | |
537 | m_metaDown = event.m_metaDown; | |
538 | ||
539 | m_wheelRotation = event.m_wheelRotation; | |
540 | m_wheelDelta = event.m_wheelDelta; | |
541 | m_linesPerAction = event.m_linesPerAction; | |
542 | } | |
543 | ||
544 | // return true if was a button dclick event | |
545 | bool wxMouseEvent::ButtonDClick(int but) const | |
546 | { | |
547 | switch (but) | |
548 | { | |
549 | default: | |
550 | wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDClick")); | |
551 | // fall through | |
552 | ||
553 | case wxMOUSE_BTN_ANY: | |
554 | return (LeftDClick() || MiddleDClick() || RightDClick()); | |
555 | ||
556 | case wxMOUSE_BTN_LEFT: | |
557 | return LeftDClick(); | |
558 | ||
559 | case wxMOUSE_BTN_MIDDLE: | |
560 | return MiddleDClick(); | |
561 | ||
562 | case wxMOUSE_BTN_RIGHT: | |
563 | return RightDClick(); | |
564 | } | |
565 | } | |
566 | ||
567 | // return true if was a button down event | |
568 | bool wxMouseEvent::ButtonDown(int but) const | |
569 | { | |
570 | switch (but) | |
571 | { | |
572 | default: | |
573 | wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDown")); | |
574 | // fall through | |
575 | ||
576 | case wxMOUSE_BTN_ANY: | |
577 | return (LeftDown() || MiddleDown() || RightDown()); | |
578 | ||
579 | case wxMOUSE_BTN_LEFT: | |
580 | return LeftDown(); | |
581 | ||
582 | case wxMOUSE_BTN_MIDDLE: | |
583 | return MiddleDown(); | |
584 | ||
585 | case wxMOUSE_BTN_RIGHT: | |
586 | return RightDown(); | |
587 | } | |
588 | } | |
589 | ||
590 | // return true if was a button up event | |
591 | bool wxMouseEvent::ButtonUp(int but) const | |
592 | { | |
593 | switch (but) | |
594 | { | |
595 | default: | |
596 | wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonUp")); | |
597 | // fall through | |
598 | ||
599 | case wxMOUSE_BTN_ANY: | |
600 | return (LeftUp() || MiddleUp() || RightUp()); | |
601 | ||
602 | case wxMOUSE_BTN_LEFT: | |
603 | return LeftUp(); | |
604 | ||
605 | case wxMOUSE_BTN_MIDDLE: | |
606 | return MiddleUp(); | |
607 | ||
608 | case wxMOUSE_BTN_RIGHT: | |
609 | return RightUp(); | |
610 | } | |
611 | } | |
612 | ||
613 | // return true if the given button is currently changing state | |
614 | bool wxMouseEvent::Button(int but) const | |
615 | { | |
616 | switch (but) | |
617 | { | |
618 | default: | |
619 | wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::Button")); | |
620 | // fall through | |
621 | ||
622 | case wxMOUSE_BTN_ANY: | |
623 | return ButtonUp(wxMOUSE_BTN_ANY) || | |
624 | ButtonDown(wxMOUSE_BTN_ANY) || | |
625 | ButtonDClick(wxMOUSE_BTN_ANY); | |
626 | ||
627 | case wxMOUSE_BTN_LEFT: | |
628 | return LeftDown() || LeftUp() || LeftDClick(); | |
629 | ||
630 | case wxMOUSE_BTN_MIDDLE: | |
631 | return MiddleDown() || MiddleUp() || MiddleDClick(); | |
632 | ||
633 | case wxMOUSE_BTN_RIGHT: | |
634 | return RightDown() || RightUp() || RightDClick(); | |
635 | } | |
636 | } | |
637 | ||
638 | bool wxMouseEvent::ButtonIsDown(int but) const | |
639 | { | |
640 | switch (but) | |
641 | { | |
642 | default: | |
643 | wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonIsDown")); | |
644 | // fall through | |
645 | ||
646 | case wxMOUSE_BTN_ANY: | |
647 | return LeftIsDown() || MiddleIsDown() || RightIsDown(); | |
648 | ||
649 | case wxMOUSE_BTN_LEFT: | |
650 | return LeftIsDown(); | |
651 | ||
652 | case wxMOUSE_BTN_MIDDLE: | |
653 | return MiddleIsDown(); | |
654 | ||
655 | case wxMOUSE_BTN_RIGHT: | |
656 | return RightIsDown(); | |
657 | } | |
658 | } | |
659 | ||
660 | int wxMouseEvent::GetButton() const | |
661 | { | |
662 | for ( int i = 1; i <= 3; i++ ) | |
663 | { | |
664 | if ( Button(i) ) | |
665 | { | |
666 | return i; | |
667 | } | |
668 | } | |
669 | ||
670 | return wxMOUSE_BTN_NONE; | |
671 | } | |
672 | ||
673 | // Find the logical position of the event given the DC | |
674 | wxPoint wxMouseEvent::GetLogicalPosition(const wxDC& dc) const | |
675 | { | |
676 | wxPoint pt(dc.DeviceToLogicalX(m_x), dc.DeviceToLogicalY(m_y)); | |
677 | return pt; | |
678 | } | |
679 | ||
680 | ||
681 | /* | |
682 | * Keyboard event | |
683 | * | |
684 | */ | |
685 | ||
686 | wxKeyEvent::wxKeyEvent(wxEventType type) | |
687 | { | |
688 | m_eventType = type; | |
689 | m_shiftDown = false; | |
690 | m_controlDown = false; | |
691 | m_metaDown = false; | |
692 | m_altDown = false; | |
693 | m_keyCode = 0; | |
694 | m_scanCode = 0; | |
695 | #if wxUSE_UNICODE | |
696 | m_uniChar = 0; | |
697 | #endif | |
698 | } | |
699 | ||
700 | wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt) | |
701 | : wxEvent(evt) | |
702 | { | |
703 | m_x = evt.m_x; | |
704 | m_y = evt.m_y; | |
705 | ||
706 | m_keyCode = evt.m_keyCode; | |
707 | ||
708 | m_controlDown = evt.m_controlDown; | |
709 | m_shiftDown = evt.m_shiftDown; | |
710 | m_altDown = evt.m_altDown; | |
711 | m_metaDown = evt.m_metaDown; | |
712 | m_scanCode = evt.m_scanCode; | |
713 | m_rawCode = evt.m_rawCode; | |
714 | m_rawFlags = evt.m_rawFlags; | |
715 | ||
716 | #if wxUSE_UNICODE | |
717 | m_uniChar = evt.m_uniChar; | |
718 | #endif | |
719 | } | |
720 | ||
721 | long wxKeyEvent::KeyCode() const | |
722 | { | |
723 | return m_keyCode; | |
724 | } | |
725 | ||
726 | wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win) | |
727 | { | |
728 | SetEventType(wxEVT_CREATE); | |
729 | SetEventObject(win); | |
730 | } | |
731 | ||
732 | wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win) | |
733 | { | |
734 | SetEventType(wxEVT_DESTROY); | |
735 | SetEventObject(win); | |
736 | } | |
737 | ||
738 | wxChildFocusEvent::wxChildFocusEvent(wxWindow *win) | |
739 | : wxCommandEvent(wxEVT_CHILD_FOCUS) | |
740 | { | |
741 | SetEventObject(win); | |
742 | } | |
743 | ||
744 | #endif // wxUSE_GUI | |
745 | ||
746 | ||
747 | #if wxUSE_BASE | |
748 | ||
749 | // ---------------------------------------------------------------------------- | |
750 | // wxEventHashTable | |
751 | // ---------------------------------------------------------------------------- | |
752 | ||
753 | static const int EVENT_TYPE_TABLE_INIT_SIZE = 31; // Not too big not too small... | |
754 | ||
755 | wxEventHashTable* wxEventHashTable::sm_first = NULL; | |
756 | ||
757 | wxEventHashTable::wxEventHashTable(const wxEventTable &table) | |
758 | : m_table(table), | |
759 | m_rebuildHash(true) | |
760 | { | |
761 | AllocEventTypeTable(EVENT_TYPE_TABLE_INIT_SIZE); | |
762 | ||
763 | m_next = sm_first; | |
764 | if (m_next) | |
765 | m_next->m_previous = this; | |
766 | sm_first = this; | |
767 | } | |
768 | ||
769 | wxEventHashTable::~wxEventHashTable() | |
770 | { | |
771 | if (m_next) | |
772 | m_next->m_previous = m_previous; | |
773 | if (m_previous) | |
774 | m_previous->m_next = m_next; | |
775 | if (sm_first == this) | |
776 | sm_first = m_next; | |
777 | ||
778 | Clear(); | |
779 | } | |
780 | ||
781 | void wxEventHashTable::Clear() | |
782 | { | |
783 | size_t i; | |
784 | for(i = 0; i < m_size; i++) | |
785 | { | |
786 | EventTypeTablePointer eTTnode = m_eventTypeTable[i]; | |
787 | if (eTTnode) | |
788 | { | |
789 | delete eTTnode; | |
790 | } | |
791 | } | |
792 | ||
793 | // Necessary in order to not invoke the | |
794 | // overloaded delete operator when statics are cleaned up | |
795 | if (m_eventTypeTable) | |
796 | delete[] m_eventTypeTable; | |
797 | ||
798 | m_eventTypeTable = NULL; | |
799 | m_size = 0; | |
800 | } | |
801 | ||
802 | // Clear all tables | |
803 | void wxEventHashTable::ClearAll() | |
804 | { | |
805 | wxEventHashTable* table = sm_first; | |
806 | while (table) | |
807 | { | |
808 | table->Clear(); | |
809 | table = table->m_next; | |
810 | } | |
811 | } | |
812 | ||
813 | bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self) | |
814 | { | |
815 | if (m_rebuildHash) | |
816 | { | |
817 | InitHashTable(); | |
818 | m_rebuildHash = false; | |
819 | } | |
820 | ||
821 | if (!m_eventTypeTable) | |
822 | return FALSE; | |
823 | ||
824 | // Find all entries for the given event type. | |
825 | wxEventType eventType = event.GetEventType(); | |
826 | const EventTypeTablePointer eTTnode = m_eventTypeTable[eventType % m_size]; | |
827 | if (eTTnode && eTTnode->eventType == eventType) | |
828 | { | |
829 | // Now start the search for an event handler | |
830 | // that can handle an event with the given ID. | |
831 | const wxEventTableEntryPointerArray& | |
832 | eventEntryTable = eTTnode->eventEntryTable; | |
833 | ||
834 | const size_t count = eventEntryTable.GetCount(); | |
835 | for (size_t n = 0; n < count; n++) | |
836 | { | |
837 | if ( wxEvtHandler:: | |
838 | ProcessEventIfMatches(*eventEntryTable[n], self, event) ) | |
839 | { | |
840 | return true; | |
841 | } | |
842 | } | |
843 | } | |
844 | ||
845 | return false; | |
846 | } | |
847 | ||
848 | void wxEventHashTable::InitHashTable() | |
849 | { | |
850 | // Loop over the event tables and all its base tables. | |
851 | const wxEventTable *table = &m_table; | |
852 | while (table) | |
853 | { | |
854 | // Retrieve all valid event handler entries | |
855 | const wxEventTableEntry *entry = table->entries; | |
856 | while (entry->m_fn != 0) | |
857 | { | |
858 | // Add the event entry in the Hash. | |
859 | AddEntry(*entry); | |
860 | ||
861 | entry++; | |
862 | } | |
863 | ||
864 | table = table->baseTable; | |
865 | } | |
866 | ||
867 | // Lets free some memory. | |
868 | size_t i; | |
869 | for(i = 0; i < m_size; i++) | |
870 | { | |
871 | EventTypeTablePointer eTTnode = m_eventTypeTable[i]; | |
872 | if (eTTnode) | |
873 | { | |
874 | eTTnode->eventEntryTable.Shrink(); | |
875 | } | |
876 | } | |
877 | } | |
878 | ||
879 | void wxEventHashTable::AddEntry(const wxEventTableEntry &entry) | |
880 | { | |
881 | // This might happen 'accidentally' as the app is exiting | |
882 | if (!m_eventTypeTable) | |
883 | return; | |
884 | ||
885 | EventTypeTablePointer *peTTnode = &m_eventTypeTable[entry.m_eventType % m_size]; | |
886 | EventTypeTablePointer eTTnode = *peTTnode; | |
887 | ||
888 | if (eTTnode) | |
889 | { | |
890 | if (eTTnode->eventType != entry.m_eventType) | |
891 | { | |
892 | // Resize the table! | |
893 | GrowEventTypeTable(); | |
894 | // Try again to add it. | |
895 | AddEntry(entry); | |
896 | return; | |
897 | } | |
898 | } | |
899 | else | |
900 | { | |
901 | eTTnode = new EventTypeTable; | |
902 | eTTnode->eventType = entry.m_eventType; | |
903 | *peTTnode = eTTnode; | |
904 | } | |
905 | ||
906 | // Fill all hash entries between entry.m_id and entry.m_lastId... | |
907 | eTTnode->eventEntryTable.Add(&entry); | |
908 | } | |
909 | ||
910 | void wxEventHashTable::AllocEventTypeTable(size_t size) | |
911 | { | |
912 | m_eventTypeTable = new EventTypeTablePointer[size]; | |
913 | memset((void *)m_eventTypeTable, 0, sizeof(EventTypeTablePointer)*size); | |
914 | m_size = size; | |
915 | } | |
916 | ||
917 | void wxEventHashTable::GrowEventTypeTable() | |
918 | { | |
919 | size_t oldSize = m_size; | |
920 | EventTypeTablePointer *oldEventTypeTable = m_eventTypeTable; | |
921 | ||
922 | // TODO: Search the most optimal grow sequence | |
923 | AllocEventTypeTable(/* GetNextPrime(oldSize) */oldSize*2+1); | |
924 | ||
925 | for ( size_t i = 0; i < oldSize; /* */ ) | |
926 | { | |
927 | EventTypeTablePointer eTToldNode = oldEventTypeTable[i]; | |
928 | if (eTToldNode) | |
929 | { | |
930 | EventTypeTablePointer *peTTnode = &m_eventTypeTable[eTToldNode->eventType % m_size]; | |
931 | EventTypeTablePointer eTTnode = *peTTnode; | |
932 | ||
933 | // Check for collision, we don't want any. | |
934 | if (eTTnode) | |
935 | { | |
936 | GrowEventTypeTable(); | |
937 | continue; // Don't increment the counter, | |
938 | // as we still need to add this element. | |
939 | } | |
940 | else | |
941 | { | |
942 | // Get the old value and put it in the new table. | |
943 | *peTTnode = oldEventTypeTable[i]; | |
944 | } | |
945 | } | |
946 | ||
947 | i++; | |
948 | } | |
949 | ||
950 | delete[] oldEventTypeTable; | |
951 | } | |
952 | ||
953 | ||
954 | // ---------------------------------------------------------------------------- | |
955 | // wxEvtHandler | |
956 | // ---------------------------------------------------------------------------- | |
957 | ||
958 | /* | |
959 | * Event handler | |
960 | */ | |
961 | ||
962 | wxEvtHandler::wxEvtHandler() | |
963 | { | |
964 | m_nextHandler = (wxEvtHandler *) NULL; | |
965 | m_previousHandler = (wxEvtHandler *) NULL; | |
966 | m_enabled = true; | |
967 | m_dynamicEvents = (wxList *) NULL; | |
968 | m_pendingEvents = (wxList *) NULL; | |
969 | #if wxUSE_THREADS | |
970 | # if !defined(__VISAGECPP__) | |
971 | m_eventsLocker = new wxCriticalSection; | |
972 | # endif | |
973 | #endif | |
974 | // no client data (yet) | |
975 | m_clientData = NULL; | |
976 | m_clientDataType = wxClientData_None; | |
977 | } | |
978 | ||
979 | wxEvtHandler::~wxEvtHandler() | |
980 | { | |
981 | // Takes itself out of the list of handlers | |
982 | if (m_previousHandler) | |
983 | m_previousHandler->m_nextHandler = m_nextHandler; | |
984 | ||
985 | if (m_nextHandler) | |
986 | m_nextHandler->m_previousHandler = m_previousHandler; | |
987 | ||
988 | if (m_dynamicEvents) | |
989 | { | |
990 | wxList::iterator it = m_dynamicEvents->begin(), | |
991 | en = m_dynamicEvents->end(); | |
992 | for (;it != en; ++it) | |
993 | { | |
994 | #if WXWIN_COMPATIBILITY_EVENT_TYPES | |
995 | wxEventTableEntry *entry = (wxEventTableEntry*)*it; | |
996 | #else // !WXWIN_COMPATIBILITY_EVENT_TYPES | |
997 | wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)*it; | |
998 | #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES | |
999 | ||
1000 | if (entry->m_callbackUserData) | |
1001 | delete entry->m_callbackUserData; | |
1002 | delete entry; | |
1003 | } | |
1004 | delete m_dynamicEvents; | |
1005 | }; | |
1006 | ||
1007 | delete m_pendingEvents; | |
1008 | ||
1009 | #if wxUSE_THREADS | |
1010 | # if !defined(__VISAGECPP__) | |
1011 | delete m_eventsLocker; | |
1012 | # endif | |
1013 | ||
1014 | // Remove us from wxPendingEvents if necessary. | |
1015 | if(wxPendingEventsLocker) | |
1016 | wxENTER_CRIT_SECT(*wxPendingEventsLocker); | |
1017 | if ( wxPendingEvents ) { | |
1018 | wxPendingEvents->DeleteObject(this); | |
1019 | } | |
1020 | if(wxPendingEventsLocker) | |
1021 | wxLEAVE_CRIT_SECT(*wxPendingEventsLocker); | |
1022 | #endif | |
1023 | ||
1024 | // we only delete object data, not untyped | |
1025 | if ( m_clientDataType == wxClientData_Object ) | |
1026 | delete m_clientObject; | |
1027 | } | |
1028 | ||
1029 | #if wxUSE_THREADS | |
1030 | ||
1031 | bool wxEvtHandler::ProcessThreadEvent(wxEvent& event) | |
1032 | { | |
1033 | // check that we are really in a child thread | |
1034 | wxASSERT_MSG( !wxThread::IsMain(), | |
1035 | wxT("use ProcessEvent() in main thread") ); | |
1036 | ||
1037 | AddPendingEvent(event); | |
1038 | ||
1039 | return true; | |
1040 | } | |
1041 | ||
1042 | void wxEvtHandler::ClearEventLocker() | |
1043 | { | |
1044 | #if !defined(__VISAGECPP__) | |
1045 | delete m_eventsLocker; | |
1046 | m_eventsLocker = NULL; | |
1047 | #endif | |
1048 | }; | |
1049 | ||
1050 | #endif // wxUSE_THREADS | |
1051 | ||
1052 | void wxEvtHandler::AddPendingEvent(wxEvent& event) | |
1053 | { | |
1054 | // 1) Add event to list of pending events of this event handler | |
1055 | ||
1056 | wxEvent *eventCopy = event.Clone(); | |
1057 | ||
1058 | // we must be able to copy the events here so the event class must | |
1059 | // implement Clone() properly instead of just providing a NULL stab for it | |
1060 | wxCHECK_RET( eventCopy, | |
1061 | _T("events of this type aren't supposed to be posted") ); | |
1062 | ||
1063 | #if defined(__VISAGECPP__) | |
1064 | wxENTER_CRIT_SECT( m_eventsLocker); | |
1065 | #else | |
1066 | wxENTER_CRIT_SECT( *m_eventsLocker); | |
1067 | #endif | |
1068 | ||
1069 | if ( !m_pendingEvents ) | |
1070 | m_pendingEvents = new wxList; | |
1071 | ||
1072 | m_pendingEvents->Append(eventCopy); | |
1073 | ||
1074 | #if defined(__VISAGECPP__) | |
1075 | wxLEAVE_CRIT_SECT( m_eventsLocker); | |
1076 | #else | |
1077 | wxLEAVE_CRIT_SECT( *m_eventsLocker); | |
1078 | #endif | |
1079 | ||
1080 | // 2) Add this event handler to list of event handlers that | |
1081 | // have pending events. | |
1082 | ||
1083 | wxENTER_CRIT_SECT(*wxPendingEventsLocker); | |
1084 | ||
1085 | if ( !wxPendingEvents ) | |
1086 | wxPendingEvents = new wxList; | |
1087 | wxPendingEvents->Append(this); | |
1088 | ||
1089 | wxLEAVE_CRIT_SECT(*wxPendingEventsLocker); | |
1090 | ||
1091 | // 3) Inform the system that new pending events are somwehere, | |
1092 | // and that these should be processed in idle time. | |
1093 | wxWakeUpIdle(); | |
1094 | } | |
1095 | ||
1096 | void wxEvtHandler::ProcessPendingEvents() | |
1097 | { | |
1098 | // this method is only called by wxApp if this handler does have pending | |
1099 | // events | |
1100 | wxCHECK_RET( m_pendingEvents, | |
1101 | wxT("Please call wxApp::ProcessPendingEvents() instead") ); | |
1102 | ||
1103 | #if defined(__VISAGECPP__) | |
1104 | wxENTER_CRIT_SECT( m_eventsLocker); | |
1105 | #else | |
1106 | wxENTER_CRIT_SECT( *m_eventsLocker); | |
1107 | #endif | |
1108 | ||
1109 | wxList::compatibility_iterator node = m_pendingEvents->GetFirst(); | |
1110 | while ( node ) | |
1111 | { | |
1112 | wxEvent *event = (wxEvent *)node->GetData(); | |
1113 | m_pendingEvents->Erase(node); | |
1114 | ||
1115 | // In ProcessEvent, new events might get added and | |
1116 | // we can safely leave the crtical section here. | |
1117 | #if defined(__VISAGECPP__) | |
1118 | wxLEAVE_CRIT_SECT( m_eventsLocker); | |
1119 | #else | |
1120 | wxLEAVE_CRIT_SECT( *m_eventsLocker); | |
1121 | #endif | |
1122 | ProcessEvent(*event); | |
1123 | delete event; | |
1124 | #if defined(__VISAGECPP__) | |
1125 | wxENTER_CRIT_SECT( m_eventsLocker); | |
1126 | #else | |
1127 | wxENTER_CRIT_SECT( *m_eventsLocker); | |
1128 | #endif | |
1129 | ||
1130 | node = m_pendingEvents->GetFirst(); | |
1131 | } | |
1132 | ||
1133 | #if defined(__VISAGECPP__) | |
1134 | wxLEAVE_CRIT_SECT( m_eventsLocker); | |
1135 | #else | |
1136 | wxLEAVE_CRIT_SECT( *m_eventsLocker); | |
1137 | #endif | |
1138 | } | |
1139 | ||
1140 | /* | |
1141 | * Event table stuff | |
1142 | */ | |
1143 | /* static */ bool | |
1144 | wxEvtHandler::ProcessEventIfMatches(const wxEventTableEntryBase& entry, | |
1145 | wxEvtHandler *handler, | |
1146 | wxEvent& event) | |
1147 | { | |
1148 | int tableId1 = entry.m_id, | |
1149 | tableId2 = entry.m_lastId; | |
1150 | ||
1151 | // match only if the event type is the same and the id is either -1 in | |
1152 | // the event table (meaning "any") or the event id matches the id | |
1153 | // specified in the event table either exactly or by falling into | |
1154 | // range between first and last | |
1155 | if ((tableId1 == -1) || | |
1156 | (tableId2 == -1 && tableId1 == event.GetId()) || | |
1157 | (tableId2 != -1 && | |
1158 | (event.GetId() >= tableId1 && event.GetId() <= tableId2))) | |
1159 | { | |
1160 | event.Skip(false); | |
1161 | event.m_callbackUserData = entry.m_callbackUserData; | |
1162 | ||
1163 | #if wxUSE_EXCEPTIONS | |
1164 | if ( wxTheApp ) | |
1165 | { | |
1166 | // call the handler via wxApp method which allows the user to catch | |
1167 | // any exceptions which may be thrown by any handler in the program | |
1168 | // in one place | |
1169 | wxTheApp->HandleEvent(handler, (wxEventFunction)entry.m_fn, event); | |
1170 | } | |
1171 | else | |
1172 | #endif // wxUSE_EXCEPTIONS | |
1173 | { | |
1174 | // no need for an extra virtual function call | |
1175 | (handler->*((wxEventFunction) (entry.m_fn)))(event); | |
1176 | } | |
1177 | ||
1178 | if (!event.GetSkipped()) | |
1179 | return true; | |
1180 | } | |
1181 | ||
1182 | return false; | |
1183 | } | |
1184 | ||
1185 | bool wxEvtHandler::TryParent(wxEvent& event) | |
1186 | { | |
1187 | if ( wxTheApp && (this != wxTheApp) ) | |
1188 | { | |
1189 | // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always | |
1190 | // swallow it. wxEVT_IDLE is sent explicitly to wxApp so it will be | |
1191 | // processed appropriately via SearchEventTable. | |
1192 | if ( event.GetEventType() != wxEVT_IDLE ) | |
1193 | { | |
1194 | if ( wxTheApp->ProcessEvent(event) ) | |
1195 | return true; | |
1196 | } | |
1197 | } | |
1198 | ||
1199 | return false; | |
1200 | } | |
1201 | ||
1202 | bool wxEvtHandler::ProcessEvent(wxEvent& event) | |
1203 | { | |
1204 | // allow the application to hook into event processing | |
1205 | if ( wxTheApp ) | |
1206 | { | |
1207 | int rc = wxTheApp->FilterEvent(event); | |
1208 | if ( rc != -1 ) | |
1209 | { | |
1210 | wxASSERT_MSG( rc == 1 || rc == 0, | |
1211 | _T("unexpected wxApp::FilterEvent return value") ); | |
1212 | ||
1213 | return rc != 0; | |
1214 | } | |
1215 | //else: proceed normally | |
1216 | } | |
1217 | ||
1218 | // An event handler can be enabled or disabled | |
1219 | if ( GetEvtHandlerEnabled() ) | |
1220 | { | |
1221 | // if we have a validator, it has higher priority than our own event | |
1222 | // table | |
1223 | if ( TryValidator(event) ) | |
1224 | return true; | |
1225 | ||
1226 | // Handle per-instance dynamic event tables first | |
1227 | if ( m_dynamicEvents && SearchDynamicEventTable(event) ) | |
1228 | return true; | |
1229 | ||
1230 | // Then static per-class event tables | |
1231 | if ( GetEventHashTable().HandleEvent(event, this) ) | |
1232 | return true; | |
1233 | } | |
1234 | ||
1235 | // Try going down the event handler chain | |
1236 | if ( GetNextHandler() ) | |
1237 | { | |
1238 | if ( GetNextHandler()->ProcessEvent(event) ) | |
1239 | return true; | |
1240 | } | |
1241 | ||
1242 | // Finally propagate the event upwards the window chain and/or to the | |
1243 | // application object as necessary | |
1244 | return TryParent(event); | |
1245 | } | |
1246 | ||
1247 | ||
1248 | bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event) | |
1249 | { | |
1250 | const wxEventType eventType = event.GetEventType(); | |
1251 | for ( int i = 0; table.entries[i].m_fn != 0; i++ ) | |
1252 | { | |
1253 | const wxEventTableEntry& entry = table.entries[i]; | |
1254 | if ( eventType == entry.m_eventType ) | |
1255 | { | |
1256 | if ( ProcessEventIfMatches(entry, this, event) ) | |
1257 | return true; | |
1258 | } | |
1259 | } | |
1260 | ||
1261 | return false; | |
1262 | } | |
1263 | ||
1264 | void wxEvtHandler::Connect( int id, int lastId, | |
1265 | int eventType, | |
1266 | wxObjectEventFunction func, | |
1267 | wxObject *userData, | |
1268 | wxEvtHandler* eventSink ) | |
1269 | { | |
1270 | #if WXWIN_COMPATIBILITY_EVENT_TYPES | |
1271 | wxEventTableEntry *entry = new wxEventTableEntry; | |
1272 | entry->m_eventType = eventType; | |
1273 | entry->m_id = id; | |
1274 | entry->m_lastId = lastId; | |
1275 | entry->m_fn = func; | |
1276 | entry->m_callbackUserData = userData; | |
1277 | #else // !WXWIN_COMPATIBILITY_EVENT_TYPES | |
1278 | wxDynamicEventTableEntry *entry = | |
1279 | new wxDynamicEventTableEntry(eventType, id, lastId, func, userData, eventSink); | |
1280 | #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES | |
1281 | ||
1282 | if (!m_dynamicEvents) | |
1283 | m_dynamicEvents = new wxList; | |
1284 | ||
1285 | // Insert at the front of the list so most recent additions are found first | |
1286 | m_dynamicEvents->Insert( (wxObject*) entry ); | |
1287 | } | |
1288 | ||
1289 | bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType, | |
1290 | wxObjectEventFunction func, | |
1291 | wxObject *userData, | |
1292 | wxEvtHandler* eventSink ) | |
1293 | { | |
1294 | if (!m_dynamicEvents) | |
1295 | return false; | |
1296 | ||
1297 | wxList::compatibility_iterator node = m_dynamicEvents->GetFirst(); | |
1298 | while (node) | |
1299 | { | |
1300 | #if WXWIN_COMPATIBILITY_EVENT_TYPES | |
1301 | wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData(); | |
1302 | #else // !WXWIN_COMPATIBILITY_EVENT_TYPES | |
1303 | wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData(); | |
1304 | #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES | |
1305 | ||
1306 | if ((entry->m_id == id) && | |
1307 | ((entry->m_lastId == lastId) || (lastId == -1)) && | |
1308 | ((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) && | |
1309 | ((entry->m_fn == func) || (func == (wxObjectEventFunction)NULL)) && | |
1310 | ((entry->m_eventSink == eventSink) || (eventSink == (wxEvtHandler*)NULL)) && | |
1311 | ((entry->m_callbackUserData == userData) || (userData == (wxObject*)NULL))) | |
1312 | { | |
1313 | if (entry->m_callbackUserData) | |
1314 | delete entry->m_callbackUserData; | |
1315 | m_dynamicEvents->Erase( node ); | |
1316 | delete entry; | |
1317 | return true; | |
1318 | } | |
1319 | node = node->GetNext(); | |
1320 | } | |
1321 | return false; | |
1322 | } | |
1323 | ||
1324 | bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event ) | |
1325 | { | |
1326 | wxCHECK_MSG( m_dynamicEvents, false, | |
1327 | wxT("caller should check that we have dynamic events") ); | |
1328 | ||
1329 | wxList::compatibility_iterator node = m_dynamicEvents->GetFirst(); | |
1330 | while (node) | |
1331 | { | |
1332 | #if WXWIN_COMPATIBILITY_EVENT_TYPES | |
1333 | wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData(); | |
1334 | #else // !WXWIN_COMPATIBILITY_EVENT_TYPES | |
1335 | wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData(); | |
1336 | #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES | |
1337 | ||
1338 | if ((event.m_eventType == entry->m_eventType) && (entry->m_fn != 0)) | |
1339 | { | |
1340 | wxEvtHandler *handler = | |
1341 | #if !WXWIN_COMPATIBILITY_EVENT_TYPES | |
1342 | entry->m_eventSink ? entry->m_eventSink | |
1343 | : | |
1344 | #endif | |
1345 | this; | |
1346 | ||
1347 | if ( ProcessEventIfMatches(*entry, handler, event) ) | |
1348 | { | |
1349 | return true; | |
1350 | } | |
1351 | } | |
1352 | ||
1353 | node = node->GetNext(); | |
1354 | } | |
1355 | ||
1356 | return false; | |
1357 | }; | |
1358 | ||
1359 | void wxEvtHandler::DoSetClientObject( wxClientData *data ) | |
1360 | { | |
1361 | wxASSERT_MSG( m_clientDataType != wxClientData_Void, | |
1362 | wxT("can't have both object and void client data") ); | |
1363 | ||
1364 | if ( m_clientObject ) | |
1365 | delete m_clientObject; | |
1366 | ||
1367 | m_clientObject = data; | |
1368 | m_clientDataType = wxClientData_Object; | |
1369 | } | |
1370 | ||
1371 | wxClientData *wxEvtHandler::DoGetClientObject() const | |
1372 | { | |
1373 | // it's not an error to call GetClientObject() on a window which doesn't | |
1374 | // have client data at all - NULL will be returned | |
1375 | wxASSERT_MSG( m_clientDataType != wxClientData_Void, | |
1376 | wxT("this window doesn't have object client data") ); | |
1377 | ||
1378 | return m_clientObject; | |
1379 | } | |
1380 | ||
1381 | void wxEvtHandler::DoSetClientData( void *data ) | |
1382 | { | |
1383 | wxASSERT_MSG( m_clientDataType != wxClientData_Object, | |
1384 | wxT("can't have both object and void client data") ); | |
1385 | ||
1386 | m_clientData = data; | |
1387 | m_clientDataType = wxClientData_Void; | |
1388 | } | |
1389 | ||
1390 | void *wxEvtHandler::DoGetClientData() const | |
1391 | { | |
1392 | // it's not an error to call GetClientData() on a window which doesn't have | |
1393 | // client data at all - NULL will be returned | |
1394 | wxASSERT_MSG( m_clientDataType != wxClientData_Object, | |
1395 | wxT("this window doesn't have void client data") ); | |
1396 | ||
1397 | return m_clientData; | |
1398 | } | |
1399 | ||
1400 | #endif // wxUSE_BASE | |
1401 | ||
1402 | #if wxUSE_GUI | |
1403 | ||
1404 | // Find a window with the focus, that is also a descendant of the given window. | |
1405 | // This is used to determine the window to initially send commands to. | |
1406 | wxWindow* wxFindFocusDescendant(wxWindow* ancestor) | |
1407 | { | |
1408 | // Process events starting with the window with the focus, if any. | |
1409 | wxWindow* focusWin = wxWindow::FindFocus(); | |
1410 | wxWindow* win = focusWin; | |
1411 | ||
1412 | // Check if this is a descendant of this frame. | |
1413 | // If not, win will be set to NULL. | |
1414 | while (win) | |
1415 | { | |
1416 | if (win == ancestor) | |
1417 | break; | |
1418 | else | |
1419 | win = win->GetParent(); | |
1420 | } | |
1421 | if (win == (wxWindow*) NULL) | |
1422 | focusWin = (wxWindow*) NULL; | |
1423 | ||
1424 | return focusWin; | |
1425 | } | |
1426 | ||
1427 | #endif // wxUSE_GUI |