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