]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: spinbutt.cpp | |
3 | // Purpose: wxSpinButton | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 17/09/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) | |
13 | #pragma implementation "spinbutt.h" | |
14 | #endif | |
15 | ||
16 | #include "wx/spinbutt.h" | |
17 | #include "wx/spinctrl.h" | |
18 | #include "wx/timer.h" | |
19 | ||
20 | #ifdef __VMS__ | |
21 | #pragma message disable nosimpint | |
22 | #endif | |
23 | #include <Xm/ArrowBG.h> | |
24 | #include <Xm/ArrowB.h> | |
25 | #ifdef __VMS__ | |
26 | #pragma message enable nosimpint | |
27 | #endif | |
28 | ||
29 | #include "wx/motif/private.h" | |
30 | ||
31 | // helper class | |
32 | enum ArrowDirection | |
33 | { | |
34 | wxARROW_UP, | |
35 | wxARROW_DOWN, | |
36 | wxARROW_LEFT, | |
37 | wxARROW_RIGHT | |
38 | }; | |
39 | ||
40 | class wxArrowButtonTimer; | |
41 | class wxArrowButton; | |
42 | ||
43 | // ---------------------------------------------------------------------------- | |
44 | // wxArrowButtonTimer | |
45 | // ---------------------------------------------------------------------------- | |
46 | ||
47 | static const unsigned int TICK_BEFORE_START = 10; | |
48 | static const unsigned int TICK_BEFORE_EXPONENTIAL = 40; | |
49 | static const unsigned int MAX_INCREMENT = 150; | |
50 | static const unsigned int TICK_INTERVAL = 113; | |
51 | ||
52 | class wxArrowButtonTimer : public wxTimer | |
53 | { | |
54 | public: | |
55 | wxArrowButtonTimer( wxArrowButton* btn, int sign ) | |
56 | : m_sign( sign ), | |
57 | m_button( btn ) | |
58 | { Reset(); }; | |
59 | ||
60 | void Notify(); | |
61 | void Reset() { m_ticks = 0; m_increment = 1; } | |
62 | private: | |
63 | unsigned int m_ticks; | |
64 | unsigned int m_increment; | |
65 | int m_sign; | |
66 | wxArrowButton* m_button; | |
67 | }; | |
68 | ||
69 | // ---------------------------------------------------------------------------- | |
70 | // wxArrowButton | |
71 | // ---------------------------------------------------------------------------- | |
72 | ||
73 | class wxArrowButton : public wxControl | |
74 | { | |
75 | friend class wxArrowButtonTimer; | |
76 | public: | |
77 | wxArrowButton( int increment ) | |
78 | : m_increment( increment ), | |
79 | m_timer( 0 ) {} | |
80 | ||
81 | wxArrowButton( wxSpinButton* parent, wxWindowID id, ArrowDirection d, | |
82 | const wxPoint& pos = wxDefaultPosition, | |
83 | const wxSize& size = wxDefaultSize, int increment = 1 ) | |
84 | : wxControl(), | |
85 | m_increment( increment ), | |
86 | m_timer( 0 ) | |
87 | { | |
88 | Create( parent, id, d, pos, size ); | |
89 | } | |
90 | ||
91 | ~wxArrowButton() | |
92 | { delete m_timer; } | |
93 | ||
94 | bool Create( wxSpinButton* parent, wxWindowID id, ArrowDirection d, | |
95 | const wxPoint& pos = wxDefaultPosition, | |
96 | const wxSize& size = wxDefaultSize ); | |
97 | private: | |
98 | // creates a new timer object, or stops the currently running one | |
99 | wxTimer* GetFreshTimer(); | |
100 | wxSpinButton* GetSpinButton() { return (wxSpinButton*)GetParent(); } | |
101 | static void SpinButtonCallback( Widget w, XtPointer clientData, | |
102 | XtPointer WXUNUSED(ptr) ); | |
103 | static void StartTimerCallback( Widget w, XtPointer clientData, | |
104 | XtPointer WXUNUSED(ptr) ); | |
105 | ||
106 | static void StopTimerCallback( Widget w, XtPointer clientData, | |
107 | XtPointer WXUNUSED(ptr) ); | |
108 | ||
109 | int m_increment; | |
110 | wxArrowButtonTimer* m_timer; | |
111 | }; | |
112 | ||
113 | // ---------------------------------------------------------------------------- | |
114 | // wxArrowButtonTimer implementation | |
115 | // ---------------------------------------------------------------------------- | |
116 | ||
117 | void wxArrowButtonTimer::Notify() | |
118 | { | |
119 | ++m_ticks; | |
120 | if( m_ticks < TICK_BEFORE_START ) return; | |
121 | // increment every other tick | |
122 | if( m_ticks <= TICK_BEFORE_EXPONENTIAL && m_ticks & 1 ) | |
123 | return; | |
124 | if( m_ticks > TICK_BEFORE_EXPONENTIAL ) | |
125 | m_increment = 2 * m_increment; | |
126 | if( m_increment >= MAX_INCREMENT ) m_increment = MAX_INCREMENT; | |
127 | m_button->GetSpinButton()->Increment( m_sign * m_increment ); | |
128 | } | |
129 | ||
130 | // ---------------------------------------------------------------------------- | |
131 | // wxArrowButton implementation | |
132 | // ---------------------------------------------------------------------------- | |
133 | ||
134 | wxTimer* wxArrowButton::GetFreshTimer() | |
135 | { | |
136 | if( m_timer ) | |
137 | { | |
138 | m_timer->Stop(); | |
139 | m_timer->Reset(); | |
140 | } | |
141 | else | |
142 | m_timer = new wxArrowButtonTimer( this, m_increment ); | |
143 | ||
144 | return m_timer; | |
145 | } | |
146 | ||
147 | void wxArrowButton::SpinButtonCallback( Widget w, XtPointer clientData, | |
148 | XtPointer WXUNUSED(ptr) ) | |
149 | { | |
150 | if( !wxGetWindowFromTable( w ) ) | |
151 | // Widget has been deleted! | |
152 | return; | |
153 | ||
154 | wxArrowButton* btn = (wxArrowButton*)clientData; | |
155 | ||
156 | btn->GetSpinButton()->Increment( btn->m_increment ); | |
157 | } | |
158 | ||
159 | void wxArrowButton::StartTimerCallback( Widget w, XtPointer clientData, | |
160 | XtPointer WXUNUSED(ptr) ) | |
161 | { | |
162 | if( !wxGetWindowFromTable( w ) ) | |
163 | // Widget has been deleted! | |
164 | return; | |
165 | ||
166 | wxArrowButton* btn = (wxArrowButton*)clientData; | |
167 | btn->GetFreshTimer()->Start( TICK_INTERVAL ); | |
168 | } | |
169 | ||
170 | void wxArrowButton::StopTimerCallback( Widget w, XtPointer clientData, | |
171 | XtPointer WXUNUSED(ptr) ) | |
172 | { | |
173 | if( !wxGetWindowFromTable( w ) ) | |
174 | // Widget has been deleted! | |
175 | return; | |
176 | ||
177 | wxArrowButton* btn = (wxArrowButton*)clientData; | |
178 | delete btn->m_timer; | |
179 | btn->m_timer = 0; | |
180 | } | |
181 | ||
182 | bool wxArrowButton::Create( wxSpinButton* parent, wxWindowID id, | |
183 | ArrowDirection d, | |
184 | const wxPoint& pos, const wxSize& size ) | |
185 | { | |
186 | int arrow_dir = XmARROW_UP; | |
187 | ||
188 | switch( d ) | |
189 | { | |
190 | case wxARROW_UP: | |
191 | arrow_dir = XmARROW_UP; | |
192 | break; | |
193 | case wxARROW_DOWN: | |
194 | arrow_dir = XmARROW_DOWN; | |
195 | break; | |
196 | case wxARROW_LEFT: | |
197 | arrow_dir = XmARROW_LEFT; | |
198 | break; | |
199 | case wxARROW_RIGHT: | |
200 | arrow_dir = XmARROW_RIGHT; | |
201 | break; | |
202 | } | |
203 | ||
204 | if( parent ) parent->AddChild( this ); | |
205 | ||
206 | Widget parentWidget = (Widget) parent->GetClientWidget(); | |
207 | m_mainWidget = (WXWidget) XtVaCreateManagedWidget( "XmArrowButton", | |
208 | xmArrowButtonWidgetClass, | |
209 | parentWidget, | |
210 | XmNarrowDirection, arrow_dir, | |
211 | XmNborderWidth, 0, | |
212 | XmNshadowThickness, 0, | |
213 | NULL ); | |
214 | ||
215 | XtAddCallback( (Widget) m_mainWidget, | |
216 | XmNactivateCallback, (XtCallbackProc) SpinButtonCallback, | |
217 | (XtPointer) this ); | |
218 | XtAddCallback( (Widget) m_mainWidget, | |
219 | XmNarmCallback, (XtCallbackProc) StartTimerCallback, | |
220 | (XtPointer) this ); | |
221 | XtAddCallback( (Widget) m_mainWidget, | |
222 | XmNactivateCallback, (XtCallbackProc) StopTimerCallback, | |
223 | (XtPointer) this ); | |
224 | ||
225 | AttachWidget( parent, m_mainWidget, (WXWidget) NULL, | |
226 | pos.x, pos.y, size.x, size.y ); | |
227 | ||
228 | SetForegroundColour( parent->GetBackgroundColour() ); | |
229 | ||
230 | return TRUE; | |
231 | } | |
232 | ||
233 | // ---------------------------------------------------------------------------- | |
234 | // wxSpinButton | |
235 | // ---------------------------------------------------------------------------- | |
236 | ||
237 | IMPLEMENT_DYNAMIC_CLASS(wxSpinButton, wxControl); | |
238 | IMPLEMENT_DYNAMIC_CLASS(wxSpinEvent, wxNotifyEvent); | |
239 | ||
240 | static void CalcSizes( wxPoint pt, wxSize sz, | |
241 | wxPoint& pt1, wxSize& sz1, | |
242 | wxPoint& pt2, wxSize& sz2, | |
243 | bool isVertical ) | |
244 | { | |
245 | typedef int wxSize::* CDPTR1; | |
246 | typedef int wxPoint::* CDPTR2; | |
247 | ||
248 | sz1 = sz2 = sz; | |
249 | pt2 = pt1 = pt; | |
250 | ||
251 | CDPTR1 szm = isVertical ? &wxSize::y : &wxSize::x; | |
252 | CDPTR2 ptm = isVertical ? &wxPoint::y : &wxPoint::x; | |
253 | int dim = sz.*szm, half = dim/2; | |
254 | ||
255 | sz1.*szm = half; | |
256 | sz2.*szm = dim - half; | |
257 | pt2.*ptm += half + 1; | |
258 | } | |
259 | ||
260 | bool wxSpinButton::Create( wxWindow *parent, wxWindowID id, | |
261 | const wxPoint& pos, const wxSize& size, | |
262 | long style, const wxString& name ) | |
263 | { | |
264 | m_windowStyle = style; | |
265 | ||
266 | wxSize newSize = GetBestSize(); | |
267 | if( size.x != -1 ) newSize.x = size.x; | |
268 | if( size.y != -1 ) newSize.y = size.y; | |
269 | ||
270 | if( !wxControl::Create( parent, id, pos, newSize, style ) ) | |
271 | { | |
272 | return FALSE; | |
273 | } | |
274 | ||
275 | SetName(name); | |
276 | ||
277 | InitBase(); | |
278 | ||
279 | m_windowId = ( id == -1 ) ? NewControlId() : id; | |
280 | ||
281 | bool isVert = IsVertical(); | |
282 | wxPoint pt1, pt2; | |
283 | wxSize sz1, sz2; | |
284 | CalcSizes( wxPoint(0,0), newSize, pt1, sz1, pt2, sz2, isVert ); | |
285 | m_up = new wxArrowButton( this, -1, isVert ? wxARROW_UP : wxARROW_RIGHT, | |
286 | pt1, sz1, 1 ); | |
287 | m_down = new wxArrowButton( this, -1, | |
288 | isVert ? wxARROW_DOWN : wxARROW_LEFT, | |
289 | pt2, sz2, -1 ); | |
290 | ||
291 | return TRUE; | |
292 | } | |
293 | ||
294 | wxSpinButton::~wxSpinButton() | |
295 | { | |
296 | } | |
297 | ||
298 | void wxSpinButton::DoMoveWindow(int x, int y, int width, int height) | |
299 | { | |
300 | wxControl::DoMoveWindow( x, y, width, height ); | |
301 | ||
302 | wxPoint pt1, pt2; | |
303 | wxSize sz1, sz2; | |
304 | ||
305 | CalcSizes( wxPoint(0,0), wxSize(width,height), pt1, | |
306 | sz1, pt2, sz2, IsVertical() ); | |
307 | m_up->SetSize( pt1.x, pt1.y, sz1.x, sz1.y ); | |
308 | m_down->SetSize( pt2.x, pt2.y, sz2.x, sz2.y ); | |
309 | } | |
310 | ||
311 | void wxSpinButton::DoSetSize(int x, int y, int width, int height, | |
312 | int sizeFlags) | |
313 | { | |
314 | #ifdef __VMS__ | |
315 | #pragma message disable codcauunr | |
316 | #endif | |
317 | if( sizeFlags & wxSIZE_USE_EXISTING && width == -1 ) | |
318 | width = GetSize().x; | |
319 | if( sizeFlags & wxSIZE_USE_EXISTING && height == -1 ) | |
320 | height = GetSize().y; | |
321 | #ifdef __VMS__ | |
322 | #pragma message enable codcauunr | |
323 | #endif | |
324 | ||
325 | wxControl::DoSetSize(x, y, width, height, 0); | |
326 | } | |
327 | ||
328 | void wxSpinButton::Increment( int delta ) | |
329 | { | |
330 | if( m_pos < m_min ) m_pos = m_min; | |
331 | if( m_pos > m_max ) m_pos = m_max; | |
332 | ||
333 | int npos = m_pos + delta; | |
334 | ||
335 | if( npos < m_min ) | |
336 | { | |
337 | if( GetWindowStyle() & wxSP_WRAP ) | |
338 | npos = m_max; | |
339 | else | |
340 | npos = m_min; | |
341 | } | |
342 | if( npos > m_max ) | |
343 | { | |
344 | if( GetWindowStyle() & wxSP_WRAP ) | |
345 | npos = m_min; | |
346 | else | |
347 | npos = m_max; | |
348 | } | |
349 | if( npos == m_pos ) return; | |
350 | ||
351 | wxSpinEvent event( delta > 0 ? wxEVT_SCROLL_LINEUP : wxEVT_SCROLL_LINEDOWN, | |
352 | m_windowId ); | |
353 | event.SetPosition( npos ); | |
354 | event.SetEventObject( this ); | |
355 | ||
356 | GetEventHandler()->ProcessEvent( event ); | |
357 | ||
358 | if( event.IsAllowed() ) | |
359 | { | |
360 | m_pos = npos; | |
361 | event.SetEventType( wxEVT_SCROLL_THUMBTRACK ); | |
362 | event.SetPosition( m_pos ); | |
363 | ||
364 | GetEventHandler()->ProcessEvent( event ); | |
365 | } | |
366 | } | |
367 | ||
368 | wxSize wxSpinButton::DoGetBestSize() const | |
369 | { | |
370 | return IsVertical() ? wxSize( 20, 30 ) : wxSize( 30, 20 ); | |
371 | } | |
372 | ||
373 | // Attributes | |
374 | //////////////////////////////////////////////////////////////////////////// | |
375 | ||
376 | int wxSpinButton::GetValue() const | |
377 | { | |
378 | return m_pos; | |
379 | } | |
380 | ||
381 | void wxSpinButton::SetValue(int val) | |
382 | { | |
383 | m_pos = val; | |
384 | } | |
385 | ||
386 | void wxSpinButton::SetRange(int minVal, int maxVal) | |
387 | { | |
388 | wxSpinButtonBase::SetRange(minVal, maxVal); | |
389 | } | |
390 | ||
391 | void wxSpinButton::ChangeFont(bool WXUNUSED(keepOriginalSize)) | |
392 | { | |
393 | // TODO | |
394 | } | |
395 | ||
396 | void wxSpinButton::ChangeBackgroundColour() | |
397 | { | |
398 | wxControl::ChangeBackgroundColour(); | |
399 | } | |
400 | ||
401 | void wxSpinButton::ChangeForegroundColour() | |
402 | { | |
403 | // TODO | |
404 | } |