]> git.saurik.com Git - wxWidgets.git/blob - interface/wx/event.h
Improve print preview appearance and functionality.
[wxWidgets.git] / interface / wx / event.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: event.h
3 // Purpose: interface of wxEvtHandler, wxEventBlocker and many
4 // wxEvent-derived classes
5 // Author: wxWidgets team
6 // RCS-ID: $Id$
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 /**
11 The predefined constants for the number of times we propagate event
12 upwards window child-parent chain.
13 */
14 enum wxEventPropagation
15 {
16 /// don't propagate it at all
17 wxEVENT_PROPAGATE_NONE = 0,
18
19 /// propagate it until it is processed
20 wxEVENT_PROPAGATE_MAX = INT_MAX
21 };
22
23 /**
24 The different categories for a wxEvent; see wxEvent::GetEventCategory.
25
26 @note They are used as OR-combinable flags by wxEventLoopBase::YieldFor.
27 */
28 enum wxEventCategory
29 {
30 /**
31 This is the category for those events which are generated to update
32 the appearance of the GUI but which (usually) do not comport data
33 processing, i.e. which do not provide input or output data
34 (e.g. size events, scroll events, etc).
35 They are events NOT directly generated by the user's input devices.
36 */
37 wxEVT_CATEGORY_UI = 1,
38
39 /**
40 This category groups those events which are generated directly from the
41 user through input devices like mouse and keyboard and usually result in
42 data to be processed from the application
43 (e.g. mouse clicks, key presses, etc).
44 */
45 wxEVT_CATEGORY_USER_INPUT = 2,
46
47 /// This category is for wxSocketEvent
48 wxEVT_CATEGORY_SOCKET = 4,
49
50 /// This category is for wxTimerEvent
51 wxEVT_CATEGORY_TIMER = 8,
52
53 /**
54 This category is for any event used to send notifications from the
55 secondary threads to the main one or in general for notifications among
56 different threads (which may or may not be user-generated).
57 See e.g. wxThreadEvent.
58 */
59 wxEVT_CATEGORY_THREAD = 16,
60
61 /**
62 This mask is used in wxEventLoopBase::YieldFor to specify that all event
63 categories should be processed.
64 */
65 wxEVT_CATEGORY_ALL =
66 wxEVT_CATEGORY_UI|wxEVT_CATEGORY_USER_INPUT|wxEVT_CATEGORY_SOCKET| \
67 wxEVT_CATEGORY_TIMER|wxEVT_CATEGORY_THREAD
68 };
69
70 /**
71 @class wxEvent
72
73 An event is a structure holding information about an event passed to a
74 callback or member function.
75
76 wxEvent used to be a multipurpose event object, and is an abstract base class
77 for other event classes (see below).
78
79 For more information about events, see the @ref overview_events overview.
80
81 @beginWxPerlOnly
82 In wxPerl custom event classes should be derived from
83 @c Wx::PlEvent and @c Wx::PlCommandEvent.
84 @endWxPerlOnly
85
86 @library{wxbase}
87 @category{events}
88
89 @see wxCommandEvent, wxMouseEvent
90 */
91 class wxEvent : public wxObject
92 {
93 public:
94 /**
95 Constructor.
96
97 Notice that events are usually created by wxWidgets itself and creating
98 e.g. a wxPaintEvent in your code and sending it to e.g. a wxTextCtrl
99 will not usually affect it at all as native controls have no specific
100 knowledge about wxWidgets events. However you may construct objects of
101 specific types and pass them to wxEvtHandler::ProcessEvent() if you
102 want to create your own custom control and want to process its events
103 in the same manner as the standard ones.
104
105 Also please notice that the order of parameters in this constructor is
106 different from almost all the derived classes which specify the event
107 type as the first argument.
108
109 @param id
110 The identifier of the object (window, timer, ...) which generated
111 this event.
112 @param eventType
113 The unique type of event, e.g. wxEVT_PAINT, wxEVT_SIZE or
114 wxEVT_COMMAND_BUTTON_CLICKED.
115 */
116 wxEvent(int id = 0, wxEventType eventType = wxEVT_NULL);
117
118 /**
119 Returns a copy of the event.
120
121 Any event that is posted to the wxWidgets event system for later action
122 (via wxEvtHandler::AddPendingEvent, wxEvtHandler::QueueEvent or wxPostEvent())
123 must implement this method.
124
125 All wxWidgets events fully implement this method, but any derived events
126 implemented by the user should also implement this method just in case they
127 (or some event derived from them) are ever posted.
128
129 All wxWidgets events implement a copy constructor, so the easiest way of
130 implementing the Clone function is to implement a copy constructor for
131 a new event (call it MyEvent) and then define the Clone function like this:
132
133 @code
134 wxEvent *Clone() const { return new MyEvent(*this); }
135 @endcode
136 */
137 virtual wxEvent* Clone() const = 0;
138
139 /**
140 Returns the object (usually a window) associated with the event, if any.
141 */
142 wxObject* GetEventObject() const;
143
144 /**
145 Returns the identifier of the given event type, such as @c wxEVT_COMMAND_BUTTON_CLICKED.
146 */
147 wxEventType GetEventType() const;
148
149 /**
150 Returns a generic category for this event.
151 wxEvent implementation returns @c wxEVT_CATEGORY_UI by default.
152
153 This function is used to selectively process events in wxEventLoopBase::YieldFor.
154 */
155 virtual wxEventCategory GetEventCategory() const;
156
157 /**
158 Returns the identifier associated with this event, such as a button command id.
159 */
160 int GetId() const;
161
162 /**
163 Returns @true if the event handler should be skipped, @false otherwise.
164 */
165 bool GetSkipped() const;
166
167 /**
168 Gets the timestamp for the event. The timestamp is the time in milliseconds
169 since some fixed moment (not necessarily the standard Unix Epoch, so only
170 differences between the timestamps and not their absolute values usually make sense).
171
172 @warning
173 wxWidgets returns a non-NULL timestamp only for mouse and key events
174 (see wxMouseEvent and wxKeyEvent).
175 */
176 long GetTimestamp() const;
177
178 /**
179 Returns @true if the event is or is derived from wxCommandEvent else it returns @false.
180
181 @note exists only for optimization purposes.
182 */
183 bool IsCommandEvent() const;
184
185 /**
186 Sets the propagation level to the given value (for example returned from an
187 earlier call to wxEvent::StopPropagation).
188 */
189 void ResumePropagation(int propagationLevel);
190
191 /**
192 Sets the originating object.
193 */
194 void SetEventObject(wxObject* object);
195
196 /**
197 Sets the event type.
198 */
199 void SetEventType(wxEventType type);
200
201 /**
202 Sets the identifier associated with this event, such as a button command id.
203 */
204 void SetId(int id);
205
206 /**
207 Sets the timestamp for the event.
208 */
209 void SetTimestamp(long timeStamp = 0);
210
211 /**
212 Test if this event should be propagated or not, i.e. if the propagation level
213 is currently greater than 0.
214 */
215 bool ShouldPropagate() const;
216
217 /**
218 This method can be used inside an event handler to control whether further
219 event handlers bound to this event will be called after the current one returns.
220
221 Without Skip() (or equivalently if Skip(@false) is used), the event will not
222 be processed any more. If Skip(@true) is called, the event processing system
223 continues searching for a further handler function for this event, even though
224 it has been processed already in the current handler.
225
226 In general, it is recommended to skip all non-command events to allow the
227 default handling to take place. The command events are, however, normally not
228 skipped as usually a single command such as a button click or menu item
229 selection must only be processed by one handler.
230 */
231 void Skip(bool skip = true);
232
233 /**
234 Stop the event from propagating to its parent window.
235
236 Returns the old propagation level value which may be later passed to
237 ResumePropagation() to allow propagating the event again.
238 */
239 int StopPropagation();
240
241 protected:
242 /**
243 Indicates how many levels the event can propagate.
244
245 This member is protected and should typically only be set in the constructors
246 of the derived classes. It may be temporarily changed by StopPropagation()
247 and ResumePropagation() and tested with ShouldPropagate().
248
249 The initial value is set to either @c wxEVENT_PROPAGATE_NONE (by default)
250 meaning that the event shouldn't be propagated at all or to
251 @c wxEVENT_PROPAGATE_MAX (for command events) meaning that it should be
252 propagated as much as necessary.
253
254 Any positive number means that the event should be propagated but no more than
255 the given number of times. E.g. the propagation level may be set to 1 to
256 propagate the event to its parent only, but not to its grandparent.
257 */
258 int m_propagationLevel;
259 };
260
261 /**
262 @class wxEventBlocker
263
264 This class is a special event handler which allows to discard
265 any event (or a set of event types) directed to a specific window.
266
267 Example:
268
269 @code
270 void MyWindow::DoSomething()
271 {
272 {
273 // block all events directed to this window while
274 // we do the 1000 FunctionWhichSendsEvents() calls
275 wxEventBlocker blocker(this);
276
277 for ( int i = 0; i 1000; i++ )
278 FunctionWhichSendsEvents(i);
279
280 } // ~wxEventBlocker called, old event handler is restored
281
282 // the event generated by this call will be processed:
283 FunctionWhichSendsEvents(0)
284 }
285 @endcode
286
287 @library{wxcore}
288 @category{events}
289
290 @see @ref overview_events_processing, wxEvtHandler
291 */
292 class wxEventBlocker : public wxEvtHandler
293 {
294 public:
295 /**
296 Constructs the blocker for the given window and for the given event type.
297
298 If @a type is @c wxEVT_ANY, then all events for that window are blocked.
299 You can call Block() after creation to add other event types to the list
300 of events to block.
301
302 Note that the @a win window @b must remain alive until the
303 wxEventBlocker object destruction.
304 */
305 wxEventBlocker(wxWindow* win, wxEventType type = -1);
306
307 /**
308 Destructor. The blocker will remove itself from the chain of event handlers for
309 the window provided in the constructor, thus restoring normal processing of events.
310 */
311 virtual ~wxEventBlocker();
312
313 /**
314 Adds to the list of event types which should be blocked the given @a eventType.
315 */
316 void Block(wxEventType eventType);
317 };
318
319
320
321 /**
322 @class wxEvtHandler
323
324 A class that can handle events from the windowing system.
325 wxWindow is (and therefore all window classes are) derived from this class.
326
327 When events are received, wxEvtHandler invokes the method listed in the
328 event table using itself as the object. When using multiple inheritance
329 <b>it is imperative that the wxEvtHandler(-derived) class is the first
330 class inherited</b> such that the @c this pointer for the overall object
331 will be identical to the @c this pointer of the wxEvtHandler portion.
332
333 @library{wxbase}
334 @category{events}
335
336 @see @ref overview_events_processing, wxEventBlocker, wxEventLoopBase
337 */
338 class wxEvtHandler : public wxObject, public wxTrackable
339 {
340 public:
341 /**
342 Constructor.
343 */
344 wxEvtHandler();
345
346 /**
347 Destructor.
348
349 If the handler is part of a chain, the destructor will unlink itself
350 (see Unlink()).
351 */
352 virtual ~wxEvtHandler();
353
354
355 /**
356 @name Event queuing and processing
357 */
358 //@{
359
360 /**
361 Queue event for a later processing.
362
363 This method is similar to ProcessEvent() but while the latter is
364 synchronous, i.e. the event is processed immediately, before the
365 function returns, this one is asynchronous and returns immediately
366 while the event will be processed at some later time (usually during
367 the next event loop iteration).
368
369 Another important difference is that this method takes ownership of the
370 @a event parameter, i.e. it will delete it itself. This implies that
371 the event should be allocated on the heap and that the pointer can't be
372 used any more after the function returns (as it can be deleted at any
373 moment).
374
375 QueueEvent() can be used for inter-thread communication from the worker
376 threads to the main thread, it is safe in the sense that it uses
377 locking internally and avoids the problem mentioned in AddPendingEvent()
378 documentation by ensuring that the @a event object is not used by the
379 calling thread any more. Care should still be taken to avoid that some
380 fields of this object are used by it, notably any wxString members of
381 the event object must not be shallow copies of another wxString object
382 as this would result in them still using the same string buffer behind
383 the scenes. For example:
384 @code
385 void FunctionInAWorkerThread(const wxString& str)
386 {
387 wxCommandEvent* evt = new wxCommandEvent;
388
389 // NOT evt->SetString(str) as this would be a shallow copy
390 evt->SetString(str.c_str()); // make a deep copy
391
392 wxTheApp->QueueEvent( evt );
393 }
394 @endcode
395
396 Note that you can use wxThreadEvent instead of wxCommandEvent
397 to avoid this problem:
398 @code
399 void FunctionInAWorkerThread(const wxString& str)
400 {
401 wxThreadEvent evt;
402 evt->SetString(str);
403
404 // wxThreadEvent::Clone() makes sure that the internal wxString
405 // member is not shared by other wxString instances:
406 wxTheApp->QueueEvent( evt.Clone() );
407 }
408 @endcode
409
410 Finally notice that this method automatically wakes up the event loop
411 if it is currently idle by calling ::wxWakeUpIdle() so there is no need
412 to do it manually when using it.
413
414 @since 2.9.0
415
416 @param event
417 A heap-allocated event to be queued, QueueEvent() takes ownership
418 of it. This parameter shouldn't be @c NULL.
419 */
420 virtual void QueueEvent(wxEvent *event);
421
422 /**
423 Post an event to be processed later.
424
425 This function is similar to QueueEvent() but can't be used to post
426 events from worker threads for the event objects with wxString fields
427 (i.e. in practice most of them) because of an unsafe use of the same
428 wxString object which happens because the wxString field in the
429 original @a event object and its copy made internally by this function
430 share the same string buffer internally. Use QueueEvent() to avoid
431 this.
432
433 A copy of @a event is made by the function, so the original can be deleted
434 as soon as function returns (it is common that the original is created
435 on the stack). This requires that the wxEvent::Clone() method be
436 implemented by event so that it can be duplicated and stored until it
437 gets processed.
438
439 @param event
440 Event to add to the pending events queue.
441 */
442 virtual void AddPendingEvent(const wxEvent& event);
443
444 /**
445 Processes an event, searching event tables and calling zero or more suitable
446 event handler function(s).
447
448 Normally, your application would not call this function: it is called in the
449 wxWidgets implementation to dispatch incoming user interface events to the
450 framework (and application).
451
452 However, you might need to call it if implementing new functionality
453 (such as a new control) where you define new event types, as opposed to
454 allowing the user to override virtual functions.
455
456 Notice that you don't usually need to override ProcessEvent() to
457 customize the event handling, overriding the specially provided
458 TryBefore() and TryAfter() functions is usually enough. For example,
459 wxMDIParentFrame may override TryBefore() to ensure that the menu
460 events are processed in the active child frame before being processed
461 in the parent frame itself.
462
463 The normal order of event table searching is as follows:
464 -# wxApp::FilterEvent() is called. If it returns anything but @c -1
465 (default) the processing stops here.
466 -# TryBefore() is called (this is where wxValidator are taken into
467 account for wxWindow objects). If this returns @true, the function exits.
468 -# If the object is disabled (via a call to wxEvtHandler::SetEvtHandlerEnabled)
469 the function skips to step (7).
470 -# Dynamic event table of the handlers bound using Bind<>() is
471 searched. If a handler is found, it is executed and the function
472 returns @true unless the handler used wxEvent::Skip() to indicate
473 that it didn't handle the event in which case the search continues.
474 -# Static events table of the handlers bound using event table
475 macros is searched for this event handler. If this fails, the base
476 class event table table is tried, and so on until no more tables
477 exist or an appropriate function was found. If a handler is found,
478 the same logic as in the previous step applies.
479 -# The search is applied down the entire chain of event handlers (usually the
480 chain has a length of one). This chain can be formed using wxEvtHandler::SetNextHandler():
481 @image html overview_events_chain.png
482 (referring to the image, if @c A->ProcessEvent is called and it doesn't handle
483 the event, @c B->ProcessEvent will be called and so on...).
484 Note that in the case of wxWindow you can build a stack of event handlers
485 (see wxWindow::PushEventHandler() for more info).
486 If any of the handlers of the chain return @true, the function exits.
487 -# TryAfter() is called: for the wxWindow object this may propagate the
488 event to the window parent (recursively). If the event is still not
489 processed, ProcessEvent() on wxTheApp object is called as the last
490 step.
491
492 Notice that steps (2)-(6) are performed in ProcessEventLocally()
493 which is called by this function.
494
495 @param event
496 Event to process.
497 @return
498 @true if a suitable event handler function was found and executed,
499 and the function did not call wxEvent::Skip.
500
501 @see SearchEventTable()
502 */
503 virtual bool ProcessEvent(wxEvent& event);
504
505 /**
506 Try to process the event in this handler and all those chained to it.
507
508 As explained in ProcessEvent() documentation, the event handlers may be
509 chained in a doubly-linked list. This function tries to process the
510 event in this handler (including performing any pre-processing done in
511 TryBefore(), e.g. applying validators) and all those following it in
512 the chain until the event is processed or the chain is exhausted.
513
514 This function is called from ProcessEvent() and, in turn, calls
515 TryThis() for each handler in turn. It is not virtual and so cannot be
516 overridden but can, and should, be called to forward an event to
517 another handler instead of ProcessEvent() which would result in a
518 duplicate call to TryAfter(), e.g. resulting in all unprocessed events
519 being sent to the application object multiple times.
520
521 @since 2.9.1
522
523 @param event
524 Event to process.
525 @return
526 @true if this handler of one of those chained to it processed the
527 event.
528 */
529 bool ProcessEventLocally(wxEvent& event);
530
531 /**
532 Processes an event by calling ProcessEvent() and handles any exceptions
533 that occur in the process.
534 If an exception is thrown in event handler, wxApp::OnExceptionInMainLoop is called.
535
536 @param event
537 Event to process.
538
539 @return @true if the event was processed, @false if no handler was found
540 or an exception was thrown.
541
542 @see wxWindow::HandleWindowEvent
543 */
544 bool SafelyProcessEvent(wxEvent& event);
545
546 /**
547 Processes the pending events previously queued using QueueEvent() or
548 AddPendingEvent(); you must call this function only if you are sure
549 there are pending events for this handler, otherwise a @c wxCHECK
550 will fail.
551
552 The real processing still happens in ProcessEvent() which is called by this
553 function.
554
555 Note that this function needs a valid application object (see
556 wxAppConsole::GetInstance()) because wxApp holds the list of the event
557 handlers with pending events and this function manipulates that list.
558 */
559 void ProcessPendingEvents();
560
561 /**
562 Deletes all events queued on this event handler using QueueEvent() or
563 AddPendingEvent().
564
565 Use with care because the events which are deleted are (obviously) not
566 processed and this may have unwanted consequences (e.g. user actions events
567 will be lost).
568 */
569 void DeletePendingEvents();
570
571 /**
572 Searches the event table, executing an event handler function if an appropriate
573 one is found.
574
575 @param table
576 Event table to be searched.
577 @param event
578 Event to be matched against an event table entry.
579
580 @return @true if a suitable event handler function was found and
581 executed, and the function did not call wxEvent::Skip.
582
583 @remarks This function looks through the object's event table and tries
584 to find an entry that will match the event.
585 An entry will match if:
586 @li The event type matches, and
587 @li the identifier or identifier range matches, or the event table
588 entry's identifier is zero.
589
590 If a suitable function is called but calls wxEvent::Skip, this
591 function will fail, and searching will continue.
592
593 @todo this function in the header is listed as an "implementation only" function;
594 are we sure we want to document it?
595
596 @see ProcessEvent()
597 */
598 virtual bool SearchEventTable(wxEventTable& table,
599 wxEvent& event);
600
601 //@}
602
603
604 /**
605 @name Connecting and disconnecting
606 */
607 //@{
608
609 /**
610 Connects the given function dynamically with the event handler, id and
611 event type.
612
613 Notice that Bind() provides a more flexible and safer way to do the
614 same thing as Connect(), please use it in any new code -- while
615 Connect() is not formally deprecated due to its existing widespread
616 usage, it has no advantages compared to Bind().
617
618 This is an alternative to the use of static event tables. It is more
619 flexible as it allows to connect events generated by some object to an
620 event handler defined in a different object of a different class (which
621 is impossible to do directly with the event tables -- the events can be
622 only handled in another object if they are propagated upwards to it).
623 Do make sure to specify the correct @a eventSink when connecting to an
624 event of a different object.
625
626 See @ref overview_events_bind for more detailed explanation
627 of this function and the @ref page_samples_event sample for usage
628 examples.
629
630 This specific overload allows you to connect an event handler to a @e range
631 of @e source IDs.
632 Do not confuse @e source IDs with event @e types: source IDs identify the
633 event generator objects (typically wxMenuItem or wxWindow objects) while the
634 event @e type identify which type of events should be handled by the
635 given @e function (an event generator object may generate many different
636 types of events!).
637
638 @param id
639 The first ID of the identifier range to be associated with the event
640 handler function.
641 @param lastId
642 The last ID of the identifier range to be associated with the event
643 handler function.
644 @param eventType
645 The event type to be associated with this event handler.
646 @param function
647 The event handler function. Note that this function should
648 be explicitly converted to the correct type which can be done using a macro
649 called @c wxFooEventHandler for the handler for any @c wxFooEvent.
650 @param userData
651 Data to be associated with the event table entry.
652 @param eventSink
653 Object whose member function should be called. It must be specified
654 when connecting an event generated by one object to a member
655 function of a different object. If it is omitted, @c this is used.
656
657 @beginWxPerlOnly
658 In wxPerl this function takes 4 arguments: @a id, @a lastid,
659 @a type, @a method; if @a method is undef, the handler is
660 disconnected.}
661 @endWxPerlOnly
662
663 @see Bind<>()
664 */
665 void Connect(int id, int lastId, wxEventType eventType,
666 wxObjectEventFunction function,
667 wxObject* userData = NULL,
668 wxEvtHandler* eventSink = NULL);
669
670 /**
671 See the Connect(int, int, wxEventType, wxObjectEventFunction, wxObject*, wxEvtHandler*)
672 overload for more info.
673
674 This overload can be used to attach an event handler to a single source ID:
675
676 Example:
677 @code
678 frame->Connect( wxID_EXIT,
679 wxEVT_COMMAND_MENU_SELECTED,
680 wxCommandEventHandler(MyFrame::OnQuit) );
681 @endcode
682
683 @beginWxPerlOnly
684 Not supported by wxPerl.
685 @endWxPerlOnly
686 */
687 void Connect(int id, wxEventType eventType,
688 wxObjectEventFunction function,
689 wxObject* userData = NULL,
690 wxEvtHandler* eventSink = NULL);
691
692 /**
693 See the Connect(int, int, wxEventType, wxObjectEventFunction, wxObject*, wxEvtHandler*)
694 overload for more info.
695
696 This overload will connect the given event handler so that regardless of the
697 ID of the event source, the handler will be called.
698
699 @beginWxPerlOnly
700 Not supported by wxPerl.
701 @endWxPerlOnly
702 */
703 void Connect(wxEventType eventType,
704 wxObjectEventFunction function,
705 wxObject* userData = NULL,
706 wxEvtHandler* eventSink = NULL);
707
708 /**
709 Disconnects the given function dynamically from the event handler, using the
710 specified parameters as search criteria and returning @true if a matching
711 function has been found and removed.
712
713 This method can only disconnect functions which have been added using the
714 Connect() method. There is no way to disconnect functions connected using
715 the (static) event tables.
716
717 @param eventType
718 The event type associated with this event handler.
719 @param function
720 The event handler function.
721 @param userData
722 Data associated with the event table entry.
723 @param eventSink
724 Object whose member function should be called.
725
726 @beginWxPerlOnly
727 Not supported by wxPerl.
728 @endWxPerlOnly
729 */
730 bool Disconnect(wxEventType eventType,
731 wxObjectEventFunction function,
732 wxObject* userData = NULL,
733 wxEvtHandler* eventSink = NULL);
734
735 /**
736 See the Disconnect(wxEventType, wxObjectEventFunction, wxObject*, wxEvtHandler*)
737 overload for more info.
738
739 This overload takes the additional @a id parameter.
740
741 @beginWxPerlOnly
742 Not supported by wxPerl.
743 @endWxPerlOnly
744 */
745 bool Disconnect(int id = wxID_ANY,
746 wxEventType eventType = wxEVT_NULL,
747 wxObjectEventFunction function = NULL,
748 wxObject* userData = NULL,
749 wxEvtHandler* eventSink = NULL);
750
751 /**
752 See the Disconnect(wxEventType, wxObjectEventFunction, wxObject*, wxEvtHandler*)
753 overload for more info.
754
755 This overload takes an additional range of source IDs.
756
757 @beginWxPerlOnly
758 In wxPerl this function takes 3 arguments: @a id,
759 @a lastid, @a type.
760 @endWxPerlOnly
761 */
762 bool Disconnect(int id, int lastId,
763 wxEventType eventType,
764 wxObjectEventFunction function = NULL,
765 wxObject* userData = NULL,
766 wxEvtHandler* eventSink = NULL);
767 //@}
768
769
770 /**
771 @name Binding and Unbinding
772 */
773 //@{
774
775 /**
776 Binds the given function, functor or method dynamically with the event.
777
778 This offers basically the same functionality as Connect(), but it is
779 more flexible as it also allows you to use ordinary functions and
780 arbitrary functors as event handlers. It is also less restrictive then
781 Connect() because you can use an arbitrary method as an event handler,
782 where as Connect() requires a wxEvtHandler derived handler.
783
784 See @ref overview_events_bind for more detailed explanation
785 of this function and the @ref page_samples_event sample for usage
786 examples.
787
788 @param eventType
789 The event type to be associated with this event handler.
790 @param functor
791 The event handler functor. This can be an ordinary function but also
792 an arbitrary functor like boost::function<>.
793 @param id
794 The first ID of the identifier range to be associated with the event
795 handler.
796 @param lastId
797 The last ID of the identifier range to be associated with the event
798 handler.
799 @param userData
800 Data to be associated with the event table entry.
801
802 @see @ref overview_cpp_rtti_disabled
803
804 @since 2.9.0
805 */
806 template <typename EventTag, typename Functor>
807 void Bind(const EventTag& eventType,
808 Functor functor,
809 int id = wxID_ANY,
810 int lastId = wxID_ANY,
811 wxObject *userData = NULL);
812
813 /**
814 See the Bind<>(const EventTag&, Functor, int, int, wxObject*) overload for
815 more info.
816
817 This overload will bind the given method as the event handler.
818
819 @param eventType
820 The event type to be associated with this event handler.
821 @param method
822 The event handler method. This can be an arbitrary method (doesn't need
823 to be from a wxEvtHandler derived class).
824 @param handler
825 Object whose method should be called. It must always be specified
826 so it can be checked at compile time whether the given method is an
827 actual member of the given handler.
828 @param id
829 The first ID of the identifier range to be associated with the event
830 handler.
831 @param lastId
832 The last ID of the identifier range to be associated with the event
833 handler.
834 @param userData
835 Data to be associated with the event table entry.
836
837 @see @ref overview_cpp_rtti_disabled
838
839 @since 2.9.0
840 */
841 template <typename EventTag, typename Class, typename EventArg, typename EventHandler>
842 void Bind(const EventTag &eventType,
843 void (Class::*method)(EventArg &),
844 EventHandler *handler,
845 int id = wxID_ANY,
846 int lastId = wxID_ANY,
847 wxObject *userData = NULL);
848 /**
849 Unbinds the given function, functor or method dynamically from the
850 event handler, using the specified parameters as search criteria and
851 returning @true if a matching function has been found and removed.
852
853 This method can only unbind functions, functors or methods which have
854 been added using the Bind<>() method. There is no way to unbind
855 functions bound using the (static) event tables.
856
857 @param eventType
858 The event type associated with this event handler.
859 @param functor
860 The event handler functor. This can be an ordinary function but also
861 an arbitrary functor like boost::function<>.
862 @param id
863 The first ID of the identifier range associated with the event
864 handler.
865 @param lastId
866 The last ID of the identifier range associated with the event
867 handler.
868 @param userData
869 Data associated with the event table entry.
870
871 @see @ref overview_cpp_rtti_disabled
872
873 @since 2.9.0
874 */
875 template <typename EventTag, typename Functor>
876 bool Unbind(const EventTag& eventType,
877 Functor functor,
878 int id = wxID_ANY,
879 int lastId = wxID_ANY,
880 wxObject *userData = NULL);
881
882 /**
883 See the Unbind<>(const EventTag&, Functor, int, int, wxObject*)
884 overload for more info.
885
886 This overload unbinds the given method from the event..
887
888 @param eventType
889 The event type associated with this event handler.
890 @param method
891 The event handler method associated with this event.
892 @param handler
893 Object whose method was called.
894 @param id
895 The first ID of the identifier range associated with the event
896 handler.
897 @param lastId
898 The last ID of the identifier range associated with the event
899 handler.
900 @param userData
901 Data associated with the event table entry.
902
903 @see @ref overview_cpp_rtti_disabled
904
905 @since 2.9.0
906 */
907 template <typename EventTag, typename Class, typename EventArg, typename EventHandler>
908 bool Unbind(const EventTag &eventType,
909 void (Class::*method)(EventArg&),
910 EventHandler *handler,
911 int id = wxID_ANY,
912 int lastId = wxID_ANY,
913 wxObject *userData = NULL );
914 //@}
915 /**
916 @name User-supplied data
917 */
918 //@{
919
920 /**
921 Returns user-supplied client data.
922
923 @remarks Normally, any extra data the programmer wishes to associate with
924 the object should be made available by deriving a new class with
925 new data members.
926
927 @see SetClientData()
928 */
929 void* GetClientData() const;
930
931 /**
932 Returns a pointer to the user-supplied client data object.
933
934 @see SetClientObject(), wxClientData
935 */
936 wxClientData* GetClientObject() const;
937
938 /**
939 Sets user-supplied client data.
940
941 @param data
942 Data to be associated with the event handler.
943
944 @remarks Normally, any extra data the programmer wishes to associate
945 with the object should be made available by deriving a new
946 class with new data members. You must not call this method
947 and SetClientObject on the same class - only one of them.
948
949 @see GetClientData()
950 */
951 void SetClientData(void* data);
952
953 /**
954 Set the client data object. Any previous object will be deleted.
955
956 @see GetClientObject(), wxClientData
957 */
958 void SetClientObject(wxClientData* data);
959
960 //@}
961
962
963 /**
964 @name Event handler chaining
965
966 wxEvtHandler can be arranged in a double-linked list of handlers
967 which is automatically iterated by ProcessEvent() if needed.
968 */
969 //@{
970
971 /**
972 Returns @true if the event handler is enabled, @false otherwise.
973
974 @see SetEvtHandlerEnabled()
975 */
976 bool GetEvtHandlerEnabled() const;
977
978 /**
979 Returns the pointer to the next handler in the chain.
980
981 @see SetNextHandler(), GetPreviousHandler(), SetPreviousHandler(),
982 wxWindow::PushEventHandler, wxWindow::PopEventHandler
983 */
984 wxEvtHandler* GetNextHandler() const;
985
986 /**
987 Returns the pointer to the previous handler in the chain.
988
989 @see SetPreviousHandler(), GetNextHandler(), SetNextHandler(),
990 wxWindow::PushEventHandler, wxWindow::PopEventHandler
991 */
992 wxEvtHandler* GetPreviousHandler() const;
993
994 /**
995 Enables or disables the event handler.
996
997 @param enabled
998 @true if the event handler is to be enabled, @false if it is to be disabled.
999
1000 @remarks You can use this function to avoid having to remove the event
1001 handler from the chain, for example when implementing a
1002 dialog editor and changing from edit to test mode.
1003
1004 @see GetEvtHandlerEnabled()
1005 */
1006 void SetEvtHandlerEnabled(bool enabled);
1007
1008 /**
1009 Sets the pointer to the next handler.
1010
1011 @remarks
1012 See ProcessEvent() for more info about how the chains of event handlers
1013 are internally used.
1014 Also remember that wxEvtHandler uses double-linked lists and thus if you
1015 use this function, you should also call SetPreviousHandler() on the
1016 argument passed to this function:
1017 @code
1018 handlerA->SetNextHandler(handlerB);
1019 handlerB->SetPreviousHandler(handlerA);
1020 @endcode
1021
1022 @param handler
1023 The event handler to be set as the next handler.
1024 Cannot be @NULL.
1025
1026 @see @ref overview_events_processing
1027 */
1028 virtual void SetNextHandler(wxEvtHandler* handler);
1029
1030 /**
1031 Sets the pointer to the previous handler.
1032 All remarks about SetNextHandler() apply to this function as well.
1033
1034 @param handler
1035 The event handler to be set as the previous handler.
1036 Cannot be @NULL.
1037
1038 @see @ref overview_events_processing
1039 */
1040 virtual void SetPreviousHandler(wxEvtHandler* handler);
1041
1042 /**
1043 Unlinks this event handler from the chain it's part of (if any);
1044 then links the "previous" event handler to the "next" one
1045 (so that the chain won't be interrupted).
1046
1047 E.g. if before calling Unlink() you have the following chain:
1048 @image html evthandler_unlink_before.png
1049 then after calling @c B->Unlink() you'll have:
1050 @image html evthandler_unlink_after.png
1051
1052 @since 2.9.0
1053 */
1054 void Unlink();
1055
1056 /**
1057 Returns @true if the next and the previous handler pointers of this
1058 event handler instance are @NULL.
1059
1060 @since 2.9.0
1061
1062 @see SetPreviousHandler(), SetNextHandler()
1063 */
1064 bool IsUnlinked() const;
1065
1066 //@}
1067
1068 protected:
1069 /**
1070 Method called by ProcessEvent() before examining this object event
1071 tables.
1072
1073 This method can be overridden to hook into the event processing logic
1074 as early as possible. You should usually call the base class version
1075 when overriding this method, even if wxEvtHandler itself does nothing
1076 here, some derived classes do use this method, e.g. wxWindow implements
1077 support for wxValidator in it.
1078
1079 Example:
1080 @code
1081 class MyClass : public BaseClass // inheriting from wxEvtHandler
1082 {
1083 ...
1084 protected:
1085 virtual bool TryBefore(wxEvent& event)
1086 {
1087 if ( MyPreProcess(event) )
1088 return true;
1089
1090 return BaseClass::TryBefore(event);
1091 }
1092 };
1093 @endcode
1094
1095 @see ProcessEvent()
1096 */
1097 virtual bool TryBefore(wxEvent& event);
1098
1099 /**
1100 Try to process the event in this event handler.
1101
1102 This method is called from ProcessEventLocally() and thus, indirectly,
1103 from ProcessEvent(), please see the detailed description of the event
1104 processing logic there.
1105
1106 It is currently @em not virtual and so may not be overridden.
1107
1108 @since 2.9.1
1109
1110 @param event
1111 Event to process.
1112 @return
1113 @true if this object itself defines a handler for this event and
1114 the handler didn't skip the event.
1115 */
1116 bool TryThis(wxEvent& event);
1117
1118 /**
1119 Method called by ProcessEvent() as last resort.
1120
1121 This method can be overridden to implement post-processing for the
1122 events which were not processed anywhere else.
1123
1124 The base class version handles forwarding the unprocessed events to
1125 wxApp at wxEvtHandler level and propagating them upwards the window
1126 child-parent chain at wxWindow level and so should usually be called
1127 when overriding this method:
1128 @code
1129 class MyClass : public BaseClass // inheriting from wxEvtHandler
1130 {
1131 ...
1132 protected:
1133 virtual bool TryAfter(wxEvent& event)
1134 {
1135 if ( BaseClass::TryAfter(event) )
1136 return true;
1137
1138 return MyPostProcess(event);
1139 }
1140 };
1141 @endcode
1142
1143 @see ProcessEvent()
1144 */
1145 virtual bool TryAfter(wxEvent& event);
1146 };
1147
1148
1149 /**
1150 Flags for categories of keys.
1151
1152 These values are used by wxKeyEvent::IsKeyInCategory(). They may be
1153 combined via the bitwise operators |, &, and ~.
1154
1155 @since 2.9.1
1156 */
1157 enum wxKeyCategoryFlags
1158 {
1159 /// arrow keys, on and off numeric keypads
1160 WXK_CATEGORY_ARROW,
1161
1162 /// page up and page down keys, on and off numeric keypads
1163 WXK_CATEGORY_PAGING,
1164
1165 /// home and end keys, on and off numeric keypads
1166 WXK_CATEGORY_JUMP,
1167
1168 /// tab key, on and off numeric keypads
1169 WXK_CATEGORY_TAB,
1170
1171 /// backspace and delete keys, on and off numeric keypads
1172 WXK_CATEGORY_CUT,
1173
1174 /// union of WXK_CATEGORY_ARROW, WXK_CATEGORY_PAGING, and WXK_CATEGORY_JUMP categories
1175 WXK_CATEGORY_NAVIGATION
1176 };
1177
1178
1179 /**
1180 @class wxKeyEvent
1181
1182 This event class contains information about key press and release events.
1183
1184 The main information carried by this event is the key being pressed or
1185 released. It can be accessed using either GetKeyCode() function or
1186 GetUnicodeKey(). For the printable characters, the latter should be used as
1187 it works for any keys, including non-Latin-1 characters that can be entered
1188 when using national keyboard layouts. GetKeyCode() should be used to handle
1189 special characters (such as cursor arrows keys or @c HOME or @c INS and so
1190 on) which correspond to ::wxKeyCode enum elements above the @c WXK_START
1191 constant. While GetKeyCode() also returns the character code for Latin-1
1192 keys for compatibility, it doesn't work for Unicode characters in general
1193 and will return @c WXK_NONE for any non-Latin-1 ones. For this reason, it's
1194 recommended to always use GetUnicodeKey() and only fall back to GetKeyCode()
1195 if GetUnicodeKey() returned @c WXK_NONE meaning that the event corresponds
1196 to a non-printable special keys.
1197
1198 While both of these functions can be used with the events of @c
1199 wxEVT_KEY_DOWN, @c wxEVT_KEY_UP and @c wxEVT_CHAR types, the values
1200 returned by them are different for the first two events and the last one.
1201 For the latter, the key returned corresponds to the character that would
1202 appear in e.g. a text zone if the user pressed the key in it. As such, its
1203 value depends on the current state of the Shift key and, for the letters,
1204 on the state of Caps Lock modifier. For example, if @c A key is pressed
1205 without Shift being held down, wxKeyEvent of type @c wxEVT_CHAR generated
1206 for this key press will return (from either GetKeyCode() or GetUnicodeKey()
1207 as their meanings coincide for ASCII characters) key code of 97
1208 corresponding the ASCII value of @c a. And if the same key is pressed but
1209 with Shift being held (or Caps Lock being active), then the key could would
1210 be 65, i.e. ASCII value of capital @c A.
1211
1212 However for the key down and up events the returned key code will instead
1213 be @c A independently of the state of the modifier keys i.e. it depends
1214 only on physical key being pressed and is not translated to its logical
1215 representation using the current keyboard state. Such untranslated key
1216 codes are defined as follows:
1217 - For the letters they correspond to the @e upper case value of the
1218 letter.
1219 - For the other alphanumeric keys (e.g. @c 7 or @c +), the untranslated
1220 key code corresponds to the character produced by the key when it is
1221 pressed without Shift. E.g. in standard US keyboard layout the
1222 untranslated key code for the key @c =/+ in the upper right corner of
1223 the keyboard is 61 which is the ASCII value of @c =.
1224 - For the rest of the keys (i.e. special non-printable keys) it is the
1225 same as the normal key code as no translation is used anyhow.
1226
1227 Notice that the first rule applies to all Unicode letters, not just the
1228 usual Latin-1 ones. However for non-Latin-1 letters only GetUnicodeKey()
1229 can be used to retrieve the key code as GetKeyCode() just returns @c
1230 WXK_NONE in this case.
1231
1232 To summarize: you should handle @c wxEVT_CHAR if you need the translated
1233 key and @c wxEVT_KEY_DOWN if you only need the value of the key itself,
1234 independent of the current keyboard state.
1235
1236 @note Not all key down events may be generated by the user. As an example,
1237 @c wxEVT_KEY_DOWN with @c = key code can be generated using the
1238 standard US keyboard layout but not using the German one because the @c
1239 = key corresponds to Shift-0 key combination in this layout and the key
1240 code for it is @c 0, not @c =. Because of this you should avoid
1241 requiring your users to type key events that might be impossible to
1242 enter on their keyboard.
1243
1244
1245 Another difference between key and char events is that another kind of
1246 translation is done for the latter ones when the Control key is pressed:
1247 char events for ASCII letters in this case carry codes corresponding to the
1248 ASCII value of Ctrl-Latter, i.e. 1 for Ctrl-A, 2 for Ctrl-B and so on until
1249 26 for Ctrl-Z. This is convenient for terminal-like applications and can be
1250 completely ignored by all the other ones (if you need to handle Ctrl-A it
1251 is probably a better idea to use the key event rather than the char one).
1252 Notice that currently no translation is done for the presses of @c [, @c
1253 \\, @c ], @c ^ and @c _ keys which might be mapped to ASCII values from 27
1254 to 31.
1255
1256 Finally, modifier keys only generate key events but no char events at all.
1257 The modifiers keys are @c WXK_SHIFT, @c WXK_CONTROL, @c WXK_ALT and various
1258 @c WXK_WINDOWS_XXX from ::wxKeyCode enum.
1259
1260 Modifier keys events are special in one additional aspect: usually the
1261 keyboard state associated with a key press is well defined, e.g.
1262 wxKeyboardState::ShiftDown() returns @c true only if the Shift key was held
1263 pressed when the key that generated this event itself was pressed. There is
1264 an ambiguity for the key press events for Shift key itself however. By
1265 convention, it is considered to be already pressed when it is pressed and
1266 already released when it is released. In other words, @c wxEVT_KEY_DOWN
1267 event for the Shift key itself will have @c wxMOD_SHIFT in GetModifiers()
1268 and ShiftDown() will return true while the @c wxEVT_KEY_UP event for Shift
1269 itself will not have @c wxMOD_SHIFT in its modifiers and ShiftDown() will
1270 return false.
1271
1272
1273 @b Tip: You may discover the key codes and modifiers generated by all the
1274 keys on your system interactively by running the @ref
1275 page_samples_keyboard wxWidgets sample and pressing some keys in it.
1276
1277 @note If a key down (@c EVT_KEY_DOWN) event is caught and the event handler
1278 does not call @c event.Skip() then the corresponding char event
1279 (@c EVT_CHAR) will not happen. This is by design and enables the
1280 programs that handle both types of events to avoid processing the
1281 same key twice. As a consequence, if you do not want to suppress the
1282 @c wxEVT_CHAR events for the keys you handle, always call @c
1283 event.Skip() in your @c wxEVT_KEY_DOWN handler. Not doing may also
1284 prevent accelerators defined using this key from working.
1285
1286 @note If a key is maintained in a pressed state, you will typically get a
1287 lot of (automatically generated) key down events but only one key up
1288 one at the end when the key is released so it is wrong to assume that
1289 there is one up event corresponding to each down one.
1290
1291 @note For Windows programmers: The key and char events in wxWidgets are
1292 similar to but slightly different from Windows @c WM_KEYDOWN and
1293 @c WM_CHAR events. In particular, Alt-x combination will generate a
1294 char event in wxWidgets (unless it is used as an accelerator) and
1295 almost all keys, including ones without ASCII equivalents, generate
1296 char events too.
1297
1298
1299 @beginEventTable{wxKeyEvent}
1300 @event{EVT_KEY_DOWN(func)}
1301 Process a @c wxEVT_KEY_DOWN event (any key has been pressed).
1302 @event{EVT_KEY_UP(func)}
1303 Process a @c wxEVT_KEY_UP event (any key has been released).
1304 @event{EVT_CHAR(func)}
1305 Process a @c wxEVT_CHAR event.
1306 @endEventTable
1307
1308 @see wxKeyboardState
1309
1310 @library{wxcore}
1311 @category{events}
1312 */
1313 class wxKeyEvent : public wxEvent,
1314 public wxKeyboardState
1315 {
1316 public:
1317 /**
1318 Constructor.
1319 Currently, the only valid event types are @c wxEVT_CHAR and @c wxEVT_CHAR_HOOK.
1320 */
1321 wxKeyEvent(wxEventType keyEventType = wxEVT_NULL);
1322
1323 /**
1324 Returns the key code of the key that generated this event.
1325
1326 ASCII symbols return normal ASCII values, while events from special
1327 keys such as "left cursor arrow" (@c WXK_LEFT) return values outside of
1328 the ASCII range. See ::wxKeyCode for a full list of the virtual key
1329 codes.
1330
1331 Note that this method returns a meaningful value only for special
1332 non-alphanumeric keys or if the user entered a character that can be
1333 represented in current locale's default charset. Otherwise, e.g. if the
1334 user enters a Japanese character in a program not using Japanese
1335 locale, this method returns @c WXK_NONE and GetUnicodeKey() should be
1336 used to obtain the corresponding Unicode character.
1337
1338 Using GetUnicodeKey() is in general the right thing to do if you are
1339 interested in the characters typed by the user, GetKeyCode() should be
1340 only used for special keys (for which GetUnicodeKey() returns @c
1341 WXK_NONE). To handle both kinds of keys you might write:
1342 @code
1343 void MyHandler::OnChar(wxKeyEvent& event)
1344 {
1345 if ( event.GetUnicodeKey() != WXK_NONE )
1346 {
1347 // It's a printable character
1348 wxLogMessage("You pressed '%c'", event.GetUnicodeKey());
1349 }
1350 else
1351 {
1352 // It's a special key, deal with all the known ones:
1353 switch ( keycode )
1354 {
1355 case WXK_LEFT:
1356 case WXK_RIGHT:
1357 ... move cursor ...
1358 break;
1359
1360 case WXK_F1:
1361 ... give help ...
1362 break;
1363 }
1364 }
1365 }
1366 @endcode
1367 */
1368 int GetKeyCode() const;
1369
1370 /**
1371 Returns true if the key is in the given key category.
1372
1373 @param category
1374 A bitwise combination of named ::wxKeyCategoryFlags constants.
1375
1376 @since 2.9.1
1377 */
1378 bool IsKeyInCategory(int category) const;
1379
1380 //@{
1381 /**
1382 Obtains the position (in client coordinates) at which the key was pressed.
1383 */
1384 wxPoint GetPosition() const;
1385 void GetPosition(long* x, long* y) const;
1386 //@}
1387
1388 /**
1389 Returns the raw key code for this event.
1390
1391 The flags are platform-dependent and should only be used if the
1392 functionality provided by other wxKeyEvent methods is insufficient.
1393
1394 Under MSW, the raw key code is the value of @c wParam parameter of the
1395 corresponding message.
1396
1397 Under GTK, the raw key code is the @c keyval field of the corresponding
1398 GDK event.
1399
1400 Under OS X, the raw key code is the @c keyCode field of the
1401 corresponding NSEvent.
1402
1403 @note Currently the raw key codes are not supported by all ports, use
1404 @ifdef_ wxHAS_RAW_KEY_CODES to determine if this feature is available.
1405 */
1406 wxUint32 GetRawKeyCode() const;
1407
1408 /**
1409 Returns the low level key flags for this event.
1410
1411 The flags are platform-dependent and should only be used if the
1412 functionality provided by other wxKeyEvent methods is insufficient.
1413
1414 Under MSW, the raw flags are just the value of @c lParam parameter of
1415 the corresponding message.
1416
1417 Under GTK, the raw flags contain the @c hardware_keycode field of the
1418 corresponding GDK event.
1419
1420 Under OS X, the raw flags contain the modifiers state.
1421
1422 @note Currently the raw key flags are not supported by all ports, use
1423 @ifdef_ wxHAS_RAW_KEY_CODES to determine if this feature is available.
1424 */
1425 wxUint32 GetRawKeyFlags() const;
1426
1427 /**
1428 Returns the Unicode character corresponding to this key event.
1429
1430 If the key pressed doesn't have any character value (e.g. a cursor key)
1431 this method will return @c WXK_NONE. In this case you should use
1432 GetKeyCode() to retrieve the value of the key.
1433
1434 This function is only available in Unicode build, i.e. when
1435 @c wxUSE_UNICODE is 1.
1436 */
1437 wxChar GetUnicodeKey() const;
1438
1439 /**
1440 Returns the X position (in client coordinates) of the event.
1441 */
1442 wxCoord GetX() const;
1443
1444 /**
1445 Returns the Y position (in client coordinates) of the event.
1446 */
1447 wxCoord GetY() const;
1448 };
1449
1450
1451
1452 /**
1453 @class wxJoystickEvent
1454
1455 This event class contains information about joystick events, particularly
1456 events received by windows.
1457
1458 @beginEventTable{wxJoystickEvent}
1459 @event{EVT_JOY_BUTTON_DOWN(func)}
1460 Process a @c wxEVT_JOY_BUTTON_DOWN event.
1461 @event{EVT_JOY_BUTTON_UP(func)}
1462 Process a @c wxEVT_JOY_BUTTON_UP event.
1463 @event{EVT_JOY_MOVE(func)}
1464 Process a @c wxEVT_JOY_MOVE event.
1465 @event{EVT_JOY_ZMOVE(func)}
1466 Process a @c wxEVT_JOY_ZMOVE event.
1467 @event{EVT_JOYSTICK_EVENTS(func)}
1468 Processes all joystick events.
1469 @endEventTable
1470
1471 @library{wxcore}
1472 @category{events}
1473
1474 @see wxJoystick
1475 */
1476 class wxJoystickEvent : public wxEvent
1477 {
1478 public:
1479 /**
1480 Constructor.
1481 */
1482 wxJoystickEvent(wxEventType eventType = wxEVT_NULL, int state = 0,
1483 int joystick = wxJOYSTICK1,
1484 int change = 0);
1485
1486 /**
1487 Returns @true if the event was a down event from the specified button
1488 (or any button).
1489
1490 @param button
1491 Can be @c wxJOY_BUTTONn where @c n is 1, 2, 3 or 4; or @c wxJOY_BUTTON_ANY to
1492 indicate any button down event.
1493 */
1494 bool ButtonDown(int button = wxJOY_BUTTON_ANY) const;
1495
1496 /**
1497 Returns @true if the specified button (or any button) was in a down state.
1498
1499 @param button
1500 Can be @c wxJOY_BUTTONn where @c n is 1, 2, 3 or 4; or @c wxJOY_BUTTON_ANY to
1501 indicate any button down event.
1502 */
1503 bool ButtonIsDown(int button = wxJOY_BUTTON_ANY) const;
1504
1505 /**
1506 Returns @true if the event was an up event from the specified button
1507 (or any button).
1508
1509 @param button
1510 Can be @c wxJOY_BUTTONn where @c n is 1, 2, 3 or 4; or @c wxJOY_BUTTON_ANY to
1511 indicate any button down event.
1512 */
1513 bool ButtonUp(int button = wxJOY_BUTTON_ANY) const;
1514
1515 /**
1516 Returns the identifier of the button changing state.
1517
1518 This is a @c wxJOY_BUTTONn identifier, where @c n is one of 1, 2, 3, 4.
1519 */
1520 int GetButtonChange() const;
1521
1522 /**
1523 Returns the down state of the buttons.
1524
1525 This is a @c wxJOY_BUTTONn identifier, where @c n is one of 1, 2, 3, 4.
1526 */
1527 int GetButtonState() const;
1528
1529 /**
1530 Returns the identifier of the joystick generating the event - one of
1531 wxJOYSTICK1 and wxJOYSTICK2.
1532 */
1533 int GetJoystick() const;
1534
1535 /**
1536 Returns the x, y position of the joystick event.
1537 */
1538 wxPoint GetPosition() const;
1539
1540 /**
1541 Returns the z position of the joystick event.
1542 */
1543 int GetZPosition() const;
1544
1545 /**
1546 Returns @true if this was a button up or down event
1547 (@e not 'is any button down?').
1548 */
1549 bool IsButton() const;
1550
1551 /**
1552 Returns @true if this was an x, y move event.
1553 */
1554 bool IsMove() const;
1555
1556 /**
1557 Returns @true if this was a z move event.
1558 */
1559 bool IsZMove() const;
1560 };
1561
1562
1563
1564 /**
1565 @class wxScrollWinEvent
1566
1567 A scroll event holds information about events sent from scrolling windows.
1568
1569 Note that you can use the EVT_SCROLLWIN* macros for intercepting scroll window events
1570 from the receiving window.
1571
1572 @beginEventTable{wxScrollWinEvent}
1573 @event{EVT_SCROLLWIN(func)}
1574 Process all scroll events.
1575 @event{EVT_SCROLLWIN_TOP(func)}
1576 Process wxEVT_SCROLLWIN_TOP scroll-to-top events.
1577 @event{EVT_SCROLLWIN_BOTTOM(func)}
1578 Process wxEVT_SCROLLWIN_BOTTOM scroll-to-bottom events.
1579 @event{EVT_SCROLLWIN_LINEUP(func)}
1580 Process wxEVT_SCROLLWIN_LINEUP line up events.
1581 @event{EVT_SCROLLWIN_LINEDOWN(func)}
1582 Process wxEVT_SCROLLWIN_LINEDOWN line down events.
1583 @event{EVT_SCROLLWIN_PAGEUP(func)}
1584 Process wxEVT_SCROLLWIN_PAGEUP page up events.
1585 @event{EVT_SCROLLWIN_PAGEDOWN(func)}
1586 Process wxEVT_SCROLLWIN_PAGEDOWN page down events.
1587 @event{EVT_SCROLLWIN_THUMBTRACK(func)}
1588 Process wxEVT_SCROLLWIN_THUMBTRACK thumbtrack events
1589 (frequent events sent as the user drags the thumbtrack).
1590 @event{EVT_SCROLLWIN_THUMBRELEASE(func)}
1591 Process wxEVT_SCROLLWIN_THUMBRELEASE thumb release events.
1592 @endEventTable
1593
1594
1595 @library{wxcore}
1596 @category{events}
1597
1598 @see wxScrollEvent, @ref overview_events
1599 */
1600 class wxScrollWinEvent : public wxEvent
1601 {
1602 public:
1603 /**
1604 Constructor.
1605 */
1606 wxScrollWinEvent(wxEventType commandType = wxEVT_NULL, int pos = 0,
1607 int orientation = 0);
1608
1609 /**
1610 Returns wxHORIZONTAL or wxVERTICAL, depending on the orientation of the
1611 scrollbar.
1612
1613 @todo wxHORIZONTAL and wxVERTICAL should go in their own enum
1614 */
1615 int GetOrientation() const;
1616
1617 /**
1618 Returns the position of the scrollbar for the thumb track and release events.
1619
1620 Note that this field can't be used for the other events, you need to query
1621 the window itself for the current position in that case.
1622 */
1623 int GetPosition() const;
1624
1625 void SetOrientation(int orient);
1626 void SetPosition(int pos);
1627 };
1628
1629
1630
1631 /**
1632 @class wxSysColourChangedEvent
1633
1634 This class is used for system colour change events, which are generated
1635 when the user changes the colour settings using the control panel.
1636 This is only appropriate under Windows.
1637
1638 @remarks
1639 The default event handler for this event propagates the event to child windows,
1640 since Windows only sends the events to top-level windows.
1641 If intercepting this event for a top-level window, remember to call the base
1642 class handler, or to pass the event on to the window's children explicitly.
1643
1644 @beginEventTable{wxSysColourChangedEvent}
1645 @event{EVT_SYS_COLOUR_CHANGED(func)}
1646 Process a @c wxEVT_SYS_COLOUR_CHANGED event.
1647 @endEventTable
1648
1649 @library{wxcore}
1650 @category{events}
1651
1652 @see @ref overview_events
1653 */
1654 class wxSysColourChangedEvent : public wxEvent
1655 {
1656 public:
1657 /**
1658 Constructor.
1659 */
1660 wxSysColourChangedEvent();
1661 };
1662
1663
1664
1665 /**
1666 @class wxWindowCreateEvent
1667
1668 This event is sent just after the actual window associated with a wxWindow
1669 object has been created.
1670
1671 Since it is derived from wxCommandEvent, the event propagates up
1672 the window hierarchy.
1673
1674 @beginEventTable{wxWindowCreateEvent}
1675 @event{EVT_WINDOW_CREATE(func)}
1676 Process a @c wxEVT_CREATE event.
1677 @endEventTable
1678
1679 @library{wxcore}
1680 @category{events}
1681
1682 @see @ref overview_events, wxWindowDestroyEvent
1683 */
1684 class wxWindowCreateEvent : public wxCommandEvent
1685 {
1686 public:
1687 /**
1688 Constructor.
1689 */
1690 wxWindowCreateEvent(wxWindow* win = NULL);
1691
1692 /// Retutn the window being created.
1693 wxWindow *GetWindow() const;
1694 };
1695
1696
1697
1698 /**
1699 @class wxPaintEvent
1700
1701 A paint event is sent when a window's contents needs to be repainted.
1702
1703 The handler of this event must create a wxPaintDC object and use it for
1704 painting the window contents. For example:
1705 @code
1706 void MyWindow::OnPaint(wxPaintEvent& event)
1707 {
1708 wxPaintDC dc(this);
1709
1710 DrawMyDocument(dc);
1711 }
1712 @endcode
1713
1714 Notice that you must @e not create other kinds of wxDC (e.g. wxClientDC or
1715 wxWindowDC) in EVT_PAINT handlers and also don't create wxPaintDC outside
1716 of this event handlers.
1717
1718
1719 You can optimize painting by retrieving the rectangles that have been damaged
1720 and only repainting these. The rectangles are in terms of the client area,
1721 and are unscrolled, so you will need to do some calculations using the current
1722 view position to obtain logical, scrolled units.
1723 Here is an example of using the wxRegionIterator class:
1724 @code
1725 // Called when window needs to be repainted.
1726 void MyWindow::OnPaint(wxPaintEvent& event)
1727 {
1728 wxPaintDC dc(this);
1729
1730 // Find Out where the window is scrolled to
1731 int vbX,vbY; // Top left corner of client
1732 GetViewStart(&vbX,&vbY);
1733
1734 int vX,vY,vW,vH; // Dimensions of client area in pixels
1735 wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
1736
1737 while (upd)
1738 {
1739 vX = upd.GetX();
1740 vY = upd.GetY();
1741 vW = upd.GetW();
1742 vH = upd.GetH();
1743
1744 // Alternatively we can do this:
1745 // wxRect rect(upd.GetRect());
1746
1747 // Repaint this rectangle
1748 ...some code...
1749
1750 upd ++ ;
1751 }
1752 }
1753 @endcode
1754
1755 @remarks
1756 Please notice that in general it is impossible to change the drawing of a
1757 standard control (such as wxButton) and so you shouldn't attempt to handle
1758 paint events for them as even if it might work on some platforms, this is
1759 inherently not portable and won't work everywhere.
1760
1761
1762 @beginEventTable{wxPaintEvent}
1763 @event{EVT_PAINT(func)}
1764 Process a @c wxEVT_PAINT event.
1765 @endEventTable
1766
1767 @library{wxcore}
1768 @category{events}
1769
1770 @see @ref overview_events
1771 */
1772 class wxPaintEvent : public wxEvent
1773 {
1774 public:
1775 /**
1776 Constructor.
1777 */
1778 wxPaintEvent(int id = 0);
1779 };
1780
1781
1782
1783 /**
1784 @class wxMaximizeEvent
1785
1786 An event being sent when a top level window is maximized. Notice that it is
1787 not sent when the window is restored to its original size after it had been
1788 maximized, only a normal wxSizeEvent is generated in this case.
1789
1790 @beginEventTable{wxMaximizeEvent}
1791 @event{EVT_MAXIMIZE(func)}
1792 Process a @c wxEVT_MAXIMIZE event.
1793 @endEventTable
1794
1795 @library{wxcore}
1796 @category{events}
1797
1798 @see @ref overview_events, wxTopLevelWindow::Maximize,
1799 wxTopLevelWindow::IsMaximized
1800 */
1801 class wxMaximizeEvent : public wxEvent
1802 {
1803 public:
1804 /**
1805 Constructor. Only used by wxWidgets internally.
1806 */
1807 wxMaximizeEvent(int id = 0);
1808 };
1809
1810 /**
1811 The possibles modes to pass to wxUpdateUIEvent::SetMode().
1812 */
1813 enum wxUpdateUIMode
1814 {
1815 /** Send UI update events to all windows. */
1816 wxUPDATE_UI_PROCESS_ALL,
1817
1818 /** Send UI update events to windows that have
1819 the wxWS_EX_PROCESS_UI_UPDATES flag specified. */
1820 wxUPDATE_UI_PROCESS_SPECIFIED
1821 };
1822
1823
1824 /**
1825 @class wxUpdateUIEvent
1826
1827 This class is used for pseudo-events which are called by wxWidgets
1828 to give an application the chance to update various user interface elements.
1829
1830 Without update UI events, an application has to work hard to check/uncheck,
1831 enable/disable, show/hide, and set the text for elements such as menu items
1832 and toolbar buttons. The code for doing this has to be mixed up with the code
1833 that is invoked when an action is invoked for a menu item or button.
1834
1835 With update UI events, you define an event handler to look at the state of the
1836 application and change UI elements accordingly. wxWidgets will call your member
1837 functions in idle time, so you don't have to worry where to call this code.
1838
1839 In addition to being a clearer and more declarative method, it also means you don't
1840 have to worry whether you're updating a toolbar or menubar identifier. The same
1841 handler can update a menu item and toolbar button, if the identifier is the same.
1842 Instead of directly manipulating the menu or button, you call functions in the event
1843 object, such as wxUpdateUIEvent::Check. wxWidgets will determine whether such a
1844 call has been made, and which UI element to update.
1845
1846 These events will work for popup menus as well as menubars. Just before a menu is
1847 popped up, wxMenu::UpdateUI is called to process any UI events for the window that
1848 owns the menu.
1849
1850 If you find that the overhead of UI update processing is affecting your application,
1851 you can do one or both of the following:
1852 @li Call wxUpdateUIEvent::SetMode with a value of wxUPDATE_UI_PROCESS_SPECIFIED,
1853 and set the extra style wxWS_EX_PROCESS_UI_UPDATES for every window that should
1854 receive update events. No other windows will receive update events.
1855 @li Call wxUpdateUIEvent::SetUpdateInterval with a millisecond value to set the delay
1856 between updates. You may need to call wxWindow::UpdateWindowUI at critical points,
1857 for example when a dialog is about to be shown, in case the user sees a slight
1858 delay before windows are updated.
1859
1860 Note that although events are sent in idle time, defining a wxIdleEvent handler
1861 for a window does not affect this because the events are sent from wxWindow::OnInternalIdle
1862 which is always called in idle time.
1863
1864 wxWidgets tries to optimize update events on some platforms.
1865 On Windows and GTK+, events for menubar items are only sent when the menu is about
1866 to be shown, and not in idle time.
1867
1868
1869 @beginEventTable{wxUpdateUIEvent}
1870 @event{EVT_UPDATE_UI(id, func)}
1871 Process a @c wxEVT_UPDATE_UI event for the command with the given id.
1872 @event{EVT_UPDATE_UI_RANGE(id1, id2, func)}
1873 Process a @c wxEVT_UPDATE_UI event for any command with id included in the given range.
1874 @endEventTable
1875
1876 @library{wxcore}
1877 @category{events}
1878
1879 @see @ref overview_events
1880 */
1881 class wxUpdateUIEvent : public wxCommandEvent
1882 {
1883 public:
1884 /**
1885 Constructor.
1886 */
1887 wxUpdateUIEvent(wxWindowID commandId = 0);
1888
1889 /**
1890 Returns @true if it is appropriate to update (send UI update events to)
1891 this window.
1892
1893 This function looks at the mode used (see wxUpdateUIEvent::SetMode),
1894 the wxWS_EX_PROCESS_UI_UPDATES flag in @a window, the time update events
1895 were last sent in idle time, and the update interval, to determine whether
1896 events should be sent to this window now. By default this will always
1897 return @true because the update mode is initially wxUPDATE_UI_PROCESS_ALL
1898 and the interval is set to 0; so update events will be sent as often as
1899 possible. You can reduce the frequency that events are sent by changing the
1900 mode and/or setting an update interval.
1901
1902 @see ResetUpdateTime(), SetUpdateInterval(), SetMode()
1903 */
1904 static bool CanUpdate(wxWindow* window);
1905
1906 /**
1907 Check or uncheck the UI element.
1908 */
1909 void Check(bool check);
1910
1911 /**
1912 Enable or disable the UI element.
1913 */
1914 void Enable(bool enable);
1915
1916 /**
1917 Returns @true if the UI element should be checked.
1918 */
1919 bool GetChecked() const;
1920
1921 /**
1922 Returns @true if the UI element should be enabled.
1923 */
1924 bool GetEnabled() const;
1925
1926 /**
1927 Static function returning a value specifying how wxWidgets will send update
1928 events: to all windows, or only to those which specify that they will process
1929 the events.
1930
1931 @see SetMode()
1932 */
1933 static wxUpdateUIMode GetMode();
1934
1935 /**
1936 Returns @true if the application has called Check().
1937 For wxWidgets internal use only.
1938 */
1939 bool GetSetChecked() const;
1940
1941 /**
1942 Returns @true if the application has called Enable().
1943 For wxWidgets internal use only.
1944 */
1945 bool GetSetEnabled() const;
1946
1947 /**
1948 Returns @true if the application has called Show().
1949 For wxWidgets internal use only.
1950 */
1951 bool GetSetShown() const;
1952
1953 /**
1954 Returns @true if the application has called SetText().
1955 For wxWidgets internal use only.
1956 */
1957 bool GetSetText() const;
1958
1959 /**
1960 Returns @true if the UI element should be shown.
1961 */
1962 bool GetShown() const;
1963
1964 /**
1965 Returns the text that should be set for the UI element.
1966 */
1967 wxString GetText() const;
1968
1969 /**
1970 Returns the current interval between updates in milliseconds.
1971 The value -1 disables updates, 0 updates as frequently as possible.
1972
1973 @see SetUpdateInterval().
1974 */
1975 static long GetUpdateInterval();
1976
1977 /**
1978 Used internally to reset the last-updated time to the current time.
1979
1980 It is assumed that update events are normally sent in idle time, so this
1981 is called at the end of idle processing.
1982
1983 @see CanUpdate(), SetUpdateInterval(), SetMode()
1984 */
1985 static void ResetUpdateTime();
1986
1987 /**
1988 Specify how wxWidgets will send update events: to all windows, or only to
1989 those which specify that they will process the events.
1990
1991 @param mode
1992 this parameter may be one of the ::wxUpdateUIMode enumeration values.
1993 The default mode is wxUPDATE_UI_PROCESS_ALL.
1994 */
1995 static void SetMode(wxUpdateUIMode mode);
1996
1997 /**
1998 Sets the text for this UI element.
1999 */
2000 void SetText(const wxString& text);
2001
2002 /**
2003 Sets the interval between updates in milliseconds.
2004
2005 Set to -1 to disable updates, or to 0 to update as frequently as possible.
2006 The default is 0.
2007
2008 Use this to reduce the overhead of UI update events if your application
2009 has a lot of windows. If you set the value to -1 or greater than 0,
2010 you may also need to call wxWindow::UpdateWindowUI at appropriate points
2011 in your application, such as when a dialog is about to be shown.
2012 */
2013 static void SetUpdateInterval(long updateInterval);
2014
2015 /**
2016 Show or hide the UI element.
2017 */
2018 void Show(bool show);
2019 };
2020
2021
2022
2023 /**
2024 @class wxClipboardTextEvent
2025
2026 This class represents the events generated by a control (typically a
2027 wxTextCtrl but other windows can generate these events as well) when its
2028 content gets copied or cut to, or pasted from the clipboard.
2029
2030 There are three types of corresponding events wxEVT_COMMAND_TEXT_COPY,
2031 wxEVT_COMMAND_TEXT_CUT and wxEVT_COMMAND_TEXT_PASTE.
2032
2033 If any of these events is processed (without being skipped) by an event
2034 handler, the corresponding operation doesn't take place which allows to
2035 prevent the text from being copied from or pasted to a control. It is also
2036 possible to examine the clipboard contents in the PASTE event handler and
2037 transform it in some way before inserting in a control -- for example,
2038 changing its case or removing invalid characters.
2039
2040 Finally notice that a CUT event is always preceded by the COPY event which
2041 makes it possible to only process the latter if it doesn't matter if the
2042 text was copied or cut.
2043
2044 @note
2045 These events are currently only generated by wxTextCtrl under GTK+.
2046 They are generated by all controls under Windows.
2047
2048 @beginEventTable{wxClipboardTextEvent}
2049 @event{EVT_TEXT_COPY(id, func)}
2050 Some or all of the controls content was copied to the clipboard.
2051 @event{EVT_TEXT_CUT(id, func)}
2052 Some or all of the controls content was cut (i.e. copied and
2053 deleted).
2054 @event{EVT_TEXT_PASTE(id, func)}
2055 Clipboard content was pasted into the control.
2056 @endEventTable
2057
2058
2059 @library{wxcore}
2060 @category{events}
2061
2062 @see wxClipboard
2063 */
2064 class wxClipboardTextEvent : public wxCommandEvent
2065 {
2066 public:
2067 /**
2068 Constructor.
2069 */
2070 wxClipboardTextEvent(wxEventType commandType = wxEVT_NULL, int id = 0);
2071 };
2072
2073
2074
2075 /**
2076 @class wxMouseEvent
2077
2078 This event class contains information about the events generated by the mouse:
2079 they include mouse buttons press and release events and mouse move events.
2080
2081 All mouse events involving the buttons use @c wxMOUSE_BTN_LEFT for the
2082 left mouse button, @c wxMOUSE_BTN_MIDDLE for the middle one and
2083 @c wxMOUSE_BTN_RIGHT for the right one. And if the system supports more
2084 buttons, the @c wxMOUSE_BTN_AUX1 and @c wxMOUSE_BTN_AUX2 events
2085 can also be generated. Note that not all mice have even a middle button so a
2086 portable application should avoid relying on the events from it (but the right
2087 button click can be emulated using the left mouse button with the control key
2088 under Mac platforms with a single button mouse).
2089
2090 For the @c wxEVT_ENTER_WINDOW and @c wxEVT_LEAVE_WINDOW events
2091 purposes, the mouse is considered to be inside the window if it is in the
2092 window client area and not inside one of its children. In other words, the
2093 parent window receives @c wxEVT_LEAVE_WINDOW event not only when the
2094 mouse leaves the window entirely but also when it enters one of its children.
2095
2096 The position associated with a mouse event is expressed in the window
2097 coordinates of the window which generated the event, you can use
2098 wxWindow::ClientToScreen() to convert it to screen coordinates and possibly
2099 call wxWindow::ScreenToClient() next to convert it to window coordinates of
2100 another window.
2101
2102 @note Note that under Windows CE mouse enter and leave events are not natively
2103 supported by the system but are generated by wxWidgets itself. This has several
2104 drawbacks: the LEAVE_WINDOW event might be received some time after the mouse
2105 left the window and the state variables for it may have changed during this time.
2106
2107 @note Note the difference between methods like wxMouseEvent::LeftDown and
2108 the inherited wxMouseState::LeftIsDown: the former returns @true when
2109 the event corresponds to the left mouse button click while the latter
2110 returns @true if the left mouse button is currently being pressed.
2111 For example, when the user is dragging the mouse you can use
2112 wxMouseEvent::LeftIsDown to test whether the left mouse button is
2113 (still) depressed. Also, by convention, if wxMouseEvent::LeftDown
2114 returns @true, wxMouseEvent::LeftIsDown will also return @true in
2115 wxWidgets whatever the underlying GUI behaviour is (which is
2116 platform-dependent). The same applies, of course, to other mouse
2117 buttons as well.
2118
2119
2120 @beginEventTable{wxMouseEvent}
2121 @event{EVT_LEFT_DOWN(func)}
2122 Process a @c wxEVT_LEFT_DOWN event. The handler of this event should normally
2123 call event.Skip() to allow the default processing to take place as otherwise
2124 the window under mouse wouldn't get the focus.
2125 @event{EVT_LEFT_UP(func)}
2126 Process a @c wxEVT_LEFT_UP event.
2127 @event{EVT_LEFT_DCLICK(func)}
2128 Process a @c wxEVT_LEFT_DCLICK event.
2129 @event{EVT_MIDDLE_DOWN(func)}
2130 Process a @c wxEVT_MIDDLE_DOWN event.
2131 @event{EVT_MIDDLE_UP(func)}
2132 Process a @c wxEVT_MIDDLE_UP event.
2133 @event{EVT_MIDDLE_DCLICK(func)}
2134 Process a @c wxEVT_MIDDLE_DCLICK event.
2135 @event{EVT_RIGHT_DOWN(func)}
2136 Process a @c wxEVT_RIGHT_DOWN event.
2137 @event{EVT_RIGHT_UP(func)}
2138 Process a @c wxEVT_RIGHT_UP event.
2139 @event{EVT_RIGHT_DCLICK(func)}
2140 Process a @c wxEVT_RIGHT_DCLICK event.
2141 @event{EVT_MOUSE_AUX1_DOWN(func)}
2142 Process a @c wxEVT_AUX1_DOWN event.
2143 @event{EVT_MOUSE_AUX1_UP(func)}
2144 Process a @c wxEVT_AUX1_UP event.
2145 @event{EVT_MOUSE_AUX1_DCLICK(func)}
2146 Process a @c wxEVT_AUX1_DCLICK event.
2147 @event{EVT_MOUSE_AUX2_DOWN(func)}
2148 Process a @c wxEVT_AUX2_DOWN event.
2149 @event{EVT_MOUSE_AUX2_UP(func)}
2150 Process a @c wxEVT_AUX2_UP event.
2151 @event{EVT_MOUSE_AUX2_DCLICK(func)}
2152 Process a @c wxEVT_AUX2_DCLICK event.
2153 @event{EVT_MOTION(func)}
2154 Process a @c wxEVT_MOTION event.
2155 @event{EVT_ENTER_WINDOW(func)}
2156 Process a @c wxEVT_ENTER_WINDOW event.
2157 @event{EVT_LEAVE_WINDOW(func)}
2158 Process a @c wxEVT_LEAVE_WINDOW event.
2159 @event{EVT_MOUSEWHEEL(func)}
2160 Process a @c wxEVT_MOUSEWHEEL event.
2161 @event{EVT_MOUSE_EVENTS(func)}
2162 Process all mouse events.
2163 @endEventTable
2164
2165 @library{wxcore}
2166 @category{events}
2167
2168 @see wxKeyEvent
2169 */
2170 class wxMouseEvent : public wxEvent,
2171 public wxMouseState
2172 {
2173 public:
2174 /**
2175 Constructor. Valid event types are:
2176
2177 @li wxEVT_ENTER_WINDOW
2178 @li wxEVT_LEAVE_WINDOW
2179 @li wxEVT_LEFT_DOWN
2180 @li wxEVT_LEFT_UP
2181 @li wxEVT_LEFT_DCLICK
2182 @li wxEVT_MIDDLE_DOWN
2183 @li wxEVT_MIDDLE_UP
2184 @li wxEVT_MIDDLE_DCLICK
2185 @li wxEVT_RIGHT_DOWN
2186 @li wxEVT_RIGHT_UP
2187 @li wxEVT_RIGHT_DCLICK
2188 @li wxEVT_MOUSE_AUX1_DOWN
2189 @li wxEVT_MOUSE_AUX1_UP
2190 @li wxEVT_MOUSE_AUX1_DCLICK
2191 @li wxEVT_MOUSE_AUX2_DOWN
2192 @li wxEVT_MOUSE_AUX2_UP
2193 @li wxEVT_MOUSE_AUX2_DCLICK
2194 @li wxEVT_MOTION
2195 @li wxEVT_MOUSEWHEEL
2196 */
2197 wxMouseEvent(wxEventType mouseEventType = wxEVT_NULL);
2198
2199 /**
2200 Returns @true if the event was a first extra button double click.
2201 */
2202 bool Aux1DClick() const;
2203
2204 /**
2205 Returns @true if the first extra button mouse button changed to down.
2206 */
2207 bool Aux1Down() const;
2208
2209 /**
2210 Returns @true if the first extra button mouse button changed to up.
2211 */
2212 bool Aux1Up() const;
2213
2214 /**
2215 Returns @true if the event was a second extra button double click.
2216 */
2217 bool Aux2DClick() const;
2218
2219 /**
2220 Returns @true if the second extra button mouse button changed to down.
2221 */
2222 bool Aux2Down() const;
2223
2224 /**
2225 Returns @true if the second extra button mouse button changed to up.
2226 */
2227 bool Aux2Up() const;
2228
2229 /**
2230 Returns @true if the event was generated by the specified button.
2231
2232 @see wxMouseState::ButtoinIsDown()
2233 */
2234 bool Button(wxMouseButton but) const;
2235
2236 /**
2237 If the argument is omitted, this returns @true if the event was a mouse
2238 double click event. Otherwise the argument specifies which double click event
2239 was generated (see Button() for the possible values).
2240 */
2241 bool ButtonDClick(wxMouseButton but = wxMOUSE_BTN_ANY) const;
2242
2243 /**
2244 If the argument is omitted, this returns @true if the event was a mouse
2245 button down event. Otherwise the argument specifies which button-down event
2246 was generated (see Button() for the possible values).
2247 */
2248 bool ButtonDown(wxMouseButton but = wxMOUSE_BTN_ANY) const;
2249
2250 /**
2251 If the argument is omitted, this returns @true if the event was a mouse
2252 button up event. Otherwise the argument specifies which button-up event
2253 was generated (see Button() for the possible values).
2254 */
2255 bool ButtonUp(wxMouseButton but = wxMOUSE_BTN_ANY) const;
2256
2257 /**
2258 Returns @true if this was a dragging event (motion while a button is depressed).
2259
2260 @see Moving()
2261 */
2262 bool Dragging() const;
2263
2264 /**
2265 Returns @true if the mouse was entering the window.
2266
2267 @see Leaving()
2268 */
2269 bool Entering() const;
2270
2271 /**
2272 Returns the mouse button which generated this event or @c wxMOUSE_BTN_NONE
2273 if no button is involved (for mouse move, enter or leave event, for example).
2274 Otherwise @c wxMOUSE_BTN_LEFT is returned for the left button down, up and
2275 double click events, @c wxMOUSE_BTN_MIDDLE and @c wxMOUSE_BTN_RIGHT
2276 for the same events for the middle and the right buttons respectively.
2277 */
2278 int GetButton() const;
2279
2280 /**
2281 Returns the number of mouse clicks for this event: 1 for a simple click, 2
2282 for a double-click, 3 for a triple-click and so on.
2283
2284 Currently this function is implemented only in wxMac and returns -1 for the
2285 other platforms (you can still distinguish simple clicks from double-clicks as
2286 they generate different kinds of events however).
2287
2288 @since 2.9.0
2289 */
2290 int GetClickCount() const;
2291
2292 /**
2293 Returns the configured number of lines (or whatever) to be scrolled per
2294 wheel action. Defaults to three.
2295 */
2296 int GetLinesPerAction() const;
2297
2298 /**
2299 Returns the logical mouse position in pixels (i.e. translated according to the
2300 translation set for the DC, which usually indicates that the window has been
2301 scrolled).
2302 */
2303 wxPoint GetLogicalPosition(const wxDC& dc) const;
2304
2305 /**
2306 Get wheel delta, normally 120.
2307
2308 This is the threshold for action to be taken, and one such action
2309 (for example, scrolling one increment) should occur for each delta.
2310 */
2311 int GetWheelDelta() const;
2312
2313 /**
2314 Get wheel rotation, positive or negative indicates direction of rotation.
2315
2316 Current devices all send an event when rotation is at least +/-WheelDelta, but
2317 finer resolution devices can be created in the future.
2318
2319 Because of this you shouldn't assume that one event is equal to 1 line, but you
2320 should be able to either do partial line scrolling or wait until several
2321 events accumulate before scrolling.
2322 */
2323 int GetWheelRotation() const;
2324
2325 /**
2326 Gets the axis the wheel operation concerns; @c 0 is the Y axis as on
2327 most mouse wheels, @c 1 is the X axis.
2328
2329 Note that only some models of mouse have horizontal wheel axis.
2330 */
2331 int GetWheelAxis() const;
2332
2333 /**
2334 Returns @true if the event was a mouse button event (not necessarily a button
2335 down event - that may be tested using ButtonDown()).
2336 */
2337 bool IsButton() const;
2338
2339 /**
2340 Returns @true if the system has been setup to do page scrolling with
2341 the mouse wheel instead of line scrolling.
2342 */
2343 bool IsPageScroll() const;
2344
2345 /**
2346 Returns @true if the mouse was leaving the window.
2347
2348 @see Entering().
2349 */
2350 bool Leaving() const;
2351
2352 /**
2353 Returns @true if the event was a left double click.
2354 */
2355 bool LeftDClick() const;
2356
2357 /**
2358 Returns @true if the left mouse button changed to down.
2359 */
2360 bool LeftDown() const;
2361
2362 /**
2363 Returns @true if the left mouse button changed to up.
2364 */
2365 bool LeftUp() const;
2366
2367 /**
2368 Returns @true if the Meta key was down at the time of the event.
2369 */
2370 bool MetaDown() const;
2371
2372 /**
2373 Returns @true if the event was a middle double click.
2374 */
2375 bool MiddleDClick() const;
2376
2377 /**
2378 Returns @true if the middle mouse button changed to down.
2379 */
2380 bool MiddleDown() const;
2381
2382 /**
2383 Returns @true if the middle mouse button changed to up.
2384 */
2385 bool MiddleUp() const;
2386
2387 /**
2388 Returns @true if this was a motion event and no mouse buttons were pressed.
2389 If any mouse button is held pressed, then this method returns @false and
2390 Dragging() returns @true.
2391 */
2392 bool Moving() const;
2393
2394 /**
2395 Returns @true if the event was a right double click.
2396 */
2397 bool RightDClick() const;
2398
2399 /**
2400 Returns @true if the right mouse button changed to down.
2401 */
2402 bool RightDown() const;
2403
2404 /**
2405 Returns @true if the right mouse button changed to up.
2406 */
2407 bool RightUp() const;
2408 };
2409
2410
2411
2412 /**
2413 @class wxDropFilesEvent
2414
2415 This class is used for drop files events, that is, when files have been dropped
2416 onto the window. This functionality is currently only available under Windows.
2417
2418 The window must have previously been enabled for dropping by calling
2419 wxWindow::DragAcceptFiles().
2420
2421 Important note: this is a separate implementation to the more general drag and drop
2422 implementation documented in the @ref overview_dnd. It uses the older, Windows
2423 message-based approach of dropping files.
2424
2425 @beginEventTable{wxDropFilesEvent}
2426 @event{EVT_DROP_FILES(func)}
2427 Process a @c wxEVT_DROP_FILES event.
2428 @endEventTable
2429
2430 @onlyfor{wxmsw}
2431
2432 @library{wxcore}
2433 @category{events}
2434
2435 @see @ref overview_events
2436 */
2437 class wxDropFilesEvent : public wxEvent
2438 {
2439 public:
2440 /**
2441 Constructor.
2442 */
2443 wxDropFilesEvent(wxEventType id = 0, int noFiles = 0,
2444 wxString* files = NULL);
2445
2446 /**
2447 Returns an array of filenames.
2448 */
2449 wxString* GetFiles() const;
2450
2451 /**
2452 Returns the number of files dropped.
2453 */
2454 int GetNumberOfFiles() const;
2455
2456 /**
2457 Returns the position at which the files were dropped.
2458 Returns an array of filenames.
2459 */
2460 wxPoint GetPosition() const;
2461 };
2462
2463
2464
2465 /**
2466 @class wxCommandEvent
2467
2468 This event class contains information about command events, which originate
2469 from a variety of simple controls.
2470
2471 Note that wxCommandEvents and wxCommandEvent-derived event classes by default
2472 and unlike other wxEvent-derived classes propagate upward from the source
2473 window (the window which emits the event) up to the first parent which processes
2474 the event. Be sure to read @ref overview_events_propagation.
2475
2476 More complex controls, such as wxTreeCtrl, have separate command event classes.
2477
2478 @beginEventTable{wxCommandEvent}
2479 @event{EVT_COMMAND(id, event, func)}
2480 Process a command, supplying the window identifier, command event identifier,
2481 and member function.
2482 @event{EVT_COMMAND_RANGE(id1, id2, event, func)}
2483 Process a command for a range of window identifiers, supplying the minimum and
2484 maximum window identifiers, command event identifier, and member function.
2485 @event{EVT_BUTTON(id, func)}
2486 Process a @c wxEVT_COMMAND_BUTTON_CLICKED command, which is generated by a wxButton control.
2487 @event{EVT_CHECKBOX(id, func)}
2488 Process a @c wxEVT_COMMAND_CHECKBOX_CLICKED command, which is generated by a wxCheckBox control.
2489 @event{EVT_CHOICE(id, func)}
2490 Process a @c wxEVT_COMMAND_CHOICE_SELECTED command, which is generated by a wxChoice control.
2491 @event{EVT_COMBOBOX(id, func)}
2492 Process a @c wxEVT_COMMAND_COMBOBOX_SELECTED command, which is generated by a wxComboBox control.
2493 @event{EVT_LISTBOX(id, func)}
2494 Process a @c wxEVT_COMMAND_LISTBOX_SELECTED command, which is generated by a wxListBox control.
2495 @event{EVT_LISTBOX_DCLICK(id, func)}
2496 Process a @c wxEVT_COMMAND_LISTBOX_DOUBLECLICKED command, which is generated by a wxListBox control.
2497 @event{EVT_CHECKLISTBOX(id, func)}
2498 Process a @c wxEVT_COMMAND_CHECKLISTBOX_TOGGLED command, which is generated by a wxCheckListBox control.
2499 @event{EVT_MENU(id, func)}
2500 Process a @c wxEVT_COMMAND_MENU_SELECTED command, which is generated by a menu item.
2501 @event{EVT_MENU_RANGE(id1, id2, func)}
2502 Process a @c wxEVT_COMMAND_MENU_RANGE command, which is generated by a range of menu items.
2503 @event{EVT_CONTEXT_MENU(func)}
2504 Process the event generated when the user has requested a popup menu to appear by
2505 pressing a special keyboard key (under Windows) or by right clicking the mouse.
2506 @event{EVT_RADIOBOX(id, func)}
2507 Process a @c wxEVT_COMMAND_RADIOBOX_SELECTED command, which is generated by a wxRadioBox control.
2508 @event{EVT_RADIOBUTTON(id, func)}
2509 Process a @c wxEVT_COMMAND_RADIOBUTTON_SELECTED command, which is generated by a wxRadioButton control.
2510 @event{EVT_SCROLLBAR(id, func)}
2511 Process a @c wxEVT_COMMAND_SCROLLBAR_UPDATED command, which is generated by a wxScrollBar
2512 control. This is provided for compatibility only; more specific scrollbar event macros
2513 should be used instead (see wxScrollEvent).
2514 @event{EVT_SLIDER(id, func)}
2515 Process a @c wxEVT_COMMAND_SLIDER_UPDATED command, which is generated by a wxSlider control.
2516 @event{EVT_TEXT(id, func)}
2517 Process a @c wxEVT_COMMAND_TEXT_UPDATED command, which is generated by a wxTextCtrl control.
2518 @event{EVT_TEXT_ENTER(id, func)}
2519 Process a @c wxEVT_COMMAND_TEXT_ENTER command, which is generated by a wxTextCtrl control.
2520 Note that you must use wxTE_PROCESS_ENTER flag when creating the control if you want it
2521 to generate such events.
2522 @event{EVT_TEXT_MAXLEN(id, func)}
2523 Process a @c wxEVT_COMMAND_TEXT_MAXLEN command, which is generated by a wxTextCtrl control
2524 when the user tries to enter more characters into it than the limit previously set
2525 with SetMaxLength().
2526 @event{EVT_TOGGLEBUTTON(id, func)}
2527 Process a @c wxEVT_COMMAND_TOGGLEBUTTON_CLICKED event.
2528 @event{EVT_TOOL(id, func)}
2529 Process a @c wxEVT_COMMAND_TOOL_CLICKED event (a synonym for @c wxEVT_COMMAND_MENU_SELECTED).
2530 Pass the id of the tool.
2531 @event{EVT_TOOL_RANGE(id1, id2, func)}
2532 Process a @c wxEVT_COMMAND_TOOL_CLICKED event for a range of identifiers. Pass the ids of the tools.
2533 @event{EVT_TOOL_RCLICKED(id, func)}
2534 Process a @c wxEVT_COMMAND_TOOL_RCLICKED event. Pass the id of the tool. (Not available on wxOSX.)
2535 @event{EVT_TOOL_RCLICKED_RANGE(id1, id2, func)}
2536 Process a @c wxEVT_COMMAND_TOOL_RCLICKED event for a range of ids. Pass the ids of the tools. (Not available on wxOSX.)
2537 @event{EVT_TOOL_ENTER(id, func)}
2538 Process a @c wxEVT_COMMAND_TOOL_ENTER event. Pass the id of the toolbar itself.
2539 The value of wxCommandEvent::GetSelection() is the tool id, or -1 if the mouse cursor
2540 has moved off a tool. (Not available on wxOSX.)
2541 @event{EVT_COMMAND_LEFT_CLICK(id, func)}
2542 Process a @c wxEVT_COMMAND_LEFT_CLICK command, which is generated by a control (wxMSW only).
2543 @event{EVT_COMMAND_LEFT_DCLICK(id, func)}
2544 Process a @c wxEVT_COMMAND_LEFT_DCLICK command, which is generated by a control (wxMSW only).
2545 @event{EVT_COMMAND_RIGHT_CLICK(id, func)}
2546 Process a @c wxEVT_COMMAND_RIGHT_CLICK command, which is generated by a control (wxMSW only).
2547 @event{EVT_COMMAND_SET_FOCUS(id, func)}
2548 Process a @c wxEVT_COMMAND_SET_FOCUS command, which is generated by a control (wxMSW only).
2549 @event{EVT_COMMAND_KILL_FOCUS(id, func)}
2550 Process a @c wxEVT_COMMAND_KILL_FOCUS command, which is generated by a control (wxMSW only).
2551 @event{EVT_COMMAND_ENTER(id, func)}
2552 Process a @c wxEVT_COMMAND_ENTER command, which is generated by a control.
2553 @endEventTable
2554
2555 @library{wxcore}
2556 @category{events}
2557 */
2558 class wxCommandEvent : public wxEvent
2559 {
2560 public:
2561 /**
2562 Constructor.
2563 */
2564 wxCommandEvent(wxEventType commandEventType = wxEVT_NULL, int id = 0);
2565
2566 /**
2567 Returns client data pointer for a listbox or choice selection event
2568 (not valid for a deselection).
2569 */
2570 void* GetClientData() const;
2571
2572 /**
2573 Returns client object pointer for a listbox or choice selection event
2574 (not valid for a deselection).
2575 */
2576 wxClientData* GetClientObject() const;
2577
2578 /**
2579 Returns extra information dependant on the event objects type.
2580
2581 If the event comes from a listbox selection, it is a boolean
2582 determining whether the event was a selection (@true) or a
2583 deselection (@false). A listbox deselection only occurs for
2584 multiple-selection boxes, and in this case the index and string values
2585 are indeterminate and the listbox must be examined by the application.
2586 */
2587 long GetExtraLong() const;
2588
2589 /**
2590 Returns the integer identifier corresponding to a listbox, choice or
2591 radiobox selection (only if the event was a selection, not a deselection),
2592 or a boolean value representing the value of a checkbox.
2593 */
2594 int GetInt() const;
2595
2596 /**
2597 Returns item index for a listbox or choice selection event (not valid for
2598 a deselection).
2599 */
2600 int GetSelection() const;
2601
2602 /**
2603 Returns item string for a listbox or choice selection event. If one
2604 or several items have been deselected, returns the index of the first
2605 deselected item. If some items have been selected and others deselected
2606 at the same time, it will return the index of the first selected item.
2607 */
2608 wxString GetString() const;
2609
2610 /**
2611 This method can be used with checkbox and menu events: for the checkboxes, the
2612 method returns @true for a selection event and @false for a deselection one.
2613 For the menu events, this method indicates if the menu item just has become
2614 checked or unchecked (and thus only makes sense for checkable menu items).
2615
2616 Notice that this method can not be used with wxCheckListBox currently.
2617 */
2618 bool IsChecked() const;
2619
2620 /**
2621 For a listbox or similar event, returns @true if it is a selection, @false
2622 if it is a deselection. If some items have been selected and others deselected
2623 at the same time, it will return @true.
2624 */
2625 bool IsSelection() const;
2626
2627 /**
2628 Sets the client data for this event.
2629 */
2630 void SetClientData(void* clientData);
2631
2632 /**
2633 Sets the client object for this event. The client object is not owned by the
2634 event object and the event object will not delete the client object in its destructor.
2635
2636 The client object must be owned and deleted by another object (e.g. a control)
2637 that has longer life time than the event object.
2638 */
2639 void SetClientObject(wxClientData* clientObject);
2640
2641 /**
2642 Sets the @b m_extraLong member.
2643 */
2644 void SetExtraLong(long extraLong);
2645
2646 /**
2647 Sets the @b m_commandInt member.
2648 */
2649 void SetInt(int intCommand);
2650
2651 /**
2652 Sets the @b m_commandString member.
2653 */
2654 void SetString(const wxString& string);
2655 };
2656
2657
2658
2659 /**
2660 @class wxActivateEvent
2661
2662 An activate event is sent when a window or application is being activated
2663 or deactivated.
2664
2665 @beginEventTable{wxActivateEvent}
2666 @event{EVT_ACTIVATE(func)}
2667 Process a @c wxEVT_ACTIVATE event.
2668 @event{EVT_ACTIVATE_APP(func)}
2669 Process a @c wxEVT_ACTIVATE_APP event.
2670 This event is received by the wxApp-derived instance only.
2671 @event{EVT_HIBERNATE(func)}
2672 Process a hibernate event, supplying the member function. This event applies
2673 to wxApp only, and only on Windows SmartPhone and PocketPC.
2674 It is generated when the system is low on memory; the application should free
2675 up as much memory as possible, and restore full working state when it receives
2676 a wxEVT_ACTIVATE or wxEVT_ACTIVATE_APP event.
2677 @endEventTable
2678
2679 @library{wxcore}
2680 @category{events}
2681
2682 @see @ref overview_events, wxApp::IsActive
2683 */
2684 class wxActivateEvent : public wxEvent
2685 {
2686 public:
2687 /**
2688 Constructor.
2689 */
2690 wxActivateEvent(wxEventType eventType = wxEVT_NULL, bool active = true,
2691 int id = 0);
2692
2693 /**
2694 Returns @true if the application or window is being activated, @false otherwise.
2695 */
2696 bool GetActive() const;
2697 };
2698
2699
2700
2701 /**
2702 @class wxContextMenuEvent
2703
2704 This class is used for context menu events, sent to give
2705 the application a chance to show a context (popup) menu for a wxWindow.
2706
2707 Note that if wxContextMenuEvent::GetPosition returns wxDefaultPosition, this
2708 means that the event originated from a keyboard context button event, and you
2709 should compute a suitable position yourself, for example by calling wxGetMousePosition().
2710
2711 When a keyboard context menu button is pressed on Windows, a right-click event
2712 with default position is sent first, and if this event is not processed, the
2713 context menu event is sent. So if you process mouse events and you find your
2714 context menu event handler is not being called, you could call wxEvent::Skip()
2715 for mouse right-down events.
2716
2717 @beginEventTable{wxContextMenuEvent}
2718 @event{EVT_CONTEXT_MENU(func)}
2719 A right click (or other context menu command depending on platform) has been detected.
2720 @endEventTable
2721
2722
2723 @library{wxcore}
2724 @category{events}
2725
2726 @see wxCommandEvent, @ref overview_events
2727 */
2728 class wxContextMenuEvent : public wxCommandEvent
2729 {
2730 public:
2731 /**
2732 Constructor.
2733 */
2734 wxContextMenuEvent(wxEventType type = wxEVT_NULL, int id = 0,
2735 const wxPoint& pos = wxDefaultPosition);
2736
2737 /**
2738 Returns the position in screen coordinates at which the menu should be shown.
2739 Use wxWindow::ScreenToClient to convert to client coordinates.
2740
2741 You can also omit a position from wxWindow::PopupMenu in order to use
2742 the current mouse pointer position.
2743
2744 If the event originated from a keyboard event, the value returned from this
2745 function will be wxDefaultPosition.
2746 */
2747 const wxPoint& GetPosition() const;
2748
2749 /**
2750 Sets the position at which the menu should be shown.
2751 */
2752 void SetPosition(const wxPoint& point);
2753 };
2754
2755
2756
2757 /**
2758 @class wxEraseEvent
2759
2760 An erase event is sent when a window's background needs to be repainted.
2761
2762 On some platforms, such as GTK+, this event is simulated (simply generated just
2763 before the paint event) and may cause flicker. It is therefore recommended that
2764 you set the text background colour explicitly in order to prevent flicker.
2765 The default background colour under GTK+ is grey.
2766
2767 To intercept this event, use the EVT_ERASE_BACKGROUND macro in an event table
2768 definition.
2769
2770 You must call wxEraseEvent::GetDC and use the returned device context if it is
2771 non-@NULL. If it is @NULL, create your own temporary wxClientDC object.
2772
2773 @remarks
2774 Use the device context returned by GetDC to draw on, don't create
2775 a wxPaintDC in the event handler.
2776
2777 @beginEventTable{wxEraseEvent}
2778 @event{EVT_ERASE_BACKGROUND(func)}
2779 Process a @c wxEVT_ERASE_BACKGROUND event.
2780 @endEventTable
2781
2782 @library{wxcore}
2783 @category{events}
2784
2785 @see @ref overview_events
2786 */
2787 class wxEraseEvent : public wxEvent
2788 {
2789 public:
2790 /**
2791 Constructor.
2792 */
2793 wxEraseEvent(int id = 0, wxDC* dc = NULL);
2794
2795 /**
2796 Returns the device context associated with the erase event to draw on.
2797 */
2798 wxDC* GetDC() const;
2799 };
2800
2801
2802
2803 /**
2804 @class wxFocusEvent
2805
2806 A focus event is sent when a window's focus changes. The window losing focus
2807 receives a "kill focus" event while the window gaining it gets a "set focus" one.
2808
2809 Notice that the set focus event happens both when the user gives focus to the
2810 window (whether using the mouse or keyboard) and when it is done from the
2811 program itself using wxWindow::SetFocus.
2812
2813 @beginEventTable{wxFocusEvent}
2814 @event{EVT_SET_FOCUS(func)}
2815 Process a @c wxEVT_SET_FOCUS event.
2816 @event{EVT_KILL_FOCUS(func)}
2817 Process a @c wxEVT_KILL_FOCUS event.
2818 @endEventTable
2819
2820 @library{wxcore}
2821 @category{events}
2822
2823 @see @ref overview_events
2824 */
2825 class wxFocusEvent : public wxEvent
2826 {
2827 public:
2828 /**
2829 Constructor.
2830 */
2831 wxFocusEvent(wxEventType eventType = wxEVT_NULL, int id = 0);
2832
2833 /**
2834 Returns the window associated with this event, that is the window which had the
2835 focus before for the @c wxEVT_SET_FOCUS event and the window which is
2836 going to receive focus for the @c wxEVT_KILL_FOCUS one.
2837
2838 Warning: the window pointer may be @NULL!
2839 */
2840 wxWindow *GetWindow() const;
2841
2842 void SetWindow(wxWindow *win);
2843 };
2844
2845
2846
2847 /**
2848 @class wxChildFocusEvent
2849
2850 A child focus event is sent to a (parent-)window when one of its child windows
2851 gains focus, so that the window could restore the focus back to its corresponding
2852 child if it loses it now and regains later.
2853
2854 Notice that child window is the direct child of the window receiving event.
2855 Use wxWindow::FindFocus() to retreive the window which is actually getting focus.
2856
2857 @beginEventTable{wxChildFocusEvent}
2858 @event{EVT_CHILD_FOCUS(func)}
2859 Process a @c wxEVT_CHILD_FOCUS event.
2860 @endEventTable
2861
2862 @library{wxcore}
2863 @category{events}
2864
2865 @see @ref overview_events
2866 */
2867 class wxChildFocusEvent : public wxCommandEvent
2868 {
2869 public:
2870 /**
2871 Constructor.
2872
2873 @param win
2874 The direct child which is (or which contains the window which is) receiving
2875 the focus.
2876 */
2877 wxChildFocusEvent(wxWindow* win = NULL);
2878
2879 /**
2880 Returns the direct child which receives the focus, or a (grand-)parent of the
2881 control receiving the focus.
2882
2883 To get the actually focused control use wxWindow::FindFocus.
2884 */
2885 wxWindow *GetWindow() const;
2886 };
2887
2888
2889
2890 /**
2891 @class wxMouseCaptureLostEvent
2892
2893 An mouse capture lost event is sent to a window that obtained mouse capture,
2894 which was subsequently loss due to "external" event, for example when a dialog
2895 box is shown or if another application captures the mouse.
2896
2897 If this happens, this event is sent to all windows that are on capture stack
2898 (i.e. called CaptureMouse, but didn't call ReleaseMouse yet). The event is
2899 not sent if the capture changes because of a call to CaptureMouse or
2900 ReleaseMouse.
2901
2902 This event is currently emitted under Windows only.
2903
2904 @beginEventTable{wxMouseCaptureLostEvent}
2905 @event{EVT_MOUSE_CAPTURE_LOST(func)}
2906 Process a @c wxEVT_MOUSE_CAPTURE_LOST event.
2907 @endEventTable
2908
2909 @onlyfor{wxmsw}
2910
2911 @library{wxcore}
2912 @category{events}
2913
2914 @see wxMouseCaptureChangedEvent, @ref overview_events,
2915 wxWindow::CaptureMouse, wxWindow::ReleaseMouse, wxWindow::GetCapture
2916 */
2917 class wxMouseCaptureLostEvent : public wxEvent
2918 {
2919 public:
2920 /**
2921 Constructor.
2922 */
2923 wxMouseCaptureLostEvent(wxWindowID windowId = 0);
2924 };
2925
2926
2927
2928 class wxDisplayChangedEvent : public wxEvent
2929 {
2930 public:
2931 wxDisplayChangedEvent();
2932 };
2933
2934
2935 class wxPaletteChangedEvent : public wxEvent
2936 {
2937 public:
2938 wxPaletteChangedEvent(wxWindowID winid = 0);
2939
2940 void SetChangedWindow(wxWindow* win);
2941 wxWindow* GetChangedWindow() const;
2942 };
2943
2944
2945 class wxQueryNewPaletteEvent : public wxEvent
2946 {
2947 public:
2948 wxQueryNewPaletteEvent(wxWindowID winid = 0);
2949
2950 void SetPaletteRealized(bool realized);
2951 bool GetPaletteRealized();
2952 };
2953
2954
2955
2956
2957 /**
2958 @class wxNotifyEvent
2959
2960 This class is not used by the event handlers by itself, but is a base class
2961 for other event classes (such as wxBookCtrlEvent).
2962
2963 It (or an object of a derived class) is sent when the controls state is being
2964 changed and allows the program to wxNotifyEvent::Veto() this change if it wants
2965 to prevent it from happening.
2966
2967 @library{wxcore}
2968 @category{events}
2969
2970 @see wxBookCtrlEvent
2971 */
2972 class wxNotifyEvent : public wxCommandEvent
2973 {
2974 public:
2975 /**
2976 Constructor (used internally by wxWidgets only).
2977 */
2978 wxNotifyEvent(wxEventType eventType = wxEVT_NULL, int id = 0);
2979
2980 /**
2981 This is the opposite of Veto(): it explicitly allows the event to be processed.
2982 For most events it is not necessary to call this method as the events are allowed
2983 anyhow but some are forbidden by default (this will be mentioned in the corresponding
2984 event description).
2985 */
2986 void Allow();
2987
2988 /**
2989 Returns @true if the change is allowed (Veto() hasn't been called) or @false
2990 otherwise (if it was).
2991 */
2992 bool IsAllowed() const;
2993
2994 /**
2995 Prevents the change announced by this event from happening.
2996
2997 It is in general a good idea to notify the user about the reasons for vetoing
2998 the change because otherwise the applications behaviour (which just refuses to
2999 do what the user wants) might be quite surprising.
3000 */
3001 void Veto();
3002 };
3003
3004
3005 /**
3006 @class wxThreadEvent
3007
3008 This class adds some simple functionalities to wxCommandEvent coinceived
3009 for inter-threads communications.
3010
3011 This event is not natively emitted by any control/class: this is just
3012 an helper class for the user.
3013 Its most important feature is the GetEventCategory() implementation which
3014 allows thread events to @b NOT be processed by wxEventLoopBase::YieldFor calls
3015 (unless the @c wxEVT_CATEGORY_THREAD is specified - which is never in wx code).
3016
3017 @library{wxcore}
3018 @category{events,threading}
3019
3020 @see @ref overview_thread, wxEventLoopBase::YieldFor
3021 */
3022 class wxThreadEvent : public wxCommandEvent
3023 {
3024 public:
3025 /**
3026 Constructor.
3027 */
3028 wxThreadEvent(wxEventType eventType = wxEVT_COMMAND_THREAD, int id = wxID_ANY);
3029
3030 /**
3031 Clones this event making sure that all internal members which use
3032 COW (only @c m_commandString for now; see @ref overview_refcount)
3033 are unshared (see wxObject::UnShare).
3034 */
3035 virtual wxEvent *Clone() const;
3036
3037 /**
3038 Returns @c wxEVT_CATEGORY_THREAD.
3039
3040 This is important to avoid unwanted processing of thread events
3041 when calling wxEventLoopBase::YieldFor().
3042 */
3043 virtual wxEventCategory GetEventCategory() const;
3044
3045 /**
3046 Sets custom data payload.
3047
3048 The @a payload argument may be of any type that wxAny can handle
3049 (i.e. pretty much anything). Note that T's copy constructor must be
3050 thread-safe, i.e. create a copy that doesn't share anything with
3051 the original (see Clone()).
3052
3053 @note This method is not available with Visual C++ 6.
3054
3055 @since 2.9.1
3056
3057 @see GetPayload(), wxAny
3058 */
3059 template<typename T>
3060 void SetPayload(const T& payload);
3061
3062 /**
3063 Get custom data payload.
3064
3065 Correct type is checked in debug builds.
3066
3067 @note This method is not available with Visual C++ 6.
3068
3069 @since 2.9.1
3070
3071 @see SetPayload(), wxAny
3072 */
3073 template<typename T>
3074 T GetPayload() const;
3075 };
3076
3077
3078 /**
3079 @class wxHelpEvent
3080
3081 A help event is sent when the user has requested context-sensitive help.
3082 This can either be caused by the application requesting context-sensitive help mode
3083 via wxContextHelp, or (on MS Windows) by the system generating a WM_HELP message when
3084 the user pressed F1 or clicked on the query button in a dialog caption.
3085
3086 A help event is sent to the window that the user clicked on, and is propagated
3087 up the window hierarchy until the event is processed or there are no more event
3088 handlers.
3089
3090 The application should call wxEvent::GetId to check the identity of the
3091 clicked-on window, and then either show some suitable help or call wxEvent::Skip()
3092 if the identifier is unrecognised.
3093
3094 Calling Skip is important because it allows wxWidgets to generate further
3095 events for ancestors of the clicked-on window. Otherwise it would be impossible to
3096 show help for container windows, since processing would stop after the first window
3097 found.
3098
3099 @beginEventTable{wxHelpEvent}
3100 @event{EVT_HELP(id, func)}
3101 Process a @c wxEVT_HELP event.
3102 @event{EVT_HELP_RANGE(id1, id2, func)}
3103 Process a @c wxEVT_HELP event for a range of ids.
3104 @endEventTable
3105
3106 @library{wxcore}
3107 @category{events}
3108
3109 @see wxContextHelp, wxDialog, @ref overview_events
3110 */
3111 class wxHelpEvent : public wxCommandEvent
3112 {
3113 public:
3114 /**
3115 Indicates how a wxHelpEvent was generated.
3116 */
3117 enum Origin
3118 {
3119 Origin_Unknown, /**< unrecognized event source. */
3120 Origin_Keyboard, /**< event generated from F1 key press. */
3121
3122 /** event generated by wxContextHelp or from the [?] button on
3123 the title bar (Windows). */
3124 Origin_HelpButton
3125 };
3126
3127 /**
3128 Constructor.
3129 */
3130 wxHelpEvent(wxEventType type = wxEVT_NULL,
3131 wxWindowID winid = 0,
3132 const wxPoint& pt = wxDefaultPosition,
3133 wxHelpEvent::Origin origin = Origin_Unknown);
3134
3135 /**
3136 Returns the origin of the help event which is one of the ::wxHelpEventOrigin
3137 values.
3138
3139 The application may handle events generated using the keyboard or mouse
3140 differently, e.g. by using wxGetMousePosition() for the mouse events.
3141
3142 @see SetOrigin()
3143 */
3144 wxHelpEvent::Origin GetOrigin() const;
3145
3146 /**
3147 Returns the left-click position of the mouse, in screen coordinates.
3148 This allows the application to position the help appropriately.
3149 */
3150 const wxPoint& GetPosition() const;
3151
3152 /**
3153 Set the help event origin, only used internally by wxWidgets normally.
3154
3155 @see GetOrigin()
3156 */
3157 void SetOrigin(wxHelpEvent::Origin origin);
3158
3159 /**
3160 Sets the left-click position of the mouse, in screen coordinates.
3161 */
3162 void SetPosition(const wxPoint& pt);
3163 };
3164
3165
3166
3167 /**
3168 @class wxScrollEvent
3169
3170 A scroll event holds information about events sent from stand-alone
3171 scrollbars (see wxScrollBar) and sliders (see wxSlider).
3172
3173 Note that scrolled windows send the wxScrollWinEvent which does not derive from
3174 wxCommandEvent, but from wxEvent directly - don't confuse these two kinds of
3175 events and use the event table macros mentioned below only for the scrollbar-like
3176 controls.
3177
3178 @section scrollevent_diff The difference between EVT_SCROLL_THUMBRELEASE and EVT_SCROLL_CHANGED
3179
3180 The EVT_SCROLL_THUMBRELEASE event is only emitted when actually dragging the thumb
3181 using the mouse and releasing it (This EVT_SCROLL_THUMBRELEASE event is also followed
3182 by an EVT_SCROLL_CHANGED event).
3183
3184 The EVT_SCROLL_CHANGED event also occurs when using the keyboard to change the thumb
3185 position, and when clicking next to the thumb (In all these cases the EVT_SCROLL_THUMBRELEASE
3186 event does not happen).
3187
3188 In short, the EVT_SCROLL_CHANGED event is triggered when scrolling/ moving has finished
3189 independently of the way it had started. Please see the widgets sample ("Slider" page)
3190 to see the difference between EVT_SCROLL_THUMBRELEASE and EVT_SCROLL_CHANGED in action.
3191
3192 @remarks
3193 Note that unless specifying a scroll control identifier, you will need to test for scrollbar
3194 orientation with wxScrollEvent::GetOrientation, since horizontal and vertical scroll events
3195 are processed using the same event handler.
3196
3197 @beginEventTable{wxScrollEvent}
3198 You can use EVT_COMMAND_SCROLL... macros with window IDs for when intercepting
3199 scroll events from controls, or EVT_SCROLL... macros without window IDs for
3200 intercepting scroll events from the receiving window -- except for this, the
3201 macros behave exactly the same.
3202 @event{EVT_SCROLL(func)}
3203 Process all scroll events.
3204 @event{EVT_SCROLL_TOP(func)}
3205 Process wxEVT_SCROLL_TOP scroll-to-top events (minimum position).
3206 @event{EVT_SCROLL_BOTTOM(func)}
3207 Process wxEVT_SCROLL_BOTTOM scroll-to-bottom events (maximum position).
3208 @event{EVT_SCROLL_LINEUP(func)}
3209 Process wxEVT_SCROLL_LINEUP line up events.
3210 @event{EVT_SCROLL_LINEDOWN(func)}
3211 Process wxEVT_SCROLL_LINEDOWN line down events.
3212 @event{EVT_SCROLL_PAGEUP(func)}
3213 Process wxEVT_SCROLL_PAGEUP page up events.
3214 @event{EVT_SCROLL_PAGEDOWN(func)}
3215 Process wxEVT_SCROLL_PAGEDOWN page down events.
3216 @event{EVT_SCROLL_THUMBTRACK(func)}
3217 Process wxEVT_SCROLL_THUMBTRACK thumbtrack events (frequent events sent as the
3218 user drags the thumbtrack).
3219 @event{EVT_SCROLL_THUMBRELEASE(func)}
3220 Process wxEVT_SCROLL_THUMBRELEASE thumb release events.
3221 @event{EVT_SCROLL_CHANGED(func)}
3222 Process wxEVT_SCROLL_CHANGED end of scrolling events (MSW only).
3223 @event{EVT_COMMAND_SCROLL(id, func)}
3224 Process all scroll events.
3225 @event{EVT_COMMAND_SCROLL_TOP(id, func)}
3226 Process wxEVT_SCROLL_TOP scroll-to-top events (minimum position).
3227 @event{EVT_COMMAND_SCROLL_BOTTOM(id, func)}
3228 Process wxEVT_SCROLL_BOTTOM scroll-to-bottom events (maximum position).
3229 @event{EVT_COMMAND_SCROLL_LINEUP(id, func)}
3230 Process wxEVT_SCROLL_LINEUP line up events.
3231 @event{EVT_COMMAND_SCROLL_LINEDOWN(id, func)}
3232 Process wxEVT_SCROLL_LINEDOWN line down events.
3233 @event{EVT_COMMAND_SCROLL_PAGEUP(id, func)}
3234 Process wxEVT_SCROLL_PAGEUP page up events.
3235 @event{EVT_COMMAND_SCROLL_PAGEDOWN(id, func)}
3236 Process wxEVT_SCROLL_PAGEDOWN page down events.
3237 @event{EVT_COMMAND_SCROLL_THUMBTRACK(id, func)}
3238 Process wxEVT_SCROLL_THUMBTRACK thumbtrack events (frequent events sent
3239 as the user drags the thumbtrack).
3240 @event{EVT_COMMAND_SCROLL_THUMBRELEASE(func)}
3241 Process wxEVT_SCROLL_THUMBRELEASE thumb release events.
3242 @event{EVT_COMMAND_SCROLL_CHANGED(func)}
3243 Process wxEVT_SCROLL_CHANGED end of scrolling events (MSW only).
3244 @endEventTable
3245
3246 @library{wxcore}
3247 @category{events}
3248
3249 @see wxScrollBar, wxSlider, wxSpinButton, wxScrollWinEvent, @ref overview_events
3250 */
3251 class wxScrollEvent : public wxCommandEvent
3252 {
3253 public:
3254 /**
3255 Constructor.
3256 */
3257 wxScrollEvent(wxEventType commandType = wxEVT_NULL, int id = 0, int pos = 0,
3258 int orientation = 0);
3259
3260 /**
3261 Returns wxHORIZONTAL or wxVERTICAL, depending on the orientation of the
3262 scrollbar.
3263 */
3264 int GetOrientation() const;
3265
3266 /**
3267 Returns the position of the scrollbar.
3268 */
3269 int GetPosition() const;
3270
3271
3272 void SetOrientation(int orient);
3273 void SetPosition(int pos);
3274 };
3275
3276 /**
3277 See wxIdleEvent::SetMode() for more info.
3278 */
3279 enum wxIdleMode
3280 {
3281 /** Send idle events to all windows */
3282 wxIDLE_PROCESS_ALL,
3283
3284 /** Send idle events to windows that have the wxWS_EX_PROCESS_IDLE flag specified */
3285 wxIDLE_PROCESS_SPECIFIED
3286 };
3287
3288
3289 /**
3290 @class wxIdleEvent
3291
3292 This class is used for idle events, which are generated when the system becomes
3293 idle. Note that, unless you do something specifically, the idle events are not
3294 sent if the system remains idle once it has become it, e.g. only a single idle
3295 event will be generated until something else resulting in more normal events
3296 happens and only then is the next idle event sent again.
3297
3298 If you need to ensure a continuous stream of idle events, you can either use
3299 wxIdleEvent::RequestMore method in your handler or call wxWakeUpIdle() periodically
3300 (for example from a timer event handler), but note that both of these approaches
3301 (and especially the first one) increase the system load and so should be avoided
3302 if possible.
3303
3304 By default, idle events are sent to all windows (and also wxApp, as usual).
3305 If this is causing a significant overhead in your application, you can call
3306 wxIdleEvent::SetMode with the value wxIDLE_PROCESS_SPECIFIED, and set the
3307 wxWS_EX_PROCESS_IDLE extra window style for every window which should receive
3308 idle events.
3309
3310 @beginEventTable{wxIdleEvent}
3311 @event{EVT_IDLE(func)}
3312 Process a @c wxEVT_IDLE event.
3313 @endEventTable
3314
3315 @library{wxbase}
3316 @category{events}
3317
3318 @see @ref overview_events, wxUpdateUIEvent, wxWindow::OnInternalIdle
3319 */
3320 class wxIdleEvent : public wxEvent
3321 {
3322 public:
3323 /**
3324 Constructor.
3325 */
3326 wxIdleEvent();
3327
3328 /**
3329 Static function returning a value specifying how wxWidgets will send idle
3330 events: to all windows, or only to those which specify that they
3331 will process the events.
3332
3333 @see SetMode().
3334 */
3335 static wxIdleMode GetMode();
3336
3337 /**
3338 Returns @true if the OnIdle function processing this event requested more
3339 processing time.
3340
3341 @see RequestMore()
3342 */
3343 bool MoreRequested() const;
3344
3345 /**
3346 Tells wxWidgets that more processing is required.
3347
3348 This function can be called by an OnIdle handler for a window or window event
3349 handler to indicate that wxApp::OnIdle should forward the OnIdle event once
3350 more to the application windows.
3351
3352 If no window calls this function during OnIdle, then the application will
3353 remain in a passive event loop (not calling OnIdle) until a new event is
3354 posted to the application by the windowing system.
3355
3356 @see MoreRequested()
3357 */
3358 void RequestMore(bool needMore = true);
3359
3360 /**
3361 Static function for specifying how wxWidgets will send idle events: to
3362 all windows, or only to those which specify that they will process the events.
3363
3364 @param mode
3365 Can be one of the ::wxIdleMode values.
3366 The default is wxIDLE_PROCESS_ALL.
3367 */
3368 static void SetMode(wxIdleMode mode);
3369 };
3370
3371
3372
3373 /**
3374 @class wxInitDialogEvent
3375
3376 A wxInitDialogEvent is sent as a dialog or panel is being initialised.
3377 Handlers for this event can transfer data to the window.
3378
3379 The default handler calls wxWindow::TransferDataToWindow.
3380
3381 @beginEventTable{wxInitDialogEvent}
3382 @event{EVT_INIT_DIALOG(func)}
3383 Process a @c wxEVT_INIT_DIALOG event.
3384 @endEventTable
3385
3386 @library{wxcore}
3387 @category{events}
3388
3389 @see @ref overview_events
3390 */
3391 class wxInitDialogEvent : public wxEvent
3392 {
3393 public:
3394 /**
3395 Constructor.
3396 */
3397 wxInitDialogEvent(int id = 0);
3398 };
3399
3400
3401
3402 /**
3403 @class wxWindowDestroyEvent
3404
3405 This event is sent as early as possible during the window destruction
3406 process.
3407
3408 For the top level windows, as early as possible means that this is done by
3409 wxFrame or wxDialog destructor, i.e. after the destructor of the derived
3410 class was executed and so any methods specific to the derived class can't
3411 be called any more from this event handler. If you need to do this, you
3412 must call wxWindow::SendDestroyEvent() from your derived class destructor.
3413
3414 For the child windows, this event is generated just before deleting the
3415 window from wxWindow::Destroy() (which is also called when the parent
3416 window is deleted) or from the window destructor if operator @c delete was
3417 used directly (which is not recommended for this very reason).
3418
3419 It is usually pointless to handle this event in the window itself but it ca
3420 be very useful to receive notifications about the window destruction in the
3421 parent window or in any other object interested in this window.
3422
3423 @library{wxcore}
3424 @category{events}
3425
3426 @see @ref overview_events, wxWindowCreateEvent
3427 */
3428 class wxWindowDestroyEvent : public wxCommandEvent
3429 {
3430 public:
3431 /**
3432 Constructor.
3433 */
3434 wxWindowDestroyEvent(wxWindow* win = NULL);
3435
3436 /// Retutn the window being destroyed.
3437 wxWindow *GetWindow() const;
3438 };
3439
3440
3441 /**
3442 @class wxNavigationKeyEvent
3443
3444 This event class contains information about navigation events,
3445 generated by navigation keys such as tab and page down.
3446
3447 This event is mainly used by wxWidgets implementations.
3448 A wxNavigationKeyEvent handler is automatically provided by wxWidgets
3449 when you make a class into a control container with the macro
3450 WX_DECLARE_CONTROL_CONTAINER.
3451
3452 @beginEventTable{wxNavigationKeyEvent}
3453 @event{EVT_NAVIGATION_KEY(func)}
3454 Process a navigation key event.
3455 @endEventTable
3456
3457 @library{wxcore}
3458 @category{events}
3459
3460 @see wxWindow::Navigate, wxWindow::NavigateIn
3461 */
3462 class wxNavigationKeyEvent : public wxEvent
3463 {
3464 public:
3465 /**
3466 Flags which can be used with wxNavigationKeyEvent.
3467 */
3468 enum wxNavigationKeyEventFlags
3469 {
3470 IsBackward = 0x0000,
3471 IsForward = 0x0001,
3472 WinChange = 0x0002,
3473 FromTab = 0x0004
3474 };
3475
3476 wxNavigationKeyEvent();
3477 wxNavigationKeyEvent(const wxNavigationKeyEvent& event);
3478
3479 /**
3480 Returns the child that has the focus, or @NULL.
3481 */
3482 wxWindow* GetCurrentFocus() const;
3483
3484 /**
3485 Returns @true if the navigation was in the forward direction.
3486 */
3487 bool GetDirection() const;
3488
3489 /**
3490 Returns @true if the navigation event was from a tab key.
3491 This is required for proper navigation over radio buttons.
3492 */
3493 bool IsFromTab() const;
3494
3495 /**
3496 Returns @true if the navigation event represents a window change
3497 (for example, from Ctrl-Page Down in a notebook).
3498 */
3499 bool IsWindowChange() const;
3500
3501 /**
3502 Sets the current focus window member.
3503 */
3504 void SetCurrentFocus(wxWindow* currentFocus);
3505
3506 /**
3507 Sets the direction to forward if @a direction is @true, or backward
3508 if @false.
3509 */
3510 void SetDirection(bool direction);
3511
3512 /**
3513 Sets the flags for this event.
3514 The @a flags can be a combination of the ::wxNavigationKeyEventFlags values.
3515 */
3516 void SetFlags(long flags);
3517
3518 /**
3519 Marks the navigation event as from a tab key.
3520 */
3521 void SetFromTab(bool fromTab);
3522
3523 /**
3524 Marks the event as a window change event.
3525 */
3526 void SetWindowChange(bool windowChange);
3527 };
3528
3529
3530
3531 /**
3532 @class wxMouseCaptureChangedEvent
3533
3534 An mouse capture changed event is sent to a window that loses its
3535 mouse capture. This is called even if wxWindow::ReleaseMouse
3536 was called by the application code. Handling this event allows
3537 an application to cater for unexpected capture releases which
3538 might otherwise confuse mouse handling code.
3539
3540 @onlyfor{wxmsw}
3541
3542 @beginEventTable{wxMouseCaptureChangedEvent}
3543 @event{EVT_MOUSE_CAPTURE_CHANGED(func)}
3544 Process a @c wxEVT_MOUSE_CAPTURE_CHANGED event.
3545 @endEventTable
3546
3547 @library{wxcore}
3548 @category{events}
3549
3550 @see wxMouseCaptureLostEvent, @ref overview_events,
3551 wxWindow::CaptureMouse, wxWindow::ReleaseMouse, wxWindow::GetCapture
3552 */
3553 class wxMouseCaptureChangedEvent : public wxEvent
3554 {
3555 public:
3556 /**
3557 Constructor.
3558 */
3559 wxMouseCaptureChangedEvent(wxWindowID windowId = 0,
3560 wxWindow* gainedCapture = NULL);
3561
3562 /**
3563 Returns the window that gained the capture, or @NULL if it was a
3564 non-wxWidgets window.
3565 */
3566 wxWindow* GetCapturedWindow() const;
3567 };
3568
3569
3570
3571 /**
3572 @class wxCloseEvent
3573
3574 This event class contains information about window and session close events.
3575
3576 The handler function for EVT_CLOSE is called when the user has tried to close a
3577 a frame or dialog box using the window manager (X) or system menu (Windows).
3578 It can also be invoked by the application itself programmatically, for example by
3579 calling the wxWindow::Close function.
3580
3581 You should check whether the application is forcing the deletion of the window
3582 using wxCloseEvent::CanVeto. If this is @false, you @e must destroy the window
3583 using wxWindow::Destroy.
3584
3585 If the return value is @true, it is up to you whether you respond by destroying
3586 the window.
3587
3588 If you don't destroy the window, you should call wxCloseEvent::Veto to
3589 let the calling code know that you did not destroy the window.
3590 This allows the wxWindow::Close function to return @true or @false depending
3591 on whether the close instruction was honoured or not.
3592
3593 Example of a wxCloseEvent handler:
3594
3595 @code
3596 void MyFrame::OnClose(wxCloseEvent& event)
3597 {
3598 if ( event.CanVeto() && m_bFileNotSaved )
3599 {
3600 if ( wxMessageBox("The file has not been saved... continue closing?",
3601 "Please confirm",
3602 wxICON_QUESTION | wxYES_NO) != wxYES )
3603 {
3604 event.Veto();
3605 return;
3606 }
3607 }
3608
3609 Destroy(); // you may also do: event.Skip();
3610 // since the default event handler does call Destroy(), too
3611 }
3612 @endcode
3613
3614 The EVT_END_SESSION event is slightly different as it is sent by the system
3615 when the user session is ending (e.g. because of log out or shutdown) and
3616 so all windows are being forcefully closed. At least under MSW, after the
3617 handler for this event is executed the program is simply killed by the
3618 system. Because of this, the default handler for this event provided by
3619 wxWidgets calls all the usual cleanup code (including wxApp::OnExit()) so
3620 that it could still be executed and exit()s the process itself, without
3621 waiting for being killed. If this behaviour is for some reason undesirable,
3622 make sure that you define a handler for this event in your wxApp-derived
3623 class and do not call @c event.Skip() in it (but be aware that the system
3624 will still kill your application).
3625
3626 @beginEventTable{wxCloseEvent}
3627 @event{EVT_CLOSE(func)}
3628 Process a @c wxEVT_CLOSE_WINDOW command event, supplying the member function.
3629 This event applies to wxFrame and wxDialog classes.
3630 @event{EVT_QUERY_END_SESSION(func)}
3631 Process a @c wxEVT_QUERY_END_SESSION session event, supplying the member function.
3632 This event can be handled in wxApp-derived class only.
3633 @event{EVT_END_SESSION(func)}
3634 Process a @c wxEVT_END_SESSION session event, supplying the member function.
3635 This event can be handled in wxApp-derived class only.
3636 @endEventTable
3637
3638 @library{wxcore}
3639 @category{events}
3640
3641 @see wxWindow::Close, @ref overview_windowdeletion
3642 */
3643 class wxCloseEvent : public wxEvent
3644 {
3645 public:
3646 /**
3647 Constructor.
3648 */
3649 wxCloseEvent(wxEventType commandEventType = wxEVT_NULL, int id = 0);
3650
3651 /**
3652 Returns @true if you can veto a system shutdown or a window close event.
3653 Vetoing a window close event is not possible if the calling code wishes to
3654 force the application to exit, and so this function must be called to check this.
3655 */
3656 bool CanVeto() const;
3657
3658 /**
3659 Returns @true if the user is just logging off or @false if the system is
3660 shutting down. This method can only be called for end session and query end
3661 session events, it doesn't make sense for close window event.
3662 */
3663 bool GetLoggingOff() const;
3664
3665 /**
3666 Sets the 'can veto' flag.
3667 */
3668 void SetCanVeto(bool canVeto);
3669
3670 /**
3671 Sets the 'logging off' flag.
3672 */
3673 void SetLoggingOff(bool loggingOff);
3674
3675 /**
3676 Call this from your event handler to veto a system shutdown or to signal
3677 to the calling application that a window close did not happen.
3678
3679 You can only veto a shutdown if CanVeto() returns @true.
3680 */
3681 void Veto(bool veto = true);
3682 };
3683
3684
3685
3686 /**
3687 @class wxMenuEvent
3688
3689 This class is used for a variety of menu-related events. Note that
3690 these do not include menu command events, which are
3691 handled using wxCommandEvent objects.
3692
3693 The default handler for @c wxEVT_MENU_HIGHLIGHT displays help
3694 text in the first field of the status bar.
3695
3696 @beginEventTable{wxMenuEvent}
3697 @event{EVT_MENU_OPEN(func)}
3698 A menu is about to be opened. On Windows, this is only sent once for each
3699 navigation of the menubar (up until all menus have closed).
3700 @event{EVT_MENU_CLOSE(func)}
3701 A menu has been just closed.
3702 @event{EVT_MENU_HIGHLIGHT(id, func)}
3703 The menu item with the specified id has been highlighted: used to show
3704 help prompts in the status bar by wxFrame
3705 @event{EVT_MENU_HIGHLIGHT_ALL(func)}
3706 A menu item has been highlighted, i.e. the currently selected menu item has changed.
3707 @endEventTable
3708
3709 @library{wxcore}
3710 @category{events}
3711
3712 @see wxCommandEvent, @ref overview_events
3713 */
3714 class wxMenuEvent : public wxEvent
3715 {
3716 public:
3717 /**
3718 Constructor.
3719 */
3720 wxMenuEvent(wxEventType type = wxEVT_NULL, int id = 0, wxMenu* menu = NULL);
3721
3722 /**
3723 Returns the menu which is being opened or closed. This method should only be
3724 used with the @c OPEN and @c CLOSE events and even for them the
3725 returned pointer may be @NULL in some ports.
3726 */
3727 wxMenu* GetMenu() const;
3728
3729 /**
3730 Returns the menu identifier associated with the event.
3731 This method should be only used with the @c HIGHLIGHT events.
3732 */
3733 int GetMenuId() const;
3734
3735 /**
3736 Returns @true if the menu which is being opened or closed is a popup menu,
3737 @false if it is a normal one.
3738
3739 This method should only be used with the @c OPEN and @c CLOSE events.
3740 */
3741 bool IsPopup() const;
3742 };
3743
3744 /**
3745 @class wxShowEvent
3746
3747 An event being sent when the window is shown or hidden.
3748 The event is triggered by calls to wxWindow::Show(), and any user
3749 action showing a previously hidden window or vice versa (if allowed by
3750 the current platform and/or window manager).
3751 Notice that the event is not triggered when the application is iconized
3752 (minimized) or restored under wxMSW.
3753
3754 Currently only wxMSW, wxGTK and wxOS2 generate such events.
3755
3756 @onlyfor{wxmsw,wxgtk,wxos2}
3757
3758 @beginEventTable{wxShowEvent}
3759 @event{EVT_SHOW(func)}
3760 Process a @c wxEVT_SHOW event.
3761 @endEventTable
3762
3763 @library{wxcore}
3764 @category{events}
3765
3766 @see @ref overview_events, wxWindow::Show,
3767 wxWindow::IsShown
3768 */
3769
3770 class wxShowEvent : public wxEvent
3771 {
3772 public:
3773 /**
3774 Constructor.
3775 */
3776 wxShowEvent(int winid = 0, bool show = false);
3777
3778 /**
3779 Set whether the windows was shown or hidden.
3780 */
3781 void SetShow(bool show);
3782
3783 /**
3784 Return @true if the window has been shown, @false if it has been
3785 hidden.
3786 */
3787 bool IsShown() const;
3788
3789 /**
3790 @deprecated This function is deprecated in favour of IsShown().
3791 */
3792 bool GetShow() const;
3793 };
3794
3795
3796
3797 /**
3798 @class wxIconizeEvent
3799
3800 An event being sent when the frame is iconized (minimized) or restored.
3801
3802 Currently only wxMSW and wxGTK generate such events.
3803
3804 @onlyfor{wxmsw,wxgtk}
3805
3806 @beginEventTable{wxIconizeEvent}
3807 @event{EVT_ICONIZE(func)}
3808 Process a @c wxEVT_ICONIZE event.
3809 @endEventTable
3810
3811 @library{wxcore}
3812 @category{events}
3813
3814 @see @ref overview_events, wxTopLevelWindow::Iconize,
3815 wxTopLevelWindow::IsIconized
3816 */
3817 class wxIconizeEvent : public wxEvent
3818 {
3819 public:
3820 /**
3821 Constructor.
3822 */
3823 wxIconizeEvent(int id = 0, bool iconized = true);
3824
3825 /**
3826 Returns @true if the frame has been iconized, @false if it has been
3827 restored.
3828 */
3829 bool IsIconized() const;
3830
3831 /**
3832 @deprecated This function is deprecated in favour of IsIconized().
3833 */
3834 bool Iconized() const;
3835 };
3836
3837
3838
3839 /**
3840 @class wxMoveEvent
3841
3842 A move event holds information about wxTopLevelWindow move change events.
3843
3844 @beginEventTable{wxMoveEvent}
3845 @event{EVT_MOVE(func)}
3846 Process a @c wxEVT_MOVE event, which is generated when a window is moved.
3847 @event{EVT_MOVE_START(func)}
3848 Process a @c wxEVT_MOVE_START event, which is generated when the user starts
3849 to move or size a window. wxMSW only.
3850 @event{EVT_MOVE_END(func)}
3851 Process a @c wxEVT_MOVE_END event, which is generated when the user stops
3852 moving or sizing a window. wxMSW only.
3853 @endEventTable
3854
3855 @library{wxcore}
3856 @category{events}
3857
3858 @see wxPoint, @ref overview_events
3859 */
3860 class wxMoveEvent : public wxEvent
3861 {
3862 public:
3863 /**
3864 Constructor.
3865 */
3866 wxMoveEvent(const wxPoint& pt, int id = 0);
3867
3868 /**
3869 Returns the position of the window generating the move change event.
3870 */
3871 wxPoint GetPosition() const;
3872
3873 wxRect GetRect() const;
3874 void SetRect(const wxRect& rect);
3875 void SetPosition(const wxPoint& pos);
3876 };
3877
3878
3879 /**
3880 @class wxSizeEvent
3881
3882 A size event holds information about size change events of wxWindow.
3883
3884 The EVT_SIZE handler function will be called when the window has been resized.
3885
3886 You may wish to use this for frames to resize their child windows as appropriate.
3887
3888 Note that the size passed is of the whole window: call wxWindow::GetClientSize()
3889 for the area which may be used by the application.
3890
3891 When a window is resized, usually only a small part of the window is damaged
3892 and you may only need to repaint that area. However, if your drawing depends on the
3893 size of the window, you may need to clear the DC explicitly and repaint the whole window.
3894 In which case, you may need to call wxWindow::Refresh to invalidate the entire window.
3895
3896 @beginEventTable{wxSizeEvent}
3897 @event{EVT_SIZE(func)}
3898 Process a @c wxEVT_SIZE event.
3899 @endEventTable
3900
3901 @library{wxcore}
3902 @category{events}
3903
3904 @see wxSize, @ref overview_events
3905 */
3906 class wxSizeEvent : public wxEvent
3907 {
3908 public:
3909 /**
3910 Constructor.
3911 */
3912 wxSizeEvent(const wxSize& sz, int id = 0);
3913
3914 /**
3915 Returns the entire size of the window generating the size change event.
3916
3917 This is the new total size of the window, i.e. the same size as would
3918 be returned by wxWindow::GetSize() if it were called now. Use
3919 wxWindow::GetClientSize() if you catch this event in a top level window
3920 such as wxFrame to find the size available for the window contents.
3921 */
3922 wxSize GetSize() const;
3923 void SetSize(wxSize size);
3924
3925 wxRect GetRect() const;
3926 void SetRect(wxRect rect);
3927 };
3928
3929
3930
3931 /**
3932 @class wxSetCursorEvent
3933
3934 A wxSetCursorEvent is generated from wxWindow when the mouse cursor is about
3935 to be set as a result of mouse motion.
3936
3937 This event gives the application the chance to perform specific mouse cursor
3938 processing based on the current position of the mouse within the window.
3939 Use wxSetCursorEvent::SetCursor to specify the cursor you want to be displayed.
3940
3941 @beginEventTable{wxSetCursorEvent}
3942 @event{EVT_SET_CURSOR(func)}
3943 Process a @c wxEVT_SET_CURSOR event.
3944 @endEventTable
3945
3946 @library{wxcore}
3947 @category{events}
3948
3949 @see ::wxSetCursor, wxWindow::wxSetCursor
3950 */
3951 class wxSetCursorEvent : public wxEvent
3952 {
3953 public:
3954 /**
3955 Constructor, used by the library itself internally to initialize the event
3956 object.
3957 */
3958 wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0);
3959
3960 /**
3961 Returns a reference to the cursor specified by this event.
3962 */
3963 const wxCursor& GetCursor() const;
3964
3965 /**
3966 Returns the X coordinate of the mouse in client coordinates.
3967 */
3968 wxCoord GetX() const;
3969
3970 /**
3971 Returns the Y coordinate of the mouse in client coordinates.
3972 */
3973 wxCoord GetY() const;
3974
3975 /**
3976 Returns @true if the cursor specified by this event is a valid cursor.
3977
3978 @remarks You cannot specify wxNullCursor with this event, as it is not
3979 considered a valid cursor.
3980 */
3981 bool HasCursor() const;
3982
3983 /**
3984 Sets the cursor associated with this event.
3985 */
3986 void SetCursor(const wxCursor& cursor);
3987 };
3988
3989
3990
3991 // ============================================================================
3992 // Global functions/macros
3993 // ============================================================================
3994
3995 /** @addtogroup group_funcmacro_events */
3996 //@{
3997
3998 /**
3999 A value uniquely identifying the type of the event.
4000
4001 The values of this type should only be created using wxNewEventType().
4002
4003 See the macro DEFINE_EVENT_TYPE() for more info.
4004
4005 @see @ref overview_events_introduction
4006 */
4007 typedef int wxEventType;
4008
4009 /**
4010 A special event type usually used to indicate that some wxEvent has yet
4011 no type assigned.
4012 */
4013 wxEventType wxEVT_NULL;
4014
4015 wxEventType wxEVT_ANY;
4016
4017 /**
4018 Generates a new unique event type.
4019
4020 Usually this function is only used by wxDEFINE_EVENT() and not called
4021 directly.
4022 */
4023 wxEventType wxNewEventType();
4024
4025 /**
4026 Define a new event type associated with the specified event class.
4027
4028 This macro defines a new unique event type @a name associated with the
4029 event class @a cls.
4030
4031 For example:
4032 @code
4033 wxDEFINE_EVENT(MY_COMMAND_EVENT, wxCommandEvent);
4034
4035 class MyCustomEvent : public wxEvent { ... };
4036 wxDEFINE_EVENT(MY_CUSTOM_EVENT, MyCustomEvent);
4037 @endcode
4038
4039 @see wxDECLARE_EVENT(), @ref overview_events_custom
4040 */
4041 #define wxDEFINE_EVENT(name, cls) \
4042 const wxEventTypeTag< cls > name(wxNewEventType())
4043
4044 /**
4045 Declares a custom event type.
4046
4047 This macro declares a variable called @a name which must be defined
4048 elsewhere using wxDEFINE_EVENT().
4049
4050 The class @a cls must be the wxEvent-derived class associated with the
4051 events of this type and its full declaration must be visible from the point
4052 of use of this macro.
4053
4054 For example:
4055 @code
4056 wxDECLARE_EVENT(MY_COMMAND_EVENT, wxCommandEvent);
4057
4058 class MyCustomEvent : public wxEvent { ... };
4059 wxDECLARE_EVENT(MY_CUSTOM_EVENT, MyCustomEvent);
4060 @endcode
4061 */
4062 #define wxDECLARE_EVENT(name, cls) \
4063 wxDECLARE_EXPORTED_EVENT(wxEMPTY_PARAMETER_VALUE, name, cls)
4064
4065 /**
4066 Variant of wxDECLARE_EVENT() used for event types defined inside a shared
4067 library.
4068
4069 This is mostly used by wxWidgets internally, e.g.
4070 @code
4071 wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEvent)
4072 @endcode
4073 */
4074 #define wxDECLARE_EXPORTED_EVENT( expdecl, name, cls ) \
4075 extern const expdecl wxEventTypeTag< cls > name;
4076
4077 /**
4078 Helper macro for definition of custom event table macros.
4079
4080 This macro must only be used if wxEVENTS_COMPATIBILITY_2_8 is 1, otherwise
4081 it is better and more clear to just use the address of the function
4082 directly as this is all this macro does in this case. However it needs to
4083 explicitly cast @a func to @a functype, which is the type of wxEvtHandler
4084 member function taking the custom event argument when
4085 wxEVENTS_COMPATIBILITY_2_8 is 0.
4086
4087 See wx__DECLARE_EVT0 for an example of use.
4088
4089 @see @ref overview_events_custom_ownclass
4090 */
4091 #define wxEVENT_HANDLER_CAST(functype, func) (&func)
4092
4093 /**
4094 This macro is used to define event table macros for handling custom
4095 events.
4096
4097 Example of use:
4098 @code
4099 class MyEvent : public wxEvent { ... };
4100
4101 // note that this is not necessary unless using old compilers: for the
4102 // reasonably new ones just use &func instead of MyEventHandler(func)
4103 typedef void (wxEvtHandler::*MyEventFunction)(MyEvent&);
4104 #define MyEventHandler(func) wxEVENT_HANDLER_CAST(MyEventFunction, func)
4105
4106 wxDEFINE_EVENT(MY_EVENT_TYPE, MyEvent);
4107
4108 #define EVT_MY(id, func) \
4109 wx__DECLARE_EVT1(MY_EVENT_TYPE, id, MyEventHandler(func))
4110
4111 ...
4112
4113 wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
4114 EVT_MY(wxID_ANY, MyFrame::OnMyEvent)
4115 wxEND_EVENT_TABLE()
4116 @endcode
4117
4118 @param evt
4119 The event type to handle.
4120 @param id
4121 The identifier of events to handle.
4122 @param fn
4123 The event handler method.
4124 */
4125 #define wx__DECLARE_EVT1(evt, id, fn) \
4126 wx__DECLARE_EVT2(evt, id, wxID_ANY, fn)
4127
4128 /**
4129 Generalized version of the wx__DECLARE_EVT1() macro taking a range of
4130 IDs instead of a single one.
4131 Argument @a id1 is the first identifier of the range, @a id2 is the
4132 second identifier of the range.
4133 */
4134 #define wx__DECLARE_EVT2(evt, id1, id2, fn) \
4135 DECLARE_EVENT_TABLE_ENTRY(evt, id1, id2, fn, NULL),
4136
4137 /**
4138 Simplified version of the wx__DECLARE_EVT1() macro, to be used when the
4139 event type must be handled regardless of the ID associated with the
4140 specific event instances.
4141 */
4142 #define wx__DECLARE_EVT0(evt, fn) \
4143 wx__DECLARE_EVT1(evt, wxID_ANY, fn)
4144
4145 /**
4146 Use this macro inside a class declaration to declare a @e static event table
4147 for that class.
4148
4149 In the implementation file you'll need to use the wxBEGIN_EVENT_TABLE()
4150 and the wxEND_EVENT_TABLE() macros, plus some additional @c EVT_xxx macro
4151 to capture events.
4152
4153 Note that this macro requires a final semicolon.
4154
4155 @see @ref overview_events_eventtables
4156 */
4157 #define wxDECLARE_EVENT_TABLE()
4158
4159 /**
4160 Use this macro in a source file to start listing @e static event handlers
4161 for a specific class.
4162
4163 Use wxEND_EVENT_TABLE() to terminate the event-declaration block.
4164
4165 @see @ref overview_events_eventtables
4166 */
4167 #define wxBEGIN_EVENT_TABLE(theClass, baseClass)
4168
4169 /**
4170 Use this macro in a source file to end listing @e static event handlers
4171 for a specific class.
4172
4173 Use wxBEGIN_EVENT_TABLE() to start the event-declaration block.
4174
4175 @see @ref overview_events_eventtables
4176 */
4177 #define wxEND_EVENT_TABLE()
4178
4179 /**
4180 In a GUI application, this function posts @a event to the specified @e dest
4181 object using wxEvtHandler::AddPendingEvent().
4182
4183 Otherwise, it dispatches @a event immediately using
4184 wxEvtHandler::ProcessEvent(). See the respective documentation for details
4185 (and caveats). Because of limitation of wxEvtHandler::AddPendingEvent()
4186 this function is not thread-safe for event objects having wxString fields,
4187 use wxQueueEvent() instead.
4188
4189 @header{wx/event.h}
4190 */
4191 void wxPostEvent(wxEvtHandler* dest, const wxEvent& event);
4192
4193 /**
4194 Queue an event for processing on the given object.
4195
4196 This is a wrapper around wxEvtHandler::QueueEvent(), see its documentation
4197 for more details.
4198
4199 @header{wx/event.h}
4200
4201 @param dest
4202 The object to queue the event on, can't be @c NULL.
4203 @param event
4204 The heap-allocated and non-@c NULL event to queue, the function takes
4205 ownership of it.
4206 */
4207 void wxQueueEvent(wxEvtHandler* dest, wxEvent *event);
4208
4209
4210
4211 wxEventType wxEVT_COMMAND_BUTTON_CLICKED;
4212 wxEventType wxEVT_COMMAND_CHECKBOX_CLICKED;
4213 wxEventType wxEVT_COMMAND_CHOICE_SELECTED;
4214 wxEventType wxEVT_COMMAND_LISTBOX_SELECTED;
4215 wxEventType wxEVT_COMMAND_LISTBOX_DOUBLECLICKED;
4216 wxEventType wxEVT_COMMAND_CHECKLISTBOX_TOGGLED;
4217 wxEventType wxEVT_COMMAND_MENU_SELECTED;
4218 wxEventType wxEVT_COMMAND_SLIDER_UPDATED;
4219 wxEventType wxEVT_COMMAND_RADIOBOX_SELECTED;
4220 wxEventType wxEVT_COMMAND_RADIOBUTTON_SELECTED;
4221 wxEventType wxEVT_COMMAND_SCROLLBAR_UPDATED;
4222 wxEventType wxEVT_COMMAND_VLBOX_SELECTED;
4223 wxEventType wxEVT_COMMAND_COMBOBOX_SELECTED;
4224 wxEventType wxEVT_COMMAND_TOOL_RCLICKED;
4225 wxEventType wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED;
4226 wxEventType wxEVT_COMMAND_TOOL_ENTER;
4227 wxEventType wxEVT_COMMAND_COMBOBOX_DROPDOWN;
4228 wxEventType wxEVT_COMMAND_COMBOBOX_CLOSEUP;
4229 wxEventType wxEVT_COMMAND_THREAD;
4230 wxEventType wxEVT_LEFT_DOWN;
4231 wxEventType wxEVT_LEFT_UP;
4232 wxEventType wxEVT_MIDDLE_DOWN;
4233 wxEventType wxEVT_MIDDLE_UP;
4234 wxEventType wxEVT_RIGHT_DOWN;
4235 wxEventType wxEVT_RIGHT_UP;
4236 wxEventType wxEVT_MOTION;
4237 wxEventType wxEVT_ENTER_WINDOW;
4238 wxEventType wxEVT_LEAVE_WINDOW;
4239 wxEventType wxEVT_LEFT_DCLICK;
4240 wxEventType wxEVT_MIDDLE_DCLICK;
4241 wxEventType wxEVT_RIGHT_DCLICK;
4242 wxEventType wxEVT_SET_FOCUS;
4243 wxEventType wxEVT_KILL_FOCUS;
4244 wxEventType wxEVT_CHILD_FOCUS;
4245 wxEventType wxEVT_MOUSEWHEEL;
4246 wxEventType wxEVT_AUX1_DOWN;
4247 wxEventType wxEVT_AUX1_UP;
4248 wxEventType wxEVT_AUX1_DCLICK;
4249 wxEventType wxEVT_AUX2_DOWN;
4250 wxEventType wxEVT_AUX2_UP;
4251 wxEventType wxEVT_AUX2_DCLICK;
4252 wxEventType wxEVT_CHAR;
4253 wxEventType wxEVT_CHAR_HOOK;
4254 wxEventType wxEVT_NAVIGATION_KEY;
4255 wxEventType wxEVT_KEY_DOWN;
4256 wxEventType wxEVT_KEY_UP;
4257 wxEventType wxEVT_HOTKEY;
4258 wxEventType wxEVT_SET_CURSOR;
4259 wxEventType wxEVT_SCROLL_TOP;
4260 wxEventType wxEVT_SCROLL_BOTTOM;
4261 wxEventType wxEVT_SCROLL_LINEUP;
4262 wxEventType wxEVT_SCROLL_LINEDOWN;
4263 wxEventType wxEVT_SCROLL_PAGEUP;
4264 wxEventType wxEVT_SCROLL_PAGEDOWN;
4265 wxEventType wxEVT_SCROLL_THUMBTRACK;
4266 wxEventType wxEVT_SCROLL_THUMBRELEASE;
4267 wxEventType wxEVT_SCROLL_CHANGED;
4268 wxEventType wxEVT_SPIN_UP;
4269 wxEventType wxEVT_SPIN_DOWN;
4270 wxEventType wxEVT_SPIN;
4271 wxEventType wxEVT_SCROLLWIN_TOP;
4272 wxEventType wxEVT_SCROLLWIN_BOTTOM;
4273 wxEventType wxEVT_SCROLLWIN_LINEUP;
4274 wxEventType wxEVT_SCROLLWIN_LINEDOWN;
4275 wxEventType wxEVT_SCROLLWIN_PAGEUP;
4276 wxEventType wxEVT_SCROLLWIN_PAGEDOWN;
4277 wxEventType wxEVT_SCROLLWIN_THUMBTRACK;
4278 wxEventType wxEVT_SCROLLWIN_THUMBRELEASE;
4279 wxEventType wxEVT_SIZE;
4280 wxEventType wxEVT_MOVE;
4281 wxEventType wxEVT_CLOSE_WINDOW;
4282 wxEventType wxEVT_END_SESSION;
4283 wxEventType wxEVT_QUERY_END_SESSION;
4284 wxEventType wxEVT_ACTIVATE_APP;
4285 wxEventType wxEVT_ACTIVATE;
4286 wxEventType wxEVT_CREATE;
4287 wxEventType wxEVT_DESTROY;
4288 wxEventType wxEVT_SHOW;
4289 wxEventType wxEVT_ICONIZE;
4290 wxEventType wxEVT_MAXIMIZE;
4291 wxEventType wxEVT_MOUSE_CAPTURE_CHANGED;
4292 wxEventType wxEVT_MOUSE_CAPTURE_LOST;
4293 wxEventType wxEVT_PAINT;
4294 wxEventType wxEVT_ERASE_BACKGROUND;
4295 wxEventType wxEVT_NC_PAINT;
4296 wxEventType wxEVT_MENU_OPEN;
4297 wxEventType wxEVT_MENU_CLOSE;
4298 wxEventType wxEVT_MENU_HIGHLIGHT;
4299 wxEventType wxEVT_CONTEXT_MENU;
4300 wxEventType wxEVT_SYS_COLOUR_CHANGED;
4301 wxEventType wxEVT_DISPLAY_CHANGED;
4302 wxEventType wxEVT_QUERY_NEW_PALETTE;
4303 wxEventType wxEVT_PALETTE_CHANGED;
4304 wxEventType wxEVT_JOY_BUTTON_DOWN;
4305 wxEventType wxEVT_JOY_BUTTON_UP;
4306 wxEventType wxEVT_JOY_MOVE;
4307 wxEventType wxEVT_JOY_ZMOVE;
4308 wxEventType wxEVT_DROP_FILES;
4309 wxEventType wxEVT_INIT_DIALOG;
4310 wxEventType wxEVT_IDLE;
4311 wxEventType wxEVT_UPDATE_UI;
4312 wxEventType wxEVT_SIZING;
4313 wxEventType wxEVT_MOVING;
4314 wxEventType wxEVT_MOVE_START;
4315 wxEventType wxEVT_MOVE_END;
4316 wxEventType wxEVT_HIBERNATE;
4317 wxEventType wxEVT_COMMAND_TEXT_COPY;
4318 wxEventType wxEVT_COMMAND_TEXT_CUT;
4319 wxEventType wxEVT_COMMAND_TEXT_PASTE;
4320 wxEventType wxEVT_COMMAND_LEFT_CLICK;
4321 wxEventType wxEVT_COMMAND_LEFT_DCLICK;
4322 wxEventType wxEVT_COMMAND_RIGHT_CLICK;
4323 wxEventType wxEVT_COMMAND_RIGHT_DCLICK;
4324 wxEventType wxEVT_COMMAND_SET_FOCUS;
4325 wxEventType wxEVT_COMMAND_KILL_FOCUS;
4326 wxEventType wxEVT_COMMAND_ENTER;
4327 wxEventType wxEVT_HELP;
4328 wxEventType wxEVT_DETAILED_HELP;
4329 wxEventType wxEVT_COMMAND_TEXT_UPDATED;
4330 wxEventType wxEVT_COMMAND_TOOL_CLICKED;
4331
4332
4333
4334 //@}
4335