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