]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: wx/timer.h | |
3 | // Purpose: wxTimer, wxStopWatch and global time-related functions | |
4 | // Author: Julian Smart | |
5 | // Modified by: Vadim Zeitlin (wxTimerBase) | |
6 | // Guillermo Rodriguez (global clean up) | |
7 | // Created: 04/01/98 | |
8 | // RCS-ID: $Id$ | |
9 | // Copyright: (c) Julian Smart | |
10 | // Licence: wxWindows licence | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | #ifndef _WX_TIMER_H_BASE_ | |
14 | #define _WX_TIMER_H_BASE_ | |
15 | ||
16 | #include "wx/defs.h" | |
17 | ||
18 | #if wxUSE_GUI && wxUSE_TIMER | |
19 | ||
20 | #include "wx/object.h" | |
21 | #include "wx/longlong.h" | |
22 | #include "wx/event.h" | |
23 | #include "wx/stopwatch.h" // for backwards compatibility | |
24 | #include "wx/window.h" // only for NewControlId() | |
25 | ||
26 | ||
27 | // more readable flags for Start(): | |
28 | ||
29 | // generate notifications periodically until the timer is stopped (default) | |
30 | #define wxTIMER_CONTINUOUS false | |
31 | ||
32 | // only send the notification once and then stop the timer | |
33 | #define wxTIMER_ONE_SHOT true | |
34 | ||
35 | // the interface of wxTimer class | |
36 | class WXDLLEXPORT wxTimerBase : public wxEvtHandler | |
37 | { | |
38 | public: | |
39 | // ctors and initializers | |
40 | // ---------------------- | |
41 | ||
42 | // default: if you don't call SetOwner(), your only chance to get timer | |
43 | // notifications is to override Notify() in the derived class | |
44 | wxTimerBase() | |
45 | { Init(); SetOwner(this); } | |
46 | ||
47 | // ctor which allows to avoid having to override Notify() in the derived | |
48 | // class: the owner will get timer notifications which can be handled with | |
49 | // EVT_TIMER | |
50 | wxTimerBase(wxEvtHandler *owner, int timerid = wxID_ANY) | |
51 | { Init(); SetOwner(owner, timerid); } | |
52 | ||
53 | // same as ctor above | |
54 | void SetOwner(wxEvtHandler *owner, int timerid = wxID_ANY) | |
55 | { | |
56 | m_owner = owner; | |
57 | m_idTimer = timerid == wxID_ANY ? wxWindow::NewControlId() : timerid; | |
58 | } | |
59 | ||
60 | wxEvtHandler *GetOwner() const { return m_owner; } | |
61 | ||
62 | virtual ~wxTimerBase(); | |
63 | ||
64 | // working with the timer | |
65 | // ---------------------- | |
66 | ||
67 | // start the timer: if milliseconds == -1, use the same value as for the | |
68 | // last Start() | |
69 | // | |
70 | // it is now valid to call Start() multiple times: this just restarts the | |
71 | // timer if it is already running | |
72 | virtual bool Start(int milliseconds = -1, bool oneShot = false); | |
73 | ||
74 | // stop the timer | |
75 | virtual void Stop() = 0; | |
76 | ||
77 | // override this in your wxTimer-derived class if you want to process timer | |
78 | // messages in it, use non default ctor or SetOwner() otherwise | |
79 | virtual void Notify(); | |
80 | ||
81 | // getting info | |
82 | // ------------ | |
83 | ||
84 | // return true if the timer is running | |
85 | virtual bool IsRunning() const = 0; | |
86 | ||
87 | // return the timer ID | |
88 | int GetId() const { return m_idTimer; } | |
89 | ||
90 | // get the (last) timer interval in milliseconds | |
91 | int GetInterval() const { return m_milli; } | |
92 | ||
93 | // return true if the timer is one shot | |
94 | bool IsOneShot() const { return m_oneShot; } | |
95 | ||
96 | protected: | |
97 | // common part of all ctors | |
98 | void Init() | |
99 | { m_owner = NULL; m_idTimer = wxID_ANY; m_milli = 0; m_oneShot = false; } | |
100 | ||
101 | wxEvtHandler *m_owner; | |
102 | int m_idTimer; | |
103 | int m_milli; // the timer interval | |
104 | bool m_oneShot; // true if one shot | |
105 | ||
106 | DECLARE_NO_COPY_CLASS(wxTimerBase) | |
107 | }; | |
108 | ||
109 | // ---------------------------------------------------------------------------- | |
110 | // wxTimer itself | |
111 | // ---------------------------------------------------------------------------- | |
112 | ||
113 | #if defined(__WXMSW__) | |
114 | #include "wx/msw/timer.h" | |
115 | #elif defined(__WXMOTIF__) | |
116 | #include "wx/motif/timer.h" | |
117 | #elif defined(__WXGTK20__) | |
118 | #include "wx/gtk/timer.h" | |
119 | #elif defined(__WXGTK__) | |
120 | #include "wx/gtk1/timer.h" | |
121 | #elif defined(__WXX11__) || defined(__WXMGL__) || defined(__WXDFB__) | |
122 | #include "wx/generic/timer.h" | |
123 | #elif defined (__WXCOCOA__) | |
124 | #include "wx/cocoa/timer.h" | |
125 | #elif defined(__WXMAC__) | |
126 | #include "wx/mac/timer.h" | |
127 | #elif defined(__WXPM__) | |
128 | #include "wx/os2/timer.h" | |
129 | #endif | |
130 | ||
131 | // ---------------------------------------------------------------------------- | |
132 | // wxTimerRunner: starts the timer in its ctor, stops in the dtor | |
133 | // ---------------------------------------------------------------------------- | |
134 | ||
135 | class WXDLLEXPORT wxTimerRunner | |
136 | { | |
137 | public: | |
138 | wxTimerRunner(wxTimer& timer) : m_timer(timer) { } | |
139 | wxTimerRunner(wxTimer& timer, int milli, bool oneShot = false) | |
140 | : m_timer(timer) | |
141 | { | |
142 | m_timer.Start(milli, oneShot); | |
143 | } | |
144 | ||
145 | void Start(int milli, bool oneShot = false) | |
146 | { | |
147 | m_timer.Start(milli, oneShot); | |
148 | } | |
149 | ||
150 | ~wxTimerRunner() | |
151 | { | |
152 | if ( m_timer.IsRunning() ) | |
153 | { | |
154 | m_timer.Stop(); | |
155 | } | |
156 | } | |
157 | ||
158 | private: | |
159 | wxTimer& m_timer; | |
160 | ||
161 | DECLARE_NO_COPY_CLASS(wxTimerRunner) | |
162 | }; | |
163 | ||
164 | // ---------------------------------------------------------------------------- | |
165 | // wxTimerEvent | |
166 | // ---------------------------------------------------------------------------- | |
167 | ||
168 | class WXDLLEXPORT wxTimerEvent : public wxEvent | |
169 | { | |
170 | public: | |
171 | wxTimerEvent(int timerid = 0, int interval = 0) : wxEvent(timerid) | |
172 | { | |
173 | m_eventType = wxEVT_TIMER; | |
174 | ||
175 | m_interval = interval; | |
176 | } | |
177 | ||
178 | // accessors | |
179 | int GetInterval() const { return m_interval; } | |
180 | ||
181 | // implement the base class pure virtual | |
182 | virtual wxEvent *Clone() const { return new wxTimerEvent(*this); } | |
183 | ||
184 | private: | |
185 | int m_interval; | |
186 | ||
187 | DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxTimerEvent) | |
188 | }; | |
189 | ||
190 | typedef void (wxEvtHandler::*wxTimerEventFunction)(wxTimerEvent&); | |
191 | ||
192 | #define wxTimerEventHandler(func) \ | |
193 | (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxTimerEventFunction, &func) | |
194 | ||
195 | #define EVT_TIMER(timerid, func) \ | |
196 | wx__DECLARE_EVT1(wxEVT_TIMER, timerid, wxTimerEventHandler(func)) | |
197 | ||
198 | #endif // wxUSE_GUI && wxUSE_TIMER | |
199 | ||
200 | #endif | |
201 | // _WX_TIMER_H_BASE_ |