]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/fl/bardragpl.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
better cleanup
[wxWidgets.git] / contrib / src / fl / bardragpl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: bardragpl.cpp
3 // Purpose: cbBarDragPlugin implementation
4 // Author: Aleksandras Gluchovas
5 // Modified by:
6 // Created: 23/09/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Aleksandras Gluchovas
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "bardragpl.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/bardragpl.h"
28
29 #define POS_UNDEFINED -32768
30
31 // helpers, FOR NOW:: static
32
33 static inline bool rect_hits_rect( const wxRect& r1, const wxRect& r2 )
34 {
35 if ( ( r2.x >= r1.x && r2.x <= r1.x + r1.width ) ||
36 ( r1.x >= r2.x && r1.x <= r2.x + r2.width ) )
37
38 if ( ( r2.y >= r1.y && r2.y <= r1.y + r1.height ) ||
39 ( r1.y >= r2.y && r1.y <= r2.y + r2.height ) )
40
41 return TRUE;
42
43 return FALSE;
44 }
45
46 static inline bool rect_contains_point( const wxRect& rect, int x, int y )
47 {
48 return ( x >= rect.x &&
49 y >= rect.y &&
50 x < rect.x + rect.width &&
51 y < rect.y + rect.height );
52 }
53
54 /***** Implementation for class cbBarDragPlugin *****/
55
56 IMPLEMENT_DYNAMIC_CLASS( cbBarDragPlugin, cbPluginBase )
57
58 BEGIN_EVENT_TABLE( cbBarDragPlugin, cbPluginBase )
59
60 //EVT_PL_LEFT_DOWN ( cbBarDragPlugin::OnLButtonDown )
61 EVT_PL_LEFT_UP ( cbBarDragPlugin::OnLButtonUp )
62 EVT_PL_MOTION ( cbBarDragPlugin::OnMouseMove )
63 EVT_PL_DRAW_HINT_RECT ( cbBarDragPlugin::OnDrawHintRect )
64 EVT_PL_START_BAR_DRAGGING ( cbBarDragPlugin::OnStartBarDragging )
65 EVT_PL_LEFT_DCLICK ( cbBarDragPlugin::OnLDblClick )
66
67 END_EVENT_TABLE()
68
69 cbBarDragPlugin::cbBarDragPlugin(void)
70
71 : mBarDragStarted ( FALSE ),
72 mCanStick ( TRUE ),
73 mpScrDc ( NULL ),
74 mpCurCursor ( NULL ),
75 mpDraggedBar ( NULL ),
76 mInClientHintBorder( 4 )
77 {}
78
79 cbBarDragPlugin::cbBarDragPlugin( wxFrameLayout* pPanel, int paneMask )
80
81 : cbPluginBase( pPanel, paneMask ),
82
83 mBarDragStarted ( FALSE ),
84 mCanStick ( TRUE ),
85 mpScrDc ( NULL ),
86 mpCurCursor ( NULL ),
87 mpDraggedBar ( NULL ),
88 mInClientHintBorder( 4 )
89 {}
90
91 cbBarDragPlugin::~cbBarDragPlugin()
92 {
93 // nothing
94 }
95
96 // helper methods (protected)
97
98 // clips (top/bottom) or (right/left) edges against the frame's bounding rect.
99
100 void do_clip_edges( int len, int& rectPos, int& rectLen )
101 {
102 if ( rectPos < 0 )
103 {
104 rectLen += rectPos;
105 rectPos = 0;
106 if ( rectLen < 0 )
107 rectLen = 1;
108 }
109 else
110 if ( rectPos > len-1 )
111 {
112 rectPos = len-1;
113 rectLen = 1;
114 }
115 else
116 if ( rectPos + rectLen - 1 > len )
117
118 rectLen -= (rectPos + rectLen) - len + 1;
119 }
120
121 void cbBarDragPlugin::ClipRectInFrame( wxRect& rect )
122 {
123 int w, h;
124 mpLayout->GetParentFrame().GetClientSize( &w, &h );
125
126 do_clip_edges( w, rect.x, rect.width );
127 do_clip_edges( h, rect.y, rect.height );
128 }
129
130 void cbBarDragPlugin::ClipPosInFrame( wxPoint& pos )
131 {
132 int w, h;
133 mpLayout->GetParentFrame().GetClientSize( &w, &h );
134
135 if ( pos.x < 0 )
136 pos.x = 0;
137 if ( pos.y < 0 )
138 pos.y = 0;
139 if ( pos.x > w )
140 pos.x = w-1;
141 if ( pos.y > h )
142 pos.y = h-1;
143 }
144
145 void cbBarDragPlugin::AdjustHintRect( wxPoint& mousePos )
146 {
147 mHintRect.x = mousePos.x - mMouseInRectX;
148 mHintRect.y = mousePos.y - mMouseInRectY;
149 }
150
151 cbDockPane* cbBarDragPlugin::HitTestPanes( wxRect& rect )
152 {
153 //wxRect clipped = rect;
154
155 //ClipRectInFrame( clipped );
156
157 cbDockPane** pPanes = mpLayout->GetPanesArray();
158
159 for( int i = 0; i != MAX_PANES; ++i )
160
161 if ( rect_hits_rect( pPanes[i]->mBoundsInParent, rect ) )
162
163 return pPanes[i];
164
165 return NULL;
166 }
167
168 cbDockPane* cbBarDragPlugin::HitTestPanes( wxPoint& pos )
169 {
170 wxPoint clipped = pos;
171
172 //ClipPosInFrame( pos );
173
174 cbDockPane** pPanes = mpLayout->GetPanesArray();
175
176 for( int i = 0; i != MAX_PANES; ++i )
177
178 if ( rect_contains_point( pPanes[i]->mBoundsInParent, clipped.x, clipped.y ) )
179
180 return pPanes[i];
181
182 return NULL;
183 }
184
185 bool cbBarDragPlugin::HitsPane( cbDockPane* pPane, wxRect& rect )
186 {
187 return rect_hits_rect( pPane->mBoundsInParent, rect );
188 }
189
190 int cbBarDragPlugin::GetDistanceToPane( cbDockPane* pPane, wxPoint& mousePos )
191 {
192 wxRect& bounds = pPane->mBoundsInParent;
193
194 switch( pPane->mAlignment )
195 {
196 case FL_ALIGN_TOP : return mousePos.y - ( bounds.y + bounds.height );
197
198 case FL_ALIGN_BOTTOM : return bounds.y - mousePos.y;
199
200 case FL_ALIGN_LEFT : return mousePos.x - ( bounds.x + bounds.width );
201
202 case FL_ALIGN_RIGHT : return bounds.x - mousePos.x;
203
204 default : return 0; // never reached
205 }
206
207 // return 0;
208 }
209
210 bool cbBarDragPlugin::IsInOtherPane( wxPoint& mousePos )
211 {
212 cbDockPane* pPane = HitTestPanes( mousePos );
213
214 if ( pPane && pPane != mpCurPane ) return TRUE;
215 else return FALSE;
216 }
217
218 bool cbBarDragPlugin::IsInClientArea( wxPoint& mousePos )
219 {
220 return ( HitTestPanes( mousePos ) == NULL );
221 }
222
223 bool cbBarDragPlugin::IsInClientArea( wxRect& rect )
224 {
225 return ( HitTestPanes( rect ) == NULL );
226 }
227
228 void cbBarDragPlugin::CalcOnScreenDims( wxRect& rect )
229 {
230 if ( !mpCurPane || mpDraggedBar->IsFixed() ) return;
231
232 wxRect inPane = rect;
233
234 mpCurPane->FrameToPane( &inPane );
235
236 int rowNo = mpCurPane->GetRowAt( inPane.y, inPane.y + inPane.height );
237
238 bool isMaximized = ( rowNo >= (int)mpCurPane->GetRowList().Count() || rowNo < 0 );
239
240 if ( isMaximized )
241 {
242 inPane.x = 0;
243 inPane.width = mpCurPane->mPaneWidth;
244
245 mpCurPane->PaneToFrame( &inPane );
246
247 rect = inPane;
248 }
249 }
250
251 // helpers
252
253 static inline void check_upper_overrun( int& pos, int width, int mousePos )
254 {
255 if ( mousePos >= pos + width )
256
257 pos = mousePos - width/2;
258 }
259
260 static inline void check_lower_overrun( int& pos, int width, int mousePos )
261 {
262 if ( mousePos <= pos )
263
264 pos = mousePos - width/2;
265 }
266
267 void cbBarDragPlugin::StickToPane( cbDockPane* pPane, wxPoint& mousePos )
268 {
269 int wInPane = GetBarWidthInPane ( pPane );
270 int hInPane = GetBarHeightInPane( pPane );
271
272 // adjsut hint-rect horizontally (in pane's orientation)
273
274 if ( pPane->IsHorizontal() )
275 {
276 mHintRect.width = wInPane;
277 mHintRect.height = hInPane;
278 }
279 else
280 {
281 mHintRect.height = wInPane;
282 mHintRect.width = hInPane;
283 }
284
285 // adjsut hint-rect vertically (in pane's orientation)
286
287 wxRect& bounds = pPane->mBoundsInParent;
288
289 // TRUE, if hint enters the pane through it's lower edge
290
291 bool fromLowerEdge = ( pPane->IsHorizontal() )
292 ? mousePos.y > bounds.y
293 : mousePos.x > bounds.x;
294
295 // NOTE:: about all the below min/max things: they are meant to ensure
296 // that the mouse pointer doesn't overrun (leave) the hint-rectangle
297 // when its dimensions are recalculated upon sticking it to the pane
298
299 if ( pPane->IsHorizontal() && fromLowerEdge )
300 {
301 int paneBottomEdgeY = bounds.y + bounds.height;
302
303 mHintRect.y = wxMin( paneBottomEdgeY, mousePos.y );
304
305 check_lower_overrun( mHintRect.y, hInPane, mousePos.y );
306
307 }
308 else
309 if ( pPane->IsHorizontal() && !fromLowerEdge )
310 {
311 int paneTopEdgeY = bounds.y;
312
313 mHintRect.y = wxMax( paneTopEdgeY - hInPane, mousePos.y - hInPane );
314
315 check_upper_overrun( mHintRect.y, hInPane, mousePos.y );
316 }
317 else
318 if ( !pPane->IsHorizontal() && fromLowerEdge )
319 {
320 int paneRightEdgeX = bounds.x + bounds.width;
321
322 mHintRect.x = wxMin( paneRightEdgeX, mousePos.x );
323
324 check_lower_overrun( mHintRect.x, hInPane, mousePos.x );
325 }
326 else
327 if ( !pPane->IsHorizontal() && !fromLowerEdge )
328 {
329 int paneLeftEdgeX = bounds.x;
330
331 mHintRect.x = wxMax( paneLeftEdgeX - hInPane, mousePos.x - hInPane );
332
333 check_upper_overrun( mHintRect.x, hInPane, mousePos.x );
334 }
335
336 mMouseInRectX = mousePos.x - mHintRect.x;
337 mMouseInRectY = mousePos.y - mHintRect.y;
338
339 mpCurPane = pPane; // memorize pane to which the hint is currently sticked
340 }
341
342 void cbBarDragPlugin::UnstickFromPane( cbDockPane* pPane, wxPoint& mousePos )
343 {
344 // unsticking causes rectangle to get the shape in which
345 // dragged control-bar would be when floated
346
347 int newWidth = mpDraggedBar->mDimInfo.mSizes[wxCBAR_FLOATING].x;
348 int newHeight = mpDraggedBar->mDimInfo.mSizes[wxCBAR_FLOATING].y;
349
350 wxRect& flBounds = mpDraggedBar->mDimInfo.mBounds[wxCBAR_FLOATING];
351
352 if ( flBounds.width != -1 )
353 {
354 newWidth = flBounds.width;
355 newHeight = flBounds.height;
356 }
357
358 mHintRect.width = newWidth;
359 mHintRect.height = newHeight;
360
361 wxRect& bounds = pPane->mBoundsInParent;
362
363 // TRUE, if hint leaves the pane through it's lower edge
364
365 bool fromLowerEdge = ( pPane->IsHorizontal() )
366 ? mousePos.y > bounds.y
367 : mousePos.x > bounds.x;
368
369 // NOTE:: ...all the below min/max things - see comments about it in StickToPane(..)
370
371 if ( pPane->IsHorizontal() && fromLowerEdge )
372 {
373 // bool fromLowerEdge = mousePos.y > bounds.y;
374
375 mHintRect.y = wxMax( bounds.y + bounds.height + 1, mousePos.y - newHeight );
376
377 check_upper_overrun( mHintRect.y, newHeight, mousePos.y );
378
379 // this is how MFC's hint behaves:
380
381 if ( mMouseInRectX > newWidth )
382
383 mHintRect.x = mousePos.x - ( newWidth / 2 );
384 }
385 else
386 if ( pPane->IsHorizontal() && !fromLowerEdge )
387 {
388 mHintRect.y = wxMin( bounds.y - newHeight - 1, mousePos.y );
389
390 // -/-
391
392 if ( mMouseInRectX > newWidth )
393
394 mHintRect.x = mousePos.x - ( newWidth / 2 );
395
396 check_lower_overrun( mHintRect.y, newHeight, mousePos.y );
397 }
398 else
399 if ( !pPane->IsHorizontal() && fromLowerEdge )
400 {
401 mHintRect.x = wxMax( bounds.x + bounds.width, mousePos.x - newWidth );
402
403 // -/-
404
405 if ( mMouseInRectY > newHeight )
406
407 mHintRect.y = mousePos.y - ( newHeight / 2 );
408
409 check_upper_overrun( mHintRect.x, newWidth, mousePos.x );
410 }
411 else
412 if ( !pPane->IsHorizontal() && !fromLowerEdge )
413 {
414 mHintRect.x = wxMin( bounds.x - newWidth - 1, mousePos.x );
415
416 // -/-
417
418 if ( mMouseInRectY > newHeight )
419
420 mHintRect.y = mousePos.y - ( newHeight / 2 );
421
422 check_lower_overrun( mHintRect.x, newWidth, mousePos.x );
423 }
424
425 mMouseInRectX = mousePos.x - mHintRect.x;
426 mMouseInRectY = mousePos.y - mHintRect.y;
427
428 mpCurPane = NULL;
429 }
430
431 int cbBarDragPlugin::GetBarWidthInPane( cbDockPane* pPane )
432 {
433 if ( pPane == mpSrcPane )
434
435 return mBarWidthInSrcPane;
436
437 // this is how MFC's bars behave:
438
439 if ( pPane->IsHorizontal() )
440
441 return mpDraggedBar->mDimInfo.mSizes[wxCBAR_DOCKED_HORIZONTALLY].x;
442 else
443 return mpDraggedBar->mDimInfo.mSizes[wxCBAR_DOCKED_VERTICALLY ].x;
444 }
445
446 int cbBarDragPlugin::GetBarHeightInPane( cbDockPane* pPane )
447 {
448 if ( pPane->IsHorizontal() )
449
450 return mpDraggedBar->mDimInfo.mSizes[wxCBAR_DOCKED_HORIZONTALLY].y;
451 else
452 return mpDraggedBar->mDimInfo.mSizes[wxCBAR_DOCKED_VERTICALLY ].y;
453 }
454
455 void cbBarDragPlugin::ShowHint( bool prevWasInClient )
456 {
457 bool wasDocked = FALSE;
458
459
460 if ( mpSrcPane->mProps.mRealTimeUpdatesOn == FALSE )
461 {
462 // do heavy calculations first
463
464 wxRect actualRect = mHintRect; // will be adjusted depending on drag-settings
465
466 if ( mpSrcPane->mProps.mExactDockPredictionOn && mpCurPane )
467 {
468 bool success = mpLayout->RedockBar( mpDraggedBar, mHintRect, mpCurPane, FALSE );
469
470 wxASSERT( success ); // DBG::
471
472 actualRect = mpDraggedBar->mBounds;
473
474 mpCurPane->PaneToFrame( &actualRect );
475 }
476 else
477 CalcOnScreenDims( actualRect );
478
479 // release previous hint
480
481 if ( mPrevHintRect.x != POS_UNDEFINED )
482 {
483 // erase previous rectangle
484
485 cbDrawHintRectEvent evt( mPrevHintRect, prevWasInClient, TRUE, FALSE );
486
487 mpLayout->FirePluginEvent( evt );
488 }
489
490 // draw new hint
491
492 cbDrawHintRectEvent evt( actualRect, mpCurPane == NULL, FALSE, FALSE );
493
494 mpLayout->FirePluginEvent( evt );
495
496 mPrevHintRect = actualRect;
497 }
498 else
499 {
500 // otherwise, if real-time updates option is ON
501
502 if ( mpDraggedBar->mState != wxCBAR_FLOATING && !mpCurPane )
503 {
504 mpLayout->SetBarState( mpDraggedBar, wxCBAR_FLOATING, TRUE );
505 }
506 else
507 if ( mpDraggedBar->mState == wxCBAR_FLOATING && mpCurPane )
508 {
509 mpLayout->SetBarState( mpDraggedBar, wxCBAR_DOCKED_HORIZONTALLY, FALSE );
510
511 wasDocked = TRUE;
512 }
513
514 if ( mpCurPane )
515 {
516 mpLayout->GetUpdatesManager().OnStartChanges();
517
518 if ( wasDocked )
519
520 mpDraggedBar->mUMgrData.SetDirty( TRUE );
521
522 bool success = mpLayout->RedockBar( mpDraggedBar, mHintRect, mpCurPane, FALSE );
523
524 wxASSERT( success ); // DBG ::
525
526 mpLayout->GetUpdatesManager().OnFinishChanges();
527 mpLayout->GetUpdatesManager().UpdateNow();
528 }
529 else
530 {
531 if ( mpLayout->mFloatingOn )
532 {
533 // move the top-most floated bar around as user drags the hint
534
535 mpDraggedBar->mDimInfo.mBounds[ wxCBAR_FLOATING ] = mHintRect;
536
537 mpLayout->ApplyBarProperties( mpDraggedBar );
538 }
539 }
540 }
541 }
542
543 /*** event handlers ***/
544
545 void cbBarDragPlugin::OnMouseMove( cbMotionEvent& event )
546 {
547 // calculate postion in frame's coordiantes
548
549 if ( !mBarDragStarted )
550 {
551 event.Skip(); // pass event to the next plugin
552 return;
553 }
554
555 wxPoint mousePos = event.mPos;
556
557 event.mpPane->PaneToFrame( &mousePos.x, &mousePos.y );
558
559 bool prevIsInClient = ( mpCurPane == 0 );
560
561 AdjustHintRect( mousePos );
562
563 // if the hint-rect is not "tempted" to any pane yet
564
565 if ( mpCurPane == NULL )
566 {
567 cbDockPane* pPane = HitTestPanes( mHintRect );
568
569 if ( !pPane )
570
571 // enable sticking again, if we've left the pane completely
572 mCanStick = TRUE;
573
574 if ( mCanStick && pPane &&
575 GetDistanceToPane( pPane, mousePos ) < GetBarHeightInPane( pPane ) )
576
577 StickToPane( pPane, mousePos );
578 else
579 if ( pPane && HitTestPanes( mousePos ) == pPane && 0 ) // FOR NOW:: disabled
580
581 StickToPane( pPane, mousePos );
582 }
583 else
584 {
585 // otherwise, when rect is now sticked to some of the panes
586 // check if it should still remain in this pane
587
588 mCanStick = TRUE;
589
590 bool mouseInOther = IsInOtherPane( mousePos );
591
592 if ( mouseInOther )
593 {
594 cbDockPane* pPane = HitTestPanes( mousePos );
595
596 StickToPane( pPane, mousePos );
597 }
598 else
599 {
600 if ( IsInClientArea( mousePos ) )
601 {
602 cbDockPane* pPane = HitTestPanes( mHintRect );
603
604 if ( pPane &&
605 pPane != mpCurPane &&
606 GetDistanceToPane( pPane, mousePos ) < GetBarHeightInPane( pPane ) )
607
608 StickToPane( pPane, mousePos );
609 else
610 if ( !pPane )
611 {
612 UnstickFromPane( mpCurPane, mousePos );
613
614 // FOR NOW:: disabled, would cause some mess
615 //mCanStick = FALSE; // prevents from sticking to this
616 // pane again, flag is reset when hint-rect
617 // leaves the pane completely
618 }
619 else
620 if ( GetDistanceToPane( pPane, mousePos ) > GetBarHeightInPane( pPane ) )
621 {
622 if ( !HitsPane( mpCurPane, mHintRect ) )
623 {
624 UnstickFromPane( mpCurPane, mousePos );
625
626 // FOR NOW:: disabled, would cause some mess
627 //mCanStick = FALSE; // prevents from sticking to this
628 // pane again, flag is reset when hint-rect
629 // leaves the pane completely
630 }
631 }
632
633 }
634 else
635 {
636 }
637 }
638 }
639
640 ShowHint( prevIsInClient );
641
642 wxCursor* pPrevCurs = mpCurCursor;
643
644 if ( mpCurPane )
645 {
646 mpCurCursor = mpLayout->mpNormalCursor;
647 }
648 else
649 {
650 // if floating is off, and we are in the client
651 // area, the cursor will be invalid, otherwise
652 // it will be the normal cursor
653
654 if (mpLayout->mFloatingOn)
655 {
656 mpCurCursor = mpLayout->mpNormalCursor;
657 }
658 else
659 {
660 mpCurCursor = mpLayout->mpNECursor;
661 }
662
663 }
664 if ( pPrevCurs != mpCurCursor )
665 mpLayout->GetParentFrame().SetCursor( *mpCurCursor );
666 }
667
668 void cbBarDragPlugin::OnLButtonDown( cbLeftDownEvent& event )
669 {
670 if ( mBarDragStarted )
671 {
672 wxMessageBox("DblClick!");
673 }
674
675 event.Skip();
676 }
677
678 void cbBarDragPlugin::OnLButtonUp( cbLeftUpEvent& event )
679 {
680 if ( mBarDragStarted )
681 {
682 if ( mpSrcPane->mProps.mRealTimeUpdatesOn == FALSE )
683 {
684 // erase current rectangle, and finsih on-screen drawing session
685
686 cbDrawHintRectEvent evt( mPrevHintRect, mpCurPane == NULL, TRUE, TRUE );
687
688 mpLayout->FirePluginEvent( evt );
689
690 if ( mpCurPane != NULL )
691 {
692 if ( mpSrcPane->mProps.mExactDockPredictionOn )
693 {
694 mpLayout->RedockBar( mpDraggedBar, mHintRect, mpCurPane, FALSE );
695
696 mpLayout->GetUpdatesManager().OnFinishChanges();
697 mpLayout->GetUpdatesManager().UpdateNow();
698 }
699 else
700 {
701 if (mpDraggedBar->mState == wxCBAR_FLOATING)
702 {
703 mpLayout->SetBarState( mpDraggedBar, wxCBAR_DOCKED_HORIZONTALLY, TRUE);
704 }
705
706 mpLayout->RedockBar( mpDraggedBar, mHintRect, mpCurPane );
707 }
708 }
709 else
710 {
711 if (mpDraggedBar->mState != wxCBAR_FLOATING)
712 {
713 mpLayout->SetBarState(mpDraggedBar, wxCBAR_FLOATING, true);
714 }
715
716 mpDraggedBar->mDimInfo.mBounds[ wxCBAR_FLOATING ] = mHintRect;
717 mpLayout->ApplyBarProperties( mpDraggedBar );
718 }
719 }
720
721 mHintRect.width = -1;
722
723 // In Windows, at least, the frame needs to have a null cursor
724 // else child windows (such as text windows) inherit the cursor
725 #if 1
726 mpLayout->GetParentFrame().SetCursor( wxNullCursor );
727 #else
728 mpLayout->GetParentFrame().SetCursor( *mpLayout->mpNormalCursor );
729 #endif
730
731 mpLayout->ReleaseEventsFromPane( event.mpPane );
732 mpLayout->ReleaseEventsFromPlugin( this );
733
734 mBarDragStarted = FALSE;
735
736 if ( mBarWasFloating && mpDraggedBar->mState != wxCBAR_FLOATING )
737 {
738 // save bar's floating position before it was docked
739
740 mpDraggedBar->mDimInfo.mBounds[ wxCBAR_FLOATING ] = mFloatedBarBounds;
741 }
742 }
743 else
744 event.Skip(); // pass event to the next plugin
745 }
746
747 void cbBarDragPlugin::OnLDblClick( cbLeftDClickEvent& event )
748 {
749 int avoidCompilerWarning = 1;
750 if ( avoidCompilerWarning )
751 {
752 cbBarInfo* pHittedBar;
753 cbRowInfo* pRow;
754
755 if ( event.mpPane->HitTestPaneItems( event.mPos, // in pane's coordiantes
756 &pRow,
757 &pHittedBar ) == CB_BAR_CONTENT_HITTED
758 )
759 {
760 mpLayout->SetBarState( pHittedBar, wxCBAR_FLOATING, TRUE );
761
762 mpLayout->RepositionFloatedBar( pHittedBar );
763
764 return; // event is "eaten" by this plugin
765 }
766
767 mBarDragStarted = FALSE;
768
769 event.Skip();
770 }
771
772 //wxMessageBox("Hi, dblclick arrived!");
773 }
774
775 void cbBarDragPlugin::OnStartBarDragging( cbStartBarDraggingEvent& event )
776 {
777 mpDraggedBar = event.mpBar;
778 mpSrcPane = event.mpPane;
779
780 mpLayout->CaptureEventsForPane( event.mpPane );
781 mpLayout->CaptureEventsForPlugin( this );
782
783 mpLayout->GetParentFrame().SetCursor( *mpLayout->mpNormalCursor );
784
785 mBarDragStarted = TRUE;
786
787 wxRect inParent = mpDraggedBar->mBounds;
788
789 mBarWasFloating = mpDraggedBar->mState == wxCBAR_FLOATING;
790
791 if ( mBarWasFloating )
792 {
793 inParent = mpDraggedBar->mDimInfo.mBounds[ wxCBAR_FLOATING ];
794 mFloatedBarBounds = inParent;
795 }
796 else
797 event.mpPane->PaneToFrame( &inParent );
798
799 mHintRect.x = POS_UNDEFINED;
800
801 mHintRect.width = inParent.width;
802 mHintRect.height = inParent.height;
803
804 mMouseInRectX = event.mPos.x - inParent.x;
805 mMouseInRectY = event.mPos.y - inParent.y;
806
807 mpSrcPane = event.mpPane;
808
809 if ( mpDraggedBar->mState == wxCBAR_FLOATING )
810
811 mpCurPane = NULL;
812 else
813 mpCurPane = event.mpPane;
814
815 mPrevHintRect.x = POS_UNDEFINED;
816
817 mCanStick = FALSE; // we're not stuck into any pane now -
818 // there's nowhere to "stick-twice"
819
820 mBarWidthInSrcPane = mpDraggedBar->mDimInfo.mSizes[ mpDraggedBar->mState ].x;
821
822 if ( mpSrcPane->mProps.mRealTimeUpdatesOn == FALSE &&
823 mpSrcPane->mProps.mExactDockPredictionOn )
824
825 mpLayout->GetUpdatesManager().OnStartChanges(); // capture initial state of layout
826
827 // simulate the first mouse movement
828
829 int x = event.mPos.x, y = event.mPos.y;
830
831 mpSrcPane->FrameToPane( &x, &y );
832
833 cbMotionEvent motionEvt( wxPoint(x,y), event.mpPane );
834
835
836 this->OnMouseMove( motionEvt );
837
838 return; // event is "eaten" by this plugin
839 }
840
841 /*** on-screen hint-tracking related methods ***/
842
843 void cbBarDragPlugin::OnDrawHintRect( cbDrawHintRectEvent& event )
844 {
845 if ( !mpScrDc ) StartTracking();
846
847 DoDrawHintRect( event.mRect, event.mIsInClient );
848
849 if ( event.mLastTime )
850
851 FinishTracking();
852 }
853
854 #define _IMG_A 0xAA // Note: modified from _A to _IMG_A, _A was already defined (cygwin)
855 #define _IMG_B 0x00 // Note: modified from _B to _IMG_A, _B was already defined (cygwin)
856 #define _IMG_C 0x55 // Note: modified from _C to _IMG_C, for consistency reasons.
857 #define _IMG_D 0x00 // Note: modified from _D to _IMG_D, for consistency reasons.
858
859 // FOR NOW:: static
860
861 static const unsigned char _gCheckerImg[16] = { _IMG_A,_IMG_B,_IMG_C,_IMG_D,
862 _IMG_A,_IMG_B,_IMG_C,_IMG_D,
863 _IMG_A,_IMG_B,_IMG_C,_IMG_D,
864 _IMG_A,_IMG_B,_IMG_C,_IMG_D
865 };
866
867 void cbBarDragPlugin::StartTracking()
868 {
869 mpScrDc = new wxScreenDC;
870
871 wxScreenDC::StartDrawingOnTop(&mpLayout->GetParentFrame());
872 }
873
874 void cbBarDragPlugin::DoDrawHintRect( wxRect& rect, bool isInClientRect)
875 {
876 wxRect scrRect;
877
878 RectToScr( rect, scrRect );
879
880 int prevLF = mpScrDc->GetLogicalFunction();
881
882 mpScrDc->SetLogicalFunction( wxINVERT );
883
884 if ( isInClientRect )
885 {
886 // BUG BUG BUG (wx):: somehow stippled brush works only
887 // when the bitmap created on stack, not
888 // as a member of the class
889
890 wxBitmap checker( (const char*)_gCheckerImg, 8,8 );
891
892 wxBrush checkerBrush( checker );
893
894 mpScrDc->SetPen( mpLayout->mNullPen );
895 mpScrDc->SetBrush( checkerBrush );
896
897 int half = mInClientHintBorder / 2;
898
899 mpScrDc->DrawRectangle( scrRect.x - half, scrRect.y - half,
900 scrRect.width + 2*half, mInClientHintBorder );
901
902 mpScrDc->DrawRectangle( scrRect.x - half, scrRect.y + scrRect.height - half,
903 scrRect.width + 2*half, mInClientHintBorder );
904
905 mpScrDc->DrawRectangle( scrRect.x - half, scrRect.y + half - 1,
906 mInClientHintBorder, scrRect.height - 2*half + 2);
907
908 mpScrDc->DrawRectangle( scrRect.x + scrRect.width - half,
909 scrRect.y + half - 1,
910 mInClientHintBorder, scrRect.height - 2*half + 2);
911
912 mpScrDc->SetBrush( wxNullBrush );
913 }
914 else
915 {
916 mpScrDc->SetPen( mpLayout->mBlackPen );
917
918 mpScrDc->DrawLine( scrRect.x, scrRect.y,
919 scrRect.x + scrRect.width, scrRect.y );
920
921 mpScrDc->DrawLine( scrRect.x, scrRect.y + 1,
922 scrRect.x, scrRect.y + scrRect.height );
923
924 mpScrDc->DrawLine( scrRect.x+1, scrRect.y + scrRect.height,
925 scrRect.x + scrRect.width, scrRect.y + scrRect.height );
926
927 mpScrDc->DrawLine( scrRect.x + scrRect.width , scrRect.y,
928 scrRect.x + scrRect.width, scrRect.y + scrRect.height + 1);
929 }
930
931 mpScrDc->SetLogicalFunction( prevLF );
932 }
933
934 void cbBarDragPlugin::DrawHintRect ( wxRect& rect, bool isInClientRect)
935 {
936 DoDrawHintRect( rect, isInClientRect );
937 }
938
939 void cbBarDragPlugin::EraseHintRect( wxRect& rect, bool isInClientRect)
940 {
941 DoDrawHintRect( rect, isInClientRect );
942 }
943
944 void cbBarDragPlugin::FinishTracking()
945 {
946 wxScreenDC::EndDrawingOnTop();
947
948 delete mpScrDc;
949
950 mpScrDc = NULL;
951 }
952
953 void cbBarDragPlugin::RectToScr( wxRect& frameRect, wxRect& scrRect )
954 {
955 scrRect = frameRect;
956
957 int x = frameRect.x, y = frameRect.y;
958
959 mpLayout->GetParentFrame().ClientToScreen( &x, &y );
960
961 scrRect.x = x;
962 scrRect.y = y;
963 }
964
wxWidgets (Impactor)