]> git.saurik.com Git - wxWidgets.git/blob - src/common/event.cpp
TIFF code 2.
[wxWidgets.git] / src / common / event.cpp
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 and Markus Holzem
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "event.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/defs.h"
33 #include "wx/app.h"
34 #include "wx/list.h"
35
36 #if wxUSE_GUI
37 #include "wx/control.h"
38 #include "wx/utils.h"
39 #include "wx/dc.h"
40 #endif // wxUSE_GUI
41 #endif
42
43 #include "wx/event.h"
44
45 #if wxUSE_GUI
46 #include "wx/validate.h"
47 #endif // wxUSE_GUI
48
49 // ----------------------------------------------------------------------------
50 // wxWin macros
51 // ----------------------------------------------------------------------------
52
53 #if !USE_SHARED_LIBRARY
54 IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
55 IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
56 IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
57
58 #if wxUSE_GUI
59 IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
60 IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent, wxCommandEvent)
61 IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
62 IMPLEMENT_DYNAMIC_CLASS(wxScrollWinEvent, wxEvent)
63 IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent, wxEvent)
64 IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent, wxEvent)
65 IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent, wxEvent)
66 IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent, wxEvent)
67 IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent, wxEvent)
68 IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent, wxEvent)
69 IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent, wxEvent)
70 IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent, wxEvent)
71 IMPLEMENT_DYNAMIC_CLASS(wxShowEvent, wxEvent)
72 IMPLEMENT_DYNAMIC_CLASS(wxMaximizeEvent, wxEvent)
73 IMPLEMENT_DYNAMIC_CLASS(wxIconizeEvent, wxEvent)
74 IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent, wxEvent)
75 IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent, wxEvent)
76 IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent, wxEvent)
77 IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent, wxEvent)
78 IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent, wxEvent)
79 IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
80 IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxCommandEvent)
81 IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent, wxCommandEvent)
82 IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent, wxEvent)
83 IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent, wxEvent)
84 IMPLEMENT_DYNAMIC_CLASS(wxWindowCreateEvent, wxEvent)
85 IMPLEMENT_DYNAMIC_CLASS(wxWindowDestroyEvent, wxEvent)
86 #endif // wxUSE_GUI
87
88 const wxEventTable *wxEvtHandler::GetEventTable() const
89 { return &wxEvtHandler::sm_eventTable; }
90
91 const wxEventTable wxEvtHandler::sm_eventTable =
92 { (const wxEventTable *)NULL, &wxEvtHandler::sm_eventTableEntries[0] };
93
94 const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
95 { { 0, 0, 0, (wxObjectEventFunction) NULL, (wxObject*) NULL } };
96
97 #endif // !USE_SHARED_LIBRARY
98
99 // ----------------------------------------------------------------------------
100 // global variables
101 // ----------------------------------------------------------------------------
102
103 // To put pending event handlers
104 wxList *wxPendingEvents = (wxList *)NULL;
105
106 #if wxUSE_THREADS
107 // protects wxPendingEvents list
108 wxCriticalSection *wxPendingEventsLocker = (wxCriticalSection *)NULL;
109 #endif
110
111 // ============================================================================
112 // implementation
113 // ============================================================================
114
115 // ----------------------------------------------------------------------------
116 // wxEvent
117 // ----------------------------------------------------------------------------
118
119 /*
120 * General wxWindows events, covering
121 * all interesting things that might happen (button clicking, resizing,
122 * setting text in widgets, etc.).
123 *
124 * For each completely new event type, derive a new event class.
125 *
126 */
127
128 wxEvent::wxEvent(int theId)
129 {
130 m_eventType = wxEVT_NULL;
131 m_eventObject = (wxObject *) NULL;
132 m_timeStamp = 0;
133 m_id = theId;
134 m_skipped = FALSE;
135 m_callbackUserData = (wxObject *) NULL;
136 m_isCommandEvent = FALSE;
137 }
138
139 void wxEvent::CopyObject(wxObject& object_dest) const
140 {
141 wxEvent *obj = (wxEvent *)&object_dest;
142 wxObject::CopyObject(object_dest);
143
144 obj->m_eventType = m_eventType;
145 obj->m_eventObject = m_eventObject;
146 obj->m_timeStamp = m_timeStamp;
147 obj->m_id = m_id;
148 obj->m_skipped = m_skipped;
149 obj->m_callbackUserData = m_callbackUserData;
150 obj->m_isCommandEvent = m_isCommandEvent;
151 }
152
153 #if wxUSE_GUI
154
155 /*
156 * Command events
157 *
158 */
159
160 wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
161 {
162 m_eventType = commandType;
163 m_clientData = (char *) NULL;
164 m_clientObject = (wxClientData *) NULL;
165 m_extraLong = 0;
166 m_commandInt = 0;
167 m_id = theId;
168 m_commandString = wxEmptyString;
169 m_isCommandEvent = TRUE;
170 }
171
172 void wxCommandEvent::CopyObject(wxObject& obj_d) const
173 {
174 wxCommandEvent *obj = (wxCommandEvent *)&obj_d;
175
176 wxEvent::CopyObject(obj_d);
177
178 obj->m_clientData = m_clientData;
179 obj->m_clientObject = m_clientObject;
180 obj->m_extraLong = m_extraLong;
181 obj->m_commandInt = m_commandInt;
182 }
183
184 /*
185 * Scroll events
186 */
187
188 wxScrollEvent::wxScrollEvent(wxEventType commandType,
189 int id,
190 int pos,
191 int orient)
192 : wxCommandEvent(commandType, id)
193 {
194 m_extraLong = orient;
195 m_commandInt = pos;
196 }
197
198 /*
199 * ScrollWin events
200 */
201
202 wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
203 int pos,
204 int orient)
205 {
206 m_eventType = commandType;
207 m_extraLong = orient;
208 m_commandInt = pos;
209 }
210
211 void wxScrollWinEvent::CopyObject(wxObject& obj_d) const
212 {
213 wxScrollWinEvent *obj = (wxScrollWinEvent*)&obj_d;
214
215 wxEvent::CopyObject(obj_d);
216
217 obj->m_extraLong = m_extraLong;
218 obj->m_commandInt = m_commandInt;
219 }
220
221 /*
222 * Mouse events
223 *
224 */
225
226 wxMouseEvent::wxMouseEvent(wxEventType commandType)
227 {
228 m_eventType = commandType;
229 m_metaDown = FALSE;
230 m_altDown = FALSE;
231 m_controlDown = FALSE;
232 m_shiftDown = FALSE;
233 m_leftDown = FALSE;
234 m_rightDown = FALSE;
235 m_middleDown = FALSE;
236 m_x = 0;
237 m_y = 0;
238 }
239
240 void wxMouseEvent::CopyObject(wxObject& obj_d) const
241 {
242 wxMouseEvent *obj = (wxMouseEvent *)&obj_d;
243
244 wxEvent::CopyObject(obj_d);
245
246 obj->m_metaDown = m_metaDown;
247 obj->m_altDown = m_altDown;
248 obj->m_controlDown = m_controlDown;
249 obj->m_shiftDown = m_shiftDown;
250 obj->m_leftDown = m_leftDown;
251 obj->m_rightDown = m_rightDown;
252 obj->m_middleDown = m_middleDown;
253 obj->m_x = m_x;
254 obj->m_y = m_y;
255 }
256
257 // True if was a button dclick event (1 = left, 2 = middle, 3 = right)
258 // or any button dclick event (but = -1)
259 bool wxMouseEvent::ButtonDClick(int but) const
260 {
261 switch (but)
262 {
263 case -1:
264 return (LeftDClick() || MiddleDClick() || RightDClick());
265 case 1:
266 return LeftDClick();
267 case 2:
268 return MiddleDClick();
269 case 3:
270 return RightDClick();
271 default:
272 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDClick"));
273 }
274
275 return FALSE;
276 }
277
278 // True if was a button down event (1 = left, 2 = middle, 3 = right)
279 // or any button down event (but = -1)
280 bool wxMouseEvent::ButtonDown(int but) const
281 {
282 switch (but)
283 {
284 case -1:
285 return (LeftDown() || MiddleDown() || RightDown());
286 case 1:
287 return LeftDown();
288 case 2:
289 return MiddleDown();
290 case 3:
291 return RightDown();
292 default:
293 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDown"));
294 }
295
296 return FALSE;
297 }
298
299 // True if was a button up event (1 = left, 2 = middle, 3 = right)
300 // or any button up event (but = -1)
301 bool wxMouseEvent::ButtonUp(int but) const
302 {
303 switch (but) {
304 case -1:
305 return (LeftUp() || MiddleUp() || RightUp());
306 case 1:
307 return LeftUp();
308 case 2:
309 return MiddleUp();
310 case 3:
311 return RightUp();
312 default:
313 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonUp"));
314 }
315
316 return FALSE;
317 }
318
319 // True if the given button is currently changing state
320 bool wxMouseEvent::Button(int but) const
321 {
322 switch (but) {
323 case -1:
324 return (ButtonUp(-1) || ButtonDown(-1) || ButtonDClick(-1));
325 case 1:
326 return (LeftDown() || LeftUp() || LeftDClick());
327 case 2:
328 return (MiddleDown() || MiddleUp() || MiddleDClick());
329 case 3:
330 return (RightDown() || RightUp() || RightDClick());
331 default:
332 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::Button"));
333 }
334
335 return FALSE;
336 }
337
338 bool wxMouseEvent::ButtonIsDown(int but) const
339 {
340 switch (but) {
341 case -1:
342 return (LeftIsDown() || MiddleIsDown() || RightIsDown());
343 case 1:
344 return LeftIsDown();
345 case 2:
346 return MiddleIsDown();
347 case 3:
348 return RightIsDown();
349 default:
350 wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonIsDown"));
351 }
352
353 return FALSE;
354 }
355
356 // Find the logical position of the event given the DC
357 wxPoint wxMouseEvent::GetLogicalPosition(const wxDC& dc) const
358 {
359 wxPoint pt(dc.DeviceToLogicalX(m_x), dc.DeviceToLogicalY(m_y));
360 return pt;
361 }
362
363
364 /*
365 * Keyboard events
366 *
367 */
368
369 wxKeyEvent::wxKeyEvent(wxEventType type)
370 {
371 m_eventType = type;
372 m_shiftDown = FALSE;
373 m_controlDown = FALSE;
374 m_metaDown = FALSE;
375 m_altDown = FALSE;
376 m_keyCode = 0;
377 m_scanCode = 0;
378 }
379
380 void wxKeyEvent::CopyObject(wxObject& obj_d) const
381 {
382 wxKeyEvent *obj = (wxKeyEvent *)&obj_d;
383 wxEvent::CopyObject(obj_d);
384
385 obj->m_shiftDown = m_shiftDown;
386 obj->m_controlDown = m_controlDown;
387 obj->m_metaDown = m_metaDown;
388 obj->m_altDown = m_altDown;
389 obj->m_keyCode = m_keyCode;
390 }
391
392
393 /*
394 * Misc events
395 */
396
397 void wxSizeEvent::CopyObject(wxObject& obj_d) const
398 {
399 wxSizeEvent *obj = (wxSizeEvent *)&obj_d;
400 wxEvent::CopyObject(obj_d);
401
402 obj->m_size = m_size;
403 }
404
405 void wxMoveEvent::CopyObject(wxObject& obj_d) const
406 {
407 wxMoveEvent *obj = (wxMoveEvent *)&obj_d;
408 wxEvent::CopyObject(obj_d);
409
410 obj->m_pos = m_pos;
411 }
412
413 void wxEraseEvent::CopyObject(wxObject& obj_d) const
414 {
415 wxEraseEvent *obj = (wxEraseEvent *)&obj_d;
416 wxEvent::CopyObject(obj_d);
417
418 obj->m_dc = m_dc;
419 }
420
421 void wxActivateEvent::CopyObject(wxObject& obj_d) const
422 {
423 wxActivateEvent *obj = (wxActivateEvent *)&obj_d;
424 wxEvent::CopyObject(obj_d);
425
426 obj->m_active = m_active;
427 }
428
429 void wxMenuEvent::CopyObject(wxObject& obj_d) const
430 {
431 wxMenuEvent *obj = (wxMenuEvent *)&obj_d;
432 wxEvent::CopyObject(obj_d);
433
434 obj->m_menuId = m_menuId;
435 }
436
437 void wxCloseEvent::CopyObject(wxObject& obj_d) const
438 {
439 wxCloseEvent *obj = (wxCloseEvent *)&obj_d;
440 wxEvent::CopyObject(obj_d);
441
442 obj->m_loggingOff = m_loggingOff;
443 obj->m_veto = m_veto;
444 #if WXWIN_COMPATIBILITY
445 obj->m_force = m_force;
446 #endif
447 obj->m_canVeto = m_canVeto;
448 }
449
450 void wxShowEvent::CopyObject(wxObject& obj_d) const
451 {
452 wxShowEvent *obj = (wxShowEvent *)&obj_d;
453 wxEvent::CopyObject(obj_d);
454
455 obj->m_show = m_show;
456 }
457
458 void wxJoystickEvent::CopyObject(wxObject& obj_d) const
459 {
460 wxJoystickEvent *obj = (wxJoystickEvent *)&obj_d;
461 wxEvent::CopyObject(obj_d);
462
463 obj->m_pos = m_pos;
464 obj->m_zPosition = m_zPosition;
465 obj->m_buttonChange = m_buttonChange;
466 obj->m_buttonState = m_buttonState;
467 obj->m_joyStick = m_joyStick;
468 }
469
470 void wxDropFilesEvent::CopyObject(wxObject& obj_d) const
471 {
472 wxDropFilesEvent *obj = (wxDropFilesEvent *)&obj_d;
473 wxEvent::CopyObject(obj_d);
474
475 obj->m_noFiles = m_noFiles;
476 obj->m_pos = m_pos;
477 // TODO: Problem with obj->m_files. It should be deallocated by the
478 // destructor of the event.
479 }
480
481 void wxUpdateUIEvent::CopyObject(wxObject &obj_d) const
482 {
483 wxUpdateUIEvent *obj = (wxUpdateUIEvent *)&obj_d;
484 wxEvent::CopyObject(obj_d);
485
486 obj->m_checked = m_checked;
487 obj->m_enabled = m_enabled;
488 obj->m_text = m_text;
489 obj->m_setText = m_setText;
490 obj->m_setChecked = m_setChecked;
491 obj->m_setEnabled = m_setEnabled;
492 }
493
494 void wxPaletteChangedEvent::CopyObject(wxObject &obj_d) const
495 {
496 wxPaletteChangedEvent *obj = (wxPaletteChangedEvent *)&obj_d;
497 wxEvent::CopyObject(obj_d);
498
499 obj->m_changedWindow = m_changedWindow;
500 }
501
502 void wxQueryNewPaletteEvent::CopyObject(wxObject& obj_d) const
503 {
504 wxQueryNewPaletteEvent *obj = (wxQueryNewPaletteEvent *)&obj_d;
505 wxEvent::CopyObject(obj_d);
506
507 obj->m_paletteRealized = m_paletteRealized;
508 }
509
510 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
511 : wxEvent(wxEVT_CREATE)
512 {
513 SetEventObject(win);
514 }
515
516 wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win)
517 : wxEvent(wxEVT_DESTROY)
518 {
519 SetEventObject(win);
520 }
521
522 #endif // wxUSE_GUI
523
524 void wxIdleEvent::CopyObject(wxObject& obj_d) const
525 {
526 wxIdleEvent *obj = (wxIdleEvent *)&obj_d;
527 wxEvent::CopyObject(obj_d);
528
529 obj->m_requestMore = m_requestMore;
530 }
531
532 /*
533 * Event handler
534 */
535
536 wxEvtHandler::wxEvtHandler()
537 {
538 m_nextHandler = (wxEvtHandler *) NULL;
539 m_previousHandler = (wxEvtHandler *) NULL;
540 m_enabled = TRUE;
541 m_dynamicEvents = (wxList *) NULL;
542 m_isWindow = FALSE;
543 m_pendingEvents = (wxList *) NULL;
544 #if wxUSE_THREADS
545 # if !defined(__VISAGECPP__)
546 m_eventsLocker = new wxCriticalSection;
547 # endif
548 #endif
549 }
550
551 wxEvtHandler::~wxEvtHandler()
552 {
553 // Takes itself out of the list of handlers
554 if (m_previousHandler)
555 m_previousHandler->m_nextHandler = m_nextHandler;
556
557 if (m_nextHandler)
558 m_nextHandler->m_previousHandler = m_previousHandler;
559
560 if (m_dynamicEvents)
561 {
562 wxNode *node = m_dynamicEvents->First();
563 while (node)
564 {
565 wxEventTableEntry *entry = (wxEventTableEntry*)node->Data();
566 if (entry->m_callbackUserData) delete entry->m_callbackUserData;
567 delete entry;
568 node = node->Next();
569 }
570 delete m_dynamicEvents;
571 };
572
573 delete m_pendingEvents;
574
575 #if wxUSE_THREADS
576 # if !defined(__VISAGECPP__)
577 delete m_eventsLocker;
578 # endif
579 #endif
580 }
581
582 #if wxUSE_THREADS
583
584 bool wxEvtHandler::ProcessThreadEvent(wxEvent& event)
585 {
586 // check that we are really in a child thread
587 wxASSERT_MSG( !wxThread::IsMain(),
588 wxT("use ProcessEvent() in main thread") );
589
590 AddPendingEvent(event);
591
592 return TRUE;
593 }
594
595 #endif // wxUSE_THREADS
596
597 void wxEvtHandler::AddPendingEvent(wxEvent& event)
598 {
599 // 1) Add event to list of pending events of this event handler
600
601 #if defined(__VISAGECPP__)
602 wxENTER_CRIT_SECT( m_eventsLocker);
603 #else
604 wxENTER_CRIT_SECT( *m_eventsLocker);
605 #endif
606
607 if ( !m_pendingEvents )
608 m_pendingEvents = new wxList;
609
610 wxEvent *event2 = (wxEvent *)event.Clone();
611
612 m_pendingEvents->Append(event2);
613
614 #if defined(__VISAGECPP__)
615 wxLEAVE_CRIT_SECT( m_eventsLocker);
616 #else
617 wxLEAVE_CRIT_SECT( *m_eventsLocker);
618 #endif
619
620 // 2) Add this event handler to list of event handlers that
621 // have pending events.
622
623 wxENTER_CRIT_SECT(*wxPendingEventsLocker);
624
625 if ( !wxPendingEvents )
626 wxPendingEvents = new wxList;
627 wxPendingEvents->Append(this);
628
629 wxLEAVE_CRIT_SECT(*wxPendingEventsLocker);
630
631 // 3) Inform the system that new pending events are somwehere,
632 // and that these should be processed in idle time.
633
634 wxWakeUpIdle();
635 }
636
637 void wxEvtHandler::ProcessPendingEvents()
638 {
639 #if defined(__VISAGECPP__)
640 wxENTER_CRIT_SECT( m_eventsLocker);
641 #else
642 wxENTER_CRIT_SECT( *m_eventsLocker);
643 #endif
644
645 wxNode *node = m_pendingEvents->First();
646 while ( node )
647 {
648 wxEvent *event = (wxEvent *)node->Data();
649 delete node;
650
651 // In ProcessEvent, new events might get added and
652 // we can safely leave the crtical section here.
653 #if defined(__VISAGECPP__)
654 wxLEAVE_CRIT_SECT( m_eventsLocker);
655 #else
656 wxLEAVE_CRIT_SECT( *m_eventsLocker);
657 #endif
658 ProcessEvent(*event);
659 delete event;
660 #if defined(__VISAGECPP__)
661 wxENTER_CRIT_SECT( m_eventsLocker);
662 #else
663 wxENTER_CRIT_SECT( *m_eventsLocker);
664 #endif
665
666 node = m_pendingEvents->First();
667 }
668
669 #if defined(__VISAGECPP__)
670 wxLEAVE_CRIT_SECT( m_eventsLocker);
671 #else
672 wxLEAVE_CRIT_SECT( *m_eventsLocker);
673 #endif
674 }
675
676 /*
677 * Event table stuff
678 */
679
680 bool wxEvtHandler::ProcessEvent(wxEvent& event)
681 {
682 #if wxUSE_GUI
683 // check that our flag corresponds to reality
684 wxASSERT( m_isWindow == IsKindOf(CLASSINFO(wxWindow)) );
685 #endif // wxUSE_GUI
686
687 // An event handler can be enabled or disabled
688 if ( GetEvtHandlerEnabled() )
689 {
690 #if wxUSE_THREADS
691 // Check whether we are in a child thread.
692 if ( !wxThread::IsMain() )
693 return ProcessThreadEvent(event);
694 #endif // wxUSE_THREADS
695
696 // Handle per-instance dynamic event tables first
697 if ( m_dynamicEvents && SearchDynamicEventTable(event) )
698 return TRUE;
699
700 // Then static per-class event tables
701 const wxEventTable *table = GetEventTable();
702
703 #if wxUSE_GUI && wxUSE_VALIDATORS
704 // Try the associated validator first, if this is a window.
705 // Problem: if the event handler of the window has been replaced,
706 // this wxEvtHandler may no longer be a window.
707 // Therefore validators won't be processed if the handler
708 // has been replaced with SetEventHandler.
709 // THIS CAN BE CURED if PushEventHandler is used instead of
710 // SetEventHandler, and then processing will be passed down the
711 // chain of event handlers.
712 if (m_isWindow)
713 {
714 wxWindow *win = (wxWindow *)this;
715
716 // Can only use the validator of the window which
717 // is receiving the event
718 if ( win == event.GetEventObject() )
719 {
720 wxValidator *validator = win->GetValidator();
721 if ( validator && validator->ProcessEvent(event) )
722 {
723 return TRUE;
724 }
725 }
726 }
727 #endif
728
729 // Search upwards through the inheritance hierarchy
730 while (table)
731 {
732 if ( SearchEventTable((wxEventTable&)*table, event) )
733 return TRUE;
734 table = table->baseTable;
735 }
736 }
737
738 // Try going down the event handler chain
739 if ( GetNextHandler() )
740 {
741 if ( GetNextHandler()->ProcessEvent(event) )
742 return TRUE;
743 }
744
745 #if wxUSE_GUI
746 // Carry on up the parent-child hierarchy,
747 // but only if event is a command event: it wouldn't
748 // make sense for a parent to receive a child's size event, for example
749 if ( m_isWindow && event.IsCommandEvent() )
750 {
751 wxWindow *win = (wxWindow *)this;
752 wxWindow *parent = win->GetParent();
753 if (parent && !parent->IsBeingDeleted())
754 return parent->GetEventHandler()->ProcessEvent(event);
755 }
756 #endif // wxUSE_GUI
757
758 // Last try - application object.
759 if ( wxTheApp && (this != wxTheApp) )
760 {
761 // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always
762 // swallow it. wxEVT_IDLE is sent explicitly to wxApp so it will be
763 // processed appropriately via SearchEventTable.
764 if ( event.GetEventType() != wxEVT_IDLE )
765 {
766 if ( wxTheApp->ProcessEvent(event) )
767 return TRUE;
768 }
769 }
770
771 return FALSE;
772 }
773
774 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
775 {
776 int i = 0;
777 int commandId = event.GetId();
778
779 // BC++ doesn't like while (table.entries[i].m_fn)
780
781 #ifdef __SC__
782 while (table.entries[i].m_fn != 0)
783 #else
784 while (table.entries[i].m_fn != 0L)
785 #endif
786 {
787 if ((event.GetEventType() == table.entries[i].m_eventType) &&
788 (table.entries[i].m_id == -1 || // Match, if event spec says any id will do (id == -1)
789 (table.entries[i].m_lastId == -1 && commandId == table.entries[i].m_id) ||
790 (table.entries[i].m_lastId != -1 &&
791 (commandId >= table.entries[i].m_id && commandId <= table.entries[i].m_lastId))))
792 {
793 event.Skip(FALSE);
794 event.m_callbackUserData = table.entries[i].m_callbackUserData;
795
796 (this->*((wxEventFunction) (table.entries[i].m_fn)))(event);
797
798 if ( event.GetSkipped() )
799 return FALSE;
800 else
801 return TRUE;
802 }
803 i++;
804 }
805 return FALSE;
806 }
807
808 void wxEvtHandler::Connect( int id, int lastId,
809 wxEventType eventType,
810 wxObjectEventFunction func,
811 wxObject *userData )
812 {
813 wxEventTableEntry *entry = new wxEventTableEntry;
814 entry->m_id = id;
815 entry->m_lastId = lastId;
816 entry->m_eventType = eventType;
817 entry->m_fn = func;
818 entry->m_callbackUserData = userData;
819
820 if (!m_dynamicEvents)
821 m_dynamicEvents = new wxList;
822
823 m_dynamicEvents->Append( (wxObject*) entry );
824 }
825
826 bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
827 wxObjectEventFunction func,
828 wxObject *userData )
829 {
830 if (!m_dynamicEvents)
831 return FALSE;
832
833 wxNode *node = m_dynamicEvents->First();
834 while (node)
835 {
836 wxEventTableEntry *entry = (wxEventTableEntry*)node->Data();
837 if ((entry->m_id == id) &&
838 ((entry->m_lastId == lastId) || (lastId == -1)) &&
839 ((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) &&
840 ((entry->m_fn == func) || (func == (wxObjectEventFunction)NULL)) &&
841 ((entry->m_callbackUserData == userData) || (userData == (wxObject*)NULL)))
842 {
843 if (entry->m_callbackUserData) delete entry->m_callbackUserData;
844 m_dynamicEvents->DeleteNode( node );
845 delete entry;
846 return TRUE;
847 }
848 node = node->Next();
849 }
850 return FALSE;
851 }
852
853 bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
854 {
855 wxCHECK_MSG( m_dynamicEvents, FALSE,
856 wxT("caller should check that we have dynamic events") );
857
858 int commandId = event.GetId();
859
860 wxNode *node = m_dynamicEvents->First();
861 while (node)
862 {
863 wxEventTableEntry *entry = (wxEventTableEntry*)node->Data();
864
865 if (entry->m_fn)
866 {
867 // Match, if event spec says any id will do (id == -1)
868 if ( (event.GetEventType() == entry->m_eventType) &&
869 (entry->m_id == -1 ||
870 (entry->m_lastId == -1 && commandId == entry->m_id) ||
871 (entry->m_lastId != -1 &&
872 (commandId >= entry->m_id && commandId <= entry->m_lastId))) )
873 {
874 event.Skip(FALSE);
875 event.m_callbackUserData = entry->m_callbackUserData;
876
877 (this->*((wxEventFunction) (entry->m_fn)))(event);
878
879 if (event.GetSkipped())
880 return FALSE;
881 else
882 return TRUE;
883 }
884 }
885 node = node->Next();
886 }
887 return FALSE;
888 };
889
890 #if WXWIN_COMPATIBILITY
891 bool wxEvtHandler::OnClose()
892 {
893 if (GetNextHandler())
894 return GetNextHandler()->OnClose();
895 else
896 return FALSE;
897 }
898 #endif // WXWIN_COMPATIBILITY
899
900 #if wxUSE_GUI
901
902 // Find a window with the focus, that is also a descendant of the given window.
903 // This is used to determine the window to initially send commands to.
904 wxWindow* wxFindFocusDescendant(wxWindow* ancestor)
905 {
906 // Process events starting with the window with the focus, if any.
907 wxWindow* focusWin = wxWindow::FindFocus();
908 wxWindow* win = focusWin;
909
910 // Check if this is a descendant of this frame.
911 // If not, win will be set to NULL.
912 while (win)
913 {
914 if (win == ancestor)
915 break;
916 else
917 win = win->GetParent();
918 }
919 if (win == (wxWindow*) NULL)
920 focusWin = (wxWindow*) NULL;
921
922 return focusWin;
923 }
924
925 #endif // wxUSE_GUI