]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/fl/hintanimpl.cpp
removed enum that was causing more problems than it was worth
[wxWidgets.git] / contrib / src / fl / hintanimpl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: hintanimpl.cpp
3 // Purpose: cbHintAnimationPlugin implementation.
4 // Author: Aleksandras Gluchovas
5 // Modified by:
6 // Created: 9/11/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Aleksandras Gluchovas
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "hintanimpl.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #ifndef WX_PRECOMP
24 #include "wx/wx.h"
25 #endif
26
27 #include "wx/fl/hintanimpl.h"
28
29 #define POS_UNDEFINED -32768
30
31 /***** Implementation for class cbHintAnimationPlugin *****/
32
33 // FIXME:: some of the below code should be eliminated by
34 // reusing parts of cbBarDragPlugin's implementation
35
36 IMPLEMENT_DYNAMIC_CLASS( cbHintAnimationPlugin, cbPluginBase )
37
38 BEGIN_EVENT_TABLE( cbHintAnimationPlugin, cbPluginBase )
39
40 EVT_PL_DRAW_HINT_RECT( cbHintAnimationPlugin::OnDrawHintRect )
41
42 END_EVENT_TABLE()
43
44 cbHintAnimationPlugin::cbHintAnimationPlugin(void)
45
46 : mpScrDc( NULL ),
47 mpAnimTimer( 0 ),
48 mAnimStarted( false ),
49
50 mMorphDelay ( 5 ),
51 mMaxFrames ( 20 ),
52 mInClientHintBorder( 4 ),
53 mAccelerationOn( true )
54 {}
55
56 cbHintAnimationPlugin::cbHintAnimationPlugin( wxFrameLayout* pPanel, int paneMask )
57
58 : cbPluginBase( pPanel, paneMask ),
59 mpScrDc( NULL ),
60 mpAnimTimer( 0 ),
61 mAnimStarted( false ),
62
63 mMorphDelay ( 5 ),
64 mMaxFrames ( 20 ),
65 mInClientHintBorder( 4 ),
66 mAccelerationOn( true )
67 {}
68
69 cbHintAnimationPlugin::~cbHintAnimationPlugin()
70 {
71 if ( mpScrDc ) delete mpScrDc;
72 }
73
74 /*** rect-tracking related methods ***/
75
76 void cbHintAnimationPlugin::OnDrawHintRect( cbDrawHintRectEvent& event )
77 {
78 if ( !mAnimStarted && !mpScrDc )
79 {
80 StartTracking();
81
82 mPrevInClient = event.mIsInClient;
83
84 mPrevRect = event.mRect;
85
86 mStopPending = false;
87 }
88
89 if ( !event.mEraseRect )
90 {
91 // pass on current hint-rect info to the animation "thread", in
92 // order to make adjustments to the morph-target on-the-fly
93
94 mCurRect.x = event.mRect.x;
95 mCurRect.y = event.mRect.y;
96 mCurRect.width = event.mRect.width;
97 mCurRect.height = event.mRect.height;
98 }
99
100 // check the amount of change in the shape of hint,
101 // and start morph-effect if change is "sufficient"
102
103 int change = abs( mCurRect.width - mPrevRect.width ) +
104 abs( mCurRect.height - mPrevRect.height );
105
106 if ( change > 10 && !event.mLastTime && !event.mEraseRect )
107 {
108 if ( !mpAnimTimer )
109
110 mpAnimTimer = new cbHintAnimTimer();
111
112 // init the animation "thread", or reinit if already started
113
114 mpAnimTimer->Init( this, mAnimStarted );
115
116 mAnimStarted = true;
117 }
118 else
119 if ( !mAnimStarted )
120 {
121 DoDrawHintRect( event.mRect, event.mIsInClient );
122
123 if ( event.mLastTime )
124
125 FinishTracking();
126
127 mPrevInClient = event.mIsInClient;
128 }
129 else
130 {
131 mCurInClient = event.mIsInClient;
132
133 if ( event.mLastTime && mpAnimTimer )
134 {
135 mStopPending = true;
136
137 if ( mpAnimTimer->mPrevMorphed.x != POS_UNDEFINED )
138
139 // erase previous rect
140 DoDrawHintRect( mpAnimTimer->mPrevMorphed, mPrevInClient );
141 }
142 }
143
144 mPrevRect = event.mRect;
145 }
146
147 #define _IMG_A 0xAA // Note: modified from _A to _IMG_A, _A was already defined (cygwin)
148 #define _IMG_B 0x00 // Note: modified from _B to _IMG_A, _B was already defined (cygwin)
149 #define _IMG_C 0x55 // Note: modified from _C to _IMG_C, for consistency reasons.
150 #define _IMG_D 0x00 // Note: modified from _D to _IMG_D, for consistency reasons.
151
152 static const unsigned char _gCheckerImg[16] = { _IMG_A,_IMG_B,_IMG_C,_IMG_D,
153 _IMG_A,_IMG_B,_IMG_C,_IMG_D,
154 _IMG_A,_IMG_B,_IMG_C,_IMG_D,
155 _IMG_A,_IMG_B,_IMG_C,_IMG_D
156 };
157
158 void cbHintAnimationPlugin::StartTracking()
159 {
160 mpScrDc = new wxScreenDC;
161
162 wxScreenDC::StartDrawingOnTop(&mpLayout->GetParentFrame());
163 }
164
165 void cbHintAnimationPlugin::DoDrawHintRect( wxRect& rect, bool isInClientRect)
166 {
167 wxRect scrRect;
168
169 RectToScr( rect, scrRect );
170
171 int prevLF = mpScrDc->GetLogicalFunction();
172
173 mpScrDc->SetLogicalFunction( wxXOR );
174
175 if ( isInClientRect )
176 {
177 // BUG BUG BUG (wx):: somehow stippled brush works only
178 // when the bitmap created on stack, not
179 // as a member of the class
180
181 wxBitmap checker( (const char*)_gCheckerImg, 8,8 );
182
183 wxBrush checkerBrush( checker );
184
185 mpScrDc->SetPen( mpLayout->mNullPen );
186 mpScrDc->SetBrush( checkerBrush );
187
188 int half = mInClientHintBorder / 2;
189
190 mpScrDc->DrawRectangle( scrRect.x - half, scrRect.y - half,
191 scrRect.width + 2*half, mInClientHintBorder );
192
193 mpScrDc->DrawRectangle( scrRect.x - half, scrRect.y + scrRect.height - half,
194 scrRect.width + 2*half, mInClientHintBorder );
195
196 mpScrDc->DrawRectangle( scrRect.x - half, scrRect.y + half - 1,
197 mInClientHintBorder, scrRect.height - 2*half + 2);
198
199 mpScrDc->DrawRectangle( scrRect.x + scrRect.width - half,
200 scrRect.y + half - 1,
201 mInClientHintBorder, scrRect.height - 2*half + 2);
202
203 mpScrDc->SetBrush( wxNullBrush );
204 }
205 else
206 {
207 // otherwise draw 1-pixel thin borders
208
209 mpScrDc->SetPen( mpLayout->mBlackPen );
210
211 mpScrDc->DrawLine( scrRect.x, scrRect.y,
212 scrRect.x + scrRect.width, scrRect.y );
213
214 mpScrDc->DrawLine( scrRect.x, scrRect.y + 1,
215 scrRect.x, scrRect.y + scrRect.height );
216
217 mpScrDc->DrawLine( scrRect.x+1, scrRect.y + scrRect.height,
218 scrRect.x + scrRect.width, scrRect.y + scrRect.height );
219
220 mpScrDc->DrawLine( scrRect.x + scrRect.width , scrRect.y,
221 scrRect.x + scrRect.width, scrRect.y + scrRect.height + 1);
222 }
223
224 mpScrDc->SetLogicalFunction( prevLF );
225 }
226
227 void cbHintAnimationPlugin::DrawHintRect ( wxRect& rect, bool isInClientRect)
228 {
229 DoDrawHintRect( rect, isInClientRect );
230 }
231
232 void cbHintAnimationPlugin::EraseHintRect( wxRect& rect, bool isInClientRect)
233 {
234 DoDrawHintRect( rect, isInClientRect );
235 }
236
237 void cbHintAnimationPlugin::FinishTracking()
238 {
239 wxScreenDC::EndDrawingOnTop();
240
241 delete mpScrDc;
242
243 mpScrDc = NULL;
244 }
245
246 void cbHintAnimationPlugin::RectToScr( wxRect& frameRect, wxRect& scrRect )
247 {
248 scrRect = frameRect;
249
250 int x = frameRect.x, y = frameRect.y;
251
252 mpLayout->GetParentFrame().ClientToScreen( &x, &y );
253
254 scrRect.x = x;
255 scrRect.y = y;
256 }
257
258 /***** Implementation for class cbHintAnimTimer *****/
259
260 cbHintAnimTimer::cbHintAnimTimer(void)
261 {
262 #ifdef __WINDOWS__
263 mLock = 0L;
264 #endif
265
266 mPrevMorphed.x = POS_UNDEFINED;
267 }
268
269 void cbHintAnimTimer::MorphPoint( wxPoint& origin, MorphInfoT& info, wxPoint& point )
270 {
271 // simulate lienar movement (FOR NOW:: without acceleration)
272
273 double k;
274
275 if ( mpPl->mAccelerationOn )
276
277 k = double( mCurIter*mCurIter ) /
278 double( (mpPl->mMaxFrames - 1)*(mpPl->mMaxFrames - 1) );
279 else
280 k = double( mCurIter ) / double( mpPl->mMaxFrames - 1 );
281
282 point.x = int ( double ( info.mFrom.x + double (info.mTill.x - info.mFrom.x) * k ) );
283
284 point.y = int ( double ( info.mFrom.y + double (info.mTill.y - info.mFrom.y) * k ) );
285
286 point.x += origin.x;
287 point.y += origin.y;
288 }
289
290 void cbHintAnimTimer::Notify(void)
291 {
292 // FIXME:: "clean" implementation should use mutex to sync
293 // between GUI and animation threads
294
295 if ( mpPl->mStopPending )
296 {
297 Stop(); // top timer
298
299 mpPl->FinishTracking();
300
301 mpPl->mStopPending = false;
302 mpPl->mpAnimTimer = NULL;
303 mpPl->mAnimStarted = false;
304
305 mPrevMorphed.x = POS_UNDEFINED;
306
307 delete this;
308
309 return;
310 }
311
312 wxPoint origin( mpPl->mCurRect.x, mpPl->mCurRect.y );
313
314 wxPoint curUpper, curLower;
315
316 MorphPoint( origin, mUpperLeft, curUpper );
317 MorphPoint( origin, mLowerRight, curLower );
318
319 if ( mPrevMorphed.x != POS_UNDEFINED )
320
321 // erase previous rect
322 mpPl->DoDrawHintRect( mPrevMorphed, mpPl->mPrevInClient );
323
324 wxRect morphed( curUpper.x, curUpper.y,
325 curLower.x - curUpper.x,
326 curLower.y - curUpper.y );
327
328 // draw rect of current iteration
329 mpPl->DoDrawHintRect( morphed,
330 ( mCurIter != mpPl->mMaxFrames - 1 )
331 ? mpPl->mPrevInClient : mpPl->mCurInClient );
332
333 mPrevMorphed = morphed;
334
335 if ( mCurIter == mpPl->mMaxFrames - 1 )
336 {
337 Stop(); // top timer
338
339 mpPl->FinishTracking();
340 mpPl->mpAnimTimer = NULL;
341 mpPl->mAnimStarted = false;
342
343 mPrevMorphed.x = POS_UNDEFINED;
344
345 delete this;
346 }
347 else
348 ++mCurIter;
349 }
350
351 bool cbHintAnimTimer::Init( cbHintAnimationPlugin* pAnimPl, bool reinit )
352 {
353
354 mpPl = pAnimPl;
355
356 // morph-points are set up relatively to the upper-left corner
357 // of the current hint-rectangle
358
359 if ( !reinit )
360 {
361 mUpperLeft.mFrom.x = mpPl->mPrevRect.x - mpPl->mCurRect.x;
362 mUpperLeft.mFrom.y = mpPl->mPrevRect.y - mpPl->mCurRect.y;
363
364 mLowerRight.mFrom.x = ( mUpperLeft.mFrom.x + mpPl->mPrevRect.width );
365 mLowerRight.mFrom.y = ( mUpperLeft.mFrom.y + mpPl->mPrevRect.height );
366 }
367 else
368 {
369 wxPoint origin( mpPl->mPrevRect.x, mpPl->mPrevRect.y );
370
371 wxPoint curUpper, curLower;
372
373 MorphPoint( origin, mUpperLeft, curUpper );
374 MorphPoint( origin, mLowerRight, curLower );
375
376 mUpperLeft.mFrom.x = curUpper.x - mpPl->mCurRect.x;
377 mUpperLeft.mFrom.y = curUpper.y - mpPl->mCurRect.y;
378
379 mLowerRight.mFrom.x = ( mUpperLeft.mFrom.x + curLower.x - curUpper.x );
380 mLowerRight.mFrom.y = ( mUpperLeft.mFrom.y + curLower.y - curUpper.y );
381 }
382
383 mUpperLeft.mTill.x = 0;
384 mUpperLeft.mTill.y = 0;
385
386 mLowerRight.mTill.x = mpPl->mCurRect.width;
387 mLowerRight.mTill.y = mpPl->mCurRect.height;
388
389 mCurIter = 1;
390
391 if ( !reinit )
392
393 Start( mpPl->mMorphDelay );
394
395 return true;
396 }
397