]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/fl/controlbar.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cleaning up the mess created by the FloodFill patch
[wxWidgets.git] / contrib / src / fl / controlbar.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: controlbar.cpp
3 // Purpose: Implementation for main controlbar classes.
4 // Author: Aleksandras Gluchovas
5 // Modified by:
6 // Created: 06/09/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Aleksandras Gluchovas
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "controlbar.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 <math.h>
28 #include <stdlib.h>
29
30 #include "wx/string.h"
31 #include "wx/utils.h" // import wxMin,wxMax macros
32 #include "wx/minifram.h"
33
34 #include "wx/fl/controlbar.h"
35
36 // import classes of default plugins
37
38 #include "wx/fl/panedrawpl.h"
39 #include "wx/fl/rowlayoutpl.h"
40 #include "wx/fl/antiflickpl.h"
41 #include "wx/fl/bardragpl.h"
42 #include "wx/fl/cbcustom.h"
43
44 #include "wx/fl/gcupdatesmgr.h" // import default updates manager class ("garbage-collecting" one)
45 #include "wx/fl/updatesmgr.h"
46
47 #include "wx/fl/toolwnd.h"
48
49 // These are the event IDs being initialized to a value to
50 // meet the new event paradigm as of wx2.3.0. Probably we
51 // should find a way to make these be non-global, but this
52 // works for right now.
53 wxEventType cbEVT_PL_LEFT_DOWN = wxNewEventType();
54 wxEventType cbEVT_PL_LEFT_UP = wxNewEventType();
55 wxEventType cbEVT_PL_RIGHT_DOWN = wxNewEventType();
56 wxEventType cbEVT_PL_RIGHT_UP = wxNewEventType();
57 wxEventType cbEVT_PL_MOTION = wxNewEventType();
58
59 wxEventType cbEVT_PL_LEFT_DCLICK = wxNewEventType();
60
61 wxEventType cbEVT_PL_LAYOUT_ROW = wxNewEventType();
62 wxEventType cbEVT_PL_RESIZE_ROW = wxNewEventType();
63 wxEventType cbEVT_PL_LAYOUT_ROWS = wxNewEventType();
64 wxEventType cbEVT_PL_INSERT_BAR = wxNewEventType();
65 wxEventType cbEVT_PL_RESIZE_BAR = wxNewEventType();
66 wxEventType cbEVT_PL_REMOVE_BAR = wxNewEventType();
67 wxEventType cbEVT_PL_SIZE_BAR_WND = wxNewEventType();
68
69 wxEventType cbEVT_PL_DRAW_BAR_DECOR = wxNewEventType();
70 wxEventType cbEVT_PL_DRAW_ROW_DECOR = wxNewEventType();
71 wxEventType cbEVT_PL_DRAW_PANE_DECOR = wxNewEventType();
72 wxEventType cbEVT_PL_DRAW_BAR_HANDLES = wxNewEventType();
73 wxEventType cbEVT_PL_DRAW_ROW_HANDLES = wxNewEventType();
74 wxEventType cbEVT_PL_DRAW_ROW_BKGROUND = wxNewEventType();
75 wxEventType cbEVT_PL_DRAW_PANE_BKGROUND = wxNewEventType();
76
77 wxEventType cbEVT_PL_START_BAR_DRAGGING = wxNewEventType();
78 wxEventType cbEVT_PL_DRAW_HINT_RECT = wxNewEventType();
79
80 wxEventType cbEVT_PL_START_DRAW_IN_AREA = wxNewEventType();
81 wxEventType cbEVT_PL_FINISH_DRAW_IN_AREA = wxNewEventType();
82
83 wxEventType cbEVT_PL_CUSTOMIZE_BAR = wxNewEventType();
84 wxEventType cbEVT_PL_CUSTOMIZE_LAYOUT = wxNewEventType();
85
86 wxEventType wxCUSTOM_CB_PLUGIN_EVENTS_START_AT = wxNewEventType();
87
88 // some ascii-art, still can't get these *nice* cursors working on wx... :-(
89
90 static const char* _gHorizCursorImg[] =
91 {
92 "............XX....XX............",
93 "............XX....XX............",
94 "............XX....XX............",
95 "............XX....XX............",
96 "............XX....XX............",
97 "...X........XX....XX........X...",
98 "..XX........XX....XX........XX..",
99 ".XXX........XX....XX........XXX.",
100 "XXXXXXXXXXXXXX....XXXXXXXXXXXXXX",
101 ".XXX........XX....XX........XXX.",
102 "..XX........XX....XX........XX..",
103 "...X........XX....XX........X...",
104 "............XX....XX............",
105 "............XX....XX............",
106 "............XX....XX............",
107 "............XX....XX............"
108 };
109
110 static const char* _gVertCursorImg[] =
111 {
112 "................X...............",
113 "...............XXX..............",
114 "..............XXXXX.............",
115 ".............XXXXXXX............",
116 "................X...............",
117 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
118 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
119 "................................",
120 "................................",
121 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
122 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
123 "................X...............",
124 ".............XXXXXXX............",
125 "..............XXXXX.............",
126 "...............XXX..............",
127 "................X..............."
128 };
129
130 // helper inline functions
131
132 static inline bool rect_contains_point( const wxRect& rect, int x, int y )
133 {
134 return ( x >= rect.x &&
135 y >= rect.y &&
136 x < rect.x + rect.width &&
137 y < rect.y + rect.height );
138 }
139
140 static inline bool rect_hits_rect( const wxRect& r1, const wxRect& r2 )
141 {
142 if ( ( r2.x >= r1.x && r2.x <= r1.x + r1.width ) ||
143 ( r1.x >= r2.x && r1.x <= r2.x + r2.width ) )
144
145 if ( ( r2.y >= r1.y && r2.y <= r1.y + r1.height ) ||
146 ( r1.y >= r2.y && r1.y <= r2.y + r2.height ) )
147
148 return 1;
149
150 return 0;
151 }
152
153 static inline void hide_rect( wxRect& r )
154 {
155 r.x = 32768;
156 r.y = 32768;
157 r.width = 1;
158 r.height = 1;
159 }
160
161 static inline void clip_rect_against_rect( wxRect& r1, const wxRect& r2 )
162 {
163 if ( r1.x < r2.x ||
164 r1.y < r2.y ||
165 r1.x >= r2.x + r2.width ||
166 r1.y >= r2.y + r2.height
167 )
168 {
169 hide_rect( r1 );
170 return;
171 }
172 else
173 {
174 if ( r1.x + r1.width > r2.x + r2.width )
175
176 r1.width = r2.x + r2.width - r1.x;
177
178 if ( r1.y + r1.height > r2.y + r2.height )
179
180 r1.height = r2.y + r2.height - r1.y;
181 }
182 }
183
184 /***** Implementation for class cbBarSpy *****/
185
186 IMPLEMENT_DYNAMIC_CLASS( cbBarSpy, wxEvtHandler )
187
188 cbBarSpy::cbBarSpy(void)
189 : mpLayout(0),
190 mpBarWnd(0)
191 {}
192
193 cbBarSpy::cbBarSpy( wxFrameLayout* pPanel )
194
195 : mpLayout(pPanel),
196 mpBarWnd(0)
197 {}
198
199 void cbBarSpy::SetBarWindow( wxWindow* pWnd )
200 {
201 mpBarWnd = pWnd;
202 }
203
204 bool cbBarSpy::ProcessEvent(wxEvent& event)
205 {
206 bool handled = wxEvtHandler::ProcessEvent( event );
207
208 int type = event.GetEventType();
209
210 if ( !handled && ( type == wxEVT_LEFT_DOWN ||
211 type == wxEVT_LEFT_DCLICK ) )
212 {
213 wxMouseEvent& mevent = *((wxMouseEvent*)&event);
214
215 int x = mevent.m_x;
216 int y = mevent.m_y;
217
218 mpBarWnd->ClientToScreen( &x, &y );
219 mpLayout->GetParentFrame().ScreenToClient( &x, &y );
220
221 mevent.m_x = x;
222 mevent.m_y = y;
223
224 // forwared not-handled event to frame-layout
225
226 if ( type == wxEVT_LEFT_DOWN )
227 {
228 //mpLayout->OnLButtonDown( mevent );
229 event.Skip();
230 }
231 else
232 mpLayout->OnLDblClick( mevent );
233
234 //event.Skip(FALSE);
235 }
236
237 return handled;
238 }
239
240 /***** Implementation for class wxFrameLayout *****/
241
242 IMPLEMENT_DYNAMIC_CLASS( wxFrameLayout, wxEvtHandler )
243
244 BEGIN_EVENT_TABLE( wxFrameLayout, wxEvtHandler )
245
246 EVT_PAINT ( wxFrameLayout::OnPaint )
247 EVT_SIZE ( wxFrameLayout::OnSize )
248 EVT_LEFT_DOWN ( wxFrameLayout::OnLButtonDown )
249 EVT_LEFT_UP ( wxFrameLayout::OnLButtonUp )
250 EVT_RIGHT_DOWN ( wxFrameLayout::OnRButtonDown )
251 EVT_RIGHT_UP ( wxFrameLayout::OnRButtonUp )
252 EVT_MOTION ( wxFrameLayout::OnMouseMove )
253
254 EVT_LEFT_DCLICK( wxFrameLayout::OnLDblClick )
255
256 EVT_IDLE ( wxFrameLayout::OnIdle )
257 EVT_SET_FOCUS ( wxFrameLayout::OnSetFocus )
258 EVT_KILL_FOCUS ( wxFrameLayout::OnKillFocus )
259
260 EVT_ACTIVATE ( wxFrameLayout::OnActivate )
261
262 EVT_ERASE_BACKGROUND( wxFrameLayout::OnEraseBackground )
263
264 END_EVENT_TABLE()
265
266 // FIXME:: how to eliminate these cut&pasted constructors?
267
268 wxFrameLayout::wxFrameLayout(void)
269
270 : mpFrame ( NULL ),
271 mpFrameClient( NULL ),
272
273 mDarkPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID ),
274 mLightPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DHILIGHT), 1, wxSOLID ),
275 mGrayPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ),
276 mBlackPen ( wxColour( 0, 0, 0), 1, wxSOLID ),
277 mBorderPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ),
278
279 mNullPen( wxColour(0,0,0), 1, wxTRANSPARENT ),
280
281 mpPaneInFocus( NULL ),
282 mpLRUPane ( NULL ),
283
284
285 mpTopPlugin ( NULL ),
286 mpCaputesInput( NULL ),
287
288 mClientWndRefreshPending( FALSE ),
289 mRecalcPending( TRUE ),
290 mCheckFocusWhenIdle( FALSE )
291 {
292 CreateCursors();
293
294 int i;
295 for ( i = 0; i != MAX_PANES; ++i )
296 mPanes[i] = NULL;
297
298 mFloatingOn = CanReparent();
299 }
300
301 wxFrameLayout::wxFrameLayout( wxWindow* pParentFrame, wxWindow* pFrameClient, bool activateNow )
302
303 : mpFrame( pParentFrame ),
304 mpFrameClient(pFrameClient),
305
306 mDarkPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID ),
307 mLightPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DHILIGHT), 1, wxSOLID ),
308 mGrayPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ),
309 mBlackPen ( wxColour( 0, 0, 0), 1, wxSOLID ),
310 mBorderPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ),
311
312 mNullPen( wxColour(0,0,0), 1, wxTRANSPARENT ),
313
314 mpPaneInFocus( NULL ),
315 mpLRUPane ( NULL ),
316
317 mFloatingOn ( TRUE ),
318
319 mpTopPlugin ( NULL ),
320 mpCaputesInput( NULL ),
321
322 mClientWndRefreshPending( FALSE ),
323 mRecalcPending( TRUE ),
324 mCheckFocusWhenIdle( FALSE ),
325
326 mpUpdatesMgr( NULL )
327 {
328 CreateCursors();
329
330 int i;
331 for ( i = 0; i != MAX_PANES; ++i )
332 mPanes[i] = new cbDockPane( i, this );
333
334 if ( activateNow )
335 {
336 HookUpToFrame();
337
338 // FOR NOW::
339 // DBG:: set RED color of frame's background for the
340 // prurpose of tracking engine bugs "visually"
341
342 GetParentFrame().SetBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE) );
343 }
344
345 mFloatingOn = CanReparent();
346 }
347
348 // NOTE:: below are the only platform-check "ifdef"s in the docking system!
349
350 bool wxFrameLayout::CanReparent()
351 {
352 #ifdef __WXMSW__
353 return TRUE;
354 #elif defined (__WXGTK__)
355 //return TRUE;
356 return FALSE;
357 #else
358
359 return FALSE; // reparenting is not yet supported by Motif and others
360 #endif
361 }
362
363 /*
364 #ifdef __WXMSW__
365 #inlcude "windows.h"
366 #endif
367 */
368
369 void wxFrameLayout::ReparentWindow( wxWindow* pChild, wxWindow* pNewParent )
370 {
371 #ifdef __WXMSW__
372 #if 0
373
374 if ( pChild->GetParent() )
375 {
376 bool success = pChild->GetParent()->GetChildren().DeleteObject( pChild );
377
378 wxASSERT( success ); // DBG::
379 }
380
381 ::SetParent( (HWND)pChild->m_hWnd, (HWND)pNewParent->m_hWnd );
382
383 pNewParent->GetChildren().Append( pChild );
384
385 pChild->SetParent( pNewParent );
386 #endif
387 pChild->Reparent(pNewParent);
388
389 return;
390 #elif defined(__WXGTK__) || defined(__WXX11__)
391 // FOR NOW:: floating with wxGtk still very buggy
392
393 return;
394
395 //pChild->ReParent( pNewParent );
396
397 //return;
398 #else
399 wxMessageBox( "Sorry, docking is not supported for ports other than MSW and wxGTK" );
400 #endif
401 }
402
403 void wxFrameLayout::DestroyBarWindows()
404 {
405 wxNode* pSpy = mBarSpyList.First();
406
407 while( pSpy )
408 {
409 cbBarSpy& spy = *((cbBarSpy*)pSpy->Data());
410
411 if ( spy.mpBarWnd->GetEventHandler() == &spy )
412
413 spy.mpBarWnd->PopEventHandler();
414
415 delete &spy;
416
417 pSpy = pSpy->Next();
418 }
419
420 mBarSpyList.Clear();
421
422 size_t i;
423 for ( i = 0; i != mAllBars.Count(); ++i )
424 {
425 if ( mAllBars[i]->mpBarWnd )
426 {
427 mAllBars[i]->mpBarWnd->Destroy();
428 mAllBars[i]->mpBarWnd = NULL;
429 }
430 }
431 }
432
433 void wxFrameLayout::ShowFloatedWindows( bool show )
434 {
435 wxNode* pNode = mFloatedFrames.First();
436
437 while( pNode )
438 {
439 cbFloatedBarWindow* pFFrm = ((cbFloatedBarWindow*)pNode->Data());
440
441 pFFrm->Show( show );
442
443 pNode = pNode->Next();
444 }
445 }
446
447 wxFrameLayout::~wxFrameLayout()
448 {
449 UnhookFromFrame();
450
451 if ( mpUpdatesMgr )
452 delete mpUpdatesMgr;
453
454 PopAllPlugins();
455
456 // destoy the chain of plugins from left to right
457
458 wxEvtHandler* pCur = mpTopPlugin;
459
460 if ( pCur )
461
462 while ( pCur->GetPreviousHandler() )
463
464 pCur = pCur->GetPreviousHandler();
465
466 while ( pCur )
467 {
468 wxEvtHandler* pNext = pCur->GetNextHandler();
469
470 delete pCur;
471
472 pCur = pNext;
473 }
474
475 // destroy contents of arrays and lists
476
477 size_t i = 0;
478 for ( i = 0; i != MAX_PANES; ++i )
479 {
480 if ( mPanes[i] )
481 delete mPanes[i];
482 }
483 if ( mpHorizCursor )
484 delete mpHorizCursor;
485 if ( mpVertCursor )
486 delete mpVertCursor;
487 if ( mpNormalCursor )
488 delete mpNormalCursor;
489 if ( mpDragCursor )
490 delete mpDragCursor;
491 if ( mpNECursor )
492 delete mpNECursor;
493
494 wxNode* pSpy = mBarSpyList.First();
495
496 while( pSpy )
497 {
498 cbBarSpy& spy = *((cbBarSpy*)pSpy->Data());
499
500 if ( spy.mpBarWnd->GetEventHandler() == &spy )
501
502 spy.mpBarWnd->PopEventHandler();
503
504 delete &spy;
505
506 pSpy = pSpy->Next();
507 }
508
509 for ( i = 0; i != mAllBars.Count(); ++i )
510 delete mAllBars[i];
511 }
512
513 void wxFrameLayout::EnableFloating( bool enable )
514 {
515 mFloatingOn = enable && CanReparent();
516 }
517
518 void wxFrameLayout::Activate()
519 {
520 HookUpToFrame();
521
522 RefreshNow( TRUE );
523
524 ShowFloatedWindows( TRUE );
525 }
526
527 void wxFrameLayout::Deactivate()
528 {
529 ShowFloatedWindows( FALSE );
530
531 UnhookFromFrame();
532
533 HideBarWindows();
534 }
535
536 void wxFrameLayout::SetFrameClient( wxWindow* pFrameClient )
537 {
538 mpFrameClient = pFrameClient;
539 }
540
541 wxWindow* wxFrameLayout::GetFrameClient()
542 {
543 return mpFrameClient;
544 }
545
546 cbUpdatesManagerBase& wxFrameLayout::GetUpdatesManager()
547 {
548 if ( !mpUpdatesMgr )
549 mpUpdatesMgr = CreateUpdatesManager();
550
551 return *mpUpdatesMgr;
552 }
553
554 void wxFrameLayout::SetUpdatesManager( cbUpdatesManagerBase* pUMgr )
555 {
556 if ( mpUpdatesMgr )
557 delete mpUpdatesMgr;
558
559 mpUpdatesMgr = pUMgr;
560
561 mpUpdatesMgr->SetLayout( this );
562 }
563
564 cbUpdatesManagerBase* wxFrameLayout::CreateUpdatesManager()
565 {
566 return new cbGCUpdatesMgr( this );
567 //return new cbSimpleUpdatesMgr( this );
568 }
569
570 void wxFrameLayout::AddBar( wxWindow* pBarWnd,
571 const cbDimInfo& dimInfo,
572 int alignment,
573 int rowNo,
574 int columnPos,
575 const wxString& name,
576 bool spyEvents,
577 int state
578 )
579 {
580 if ( pBarWnd && spyEvents )
581 {
582 // hook up spy to bar window
583 cbBarSpy* pSpy = new cbBarSpy( this );
584
585 pSpy->SetBarWindow( pBarWnd );
586 pBarWnd->PushEventHandler( pSpy );
587
588 mBarSpyList.Append( pSpy );
589 }
590
591 cbBarInfo* pInfo = new cbBarInfo();
592
593 pInfo->mName = name;
594 pInfo->mpBarWnd = pBarWnd;
595 pInfo->mDimInfo = dimInfo;
596 pInfo->mState = state;
597 pInfo->mAlignment = alignment;
598 pInfo->mRowNo = rowNo;
599 pInfo->mBounds.x = columnPos;
600
601 mAllBars.Add( pInfo );
602
603 DoSetBarState( pInfo );
604 }
605
606 bool wxFrameLayout::RedockBar( cbBarInfo* pBar,
607 const wxRect& shapeInParent,
608 cbDockPane* pToPane,
609 bool updateNow )
610 {
611 if ( !pToPane )
612
613 pToPane = HitTestPanes( shapeInParent, NULL );
614
615 if ( !pToPane )
616
617 return FALSE; // bar's shape does not hit any pane
618 // - redocking is NOT possible
619
620 cbDockPane* pBarPane = GetBarPane( pBar );
621
622 if ( updateNow )
623
624 GetUpdatesManager().OnStartChanges();
625
626 pBarPane->RemoveBar( pBar );
627
628 // FIXME FIXME:: the recalculation below may be a *huge* performance
629 // hit, it could be eliminated though...
630 // but first the "pane-postion-changed" problem
631 // has to be fixed
632
633 RecalcLayout( FALSE );
634
635 pToPane->InsertBar( pBar, shapeInParent );
636
637 RecalcLayout( FALSE );
638
639 // finish update "transaction"
640
641 if ( updateNow )
642 {
643 GetUpdatesManager().OnFinishChanges();
644 GetUpdatesManager().UpdateNow();
645 }
646
647 return TRUE;
648 }
649
650 cbBarInfo* wxFrameLayout::FindBarByName( const wxString& name )
651 {
652 size_t i;
653 for ( i = 0; i != mAllBars.Count(); ++i )
654 if ( mAllBars[i]->mName == name )
655 return mAllBars[i];
656
657 return NULL;
658 }
659
660 cbBarInfo* wxFrameLayout::FindBarByWindow( const wxWindow* pWnd )
661 {
662 size_t i;
663 for ( i = 0; i != mAllBars.Count(); ++i )
664 if ( mAllBars[i]->mpBarWnd == pWnd )
665 return mAllBars[i];
666
667 return NULL;
668 }
669
670 BarArrayT& wxFrameLayout::GetBars()
671 {
672 return mAllBars;
673 }
674
675 void wxFrameLayout::SetBarState( cbBarInfo* pBar, int newState, bool updateNow )
676 {
677 if ( newState == wxCBAR_FLOATING && !mFloatingOn )
678
679 return;
680
681 if ( updateNow )
682
683 GetUpdatesManager().OnStartChanges();
684
685 pBar->mUMgrData.SetDirty(TRUE);
686
687 // check bar's previous state
688
689 if ( pBar->mState != wxCBAR_HIDDEN && pBar->mState != wxCBAR_FLOATING )
690 {
691 cbDockPane* pPane;
692 cbRowInfo* pRow;
693
694 bool success = LocateBar( pBar, &pRow, &pPane );
695
696 wxASSERT( success ); // DBG::
697
698 // save LRU-dim info before removing bar
699
700 pBar->mDimInfo.mLRUPane = pPane->GetAlignment();
701 pBar->mDimInfo.mBounds[ pPane->GetAlignment() ] = pBar->mBounds;
702
703 // remove it from the pane it was docked on
704
705 pPane->RemoveBar( pBar );
706
707 }
708
709 if ( pBar->mState == wxCBAR_FLOATING && newState != wxCBAR_FLOATING )
710 {
711 // remove bar's window from the containing mini-frame
712 // and set its parent to be layout's parent frame
713
714 if ( pBar->mpBarWnd )
715 {
716 pBar->mpBarWnd->Show(FALSE); // to avoid flicker upon reparenting
717
718 wxNode* pNode = mFloatedFrames.First();
719
720 while( pNode )
721 {
722 cbFloatedBarWindow* pFFrm = ((cbFloatedBarWindow*)pNode->Data());
723
724 if ( pFFrm->GetBar() == pBar )
725 {
726 pFFrm->Show( FALSE ); // reduces flicker sligthly
727
728 ReparentWindow( pBar->mpBarWnd, &GetParentFrame() );
729
730 pBar->mBounds = pBar->mDimInfo.mBounds[ pBar->mDimInfo.mLRUPane ];
731
732 if ( newState != wxCBAR_HIDDEN )
733
734 pBar->mAlignment = pBar->mDimInfo.mLRUPane;
735
736 mFloatedFrames.DeleteNode( pNode );
737
738 pFFrm->Show( FALSE );
739 pFFrm->Destroy(); break;
740 }
741
742 pNode = pNode->Next();
743 }
744
745 // FOR NOW:: excessive!
746 //if ( mpFrameClient ) mpFrameClient->Refresh();
747 if ( mpFrameClient )
748 mClientWndRefreshPending = TRUE;
749 }
750 }
751
752 if ( pBar->mDimInfo.GetDimHandler() )
753 {
754 pBar->mDimInfo.GetDimHandler()->OnChangeBarState( pBar, newState );
755 }
756
757 pBar->mState = newState;
758
759 DoSetBarState( pBar );
760
761 if ( updateNow )
762 {
763 RecalcLayout(FALSE);
764
765 GetUpdatesManager().OnFinishChanges();
766 GetUpdatesManager().UpdateNow();
767 }
768 }
769
770 void wxFrameLayout::InverseVisibility( cbBarInfo* pBar )
771 {
772 wxASSERT( pBar ); // DBG::
773
774 // "inverse" bar-visibility of the selected bar
775
776 int newState = 0;
777
778 if ( pBar->mState == wxCBAR_HIDDEN )
779 {
780 if ( pBar->mAlignment == -1 )
781 {
782 pBar->mAlignment = 0; // just remove "-1" marking
783 newState = wxCBAR_FLOATING;
784 }
785 else
786 if ( pBar->mAlignment == FL_ALIGN_TOP ||
787 pBar->mAlignment == FL_ALIGN_BOTTOM )
788
789 newState = wxCBAR_DOCKED_HORIZONTALLY;
790 else
791 newState = wxCBAR_DOCKED_VERTICALLY;
792 }
793 else
794 {
795 newState = wxCBAR_HIDDEN;
796
797 if ( pBar->mState == wxCBAR_FLOATING )
798
799 pBar->mAlignment = -1;
800 }
801
802 this->SetBarState( pBar, newState, TRUE );
803
804 if ( newState == wxCBAR_FLOATING )
805
806 this->RepositionFloatedBar( pBar );
807 }
808
809 void wxFrameLayout::ApplyBarProperties( cbBarInfo* pBar )
810 {
811 if ( pBar->mState == wxCBAR_FLOATING )
812 {
813 RepositionFloatedBar( pBar );
814 }
815 else
816 if ( pBar->mState == wxCBAR_DOCKED_HORIZONTALLY ||
817 pBar->mState == wxCBAR_DOCKED_VERTICALLY
818 )
819 {
820 // FOR NOW:: nothing
821 }
822
823 }
824
825 void wxFrameLayout::RepositionFloatedBar( cbBarInfo* pBar )
826 {
827 if ( !mFloatingOn ) return;
828
829 wxNode* pNode = mFloatedFrames.First();
830
831 while( pNode )
832 {
833 cbFloatedBarWindow* pFFrm = ((cbFloatedBarWindow*)pNode->Data());
834
835 if ( pFFrm->GetBar() == pBar )
836 {
837 wxRect& bounds = pBar->mDimInfo.mBounds[wxCBAR_FLOATING];
838
839 int x = bounds.x,
840 y = bounds.y;
841
842 GetParentFrame().ClientToScreen( &x, &y );
843
844 pFFrm->PositionFloatedWnd( x,y,
845 bounds.width,
846 bounds.height );
847
848 break;
849 }
850
851 pNode = pNode->Next();
852 }
853 }
854
855 void wxFrameLayout::DoSetBarState( cbBarInfo* pBar )
856 {
857 if ( pBar->mState != wxCBAR_FLOATING &&
858 pBar->mState != wxCBAR_HIDDEN )
859
860 // dock it
861
862 mPanes[pBar->mAlignment]->InsertBar( pBar );
863 else
864 if ( pBar->mState == wxCBAR_HIDDEN )
865 {
866 // hide it
867
868 if ( pBar->mpBarWnd )
869
870 pBar->mpBarWnd->Show( FALSE );
871 }
872 else
873 {
874 if ( !mFloatingOn ) return;
875
876 // float it
877
878 if ( pBar->mpBarWnd == NULL || !CanReparent() )
879 {
880 // FOR NOW:: just hide it
881
882 if ( pBar->mpBarWnd )
883
884 pBar->mpBarWnd->Show( FALSE );
885
886 pBar->mState = wxCBAR_HIDDEN;
887
888 return;
889 }
890
891 cbFloatedBarWindow* pMiniFrm = new cbFloatedBarWindow();
892
893 pMiniFrm->SetBar( pBar );
894 pMiniFrm->SetLayout( this );
895
896 pMiniFrm->Create( &GetParentFrame(), -1, pBar->mName,
897 wxPoint( 50,50 ),
898 wxSize ( 0, 0 ),
899 wxFRAME_FLOAT_ON_PARENT | wxFRAME_TOOL_WINDOW
900 );
901
902 pMiniFrm->SetClient( pBar->mpBarWnd );
903
904 ReparentWindow( pBar->mpBarWnd, pMiniFrm );
905
906 mFloatedFrames.Append( pMiniFrm );
907
908 wxRect& bounds = pBar->mDimInfo.mBounds[wxCBAR_FLOATING];
909
910 // check if it wasn't floated anytime before
911
912 if ( bounds.width == -1 )
913 {
914 wxRect& clntRect = GetClientRect();
915
916 // adjust position into which the next floated bar will be placed
917
918 if ( mNextFloatedWndPos.x + bounds.width > clntRect.width )
919
920 mNextFloatedWndPos.x = mFloatingPosStep.x;
921
922 if ( mNextFloatedWndPos.y + bounds.height > clntRect.height )
923
924 mNextFloatedWndPos.y = mFloatingPosStep.y;
925
926 bounds.x = mNextFloatedWndPos.x + clntRect.x;
927 bounds.y = mNextFloatedWndPos.y + clntRect.y;
928
929 bounds.width = pBar->mDimInfo.mSizes[wxCBAR_FLOATING].x;
930 bounds.height = pBar->mDimInfo.mSizes[wxCBAR_FLOATING].y;
931
932 mNextFloatedWndPos.x += mFloatingPosStep.x;
933 mNextFloatedWndPos.y += mFloatingPosStep.y;
934 }
935
936 pMiniFrm->Show( TRUE );
937
938 // FIXME:: this is excessive
939 pBar->mpBarWnd->Show(TRUE);
940 }
941 }
942
943 void wxFrameLayout::RemoveBar( cbBarInfo* pBarInfo )
944 {
945 // first, try to "guess" what was the perviouse state of the bar
946
947 cbDockPane* pPane;
948 cbRowInfo* pRow;
949
950 if ( LocateBar( pBarInfo, &pRow, &pPane ) )
951 {
952 // ...aha, bar was docked into one of the panes,
953 // remove it from there
954
955 pPane->RemoveBar( pBarInfo );
956 }
957
958 size_t i;
959 for ( i = 0; i != mAllBars.Count(); ++i )
960 {
961 if ( mAllBars[i] == pBarInfo )
962 {
963 #if wxCHECK_VERSION(2,3,2)
964 mAllBars.RemoveAt(i);
965 #else
966 mAllBars.Remove(i);
967 #endif
968 if ( pBarInfo->mpBarWnd ) // hides it's window
969
970 pBarInfo->mpBarWnd->Show( FALSE );
971
972 delete pBarInfo;
973
974 return;
975 }
976 }
977 wxFAIL_MSG("bar info should be present in the list of all bars of all panes");
978 }
979
980 bool wxFrameLayout::LocateBar( cbBarInfo* pBarInfo,
981 cbRowInfo** ppRow,
982 cbDockPane** ppPane )
983 {
984 (*ppRow) = NULL;
985 (*ppPane) = NULL;
986
987 int n;
988 for ( n = 0; n != MAX_PANES; ++n )
989 {
990 wxBarIterator i( mPanes[n]->GetRowList() );
991
992 while ( i.Next() )
993
994 if ( &i.BarInfo() == pBarInfo )
995 {
996 (*ppPane) = mPanes[n];
997 (*ppRow ) = &i.RowInfo();
998
999 return TRUE;
1000 }
1001 }
1002
1003 return FALSE;
1004 }
1005
1006 void wxFrameLayout::RecalcLayout( bool repositionBarsNow )
1007 {
1008 mRecalcPending = FALSE;
1009
1010 int frmWidth, frmHeight;
1011 mpFrame->GetClientSize( &frmWidth, &frmHeight );
1012 int paneHeight = 0;
1013
1014 int curY = 0;
1015 int curX = 0;
1016 wxRect rect;
1017
1018 // pane positioning priorities in decreasing order:
1019 // top, bottom, left, right
1020
1021 // setup TOP pane
1022
1023 cbDockPane* pPane = mPanes[ FL_ALIGN_TOP ];
1024
1025 pPane->SetPaneWidth( frmWidth );
1026 pPane->RecalcLayout();
1027
1028 paneHeight = pPane->GetPaneHeight();
1029
1030 rect.x = curX;
1031 rect.y = curY;
1032 rect.width = frmWidth;
1033 rect.height = wxMin( paneHeight, frmHeight - curY );
1034
1035 pPane->SetBoundsInParent( rect );
1036
1037 curY += paneHeight;
1038
1039 // setup BOTTOM pane
1040
1041 pPane = mPanes[ FL_ALIGN_BOTTOM ];
1042
1043 pPane->SetPaneWidth( frmWidth );
1044 pPane->RecalcLayout();
1045
1046 paneHeight = pPane->GetPaneHeight();
1047
1048 rect.x = curX;
1049 rect.y = wxMax( frmHeight - paneHeight, curY );
1050 rect.width = frmWidth;
1051 rect.height = frmHeight - rect.y;
1052
1053 pPane->SetBoundsInParent( rect );
1054
1055 // setup LEFT pane
1056
1057 pPane = mPanes[ FL_ALIGN_LEFT ];
1058
1059 // bottom pane's y
1060 pPane->SetPaneWidth( rect.y - curY );
1061
1062 pPane->RecalcLayout();
1063 paneHeight = pPane->GetPaneHeight();
1064
1065 // bottom rect's y
1066 rect.height = rect.y - curY;
1067 rect.x = curX;
1068 rect.y = curY;
1069 rect.width = wxMin( paneHeight, frmWidth );
1070
1071 pPane->SetBoundsInParent( rect );
1072
1073 curX += rect.width;
1074
1075 // setup RIGHT pane
1076
1077 pPane = mPanes[ FL_ALIGN_RIGHT ];
1078
1079 // left pane's height
1080 pPane->SetPaneWidth( rect.height );
1081
1082 pPane->RecalcLayout();
1083 paneHeight = pPane->GetPaneHeight();
1084
1085 // left pane's height
1086 rect.height = rect.height;
1087 rect.x = wxMax( frmWidth - paneHeight, curX );
1088 rect.y = curY;
1089 rect.width = frmWidth - rect.x;
1090
1091 pPane->SetBoundsInParent( rect );
1092
1093 // recalc bounds of the client-window
1094
1095 mClntWndBounds.x = mPanes[FL_ALIGN_LEFT]->mBoundsInParent.x +
1096 mPanes[FL_ALIGN_LEFT]->mBoundsInParent.width;
1097 mClntWndBounds.y = mPanes[FL_ALIGN_TOP ]->mBoundsInParent.y +
1098 mPanes[FL_ALIGN_TOP ]->mBoundsInParent.height;
1099
1100 mClntWndBounds.width = mPanes[FL_ALIGN_RIGHT]->mBoundsInParent.x -
1101 mClntWndBounds.x;
1102 mClntWndBounds.height = mPanes[FL_ALIGN_BOTTOM]->mBoundsInParent.y -
1103 mClntWndBounds.y;
1104
1105 if ( repositionBarsNow )
1106
1107 PositionPanes();
1108 }
1109
1110 int wxFrameLayout::GetClientHeight()
1111 {
1112 // for better portablility wxWindow::GetSzie() is not used here
1113
1114 return mClntWndBounds.height;
1115 }
1116
1117 int wxFrameLayout::GetClientWidth()
1118 {
1119 // for better portablility wxWindow::GetSzie() is not used here
1120
1121 return mClntWndBounds.width;
1122 }
1123
1124 void wxFrameLayout::PositionClientWindow()
1125 {
1126 if ( mpFrameClient )
1127 {
1128 if ( mClntWndBounds.width >= 1 && mClntWndBounds.height >= 1 )
1129 {
1130 mpFrameClient->SetSize( mClntWndBounds.x, mClntWndBounds.y,
1131 mClntWndBounds.width, mClntWndBounds.height, 0 );
1132
1133 if ( !mpFrameClient->IsShown() )
1134
1135 mpFrameClient->Show( TRUE );
1136 }
1137 else
1138 mpFrameClient->Show( FALSE );
1139 }
1140 }
1141
1142 void wxFrameLayout::PositionPanes()
1143 {
1144 PositionClientWindow();
1145
1146 // FOR NOW:: excessive updates!
1147 // reposition bars within all panes
1148
1149 int i;
1150 for ( i = 0; i != MAX_PANES; ++i )
1151 mPanes[i]->SizePaneObjects();
1152 }
1153
1154 void wxFrameLayout::OnSize( wxSizeEvent& event )
1155 {
1156 if ( event.GetEventObject() == (wxObject*) mpFrame )
1157 {
1158 GetUpdatesManager().OnStartChanges();
1159 RecalcLayout(TRUE);
1160 GetUpdatesManager().OnFinishChanges();
1161 GetUpdatesManager().UpdateNow();
1162 }
1163
1164 }
1165
1166 /*** protected members ***/
1167
1168 void wxFrameLayout::HideBarWindows()
1169 {
1170 size_t i;
1171 for ( i = 0; i != mAllBars.Count(); ++i )
1172 if ( mAllBars[i]->mpBarWnd && mAllBars[i]->mState != wxCBAR_FLOATING )
1173 mAllBars[i]->mpBarWnd->Show( FALSE );
1174
1175 // then floated frames
1176
1177 ShowFloatedWindows( FALSE );
1178
1179 if ( mpFrameClient )
1180
1181 mpFrameClient->Show( FALSE );
1182 }
1183
1184 void wxFrameLayout::UnhookFromFrame()
1185 {
1186 // NOTE:: the SetEvtHandlerEnabled() method is not used
1187 // here, since it is assumed that unhooking layout
1188 // from window may result destroying of the layout itself
1189 //
1190 // BUG BUG BUG (wx):: this would not be a problem if
1191 // wxEvtHandler's destructor checked if
1192 // this handler is currently the top-most
1193 // handler of some window, and additionally
1194 // to the reconnecting itself from the chain.
1195 // It would also re-setup current event handler
1196 // of the window using wxWindow::SetEventHandler()
1197
1198 // FOR NOW::
1199
1200 if ( mpFrame->GetEventHandler() == this )
1201 {
1202 mpFrame->PopEventHandler();
1203 return;
1204 }
1205
1206 if ( mpFrame )
1207 {
1208 if ( this == mpFrame->GetEventHandler() )
1209 {
1210 mpFrame->SetEventHandler( this->GetNextHandler() );
1211 }
1212 else
1213 {
1214 wxEvtHandler* pCur = mpFrame->GetEventHandler();
1215
1216 while ( pCur )
1217 {
1218 if ( pCur == this )
1219 break;
1220
1221 pCur = pCur->GetNextHandler();
1222 }
1223
1224 // do not try to unhook ourselves if we're not hooked yet
1225 if ( !pCur )
1226 return;
1227 }
1228
1229 if ( GetPreviousHandler() )
1230 GetPreviousHandler()->SetNextHandler( GetNextHandler() );
1231 else
1232 {
1233 mpFrame->PopEventHandler();
1234 return;
1235 }
1236
1237 if ( GetNextHandler() )
1238 GetNextHandler()->SetPreviousHandler( GetPreviousHandler() );
1239
1240 SetNextHandler( NULL );
1241 SetPreviousHandler( NULL );
1242 }
1243 }
1244
1245 void wxFrameLayout::HookUpToFrame()
1246 {
1247 // unhook us first, we're already hooked up
1248
1249 UnhookFromFrame();
1250
1251 // put ourselves on top
1252
1253 mpFrame->PushEventHandler( this );
1254 }
1255
1256 cbDockPane* wxFrameLayout::GetBarPane( cbBarInfo* pBar )
1257 {
1258 int i;
1259 for ( i = 0; i != MAX_PANES; ++i )
1260 if ( mPanes[i]->BarPresent( pBar ) )
1261 return mPanes[i];
1262
1263 return NULL;
1264 }
1265
1266 void wxFrameLayout::CreateCursors()
1267 {
1268 /*
1269 // FIXME:: The below code somehow doesn't work - cursors remain unchanged
1270 char bits[64];
1271
1272 set_cursor_bits( _gHorizCursorImg, bits, 32, 16 );
1273
1274 mpHorizCursor = new wxCursor( bits, 32, 16 );
1275
1276 set_cursor_bits( _gVertCursorImg, bits, 32, 16 );
1277
1278 mpVertCursor = new wxCursor( bits, 32, 16 );
1279 */
1280
1281 // FOR NOW:: use standard ones
1282
1283 mpHorizCursor = new wxCursor(wxCURSOR_SIZEWE);
1284 mpVertCursor = new wxCursor(wxCURSOR_SIZENS);
1285 mpNormalCursor = new wxCursor(wxCURSOR_ARROW );
1286 mpDragCursor = new wxCursor(wxCURSOR_CROSS );
1287 mpNECursor = new wxCursor(wxCURSOR_NO_ENTRY);
1288
1289 mFloatingPosStep.x = 25;
1290 mFloatingPosStep.y = 25;
1291
1292 mNextFloatedWndPos.x = mFloatingPosStep.x;
1293 mNextFloatedWndPos.y = mFloatingPosStep.y;
1294 }
1295
1296 bool wxFrameLayout::HitTestPane( cbDockPane* pPane, int x, int y )
1297 {
1298 return rect_contains_point( pPane->GetRealRect(), x, y );
1299 }
1300
1301 cbDockPane* wxFrameLayout::HitTestPanes( const wxRect& rect,
1302 cbDockPane* pCurPane )
1303 {
1304 // first, give the privilege to the current pane
1305
1306 if ( pCurPane && rect_hits_rect( pCurPane->GetRealRect(), rect ) )
1307
1308 return pCurPane;
1309
1310 int i;
1311 for ( i = 0; i != MAX_PANES; ++i )
1312 {
1313 if ( pCurPane != mPanes[i] &&
1314 rect_hits_rect( mPanes[i]->GetRealRect(), rect ) )
1315 {
1316 return mPanes[i];
1317 }
1318 }
1319 return 0;
1320 }
1321
1322 void wxFrameLayout::ForwardMouseEvent( wxMouseEvent& event,
1323 cbDockPane* pToPane,
1324 int eventType )
1325 {
1326 wxPoint pos( event.m_x, event.m_y );
1327 pToPane->FrameToPane( &pos.x, &pos.y );
1328
1329 if ( eventType == cbEVT_PL_LEFT_DOWN )
1330 {
1331 cbLeftDownEvent evt( pos, pToPane );
1332 FirePluginEvent( evt );
1333 }
1334 else if ( eventType == cbEVT_PL_LEFT_DCLICK )
1335 {
1336 cbLeftDClickEvent evt( pos, pToPane );
1337 FirePluginEvent( evt );
1338 }
1339 else if ( eventType == cbEVT_PL_LEFT_UP )
1340 {
1341 cbLeftUpEvent evt( pos, pToPane );
1342 FirePluginEvent( evt );
1343 }
1344 else if ( eventType == cbEVT_PL_RIGHT_DOWN )
1345 {
1346 cbRightDownEvent evt( pos, pToPane );
1347 FirePluginEvent( evt );
1348 }
1349 else if ( eventType == cbEVT_PL_RIGHT_UP )
1350 {
1351 cbRightUpEvent evt( pos, pToPane );
1352 FirePluginEvent( evt );
1353 }
1354 else if ( eventType == cbEVT_PL_MOTION )
1355 {
1356 cbMotionEvent evt( pos, pToPane );
1357 FirePluginEvent( evt );
1358 }
1359 else
1360 {
1361 int avoidCompilerWarning = 0;
1362 wxASSERT(avoidCompilerWarning); // DBG::
1363 }
1364 } // wxFrameLayout::ForwardMouseEvent()
1365
1366
1367 void wxFrameLayout::RouteMouseEvent( wxMouseEvent& event, int pluginEvtType )
1368 {
1369 if ( mpPaneInFocus )
1370
1371 ForwardMouseEvent( event, mpPaneInFocus, pluginEvtType );
1372 else
1373 {
1374 int i;
1375 for ( i = 0; i != MAX_PANES; ++i )
1376 {
1377 if ( HitTestPane( mPanes[i], event.m_x, event.m_y ) )
1378 {
1379 ForwardMouseEvent( event, mPanes[i], pluginEvtType );
1380 return;
1381 }
1382 }
1383 }
1384 }
1385
1386 /*** event handlers ***/
1387
1388 void wxFrameLayout::OnRButtonDown( wxMouseEvent& event )
1389 {
1390 RouteMouseEvent( event, cbEVT_PL_RIGHT_DOWN );
1391 }
1392
1393 void wxFrameLayout::OnRButtonUp( wxMouseEvent& event )
1394 {
1395 RouteMouseEvent( event, cbEVT_PL_RIGHT_UP );
1396 }
1397
1398 void wxFrameLayout::OnLButtonDown( wxMouseEvent& event )
1399 {
1400 RouteMouseEvent( event, cbEVT_PL_LEFT_DOWN );
1401 }
1402
1403 void wxFrameLayout::OnLDblClick( wxMouseEvent& event )
1404 {
1405 RouteMouseEvent( event, cbEVT_PL_LEFT_DCLICK );
1406 }
1407
1408 void wxFrameLayout::OnLButtonUp( wxMouseEvent& event )
1409 {
1410 RouteMouseEvent( event, cbEVT_PL_LEFT_UP );
1411 }
1412
1413 void wxFrameLayout::OnMouseMove( wxMouseEvent& event )
1414 {
1415 if ( mpPaneInFocus )
1416
1417 ForwardMouseEvent( event, mpPaneInFocus, cbEVT_PL_MOTION );
1418 else
1419 {
1420 int i;
1421 for ( i = 0; i != MAX_PANES; ++i )
1422 {
1423 if ( HitTestPane( mPanes[i], event.m_x, event.m_y ) )
1424 {
1425 if ( mpLRUPane && mpLRUPane != mPanes[i] )
1426 {
1427 // simulate "mouse-leave" event
1428 ForwardMouseEvent( event, mpLRUPane, cbEVT_PL_MOTION );
1429 }
1430
1431 ForwardMouseEvent( event, mPanes[i], cbEVT_PL_MOTION );
1432
1433 mpLRUPane = mPanes[i];
1434
1435 return;
1436 }
1437 }
1438 }
1439
1440 if ( mpLRUPane )
1441 {
1442 // simulate "mouse-leave" event
1443 ForwardMouseEvent( event, mpLRUPane, cbEVT_PL_MOTION );
1444 mpLRUPane = 0;
1445 }
1446 }
1447
1448 void wxFrameLayout::OnPaint( wxPaintEvent& event )
1449 {
1450 if ( mRecalcPending )
1451 RecalcLayout( TRUE );
1452
1453 wxPaintDC dc(mpFrame);
1454
1455 int i;
1456 for ( i = 0; i != MAX_PANES; ++i )
1457 {
1458 wxRect& rect = mPanes[i]->mBoundsInParent;
1459
1460 dc.SetClippingRegion( rect.x, rect.y, rect.width, rect.height );
1461
1462 mPanes[i]->PaintPane(dc);
1463
1464 dc.DestroyClippingRegion();
1465 }
1466
1467 event.Skip();
1468 }
1469
1470 void wxFrameLayout::OnEraseBackground( wxEraseEvent& event )
1471 {
1472 // do nothing
1473 }
1474
1475 void wxFrameLayout::OnIdle( wxIdleEvent& event )
1476 {
1477 wxWindow* focus = wxWindow::FindFocus();
1478
1479 if ( !focus && mCheckFocusWhenIdle )
1480 {
1481 wxMessageBox( "Hi, no more focus in this app!" );
1482
1483 mCheckFocusWhenIdle = FALSE;
1484 //ShowFloatedWindows( FALSE );
1485 }
1486
1487 mCheckFocusWhenIdle = FALSE;
1488
1489 event.Skip();
1490 }
1491
1492
1493 void wxFrameLayout::OnKillFocus( wxFocusEvent& event )
1494 {
1495 //wxMessageBox( "wxFrameLayoutGot Kill Focus!" );
1496 //ShowFloatedWindows( FALSE );
1497 }
1498
1499 void wxFrameLayout::OnSetFocus( wxFocusEvent& event )
1500 {
1501 //ShowFloatedWindows( TRUE );
1502 }
1503
1504 void wxFrameLayout::OnActivate( wxActivateEvent& event )
1505 {
1506 #if 0
1507 if ( event.GetActive() == FALSE )
1508 {
1509 wxWindow* focus = wxWindow::FindFocus();
1510
1511 if ( !focus || focus == &GetParentFrame() )
1512 {
1513 mCheckFocusWhenIdle = TRUE;
1514
1515 if ( !focus )
1516
1517 wxMessageBox("Deactivated!" );
1518
1519 }
1520 }
1521 #endif
1522 }
1523
1524 void wxFrameLayout::GetPaneProperties( cbCommonPaneProperties& props, int alignment )
1525 {
1526 props = mPanes[alignment]->mProps;
1527 }
1528
1529 void wxFrameLayout::SetPaneProperties( const cbCommonPaneProperties& props, int paneMask )
1530 {
1531 int i;
1532 for ( i = 0; i != MAX_PANES; ++i )
1533 {
1534 if ( mPanes[i]->MatchesMask( paneMask ) )
1535 mPanes[i]->mProps = props;
1536 }
1537 }
1538
1539 void wxFrameLayout::SetMargins( int top, int bottom, int left, int right,
1540 int paneMask )
1541 {
1542 int i;
1543 for ( i = 0; i != MAX_PANES; ++i )
1544 {
1545 cbDockPane& pane = *mPanes[i];
1546
1547 if ( pane.MatchesMask( paneMask ) )
1548 {
1549 pane.mTopMargin = top;
1550 pane.mBottomMargin = bottom;
1551 pane.mLeftMargin = left;
1552 pane.mRightMargin = right;
1553 }
1554 }
1555 }
1556
1557 void wxFrameLayout::SetPaneBackground( const wxColour& colour )
1558 {
1559 mBorderPen.SetColour( colour );
1560 }
1561
1562 void wxFrameLayout::RefreshNow( bool recalcLayout )
1563 {
1564 if ( recalcLayout )
1565 RecalcLayout( TRUE );
1566
1567 if ( mpFrame )
1568 mpFrame->Refresh();
1569 }
1570
1571 /*** plugin-related methods ***/
1572
1573 void wxFrameLayout::FirePluginEvent( cbPluginEvent& event )
1574 {
1575 // check state of input capture, before processing the event
1576
1577 if ( mpCaputesInput )
1578 {
1579 bool isInputEvt = TRUE;
1580 #if wxCHECK_VERSION(2,3,0)
1581 if ( event.m_eventType != cbEVT_PL_LEFT_DOWN &&
1582 event.m_eventType != cbEVT_PL_LEFT_UP &&
1583 event.m_eventType != cbEVT_PL_RIGHT_DOWN &&
1584 event.m_eventType != cbEVT_PL_RIGHT_UP &&
1585 event.m_eventType != cbEVT_PL_MOTION )
1586 isInputEvt = FALSE;
1587 #else
1588 switch ( event.m_eventType )
1589 {
1590 case cbEVT_PL_LEFT_DOWN : break;
1591 case cbEVT_PL_LEFT_UP : break;
1592 case cbEVT_PL_RIGHT_DOWN : break;
1593 case cbEVT_PL_RIGHT_UP : break;
1594 case cbEVT_PL_MOTION : break;
1595
1596 default : isInputEvt = FALSE; break;
1597 }
1598 #endif // #if wxCHECK_VERSION(2,3,0)
1599
1600 if ( isInputEvt )
1601 {
1602 mpCaputesInput->ProcessEvent( event );
1603 return;
1604 }
1605 }
1606
1607 GetTopPlugin().ProcessEvent( event );
1608 }
1609
1610 void wxFrameLayout::CaptureEventsForPlugin ( cbPluginBase* pPlugin )
1611 {
1612 // cannot capture events for more than one plugin at a time
1613 wxASSERT( mpCaputesInput == NULL );
1614
1615 mpCaputesInput = pPlugin;
1616
1617 }
1618
1619 void wxFrameLayout::ReleaseEventsFromPlugin( cbPluginBase* pPlugin )
1620 {
1621 // events should be captured first
1622 wxASSERT( mpCaputesInput != NULL );
1623
1624 mpCaputesInput = NULL;
1625 }
1626
1627 void wxFrameLayout::CaptureEventsForPane( cbDockPane* toPane )
1628 {
1629 // cannot capture events twice (without releasing)
1630 wxASSERT( mpPaneInFocus == NULL );
1631
1632 mpFrame->CaptureMouse();
1633
1634 mpPaneInFocus = toPane;
1635 }
1636
1637 void wxFrameLayout::ReleaseEventsFromPane( cbDockPane* fromPane )
1638 {
1639 // cannot release events without capturing them
1640 wxASSERT( mpPaneInFocus != NULL );
1641
1642 mpFrame->ReleaseMouse();
1643
1644 mpPaneInFocus = NULL;
1645 }
1646
1647 cbPluginBase& wxFrameLayout::GetTopPlugin()
1648 {
1649 if ( !mpTopPlugin )
1650
1651 PushDefaultPlugins(); // automatic configuration
1652
1653 return *mpTopPlugin;
1654 }
1655
1656 void wxFrameLayout::SetTopPlugin( cbPluginBase* pPlugin )
1657 {
1658 mpTopPlugin = pPlugin;
1659 }
1660
1661 bool wxFrameLayout::HasTopPlugin()
1662 {
1663 return ( mpTopPlugin != NULL );
1664 }
1665
1666 void wxFrameLayout::PushPlugin( cbPluginBase* pPlugin )
1667 {
1668 if ( !mpTopPlugin )
1669
1670 mpTopPlugin = pPlugin;
1671 else
1672 {
1673 pPlugin->SetNextHandler( mpTopPlugin );
1674
1675 mpTopPlugin->SetPreviousHandler( pPlugin );
1676
1677 mpTopPlugin = pPlugin;
1678 }
1679
1680 mpTopPlugin->OnInitPlugin(); // notification
1681 }
1682
1683 void wxFrameLayout::PopPlugin()
1684 {
1685 wxASSERT( mpTopPlugin ); // DBG:: at least one plugin should be present
1686
1687 cbPluginBase* pPopped = mpTopPlugin;
1688
1689 mpTopPlugin = (cbPluginBase*)mpTopPlugin->GetNextHandler();
1690
1691 delete pPopped;
1692 }
1693
1694 void wxFrameLayout::PopAllPlugins()
1695 {
1696 while( mpTopPlugin ) PopPlugin();
1697 }
1698
1699 void wxFrameLayout::PushDefaultPlugins()
1700 {
1701 // FIXME:: to much of the stuff for the default...
1702
1703 AddPlugin( CLASSINFO( cbRowLayoutPlugin ) );
1704 AddPlugin( CLASSINFO( cbBarDragPlugin ) );
1705 AddPlugin( CLASSINFO( cbPaneDrawPlugin ) );
1706 }
1707
1708 void wxFrameLayout::AddPlugin( wxClassInfo* pPlInfo, int paneMask )
1709 {
1710 if ( FindPlugin ( pPlInfo ) ) return; // same type of plugin cannot be added twice
1711
1712 cbPluginBase* pObj = (cbPluginBase*)pPlInfo->CreateObject();
1713
1714 wxASSERT(pObj); // DBG:: plugin's class should be dynamic
1715
1716 pObj->mPaneMask = paneMask;
1717 pObj->mpLayout = this;
1718
1719 PushPlugin( pObj );
1720 }
1721
1722 void wxFrameLayout::AddPluginBefore( wxClassInfo* pNextPlInfo, wxClassInfo* pPlInfo,
1723 int paneMask )
1724 {
1725 wxASSERT( pNextPlInfo != pPlInfo ); // DBG:: no sense
1726
1727 cbPluginBase* pNextPl = FindPlugin( pNextPlInfo );
1728
1729 if ( !pNextPl )
1730 {
1731 AddPlugin( pPlInfo, paneMask );
1732
1733 return;
1734 }
1735
1736 // remove existing one if present
1737
1738 cbPluginBase* pExistingPl = FindPlugin( pPlInfo );
1739
1740 if ( pExistingPl ) RemovePlugin( pPlInfo );
1741
1742 // create an instance
1743
1744 cbPluginBase* pNewPl = (cbPluginBase*)pPlInfo->CreateObject();
1745
1746 wxASSERT(pNewPl); // DBG:: plugin's class should be dynamic
1747
1748 // insert it to the chain
1749
1750 if ( pNextPl->GetPreviousHandler() )
1751
1752 pNextPl->GetPreviousHandler()->SetNextHandler( pNewPl );
1753 else
1754 mpTopPlugin = pNewPl;
1755
1756 pNewPl->SetNextHandler( pNextPl );
1757
1758 pNewPl->SetPreviousHandler( pNextPl->GetPreviousHandler() );
1759
1760 pNextPl->SetPreviousHandler( pNewPl );
1761
1762 // set it up
1763
1764 pNewPl->mPaneMask = paneMask;
1765 pNewPl->mpLayout = this;
1766
1767 pNewPl->OnInitPlugin();
1768 }
1769
1770 void wxFrameLayout::RemovePlugin( wxClassInfo* pPlInfo )
1771 {
1772 cbPluginBase* pPlugin = FindPlugin( pPlInfo );
1773
1774 if ( !pPlugin ) return; // it's OK to remove not-existing plugin ;-)
1775
1776 if ( pPlugin->GetPreviousHandler() == NULL )
1777
1778 mpTopPlugin = (cbPluginBase*)pPlugin->GetNextHandler();
1779
1780 delete pPlugin;
1781 }
1782
1783 cbPluginBase* wxFrameLayout::FindPlugin( wxClassInfo* pPlInfo )
1784 {
1785 cbPluginBase *pCur = mpTopPlugin;
1786
1787 while( pCur )
1788 {
1789 // NOTE:: it might appear useful matching plugin
1790 // classes "polymorphically":
1791
1792 if ( pCur->GetClassInfo()->IsKindOf( pPlInfo ) )
1793
1794 return pCur;
1795
1796 pCur = (cbPluginBase*)pCur->GetNextHandler();
1797 }
1798
1799 return NULL;
1800 }
1801
1802 /***** Implementation for class cbUpdateMgrData *****/
1803
1804 IMPLEMENT_DYNAMIC_CLASS( cbUpdateMgrData, wxObject )
1805
1806 cbUpdateMgrData::cbUpdateMgrData()
1807
1808 : mPrevBounds( -1,-1,0,0 ),
1809 mIsDirty( TRUE ) // inidicate initial change
1810 {}
1811
1812 void cbUpdateMgrData::StoreItemState( const wxRect& boundsInParent )
1813 {
1814 mPrevBounds = boundsInParent;
1815 }
1816
1817 void cbUpdateMgrData::SetDirty( bool isDirty )
1818 {
1819 mIsDirty = isDirty;
1820 }
1821
1822 void cbUpdateMgrData::SetCustomData( wxObject* pCustomData )
1823 {
1824 mpCustomData = pCustomData;
1825 }
1826
1827 /***** Implementation for class cbDockPane *****/
1828
1829 void wxBarIterator::Reset()
1830 {
1831 mpRow = ( mpRows->Count() ) ? (*mpRows)[0] : NULL;
1832 mpBar = NULL;
1833 }
1834
1835 wxBarIterator::wxBarIterator( RowArrayT& rows )
1836
1837 : mpRows( &rows ),
1838 mpRow ( NULL ),
1839 mpBar ( NULL )
1840 {
1841 Reset();
1842 }
1843
1844 bool wxBarIterator::Next()
1845 {
1846 if ( mpRow )
1847 {
1848 if ( mpBar )
1849 mpBar = mpBar->mpNext;
1850 else
1851 {
1852 if ( mpRow->mBars.GetCount() == 0 )
1853 {
1854 return FALSE;
1855 }
1856
1857 mpBar = mpRow->mBars[0];
1858 }
1859
1860 if ( !mpBar )
1861 {
1862 // skip to the next row
1863
1864 mpRow = mpRow->mpNext;
1865
1866 if ( mpRow )
1867
1868 mpBar = mpRow->mBars[0];
1869 else
1870 return FALSE;
1871 }
1872
1873 return TRUE;
1874 }
1875 else
1876 return FALSE;
1877 }
1878
1879 cbBarInfo& wxBarIterator::BarInfo()
1880 {
1881 return *mpBar;
1882 }
1883
1884 cbRowInfo& wxBarIterator::RowInfo()
1885 {
1886 return *mpRow;
1887 }
1888
1889 /***** Implementation for class cbBarDimHandlerBase *****/
1890
1891 IMPLEMENT_ABSTRACT_CLASS( cbBarDimHandlerBase, wxObject )
1892
1893 cbBarDimHandlerBase::cbBarDimHandlerBase()
1894 : mRefCount(0)
1895 {}
1896
1897 void cbBarDimHandlerBase::AddRef()
1898 {
1899 ++mRefCount;
1900 }
1901
1902 void cbBarDimHandlerBase::RemoveRef()
1903 {
1904 if ( --mRefCount <= 0 ) delete this;
1905 }
1906
1907 /***** Implementation for class cbDimInfo *****/
1908
1909 IMPLEMENT_DYNAMIC_CLASS( cbDimInfo, wxObject )
1910
1911 cbDimInfo::cbDimInfo()
1912
1913 : mVertGap ( 0 ),
1914 mHorizGap( 0 ),
1915
1916 mIsFixed(TRUE),
1917 mpHandler( NULL )
1918 {
1919 size_t i;
1920 for ( i = 0; i != MAX_BAR_STATES; ++i )
1921 {
1922 mSizes[i].x = 20;
1923 mSizes[i].y = 20;
1924
1925 mBounds[i] = wxRect( -1,-1,-1,-1 );
1926 }
1927 }
1928
1929 cbDimInfo::cbDimInfo( cbBarDimHandlerBase* pDimHandler,
1930 bool isFixed )
1931
1932 : mVertGap ( 0 ),
1933 mHorizGap( 0 ),
1934 mIsFixed ( isFixed ),
1935
1936 mpHandler( pDimHandler )
1937 {
1938 if ( mpHandler )
1939 {
1940 // int vtad = *((int*)mpHandler);
1941 mpHandler->AddRef();
1942 }
1943
1944 size_t i;
1945 for ( i = 0; i != MAX_BAR_STATES; ++i )
1946 {
1947 mSizes[i].x = -1;
1948 mSizes[i].y = -1;
1949
1950 mBounds[i] = wxRect( -1,-1,-1,-1 );
1951 }
1952 }
1953
1954 cbDimInfo::cbDimInfo( int dh_x, int dh_y,
1955 int dv_x, int dv_y,
1956 int f_x, int f_y,
1957
1958 bool isFixed,
1959 int horizGap,
1960 int vertGap,
1961
1962 cbBarDimHandlerBase* pDimHandler
1963 )
1964 : mVertGap ( vertGap ),
1965 mHorizGap ( horizGap ),
1966 mIsFixed ( isFixed ),
1967 mpHandler( pDimHandler )
1968 {
1969 if ( mpHandler )
1970 {
1971 // int vtad = *((int*)mpHandler);
1972 mpHandler->AddRef();
1973 }
1974
1975 mSizes[wxCBAR_DOCKED_HORIZONTALLY].x = dh_x;
1976 mSizes[wxCBAR_DOCKED_HORIZONTALLY].y = dh_y;
1977 mSizes[wxCBAR_DOCKED_VERTICALLY ].x = dv_x;
1978 mSizes[wxCBAR_DOCKED_VERTICALLY ].y = dv_y;
1979 mSizes[wxCBAR_FLOATING ].x = f_x;
1980 mSizes[wxCBAR_FLOATING ].y = f_y;
1981
1982 size_t i;
1983 for ( i = 0; i != MAX_BAR_STATES; ++i )
1984 mBounds[i] = wxRect( -1,-1,-1,-1 );
1985 }
1986
1987 cbDimInfo::cbDimInfo( int x, int y,
1988 bool isFixed, int gap,
1989 cbBarDimHandlerBase* pDimHandler)
1990 : mVertGap ( gap ),
1991 mHorizGap ( gap ),
1992 mIsFixed ( isFixed ),
1993 mpHandler( pDimHandler )
1994 {
1995 if ( mpHandler )
1996 {
1997 // int vtad = *((int*)mpHandler);
1998 mpHandler->AddRef();
1999 }
2000
2001 mSizes[wxCBAR_DOCKED_HORIZONTALLY].x = x;
2002 mSizes[wxCBAR_DOCKED_HORIZONTALLY].y = y;
2003 mSizes[wxCBAR_DOCKED_VERTICALLY ].x = x;
2004 mSizes[wxCBAR_DOCKED_VERTICALLY ].y = y;
2005 mSizes[wxCBAR_FLOATING ].x = x;
2006 mSizes[wxCBAR_FLOATING ].y = y;
2007
2008 size_t i;
2009 for ( i = 0; i != MAX_BAR_STATES; ++i )
2010 mBounds[i] = wxRect( -1,-1,-1,-1 );
2011 }
2012
2013 cbDimInfo::~cbDimInfo()
2014 {
2015 if ( mpHandler )
2016
2017 mpHandler->RemoveRef();
2018 }
2019
2020 const cbDimInfo& cbDimInfo::operator=( const cbDimInfo& other )
2021 {
2022 if ( this == &other )
2023 return *this;
2024
2025 int i;
2026 for ( i = 0; i != MAX_BAR_STATES; ++i )
2027 mSizes[i] = other.mSizes[i];
2028
2029 mIsFixed = other.mIsFixed;
2030 mpHandler = other.mpHandler;
2031
2032 mVertGap = other.mVertGap;
2033 mHorizGap = other.mHorizGap;
2034
2035 if ( mpHandler )
2036
2037 mpHandler->AddRef();
2038
2039 return *this;
2040 }
2041
2042 /***** Implementation for structure cbCommonPaneProperties *****/
2043
2044 IMPLEMENT_DYNAMIC_CLASS( cbCommonPaneProperties, wxObject )
2045
2046 cbCommonPaneProperties::cbCommonPaneProperties(void)
2047
2048 : mRealTimeUpdatesOn ( TRUE ),
2049 mOutOfPaneDragOn ( TRUE ),
2050 mExactDockPredictionOn( FALSE ),
2051 mNonDestructFrictionOn( FALSE ),
2052 mShow3DPaneBorderOn ( TRUE ),
2053 mBarFloatingOn ( FALSE ),
2054 mRowProportionsOn ( FALSE ),
2055 mColProportionsOn ( TRUE ),
2056 mBarCollapseIconsOn ( FALSE ),
2057 mBarDragHintsOn ( FALSE ),
2058
2059 mMinCBarDim( 16, 16 ),
2060 mResizeHandleSize( 4 )
2061 {}
2062
2063 /***** Implementation for class cbRowInfo *****/
2064
2065 IMPLEMENT_DYNAMIC_CLASS( cbRowInfo, wxObject )
2066
2067 cbRowInfo::cbRowInfo(void)
2068
2069 : mNotFixedBarsCnt( FALSE ),
2070 mpNext ( NULL ),
2071 mpPrev ( NULL ),
2072 mpExpandedBar ( NULL )
2073 {}
2074
2075 cbRowInfo::~cbRowInfo()
2076 {
2077 // nothing! all bars are removed using global bar
2078 // list in wxFrameLayout class
2079 }
2080
2081 /***** Implementation for class cbBarInfo *****/
2082
2083 IMPLEMENT_DYNAMIC_CLASS( cbBarInfo, wxObject )
2084
2085 cbBarInfo::cbBarInfo(void)
2086
2087 : mpRow( NULL ),
2088
2089 mpNext( NULL ),
2090 mpPrev( NULL )
2091 {}
2092
2093 cbBarInfo::~cbBarInfo()
2094 {
2095 // nothing
2096 }
2097
2098 /***** Implementation for class cbDockPane *****/
2099
2100 IMPLEMENT_DYNAMIC_CLASS( cbDockPane, wxObject )
2101
2102 // FIXME:: how to eliminate these cut&pasted constructors?
2103
2104 cbDockPane::cbDockPane(void)
2105 : mLeftMargin ( 1 ),
2106 mRightMargin ( 1 ),
2107 mTopMargin ( 1 ),
2108 mBottomMargin( 1 ),
2109 mPaneWidth ( 32768 ), // fake-up very large pane dims,
2110 // since the real dimensions of the pane may not
2111 // be known, while inserting bars initially
2112 mPaneHeight( 32768 ),
2113 mAlignment ( -1 ),
2114 mpLayout ( 0 ),
2115 mpStoredRow( NULL )
2116 {}
2117
2118 cbDockPane::cbDockPane( int alignment, wxFrameLayout* pPanel )
2119
2120 : mLeftMargin ( 1 ),
2121 mRightMargin ( 1 ),
2122 mTopMargin ( 1 ),
2123 mBottomMargin( 1 ),
2124 mPaneWidth ( 32768 ), // fake-up very large pane dims,
2125 // since the real dimensions of the pane may not
2126 // be known, while inserting bars initially
2127 mPaneHeight( 32768 ),
2128 mAlignment ( alignment ),
2129 mpLayout ( pPanel ),
2130 mpStoredRow( NULL )
2131 {}
2132
2133 cbDockPane::~cbDockPane()
2134 {
2135 size_t i;
2136 for ( i = 0; i != mRows.Count(); ++i )
2137 delete mRows[i];
2138
2139 mRowShapeData.DeleteContents( TRUE );
2140
2141 // NOTE:: control bar infromation structures are cleaned-up
2142 // in wxFrameLayout's destructor, using global control-bar list
2143 }
2144
2145 void cbDockPane::SetMargins( int top, int bottom, int left, int right )
2146 {
2147 mTopMargin = top;
2148 mBottomMargin = bottom;
2149 mLeftMargin = left;
2150 mRightMargin = right;
2151 }
2152
2153 /*** helpers of cbDockPane ***/
2154
2155 void cbDockPane::PaintBarDecorations( cbBarInfo* pBar, wxDC& dc )
2156 {
2157 cbDrawBarDecorEvent evt( pBar, dc, this );
2158
2159 mpLayout->FirePluginEvent( evt );
2160 }
2161
2162 void cbDockPane::PaintBarHandles( cbBarInfo* pBar, wxDC& dc )
2163 {
2164 cbDrawBarHandlesEvent evt( pBar, dc, this );
2165
2166 mpLayout->FirePluginEvent( evt );
2167 }
2168
2169 void cbDockPane::PaintBar( cbBarInfo* pBar, wxDC& dc )
2170 {
2171 PaintBarDecorations( pBar, dc );
2172 PaintBarHandles( pBar, dc );
2173 }
2174
2175 void cbDockPane::PaintRowHandles( cbRowInfo* pRow, wxDC& dc )
2176 {
2177 cbDrawRowHandlesEvent evt( pRow, dc, this );
2178
2179 mpLayout->FirePluginEvent( evt );
2180
2181 cbDrawRowDecorEvent evt1( pRow, dc, this );
2182
2183 mpLayout->FirePluginEvent( evt1 );
2184 }
2185
2186 void cbDockPane::PaintRowBackground ( cbRowInfo* pRow, wxDC& dc )
2187 {
2188 cbDrawRowBkGroundEvent evt( pRow, dc, this );
2189
2190 mpLayout->FirePluginEvent( evt );
2191 }
2192
2193 void cbDockPane::PaintRowDecorations( cbRowInfo* pRow, wxDC& dc )
2194 {
2195 size_t i = 0;
2196
2197 // decorations first
2198 for ( i = 0; i != pRow->mBars.Count(); ++i )
2199
2200 PaintBarDecorations( pRow->mBars[i], dc );
2201
2202 // then handles if present
2203 for ( i = 0; i != pRow->mBars.Count(); ++i )
2204
2205 PaintBarHandles( pRow->mBars[i], dc );
2206 }
2207
2208 void cbDockPane::PaintRow( cbRowInfo* pRow, wxDC& dc )
2209 {
2210 PaintRowBackground ( pRow, dc );
2211 PaintRowDecorations( pRow, dc );
2212 PaintRowHandles ( pRow, dc );
2213 }
2214
2215 void cbDockPane::PaintPaneBackground( wxDC& dc )
2216 {
2217 cbDrawPaneBkGroundEvent evt( dc, this );
2218
2219 mpLayout->FirePluginEvent( evt );
2220 }
2221
2222 void cbDockPane::PaintPaneDecorations( wxDC& dc )
2223 {
2224 cbDrawPaneDecorEvent evt( dc, this );
2225
2226 mpLayout->FirePluginEvent( evt );
2227 }
2228
2229 void cbDockPane::PaintPane( wxDC& dc )
2230 {
2231 PaintPaneBackground( dc );
2232
2233 size_t i = 0;
2234
2235 // first decorations
2236 for ( i = 0; i != mRows.Count(); ++i )
2237 {
2238 PaintRowBackground( mRows[i], dc );
2239 PaintRowDecorations( mRows[i], dc );
2240 }
2241
2242 // than handles
2243 for ( i = 0; i != mRows.Count(); ++i )
2244 PaintRowHandles( mRows[i], dc );
2245
2246 // and finally
2247 PaintPaneDecorations( dc );
2248 }
2249
2250 void cbDockPane::SizeBar( cbBarInfo* pBar )
2251 {
2252 cbSizeBarWndEvent evt( pBar, this );
2253
2254 mpLayout->FirePluginEvent( evt );
2255 return;
2256 }
2257
2258 void cbDockPane::SizeRowObjects( cbRowInfo* pRow )
2259 {
2260 size_t i;
2261 for ( i = 0; i != pRow->mBars.Count(); ++i )
2262 SizeBar( pRow->mBars[i] );
2263 }
2264
2265 void cbDockPane::SizePaneObjects()
2266 {
2267 size_t i;
2268 for ( i = 0; i != mRows.Count(); ++i )
2269 SizeRowObjects( mRows[i] );
2270 }
2271
2272 wxDC* cbDockPane::StartDrawInArea( const wxRect& area )
2273 {
2274 wxDC* pDc = 0;
2275
2276 cbStartDrawInAreaEvent evt( area, &pDc, this );
2277
2278 mpLayout->FirePluginEvent( evt );
2279
2280 return pDc;
2281 }
2282
2283 void cbDockPane::FinishDrawInArea( const wxRect& area )
2284 {
2285 cbFinishDrawInAreaEvent evt( area, this );
2286
2287 mpLayout->FirePluginEvent( evt );
2288 }
2289
2290 bool cbDockPane::IsFixedSize( cbBarInfo* pInfo )
2291 {
2292 return ( pInfo->mDimInfo.mIsFixed );
2293 }
2294
2295 int cbDockPane::GetNotFixedBarsCount( cbRowInfo* pRow )
2296 {
2297 int cnt = 0;
2298
2299 size_t i;
2300 for ( i = 0; i != pRow->mBars.Count(); ++i )
2301 {
2302 if ( !pRow->mBars[i]->IsFixed() )
2303 ++cnt;
2304 }
2305
2306 return cnt;
2307 }
2308
2309 void cbDockPane::RemoveBar( cbBarInfo* pBar )
2310 {
2311 bool needsRestoring = mProps.mNonDestructFrictionOn &&
2312 mpStoredRow == pBar->mpRow;
2313
2314 cbRemoveBarEvent evt( pBar, this );
2315
2316 mpLayout->FirePluginEvent( evt );
2317
2318 if ( needsRestoring )
2319 {
2320 SetRowShapeData( mpStoredRow, &mRowShapeData );
2321
2322 mpStoredRow = NULL;
2323 }
2324 }
2325
2326 void cbDockPane::SyncRowFlags( cbRowInfo* pRow )
2327 {
2328 // setup mHasOnlyFixedBars flag for the row information
2329 pRow->mHasOnlyFixedBars = TRUE;
2330
2331 pRow->mNotFixedBarsCnt = 0;
2332
2333 size_t i;
2334 for ( i = 0; i != pRow->mBars.Count(); ++i )
2335 {
2336 cbBarInfo& bar = *pRow->mBars[i];
2337
2338 bar.mpRow = pRow;
2339
2340 if ( !bar.IsFixed() )
2341 {
2342 pRow->mHasOnlyFixedBars = FALSE;
2343 ++pRow->mNotFixedBarsCnt;
2344 }
2345 }
2346 }
2347
2348 void cbDockPane::FrameToPane( int* x, int* y )
2349 {
2350 *x -= mLeftMargin;
2351 *y -= mTopMargin;
2352
2353 if ( mAlignment == FL_ALIGN_TOP ||
2354 mAlignment == FL_ALIGN_BOTTOM
2355 )
2356 {
2357 *x -= mBoundsInParent.x;
2358 *y -= mBoundsInParent.y;
2359 }
2360 else
2361 {
2362 int rx = *x, ry = *y;
2363
2364 *x = ry - mBoundsInParent.y;
2365
2366 *y = rx - mBoundsInParent.x;
2367 }
2368 }
2369
2370 void cbDockPane::PaneToFrame( int* x, int* y )
2371 {
2372 if ( mAlignment == FL_ALIGN_TOP ||
2373 mAlignment == FL_ALIGN_BOTTOM
2374 )
2375 {
2376 *x += mBoundsInParent.x;
2377 *y += mBoundsInParent.y;
2378 }
2379 else
2380 {
2381 int rx = *x, ry = *y;
2382
2383 *x = ry + mBoundsInParent.x;
2384
2385 *y = mBoundsInParent.y + rx;
2386 }
2387
2388 *x += mLeftMargin;
2389 *y += mTopMargin;
2390 }
2391
2392 void cbDockPane::FrameToPane( wxRect* pRect )
2393 {
2394 wxPoint upperLeft ( pRect->x, pRect->y );
2395 wxPoint lowerRight( pRect->x + pRect->width,
2396 pRect->y + pRect->height );
2397
2398 FrameToPane( &upperLeft.x, &upperLeft.y );
2399 FrameToPane( &lowerRight.x, &lowerRight.y );
2400
2401 pRect->x = wxMin(upperLeft.x,lowerRight.x);
2402 pRect->y = wxMin(upperLeft.y,lowerRight.y);
2403
2404 pRect->width = abs( lowerRight.x - upperLeft.x );
2405 pRect->height = abs( lowerRight.y - upperLeft.y );
2406 }
2407
2408 void cbDockPane::PaneToFrame( wxRect* pRect )
2409 {
2410 wxPoint upperLeft ( pRect->x, pRect->y );
2411 wxPoint lowerRight( pRect->x + pRect->width,
2412 pRect->y + pRect->height );
2413
2414 PaneToFrame( &upperLeft.x, &upperLeft.y );
2415 PaneToFrame( &lowerRight.x, &lowerRight.y );
2416
2417 //wxRect newRect = wxRect( upperLeft, lowerRight );
2418
2419 pRect->x = wxMin(upperLeft.x,lowerRight.x);
2420 pRect->y = wxMin(upperLeft.y,lowerRight.y);
2421
2422 pRect->width = abs( lowerRight.x - upperLeft.x );
2423 pRect->height = abs( lowerRight.y - upperLeft.y );
2424 }
2425
2426 int cbDockPane::GetRowAt( int paneY )
2427 {
2428 if ( paneY < 0 )
2429 return -1;
2430
2431 int curY = 0;
2432
2433 size_t i = 0;
2434
2435 for ( ; i != mRows.Count(); ++i )
2436 {
2437 int rowHeight = mRows[i]->mRowHeight;
2438
2439 int third = rowHeight/3;
2440
2441 if ( paneY >= curY && paneY < curY + third )
2442 return i-1;
2443
2444 if ( paneY >= curY + third && paneY < curY + rowHeight - third )
2445 return i;
2446
2447 curY += rowHeight;
2448 }
2449
2450 return i;
2451 }
2452
2453 int cbDockPane::GetRowAt( int upperY, int lowerY )
2454 {
2455 /*
2456 // OLD STUFF::
2457 int range = lowerY - upperY;
2458 int oneThird = range / 3;
2459
2460 wxNode* pRow = mRows.First();
2461 int row = 0;
2462 int curY = 0;
2463
2464 if ( lowerY <= 0 ) return -1;
2465
2466 while( pRow )
2467 {
2468 int rowHeight = GetRowHeight( (wxList*)pRow->Data() );
2469
2470 if ( upperY >= curY &&
2471 lowerY < curY ) return row;
2472
2473 if ( upperY <= curY &&
2474 lowerY >= curY &&
2475 curY - upperY >= oneThird ) return row-1;
2476
2477 if ( ( upperY < curY + rowHeight &&
2478 lowerY >= curY + rowHeight &&
2479 curY + rowHeight - lowerY >= oneThird )
2480 )
2481 return row+1;
2482
2483 if ( lowerY <= curY + rowHeight ) return row;
2484
2485 ++row;
2486 curY += rowHeight;
2487 pRow = pRow->Next();
2488 }
2489 */
2490
2491 int mid = upperY + (lowerY - upperY)/2;
2492
2493 if ( mid < 0 )
2494 return -1;
2495
2496 int curY = 0;
2497 size_t i = 0;
2498
2499 for ( ; i != mRows.Count(); ++i )
2500 {
2501 int rowHeight = mRows[i]->mRowHeight;
2502
2503 if ( mid >= curY && mid < curY + rowHeight ) return i;
2504
2505 curY += rowHeight;
2506 }
2507
2508 return i;
2509 }
2510
2511 int cbDockPane::GetRowY( cbRowInfo* pRow )
2512 {
2513 int curY = 0;
2514
2515 size_t i;
2516 for ( i = 0; i != mRows.Count(); ++i )
2517 {
2518 if ( mRows[i] == pRow )
2519 break;
2520
2521 curY += mRows[i]->mRowHeight;
2522 }
2523
2524 return curY;
2525 }
2526
2527 bool cbDockPane::HasNotFixedRowsAbove( cbRowInfo* pRow )
2528 {
2529 while ( pRow->mpPrev )
2530 {
2531 pRow = pRow->mpPrev;
2532
2533 if ( pRow->mHasOnlyFixedBars )
2534
2535 return TRUE;
2536 }
2537
2538 return FALSE;
2539 }
2540
2541 bool cbDockPane::HasNotFixedRowsBelow( cbRowInfo* pRow )
2542 {
2543 while( pRow->mpNext )
2544 {
2545 pRow = pRow->mpNext;
2546
2547 if ( pRow->mHasOnlyFixedBars )
2548
2549 return TRUE;
2550 }
2551
2552 return FALSE;
2553 }
2554
2555 bool cbDockPane::HasNotFixedBarsLeft( cbBarInfo* pBar )
2556 {
2557 while( pBar->mpPrev )
2558 {
2559 pBar = pBar->mpPrev;
2560
2561 if ( pBar->IsFixed() )
2562
2563 return TRUE;
2564 }
2565
2566 return FALSE;
2567 }
2568
2569 bool cbDockPane::HasNotFixedBarsRight( cbBarInfo* pBar )
2570 {
2571 while( pBar->mpNext )
2572 {
2573 pBar = pBar->mpNext;
2574
2575 if ( pBar->IsFixed() )
2576
2577 return TRUE;
2578 }
2579
2580 return FALSE;
2581 }
2582
2583 void cbDockPane::CalcLengthRatios( cbRowInfo* pInRow )
2584 {
2585 int totalWidth = 0;
2586
2587 size_t i = 0;
2588
2589 // calc current-maximal-total-length of all maximized bars
2590
2591 for ( i = 0; i != pInRow->mBars.GetCount(); ++i )
2592 {
2593 cbBarInfo& bar = *pInRow->mBars[i];
2594
2595 if ( !bar.IsFixed() )
2596 totalWidth += bar.mBounds.width;
2597 }
2598
2599 // set up percentages of occupied space for each maximized bar
2600
2601 for ( i = 0; i != pInRow->mBars.Count(); ++i )
2602 {
2603 cbBarInfo& bar = *pInRow->mBars[i];
2604
2605 if ( !bar.IsFixed() )
2606 bar.mLenRatio = double(bar.mBounds.width)/double(totalWidth);
2607 }
2608 }
2609
2610 void cbDockPane::RecalcRowLayout( cbRowInfo* pRow )
2611 {
2612 cbLayoutRowEvent evt( pRow, this );
2613
2614 mpLayout->FirePluginEvent( evt );
2615 }
2616
2617 void cbDockPane::ExpandBar( cbBarInfo* pBar )
2618 {
2619 mpLayout->GetUpdatesManager().OnStartChanges();
2620
2621 if ( !pBar->mpRow->mpExpandedBar )
2622 {
2623 // save ratios only when there arent any bars expanded yet
2624
2625 cbArrayFloat& ratios = pBar->mpRow->mSavedRatios;
2626
2627 ratios.Clear();
2628 ratios.Alloc( pBar->mpRow->mNotFixedBarsCnt );
2629
2630 cbBarInfo* pCur = pBar->mpRow->mBars[0];
2631
2632 while( pCur )
2633 {
2634 if ( !pCur->IsFixed() )
2635 {
2636 ratios.Add( 0.0 );
2637 ratios[ ratios.GetCount() - 1 ] = pCur->mLenRatio;
2638 }
2639
2640 pCur = pCur->mpNext;
2641 }
2642 }
2643
2644 cbBarInfo* pCur = pBar->mpRow->mBars[0];
2645
2646 while( pCur )
2647 {
2648 pCur->mLenRatio = 0.0; // minimize the rest
2649
2650 pCur = pCur->mpNext;
2651 }
2652
2653 pBar->mLenRatio = 1.0; // 100%
2654 pBar->mBounds.width = 0;
2655
2656 pBar->mpRow->mpExpandedBar = pBar;
2657
2658 mpLayout->RecalcLayout( FALSE );
2659
2660 mpLayout->GetUpdatesManager().OnFinishChanges();
2661 mpLayout->GetUpdatesManager().UpdateNow();
2662 }
2663
2664 void cbDockPane::ContractBar( cbBarInfo* pBar )
2665 {
2666 mpLayout->GetUpdatesManager().OnStartChanges();
2667
2668 // FIXME: What's the purpose of this???
2669 // double ratio = 1.0/ double( pBar->mpRow->mNotFixedBarsCnt );
2670
2671 // restore ratios which were present before expansion
2672
2673 cbBarInfo* pCur = pBar->mpRow->mBars[0];
2674
2675 cbArrayFloat& ratios = pBar->mpRow->mSavedRatios;
2676
2677 size_t i = 0;
2678
2679 while( pCur )
2680 {
2681 if ( !pCur->IsFixed() )
2682 {
2683 pCur->mLenRatio = ratios[i];
2684 ++i;
2685 }
2686
2687 pCur = pCur->mpNext;
2688 }
2689
2690 ratios.Clear();
2691 ratios.Shrink();
2692
2693 pBar->mpRow->mpExpandedBar = NULL;
2694
2695 mpLayout->RecalcLayout( FALSE );
2696
2697 mpLayout->GetUpdatesManager().OnFinishChanges();
2698 mpLayout->GetUpdatesManager().UpdateNow();
2699 }
2700
2701 void cbDockPane::InitLinksForRow( cbRowInfo* pRow )
2702 {
2703 size_t i;
2704 for ( i = 0; i != pRow->mBars.Count(); ++i )
2705 {
2706 cbBarInfo& bar = *pRow->mBars[i];
2707
2708 if ( i == 0 )
2709 bar.mpPrev = NULL;
2710 else
2711 bar.mpPrev = pRow->mBars[i-1];
2712
2713 if ( i == pRow->mBars.Count() - 1 )
2714 bar.mpNext = NULL;
2715 else
2716 bar.mpNext = pRow->mBars[i+1];
2717 }
2718 }
2719
2720 void cbDockPane::InitLinksForRows()
2721 {
2722 size_t i;
2723 for ( i = 0; i != mRows.Count(); ++i )
2724 {
2725 cbRowInfo& row = *mRows[i];
2726
2727 if ( i == 0 )
2728 row.mpPrev = NULL;
2729 else
2730 row.mpPrev = mRows[i-1];
2731
2732 if ( i == mRows.Count() - 1 )
2733 row.mpNext = NULL;
2734 else
2735 row.mpNext = mRows[i+1];
2736 }
2737 }
2738
2739 void cbDockPane::DoInsertBar( cbBarInfo* pBar, int rowNo )
2740 {
2741 cbRowInfo* pRow = NULL;
2742
2743 if ( rowNo == -1 || rowNo >= (int)mRows.Count() )
2744 {
2745 pRow = new cbRowInfo();
2746
2747 if ( rowNo == -1 && mRows.Count() )
2748
2749 mRows.Insert( pRow, 0 );
2750 else
2751 mRows.Add( pRow );
2752
2753 InitLinksForRows();
2754 }
2755 else
2756 {
2757 pRow = mRows[rowNo];
2758
2759 if ( mProps.mNonDestructFrictionOn == TRUE )
2760 {
2761 // store original shape of the row (before the bar is inserted)
2762
2763 mpStoredRow = pRow;
2764
2765 GetRowShapeData( mpStoredRow, &mRowShapeData );
2766 }
2767 }
2768
2769 if ( pRow->mBars.Count() )
2770
2771 pRow->mpExpandedBar = NULL;
2772
2773 cbInsertBarEvent insEvt( pBar, pRow, this );
2774
2775 mpLayout->FirePluginEvent( insEvt );
2776
2777 mpLayout->GetUpdatesManager().OnRowWillChange( pRow, this );
2778 }
2779
2780 void cbDockPane::InsertBar( cbBarInfo* pBarInfo, const wxRect& atRect )
2781 {
2782 wxRect rect = atRect;
2783 FrameToPane( &rect );
2784
2785 pBarInfo->mBounds.x = rect.x;
2786 pBarInfo->mBounds.width = rect.width;
2787 pBarInfo->mBounds.height = rect.height;
2788
2789 int row = GetRowAt( rect.y, rect.y + rect.height );
2790
2791 DoInsertBar( pBarInfo, row );
2792 }
2793
2794 void cbDockPane::InsertBar( cbBarInfo* pBar, cbRowInfo* pIntoRow )
2795 {
2796 cbInsertBarEvent insEvt( pBar, pIntoRow, this );
2797
2798 mpLayout->FirePluginEvent( insEvt );
2799
2800 mpLayout->GetUpdatesManager().OnRowWillChange( pIntoRow, this );
2801 }
2802
2803 void cbDockPane::InsertBar( cbBarInfo* pBarInfo )
2804 {
2805 // set transient properties
2806
2807 pBarInfo->mpRow = NULL;
2808 pBarInfo->mHasLeftHandle = FALSE;
2809 pBarInfo->mHasRightHandle = FALSE;
2810 pBarInfo->mLenRatio = 0.0;
2811
2812 // set preferred bar dimensions, according to the state in which
2813 // the bar is being inserted
2814
2815 pBarInfo->mBounds.width = pBarInfo->mDimInfo.mSizes[ pBarInfo->mState ].x;
2816 pBarInfo->mBounds.height = pBarInfo->mDimInfo.mSizes[ pBarInfo->mState ].y;
2817
2818 DoInsertBar( pBarInfo, pBarInfo->mRowNo );
2819 }
2820
2821 void cbDockPane::RemoveRow( cbRowInfo* pRow )
2822 {
2823 size_t i;
2824 // first, hide all bar-windows in the removed row
2825 for ( i = 0; i != pRow->mBars.Count(); ++i )
2826 {
2827 if ( pRow->mBars[i]->mpBarWnd )
2828 pRow->mBars[i]->mpBarWnd->Show( FALSE );
2829 }
2830
2831 mRows.Remove( pRow );
2832
2833 pRow->mUMgrData.SetDirty(TRUE);
2834 }
2835
2836 void cbDockPane::InsertRow( cbRowInfo* pRow, cbRowInfo* pBeforeRow )
2837 {
2838 if ( !pBeforeRow )
2839
2840 mRows.Add( pRow );
2841 else
2842 mRows.Insert( pRow, mRows.Index( pBeforeRow ) );
2843
2844 InitLinksForRows();
2845
2846 pRow->mUMgrData.SetDirty(TRUE);
2847
2848 size_t i;
2849 for ( i = 0; i != pRow->mBars.Count(); ++i )
2850 pRow->mBars[i]->mUMgrData.SetDirty( TRUE );
2851
2852 SyncRowFlags( pRow );
2853 }
2854
2855 void cbDockPane::SetPaneWidth(int width)
2856 {
2857 if ( IsHorizontal() )
2858 mPaneWidth = width - mLeftMargin - mRightMargin;
2859 else
2860 mPaneWidth = width - mTopMargin - mBottomMargin;
2861 }
2862
2863
2864 void cbDockPane::SetBoundsInParent( const wxRect& rect )
2865 {
2866 mBoundsInParent = rect;
2867
2868 // set pane dimensions in local coordinates
2869
2870 if ( IsHorizontal() )
2871 {
2872 mPaneWidth = mBoundsInParent.width - ( mRightMargin + mLeftMargin );
2873 mPaneHeight = mBoundsInParent.height - ( mTopMargin + mBottomMargin );
2874 }
2875 else
2876 {
2877 mPaneWidth = mBoundsInParent.height - ( mTopMargin + mBottomMargin );
2878 mPaneHeight = mBoundsInParent.width - ( mRightMargin + mLeftMargin );
2879 }
2880
2881 // convert bounding rectangles of all pane items into parent frame's coordinates
2882
2883 wxBarIterator i( mRows );
2884
2885 wxRect noMarginsRect = mBoundsInParent;
2886
2887 noMarginsRect.x += mLeftMargin;
2888 noMarginsRect.y += mTopMargin;
2889 noMarginsRect.width -= ( mLeftMargin + mRightMargin );
2890 noMarginsRect.height -= ( mTopMargin + mBottomMargin );
2891
2892 // hide the whole pane, if it's bounds became reverted (i.e. pane vanished)
2893
2894 if ( mBoundsInParent.width < 0 ||
2895 mBoundsInParent.height < 0 )
2896
2897 hide_rect( mBoundsInParent );
2898
2899 if ( noMarginsRect.width < 0 ||
2900 noMarginsRect.height < 0 )
2901
2902 hide_rect( noMarginsRect );
2903
2904 // calculate mBoundsInParent for each item in the pane
2905
2906 while( i.Next() )
2907 {
2908 cbBarInfo& bar = i.BarInfo();
2909
2910 cbRowInfo* pRowInfo = bar.mpRow;
2911
2912 // set up row info, if this is first bar in the row
2913
2914 if ( pRowInfo && bar.mpPrev == NULL )
2915 {
2916 pRowInfo->mBoundsInParent.y = pRowInfo->mRowY;
2917 pRowInfo->mBoundsInParent.x = 0;
2918 pRowInfo->mBoundsInParent.width = mPaneWidth;
2919 pRowInfo->mBoundsInParent.height = pRowInfo->mRowHeight;
2920
2921 PaneToFrame( &pRowInfo->mBoundsInParent );
2922
2923 clip_rect_against_rect( pRowInfo->mBoundsInParent, noMarginsRect );
2924 }
2925
2926 wxRect bounds = bar.mBounds;
2927
2928 // exclude dimensions of handles, when calculating
2929 // bar's bounds in parent (i.e. "visual bounds")
2930
2931 if ( bar.mHasLeftHandle )
2932 {
2933 bounds.x += mProps.mResizeHandleSize;
2934 bounds.width -= mProps.mResizeHandleSize;
2935 }
2936
2937 if ( bar.mHasRightHandle )
2938
2939 bounds.width -= mProps.mResizeHandleSize;
2940
2941 PaneToFrame( &bounds );
2942
2943 clip_rect_against_rect( bounds, noMarginsRect );
2944
2945 bar.mBoundsInParent = bounds;
2946 }
2947 }
2948
2949 bool cbDockPane::BarPresent( cbBarInfo* pBar )
2950 {
2951 wxBarIterator iter( mRows );
2952
2953 while( iter.Next() )
2954
2955 if ( &iter.BarInfo() == pBar ) return TRUE;
2956
2957 return FALSE;
2958 }
2959
2960 cbRowInfo* cbDockPane::GetRow( int row )
2961 {
2962 if ( row >= (int)mRows.Count() ) return NULL;
2963
2964 return mRows[ row ];
2965 }
2966
2967 int cbDockPane::GetRowIndex( cbRowInfo* pRow )
2968 {
2969 size_t i;
2970 for ( i = 0; i != mRows.Count(); ++i )
2971 {
2972 if ( mRows[i] == pRow )
2973 return i;
2974 }
2975
2976 wxFAIL_MSG("Row must be present to call cbDockPane::GetRowIndex()");
2977
2978 return 0;
2979 }
2980
2981 int cbDockPane::GetPaneHeight()
2982 {
2983 // first, recalculate row heights and the Y-positions
2984
2985 cbLayoutRowsEvent evt( this );
2986 mpLayout->FirePluginEvent( evt );
2987
2988 int height = 0;
2989
2990 if ( IsHorizontal() )
2991
2992 height += mTopMargin + mBottomMargin;
2993 else
2994 height += mLeftMargin + mRightMargin;
2995
2996 int count = mRows.Count();
2997
2998 if ( count )
2999
3000 height += mRows[count-1]->mRowY + mRows[count-1]->mRowHeight;
3001
3002 return height;
3003 }
3004
3005 int cbDockPane::GetAlignment()
3006 {
3007 return mAlignment;
3008 }
3009
3010 bool cbDockPane::MatchesMask( int paneMask )
3011 {
3012 int thisMask = 0;
3013
3014 // FIXME:: use array instead of switch()
3015
3016 switch (mAlignment)
3017 {
3018 case FL_ALIGN_TOP : thisMask = FL_ALIGN_TOP_PANE; break;
3019 case FL_ALIGN_BOTTOM : thisMask = FL_ALIGN_BOTTOM_PANE;break;
3020 case FL_ALIGN_LEFT : thisMask = FL_ALIGN_LEFT_PANE; break;
3021 case FL_ALIGN_RIGHT : thisMask = FL_ALIGN_RIGHT_PANE; break;
3022
3023 default:
3024 wxFAIL_MSG("Bad FL alignment type detected in cbDockPane::MatchesMask()");
3025 }
3026
3027 return ( thisMask & paneMask ) != 0;
3028 }
3029
3030 void cbDockPane::RecalcLayout()
3031 {
3032 // first, reposition rows and items vertically
3033
3034 cbLayoutRowsEvent evt( this );
3035 mpLayout->FirePluginEvent( evt );
3036
3037 // then horizontally in each row
3038
3039 size_t i;
3040 for ( i = 0; i != mRows.Count(); ++i )
3041 RecalcRowLayout( mRows[i] );
3042 }
3043
3044 int cbDockPane::GetDockingState()
3045 {
3046 if ( mAlignment == FL_ALIGN_TOP ||
3047 mAlignment == FL_ALIGN_BOTTOM )
3048 {
3049 return wxCBAR_DOCKED_HORIZONTALLY;
3050 }
3051 else
3052 return wxCBAR_DOCKED_VERTICALLY;
3053 }
3054
3055 inline bool cbDockPane::HasPoint( const wxPoint& pos, int x, int y,
3056 int width, int height )
3057 {
3058 return ( pos.x >= x &&
3059 pos.y >= y &&
3060 pos.x < x + width &&
3061 pos.y < y + height );
3062 }
3063
3064 int cbDockPane::HitTestPaneItems( const wxPoint& pos,
3065 cbRowInfo** ppRow,
3066 cbBarInfo** ppBar
3067 )
3068 {
3069 (*ppRow) = NULL;
3070 (*ppBar) = NULL;
3071
3072 size_t i;
3073 for ( i = 0; i != mRows.Count(); ++i )
3074 {
3075 cbRowInfo& row = *mRows[i];
3076
3077 *ppRow = &row;
3078
3079 // hit-test handles of the row, if present
3080
3081 if ( row.mHasUpperHandle )
3082 {
3083 if ( HasPoint( pos, 0, row.mRowY,
3084 row.mRowWidth, mProps.mResizeHandleSize ) )
3085
3086 return CB_UPPER_ROW_HANDLE_HITTED;
3087 }
3088 else
3089 if ( row.mHasLowerHandle )
3090 {
3091 if ( HasPoint( pos, 0, row.mRowY + row.mRowHeight - mProps.mResizeHandleSize,
3092 row.mRowWidth, mProps.mResizeHandleSize ) )
3093
3094 return CB_LOWER_ROW_HANDLE_HITTED;
3095 }
3096
3097 // hit-test bar handles and bar content
3098
3099 size_t k;
3100 for ( k = 0; k != row.mBars.Count(); ++k )
3101 {
3102 cbBarInfo& bar = *row.mBars[k];
3103 wxRect& bounds = bar.mBounds;
3104
3105 *ppBar = &bar;
3106
3107 if ( bar.mHasLeftHandle )
3108 {
3109 if ( HasPoint( pos, bounds.x, bounds.y,
3110 mProps.mResizeHandleSize, bounds.height ) )
3111
3112 return CB_LEFT_BAR_HANDLE_HITTED;
3113 }
3114 else
3115 if ( bar.mHasRightHandle )
3116 {
3117 if ( HasPoint( pos, bounds.x + bounds.width - mProps.mResizeHandleSize, bounds.y,
3118 mProps.mResizeHandleSize, bounds.height ) )
3119
3120 return CB_RIGHT_BAR_HANDLE_HITTED;
3121 }
3122
3123 if ( HasPoint( pos, bounds.x, bounds.y, bounds.width, bounds.height ) )
3124 return CB_BAR_CONTENT_HITTED;
3125
3126 } // hit-test next bar
3127
3128 } // next row
3129
3130 return CB_NO_ITEMS_HITTED;
3131 }
3132
3133 void cbDockPane::GetBarResizeRange( cbBarInfo* pBar, int* from, int *till,
3134 bool forLeftHandle )
3135 {
3136 cbBarInfo* pGivenBar = pBar;
3137
3138 int notFree = 0;
3139
3140 // calc unavailable space from the left
3141
3142 while( pBar->mpPrev )
3143 {
3144 pBar = pBar->mpPrev;
3145
3146 if ( !pBar->IsFixed() ) notFree += mProps.mMinCBarDim.x;
3147 else notFree += pBar->mBounds.width;
3148 }
3149
3150 *from = notFree;
3151
3152 pBar = pGivenBar;
3153
3154 notFree = 0;
3155
3156 // calc unavailable space from the right
3157
3158 while( pBar->mpNext )
3159 {
3160 pBar = pBar->mpNext;
3161
3162 if ( pBar->mBounds.x >= mPaneWidth ) break;
3163
3164 // treat not-fixed bars as minimized
3165
3166 if ( !pBar->IsFixed() )
3167
3168 notFree += mProps.mMinCBarDim.x;
3169 else
3170 {
3171 if ( pBar->mBounds.x + pBar->mBounds.width >= mPaneWidth )
3172 {
3173 notFree += mPaneWidth - pBar->mBounds.x;
3174 break;
3175 }
3176 else
3177 notFree += pBar->mBounds.width;
3178 }
3179
3180 }
3181
3182 *till = mPaneWidth - notFree;
3183
3184 // do not let resizing totally deform the bar itself
3185
3186 if ( forLeftHandle )
3187
3188 (*till) -= mProps.mMinCBarDim.x;
3189 else
3190
3191 (*from) += mProps.mMinCBarDim.x;
3192 }
3193
3194 int cbDockPane::GetMinimalRowHeight( cbRowInfo* pRow )
3195 {
3196 int height = mProps.mMinCBarDim.y;
3197
3198 size_t i;
3199 for ( i = 0; i != pRow->mBars.Count(); ++i )
3200 {
3201 if ( pRow->mBars[i]->IsFixed() )
3202 height = wxMax( height, pRow->mBars[i]->mBounds.height );
3203 }
3204
3205 if ( pRow->mHasUpperHandle )
3206 height += mProps.mResizeHandleSize;
3207
3208 if ( pRow->mHasLowerHandle )
3209 height += mProps.mResizeHandleSize;
3210
3211 return height;
3212 }
3213
3214 void cbDockPane::SetRowHeight( cbRowInfo* pRow, int newHeight )
3215 {
3216 if ( pRow->mHasUpperHandle )
3217
3218 newHeight -= mProps.mResizeHandleSize;
3219
3220 if ( pRow->mHasLowerHandle )
3221
3222 newHeight -= mProps.mResizeHandleSize;
3223
3224 size_t i;
3225 for ( i = 0; i != pRow->mBars.Count(); ++i )
3226 {
3227 if ( !pRow->mBars[i]->IsFixed() )
3228 pRow->mBars[i]->mBounds.height = newHeight;
3229 }
3230 }
3231
3232 void cbDockPane::GetRowResizeRange( cbRowInfo* pRow, int* from, int* till,
3233 bool forUpperHandle )
3234 {
3235 cbRowInfo* pGivenRow = pRow;
3236
3237 // calc unavailable space from above
3238
3239 int notFree = 0;
3240
3241 while( pRow->mpPrev )
3242 {
3243 pRow = pRow->mpPrev;
3244
3245 notFree += GetMinimalRowHeight( pRow );
3246
3247 };
3248
3249 *from = notFree;
3250
3251 // allow accupy the client window space by resizing pane rows
3252 if ( mAlignment == FL_ALIGN_BOTTOM )
3253
3254 *from -= mpLayout->GetClientHeight();
3255 else
3256 if ( mAlignment == FL_ALIGN_RIGHT )
3257
3258 *from -= mpLayout->GetClientWidth();
3259
3260 // calc unavailable space from below
3261
3262 pRow = pGivenRow;
3263
3264 notFree = 0;
3265
3266 while( pRow->mpNext )
3267 {
3268 pRow = pRow->mpNext;
3269
3270 notFree += GetMinimalRowHeight( pRow );
3271
3272 }
3273
3274 *till = mPaneHeight - notFree;
3275
3276 // allow adjustinig pane space vs. client window space by resizing pane row heights
3277
3278 if ( mAlignment == FL_ALIGN_TOP )
3279
3280 *till += mpLayout->GetClientHeight();
3281 else
3282 if ( mAlignment == FL_ALIGN_LEFT )
3283
3284 *till += mpLayout->GetClientWidth();
3285
3286 // do not let the resizing of the row totally squeeze the row itself
3287
3288 cbRowInfo& row = *pGivenRow;
3289
3290 if ( forUpperHandle )
3291 {
3292 *till = row.mRowY + row.mRowHeight - GetMinimalRowHeight( pGivenRow );
3293
3294 if ( row.mHasUpperHandle )
3295
3296 *till -= mProps.mResizeHandleSize;
3297 }
3298 else
3299 {
3300 *from += GetMinimalRowHeight( pGivenRow );
3301
3302 if ( row.mHasLowerHandle )
3303
3304 *from -= mProps.mResizeHandleSize;
3305 }
3306 }
3307
3308 void cbDockPane::ResizeRow( cbRowInfo* pRow, int ofs,
3309 bool forUpperHandle )
3310 {
3311 cbResizeRowEvent evt( pRow, ofs, forUpperHandle, this );
3312
3313 mpLayout->FirePluginEvent( evt );
3314 }
3315
3316 void cbDockPane::ResizeBar( cbBarInfo* pBar, int ofs,
3317 bool forLeftHandle )
3318 {
3319 pBar->mpRow->mpExpandedBar = NULL;
3320
3321 mpLayout->GetUpdatesManager().OnStartChanges();
3322
3323 wxRect& bounds = pBar->mBounds;
3324
3325 if ( forLeftHandle )
3326 {
3327 // do not allow bar width become less then minimal
3328 if ( bounds.x + ofs > bounds.x + bounds.width - mProps.mMinCBarDim.x )
3329 {
3330 bounds.width = mProps.mMinCBarDim.x;
3331 bounds.x += ofs;
3332 }
3333 else
3334 {
3335 bounds.x += ofs;
3336 bounds.width -= ofs;
3337 }
3338 }
3339 else
3340 {
3341 // move bar left if necessary
3342 if ( bounds.width + ofs < mProps.mMinCBarDim.x )
3343 {
3344 bounds.x = bounds.x + bounds.width + ofs - mProps.mMinCBarDim.x;
3345 bounds.width = mProps.mMinCBarDim.x;
3346 }
3347 else
3348 // resize right border only
3349 bounds.width += ofs;
3350 }
3351
3352
3353 cbRowInfo* pToRow = pBar->mpRow;
3354
3355 this->RemoveBar( pBar );
3356
3357 InsertBar( pBar, pToRow );
3358
3359 mpLayout->RecalcLayout(FALSE);
3360
3361 mpLayout->GetUpdatesManager().OnFinishChanges();
3362 mpLayout->GetUpdatesManager().UpdateNow();
3363 }
3364
3365
3366 /*** row/bar resizing related methods ***/
3367
3368 void cbDockPane::DrawVertHandle( wxDC& dc, int x, int y, int height )
3369 {
3370 int lower = y + height;
3371
3372 dc.SetPen( mpLayout->mLightPen );
3373 dc.DrawLine( x,y, x, lower );
3374
3375 dc.SetPen( mpLayout->mGrayPen );
3376 int i;
3377 for ( i = 0; i != mProps.mResizeHandleSize-1; ++i )
3378 {
3379 ++x;
3380 dc.DrawLine( x,y, x, lower );
3381 }
3382
3383 dc.SetPen( mpLayout->mDarkPen );
3384 ++x;
3385 dc.DrawLine( x,y, x, lower );
3386
3387 dc.SetPen( mpLayout->mBlackPen );
3388 ++x;
3389 dc.DrawLine( x,y, x, lower );
3390 }
3391
3392 void cbDockPane::DrawHorizHandle( wxDC& dc, int x, int y, int width )
3393 {
3394 int right = x + width;
3395
3396 dc.SetPen( mpLayout->mLightPen );
3397 dc.DrawLine( x,y, right, y );
3398
3399 dc.SetPen( mpLayout->mGrayPen );
3400
3401 int i;
3402 for ( i = 0; i != mProps.mResizeHandleSize-1; ++i )
3403 {
3404 ++y;
3405 dc.DrawLine( x,y, right, y );
3406 }
3407
3408 dc.SetPen( mpLayout->mDarkPen );
3409 dc.DrawLine( x,y, right, ++y );
3410
3411 dc.SetPen( mpLayout->mBlackPen );
3412 dc.DrawLine( x,y, right, ++y );
3413 }
3414
3415 cbBarInfo* cbDockPane::GetBarInfoByWindow( wxWindow* pBarWnd )
3416 {
3417 wxBarIterator i( mRows );
3418
3419 while( i.Next() )
3420
3421 if ( i.BarInfo().mpBarWnd == pBarWnd )
3422
3423 return &i.BarInfo();
3424
3425 return NULL;
3426 }
3427
3428 void cbDockPane::GetRowShapeData( cbRowInfo* pRow, wxList* pLst )
3429 {
3430 pLst->DeleteContents( TRUE );
3431 pLst->Clear();
3432
3433 size_t i;
3434 for ( i = 0; i != pRow->mBars.Count(); ++i )
3435 {
3436 cbBarInfo& bar = *pRow->mBars[i];
3437
3438 cbBarShapeData* pData = new cbBarShapeData();
3439
3440 pLst->Append( (wxObject*)pData );
3441
3442 pData->mBounds = bar.mBounds;
3443 pData->mLenRatio = bar.mLenRatio;
3444 }
3445 }
3446
3447 void cbDockPane::SetRowShapeData( cbRowInfo* pRow, wxList* pLst )
3448 {
3449 if ( pLst->First() == NULL )
3450 return;
3451
3452 wxNode* pData = pLst->First();
3453
3454 size_t i;
3455 for ( i = 0; i != pRow->mBars.Count(); ++i )
3456 {
3457 wxASSERT( pData ); // DBG::
3458
3459 cbBarInfo& bar = *pRow->mBars[i];;
3460
3461 cbBarShapeData& data = *((cbBarShapeData*)pData->Data());
3462
3463 bar.mBounds = data.mBounds;
3464 bar.mLenRatio = data.mLenRatio;
3465
3466 pData = pData->Next();
3467 }
3468 }
3469
3470 /***** Implementation for class cbUpdatesManagerBase *****/
3471
3472 IMPLEMENT_ABSTRACT_CLASS( cbUpdatesManagerBase, wxObject )
3473
3474 /***** Implementation for class cbPluginBase *****/
3475
3476 IMPLEMENT_ABSTRACT_CLASS( cbPluginBase, wxEvtHandler )
3477
3478 cbPluginBase::~cbPluginBase()
3479 {
3480 // nothing
3481 }
3482
3483 bool cbPluginBase::ProcessEvent(wxEvent& event)
3484 {
3485 if ( mPaneMask == wxALL_PANES )
3486
3487 return wxEvtHandler::ProcessEvent( event );
3488
3489 // extract mask info. from received event
3490
3491 cbPluginEvent& evt = *( (cbPluginEvent*)&event );
3492
3493 if ( evt.mpPane == 0 &&
3494 mPaneMask == wxALL_PANES )
3495
3496 return wxEvtHandler::ProcessEvent( event );
3497
3498 int mask = 0;
3499
3500 switch ( evt.mpPane->mAlignment )
3501 {
3502 case FL_ALIGN_TOP : mask = FL_ALIGN_TOP_PANE; break;
3503 case FL_ALIGN_BOTTOM : mask = FL_ALIGN_BOTTOM_PANE;break;
3504 case FL_ALIGN_LEFT : mask = FL_ALIGN_LEFT_PANE; break;
3505 case FL_ALIGN_RIGHT : mask = FL_ALIGN_RIGHT_PANE; break;
3506 }
3507
3508 // if event's pane maks matches the plugin's mask
3509
3510 if ( mPaneMask & mask )
3511
3512 return wxEvtHandler::ProcessEvent( event );
3513
3514 // otherwise pass to the next handler if present
3515
3516 if ( GetNextHandler() && GetNextHandler()->ProcessEvent( event ) )
3517
3518 return TRUE;
3519 else
3520 return FALSE;
3521 }
3522
wxWidgets (Impactor)