]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/fl/controlbar.cpp
projects / wxWidgets.git / blob
? search:


15390fcc7075e1022cce2ee0dca9efd5ed0445ac
[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 && pBar->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 && pBar->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 && pBar->mFloatingOn) )
875 return;
876
877 // float it
878
879 if ( pBar->mpBarWnd == NULL || !CanReparent() )
880 {
881 // FOR NOW:: just hide it
882
883 if ( pBar->mpBarWnd )
884
885 pBar->mpBarWnd->Show( FALSE );
886
887 pBar->mState = wxCBAR_HIDDEN;
888
889 return;
890 }
891
892 cbFloatedBarWindow* pMiniFrm = new cbFloatedBarWindow();
893
894 pMiniFrm->SetBar( pBar );
895 pMiniFrm->SetLayout( this );
896
897 pMiniFrm->Create( &GetParentFrame(), -1, pBar->mName,
898 wxPoint( 50,50 ),
899 wxSize ( 0, 0 ),
900 wxFRAME_FLOAT_ON_PARENT |
901 wxFRAME_TOOL_WINDOW |
902 wxFRAME_NO_TASKBAR
903 );
904
905 pMiniFrm->SetClient( pBar->mpBarWnd );
906
907 ReparentWindow( pBar->mpBarWnd, pMiniFrm );
908
909 mFloatedFrames.Append( pMiniFrm );
910
911 wxRect& bounds = pBar->mDimInfo.mBounds[wxCBAR_FLOATING];
912
913 // check if it wasn't floated anytime before
914
915 if ( bounds.width == -1 )
916 {
917 wxRect& clntRect = GetClientRect();
918
919 // adjust position into which the next floated bar will be placed
920
921 if ( mNextFloatedWndPos.x + bounds.width > clntRect.width )
922
923 mNextFloatedWndPos.x = mFloatingPosStep.x;
924
925 if ( mNextFloatedWndPos.y + bounds.height > clntRect.height )
926
927 mNextFloatedWndPos.y = mFloatingPosStep.y;
928
929 bounds.x = mNextFloatedWndPos.x + clntRect.x;
930 bounds.y = mNextFloatedWndPos.y + clntRect.y;
931
932 bounds.width = pBar->mDimInfo.mSizes[wxCBAR_FLOATING].x;
933 bounds.height = pBar->mDimInfo.mSizes[wxCBAR_FLOATING].y;
934
935 mNextFloatedWndPos.x += mFloatingPosStep.x;
936 mNextFloatedWndPos.y += mFloatingPosStep.y;
937 }
938
939 pMiniFrm->Show( TRUE );
940
941 // FIXME:: this is excessive
942 pBar->mpBarWnd->Show(TRUE);
943 }
944 }
945
946 void wxFrameLayout::RemoveBar( cbBarInfo* pBarInfo )
947 {
948 // first, try to "guess" what was the perviouse state of the bar
949
950 cbDockPane* pPane;
951 cbRowInfo* pRow;
952
953 if ( LocateBar( pBarInfo, &pRow, &pPane ) )
954 {
955 // ...aha, bar was docked into one of the panes,
956 // remove it from there
957
958 pPane->RemoveBar( pBarInfo );
959 }
960
961 size_t i;
962 for ( i = 0; i != mAllBars.Count(); ++i )
963 {
964 if ( mAllBars[i] == pBarInfo )
965 {
966 #if wxCHECK_VERSION(2,3,2)
967 mAllBars.RemoveAt(i);
968 #else
969 mAllBars.Remove(i);
970 #endif
971 if ( pBarInfo->mpBarWnd ) // hides it's window
972
973 pBarInfo->mpBarWnd->Show( FALSE );
974
975 delete pBarInfo;
976
977 return;
978 }
979 }
980 wxFAIL_MSG("bar info should be present in the list of all bars of all panes");
981 }
982
983 bool wxFrameLayout::LocateBar( cbBarInfo* pBarInfo,
984 cbRowInfo** ppRow,
985 cbDockPane** ppPane )
986 {
987 (*ppRow) = NULL;
988 (*ppPane) = NULL;
989
990 int n;
991 for ( n = 0; n != MAX_PANES; ++n )
992 {
993 wxBarIterator i( mPanes[n]->GetRowList() );
994
995 while ( i.Next() )
996
997 if ( &i.BarInfo() == pBarInfo )
998 {
999 (*ppPane) = mPanes[n];
1000 (*ppRow ) = &i.RowInfo();
1001
1002 return TRUE;
1003 }
1004 }
1005
1006 return FALSE;
1007 }
1008
1009 void wxFrameLayout::RecalcLayout( bool repositionBarsNow )
1010 {
1011 mRecalcPending = FALSE;
1012
1013 int frmWidth, frmHeight;
1014 mpFrame->GetClientSize( &frmWidth, &frmHeight );
1015 int paneHeight = 0;
1016
1017 int curY = 0;
1018 int curX = 0;
1019 wxRect rect;
1020
1021 // pane positioning priorities in decreasing order:
1022 // top, bottom, left, right
1023
1024 // setup TOP pane
1025
1026 cbDockPane* pPane = mPanes[ FL_ALIGN_TOP ];
1027
1028 pPane->SetPaneWidth( frmWidth );
1029 pPane->RecalcLayout();
1030
1031 paneHeight = pPane->GetPaneHeight();
1032
1033 rect.x = curX;
1034 rect.y = curY;
1035 rect.width = frmWidth;
1036 rect.height = wxMin( paneHeight, frmHeight - curY );
1037
1038 pPane->SetBoundsInParent( rect );
1039
1040 curY += paneHeight;
1041
1042 // setup BOTTOM pane
1043
1044 pPane = mPanes[ FL_ALIGN_BOTTOM ];
1045
1046 pPane->SetPaneWidth( frmWidth );
1047 pPane->RecalcLayout();
1048
1049 paneHeight = pPane->GetPaneHeight();
1050
1051 rect.x = curX;
1052 rect.y = wxMax( frmHeight - paneHeight, curY );
1053 rect.width = frmWidth;
1054 rect.height = frmHeight - rect.y;
1055
1056 pPane->SetBoundsInParent( rect );
1057
1058 // setup LEFT pane
1059
1060 pPane = mPanes[ FL_ALIGN_LEFT ];
1061
1062 // bottom pane's y
1063 pPane->SetPaneWidth( rect.y - curY );
1064
1065 pPane->RecalcLayout();
1066 paneHeight = pPane->GetPaneHeight();
1067
1068 // bottom rect's y
1069 rect.height = rect.y - curY;
1070 rect.x = curX;
1071 rect.y = curY;
1072 rect.width = wxMin( paneHeight, frmWidth );
1073
1074 pPane->SetBoundsInParent( rect );
1075
1076 curX += rect.width;
1077
1078 // setup RIGHT pane
1079
1080 pPane = mPanes[ FL_ALIGN_RIGHT ];
1081
1082 // left pane's height
1083 pPane->SetPaneWidth( rect.height );
1084
1085 pPane->RecalcLayout();
1086 paneHeight = pPane->GetPaneHeight();
1087
1088 // left pane's height
1089 rect.height = rect.height;
1090 rect.x = wxMax( frmWidth - paneHeight, curX );
1091 rect.y = curY;
1092 rect.width = frmWidth - rect.x;
1093
1094 pPane->SetBoundsInParent( rect );
1095
1096 // recalc bounds of the client-window
1097
1098 mClntWndBounds.x = mPanes[FL_ALIGN_LEFT]->mBoundsInParent.x +
1099 mPanes[FL_ALIGN_LEFT]->mBoundsInParent.width;
1100 mClntWndBounds.y = mPanes[FL_ALIGN_TOP ]->mBoundsInParent.y +
1101 mPanes[FL_ALIGN_TOP ]->mBoundsInParent.height;
1102
1103 mClntWndBounds.width = mPanes[FL_ALIGN_RIGHT]->mBoundsInParent.x -
1104 mClntWndBounds.x;
1105 mClntWndBounds.height = mPanes[FL_ALIGN_BOTTOM]->mBoundsInParent.y -
1106 mClntWndBounds.y;
1107
1108 if ( repositionBarsNow )
1109
1110 PositionPanes();
1111 }
1112
1113 int wxFrameLayout::GetClientHeight()
1114 {
1115 // for better portablility wxWindow::GetSzie() is not used here
1116
1117 return mClntWndBounds.height;
1118 }
1119
1120 int wxFrameLayout::GetClientWidth()
1121 {
1122 // for better portablility wxWindow::GetSzie() is not used here
1123
1124 return mClntWndBounds.width;
1125 }
1126
1127 void wxFrameLayout::PositionClientWindow()
1128 {
1129 if ( mpFrameClient )
1130 {
1131 if ( mClntWndBounds.width >= 1 && mClntWndBounds.height >= 1 )
1132 {
1133 mpFrameClient->SetSize( mClntWndBounds.x, mClntWndBounds.y,
1134 mClntWndBounds.width, mClntWndBounds.height, 0 );
1135
1136 if ( !mpFrameClient->IsShown() )
1137
1138 mpFrameClient->Show( TRUE );
1139 }
1140 else
1141 mpFrameClient->Show( FALSE );
1142 }
1143 }
1144
1145 void wxFrameLayout::PositionPanes()
1146 {
1147 PositionClientWindow();
1148
1149 // FOR NOW:: excessive updates!
1150 // reposition bars within all panes
1151
1152 int i;
1153 for ( i = 0; i != MAX_PANES; ++i )
1154 mPanes[i]->SizePaneObjects();
1155 }
1156
1157 void wxFrameLayout::OnSize( wxSizeEvent& event )
1158 {
1159 if ( event.GetEventObject() == (wxObject*) mpFrame )
1160 {
1161 GetUpdatesManager().OnStartChanges();
1162 RecalcLayout(TRUE);
1163 GetUpdatesManager().OnFinishChanges();
1164 GetUpdatesManager().UpdateNow();
1165 }
1166
1167 }
1168
1169 /*** protected members ***/
1170
1171 void wxFrameLayout::HideBarWindows()
1172 {
1173 size_t i;
1174 for ( i = 0; i != mAllBars.Count(); ++i )
1175 if ( mAllBars[i]->mpBarWnd && mAllBars[i]->mState != wxCBAR_FLOATING )
1176 mAllBars[i]->mpBarWnd->Show( FALSE );
1177
1178 // then floated frames
1179
1180 ShowFloatedWindows( FALSE );
1181
1182 if ( mpFrameClient )
1183
1184 mpFrameClient->Show( FALSE );
1185 }
1186
1187 void wxFrameLayout::UnhookFromFrame()
1188 {
1189 // NOTE:: the SetEvtHandlerEnabled() method is not used
1190 // here, since it is assumed that unhooking layout
1191 // from window may result destroying of the layout itself
1192 //
1193 // BUG BUG BUG (wx):: this would not be a problem if
1194 // wxEvtHandler's destructor checked if
1195 // this handler is currently the top-most
1196 // handler of some window, and additionally
1197 // to the reconnecting itself from the chain.
1198 // It would also re-setup current event handler
1199 // of the window using wxWindow::SetEventHandler()
1200
1201 // FOR NOW::
1202
1203 if ( mpFrame->GetEventHandler() == this )
1204 {
1205 mpFrame->PopEventHandler();
1206 return;
1207 }
1208
1209 if ( mpFrame )
1210 {
1211 if ( this == mpFrame->GetEventHandler() )
1212 {
1213 mpFrame->SetEventHandler( this->GetNextHandler() );
1214 }
1215 else
1216 {
1217 wxEvtHandler* pCur = mpFrame->GetEventHandler();
1218
1219 while ( pCur )
1220 {
1221 if ( pCur == this )
1222 break;
1223
1224 pCur = pCur->GetNextHandler();
1225 }
1226
1227 // do not try to unhook ourselves if we're not hooked yet
1228 if ( !pCur )
1229 return;
1230 }
1231
1232 if ( GetPreviousHandler() )
1233 GetPreviousHandler()->SetNextHandler( GetNextHandler() );
1234 else
1235 {
1236 mpFrame->PopEventHandler();
1237 return;
1238 }
1239
1240 if ( GetNextHandler() )
1241 GetNextHandler()->SetPreviousHandler( GetPreviousHandler() );
1242
1243 SetNextHandler( NULL );
1244 SetPreviousHandler( NULL );
1245 }
1246 }
1247
1248 void wxFrameLayout::HookUpToFrame()
1249 {
1250 // unhook us first, we're already hooked up
1251
1252 UnhookFromFrame();
1253
1254 // put ourselves on top
1255
1256 mpFrame->PushEventHandler( this );
1257 }
1258
1259 cbDockPane* wxFrameLayout::GetBarPane( cbBarInfo* pBar )
1260 {
1261 int i;
1262 for ( i = 0; i != MAX_PANES; ++i )
1263 if ( mPanes[i]->BarPresent( pBar ) )
1264 return mPanes[i];
1265
1266 return NULL;
1267 }
1268
1269 void wxFrameLayout::CreateCursors()
1270 {
1271 /*
1272 // FIXME:: The below code somehow doesn't work - cursors remain unchanged
1273 char bits[64];
1274
1275 set_cursor_bits( _gHorizCursorImg, bits, 32, 16 );
1276
1277 mpHorizCursor = new wxCursor( bits, 32, 16 );
1278
1279 set_cursor_bits( _gVertCursorImg, bits, 32, 16 );
1280
1281 mpVertCursor = new wxCursor( bits, 32, 16 );
1282 */
1283
1284 // FOR NOW:: use standard ones
1285
1286 mpHorizCursor = new wxCursor(wxCURSOR_SIZEWE);
1287 mpVertCursor = new wxCursor(wxCURSOR_SIZENS);
1288 mpNormalCursor = new wxCursor(wxCURSOR_ARROW );
1289 mpDragCursor = new wxCursor(wxCURSOR_CROSS );
1290 mpNECursor = new wxCursor(wxCURSOR_NO_ENTRY);
1291
1292 mFloatingPosStep.x = 25;
1293 mFloatingPosStep.y = 25;
1294
1295 mNextFloatedWndPos.x = mFloatingPosStep.x;
1296 mNextFloatedWndPos.y = mFloatingPosStep.y;
1297 }
1298
1299 bool wxFrameLayout::HitTestPane( cbDockPane* pPane, int x, int y )
1300 {
1301 return rect_contains_point( pPane->GetRealRect(), x, y );
1302 }
1303
1304 cbDockPane* wxFrameLayout::HitTestPanes( const wxRect& rect,
1305 cbDockPane* pCurPane )
1306 {
1307 // first, give the privilege to the current pane
1308
1309 if ( pCurPane && rect_hits_rect( pCurPane->GetRealRect(), rect ) )
1310
1311 return pCurPane;
1312
1313 int i;
1314 for ( i = 0; i != MAX_PANES; ++i )
1315 {
1316 if ( pCurPane != mPanes[i] &&
1317 rect_hits_rect( mPanes[i]->GetRealRect(), rect ) )
1318 {
1319 return mPanes[i];
1320 }
1321 }
1322 return 0;
1323 }
1324
1325 void wxFrameLayout::ForwardMouseEvent( wxMouseEvent& event,
1326 cbDockPane* pToPane,
1327 int eventType )
1328 {
1329 wxPoint pos( event.m_x, event.m_y );
1330 pToPane->FrameToPane( &pos.x, &pos.y );
1331
1332 if ( eventType == cbEVT_PL_LEFT_DOWN )
1333 {
1334 cbLeftDownEvent evt( pos, pToPane );
1335 FirePluginEvent( evt );
1336 }
1337 else if ( eventType == cbEVT_PL_LEFT_DCLICK )
1338 {
1339 cbLeftDClickEvent evt( pos, pToPane );
1340 FirePluginEvent( evt );
1341 }
1342 else if ( eventType == cbEVT_PL_LEFT_UP )
1343 {
1344 cbLeftUpEvent evt( pos, pToPane );
1345 FirePluginEvent( evt );
1346 }
1347 else if ( eventType == cbEVT_PL_RIGHT_DOWN )
1348 {
1349 cbRightDownEvent evt( pos, pToPane );
1350 FirePluginEvent( evt );
1351 }
1352 else if ( eventType == cbEVT_PL_RIGHT_UP )
1353 {
1354 cbRightUpEvent evt( pos, pToPane );
1355 FirePluginEvent( evt );
1356 }
1357 else if ( eventType == cbEVT_PL_MOTION )
1358 {
1359 cbMotionEvent evt( pos, pToPane );
1360 FirePluginEvent( evt );
1361 }
1362 else
1363 {
1364 int avoidCompilerWarning = 0;
1365 wxASSERT(avoidCompilerWarning); // DBG::
1366 }
1367 } // wxFrameLayout::ForwardMouseEvent()
1368
1369
1370 void wxFrameLayout::RouteMouseEvent( wxMouseEvent& event, int pluginEvtType )
1371 {
1372 if ( mpPaneInFocus )
1373
1374 ForwardMouseEvent( event, mpPaneInFocus, pluginEvtType );
1375 else
1376 {
1377 int i;
1378 for ( i = 0; i != MAX_PANES; ++i )
1379 {
1380 if ( HitTestPane( mPanes[i], event.m_x, event.m_y ) )
1381 {
1382 ForwardMouseEvent( event, mPanes[i], pluginEvtType );
1383 return;
1384 }
1385 }
1386 }
1387 }
1388
1389 /*** event handlers ***/
1390
1391 void wxFrameLayout::OnRButtonDown( wxMouseEvent& event )
1392 {
1393 RouteMouseEvent( event, cbEVT_PL_RIGHT_DOWN );
1394 }
1395
1396 void wxFrameLayout::OnRButtonUp( wxMouseEvent& event )
1397 {
1398 RouteMouseEvent( event, cbEVT_PL_RIGHT_UP );
1399 }
1400
1401 void wxFrameLayout::OnLButtonDown( wxMouseEvent& event )
1402 {
1403 RouteMouseEvent( event, cbEVT_PL_LEFT_DOWN );
1404 }
1405
1406 void wxFrameLayout::OnLDblClick( wxMouseEvent& event )
1407 {
1408 RouteMouseEvent( event, cbEVT_PL_LEFT_DCLICK );
1409 }
1410
1411 void wxFrameLayout::OnLButtonUp( wxMouseEvent& event )
1412 {
1413 RouteMouseEvent( event, cbEVT_PL_LEFT_UP );
1414 }
1415
1416 void wxFrameLayout::OnMouseMove( wxMouseEvent& event )
1417 {
1418 if ( mpPaneInFocus )
1419
1420 ForwardMouseEvent( event, mpPaneInFocus, cbEVT_PL_MOTION );
1421 else
1422 {
1423 int i;
1424 for ( i = 0; i != MAX_PANES; ++i )
1425 {
1426 if ( HitTestPane( mPanes[i], event.m_x, event.m_y ) )
1427 {
1428 if ( mpLRUPane && mpLRUPane != mPanes[i] )
1429 {
1430 // simulate "mouse-leave" event
1431 ForwardMouseEvent( event, mpLRUPane, cbEVT_PL_MOTION );
1432 }
1433
1434 ForwardMouseEvent( event, mPanes[i], cbEVT_PL_MOTION );
1435
1436 mpLRUPane = mPanes[i];
1437
1438 return;
1439 }
1440 }
1441 }
1442
1443 if ( mpLRUPane )
1444 {
1445 // simulate "mouse-leave" event
1446 ForwardMouseEvent( event, mpLRUPane, cbEVT_PL_MOTION );
1447 mpLRUPane = 0;
1448 }
1449 }
1450
1451 void wxFrameLayout::OnPaint( wxPaintEvent& event )
1452 {
1453 if ( mRecalcPending )
1454 RecalcLayout( TRUE );
1455
1456 wxPaintDC dc(mpFrame);
1457
1458 int i;
1459 for ( i = 0; i != MAX_PANES; ++i )
1460 {
1461 wxRect& rect = mPanes[i]->mBoundsInParent;
1462
1463 dc.SetClippingRegion( rect.x, rect.y, rect.width, rect.height );
1464
1465 mPanes[i]->PaintPane(dc);
1466
1467 dc.DestroyClippingRegion();
1468 }
1469
1470 event.Skip();
1471 }
1472
1473 void wxFrameLayout::OnEraseBackground( wxEraseEvent& event )
1474 {
1475 // do nothing
1476 }
1477
1478 void wxFrameLayout::OnIdle( wxIdleEvent& event )
1479 {
1480 wxWindow* focus = wxWindow::FindFocus();
1481
1482 if ( !focus && mCheckFocusWhenIdle )
1483 {
1484 wxMessageBox( "Hi, no more focus in this app!" );
1485
1486 mCheckFocusWhenIdle = FALSE;
1487 //ShowFloatedWindows( FALSE );
1488 }
1489
1490 mCheckFocusWhenIdle = FALSE;
1491
1492 event.Skip();
1493 }
1494
1495
1496 void wxFrameLayout::OnKillFocus( wxFocusEvent& event )
1497 {
1498 //wxMessageBox( "wxFrameLayoutGot Kill Focus!" );
1499 //ShowFloatedWindows( FALSE );
1500 }
1501
1502 void wxFrameLayout::OnSetFocus( wxFocusEvent& event )
1503 {
1504 //ShowFloatedWindows( TRUE );
1505 }
1506
1507 void wxFrameLayout::OnActivate( wxActivateEvent& event )
1508 {
1509 #if 0
1510 if ( event.GetActive() == FALSE )
1511 {
1512 wxWindow* focus = wxWindow::FindFocus();
1513
1514 if ( !focus || focus == &GetParentFrame() )
1515 {
1516 mCheckFocusWhenIdle = TRUE;
1517
1518 if ( !focus )
1519
1520 wxMessageBox("Deactivated!" );
1521
1522 }
1523 }
1524 #endif
1525 }
1526
1527 void wxFrameLayout::GetPaneProperties( cbCommonPaneProperties& props, int alignment )
1528 {
1529 props = mPanes[alignment]->mProps;
1530 }
1531
1532 void wxFrameLayout::SetPaneProperties( const cbCommonPaneProperties& props, int paneMask )
1533 {
1534 int i;
1535 for ( i = 0; i != MAX_PANES; ++i )
1536 {
1537 if ( mPanes[i]->MatchesMask( paneMask ) )
1538 mPanes[i]->mProps = props;
1539 }
1540 }
1541
1542 void wxFrameLayout::SetMargins( int top, int bottom, int left, int right,
1543 int paneMask )
1544 {
1545 int i;
1546 for ( i = 0; i != MAX_PANES; ++i )
1547 {
1548 cbDockPane& pane = *mPanes[i];
1549
1550 if ( pane.MatchesMask( paneMask ) )
1551 {
1552 pane.mTopMargin = top;
1553 pane.mBottomMargin = bottom;
1554 pane.mLeftMargin = left;
1555 pane.mRightMargin = right;
1556 }
1557 }
1558 }
1559
1560 void wxFrameLayout::SetPaneBackground( const wxColour& colour )
1561 {
1562 mBorderPen.SetColour( colour );
1563 }
1564
1565 void wxFrameLayout::RefreshNow( bool recalcLayout )
1566 {
1567 if ( recalcLayout )
1568 RecalcLayout( TRUE );
1569
1570 if ( mpFrame )
1571 mpFrame->Refresh();
1572 }
1573
1574 /*** plugin-related methods ***/
1575
1576 void wxFrameLayout::FirePluginEvent( cbPluginEvent& event )
1577 {
1578 // check state of input capture, before processing the event
1579
1580 if ( mpCaputesInput )
1581 {
1582 bool isInputEvt = TRUE;
1583 #if wxCHECK_VERSION(2,3,0)
1584 if ( event.m_eventType != cbEVT_PL_LEFT_DOWN &&
1585 event.m_eventType != cbEVT_PL_LEFT_UP &&
1586 event.m_eventType != cbEVT_PL_RIGHT_DOWN &&
1587 event.m_eventType != cbEVT_PL_RIGHT_UP &&
1588 event.m_eventType != cbEVT_PL_MOTION )
1589 isInputEvt = FALSE;
1590 #else
1591 switch ( event.m_eventType )
1592 {
1593 case cbEVT_PL_LEFT_DOWN : break;
1594 case cbEVT_PL_LEFT_UP : break;
1595 case cbEVT_PL_RIGHT_DOWN : break;
1596 case cbEVT_PL_RIGHT_UP : break;
1597 case cbEVT_PL_MOTION : break;
1598
1599 default : isInputEvt = FALSE; break;
1600 }
1601 #endif // #if wxCHECK_VERSION(2,3,0)
1602
1603 if ( isInputEvt )
1604 {
1605 mpCaputesInput->ProcessEvent( event );
1606 return;
1607 }
1608 }
1609
1610 GetTopPlugin().ProcessEvent( event );
1611 }
1612
1613 void wxFrameLayout::CaptureEventsForPlugin ( cbPluginBase* pPlugin )
1614 {
1615 // cannot capture events for more than one plugin at a time
1616 wxASSERT( mpCaputesInput == NULL );
1617
1618 mpCaputesInput = pPlugin;
1619
1620 }
1621
1622 void wxFrameLayout::ReleaseEventsFromPlugin( cbPluginBase* pPlugin )
1623 {
1624 // events should be captured first
1625 wxASSERT( mpCaputesInput != NULL );
1626
1627 mpCaputesInput = NULL;
1628 }
1629
1630 void wxFrameLayout::CaptureEventsForPane( cbDockPane* toPane )
1631 {
1632 // cannot capture events twice (without releasing)
1633 wxASSERT( mpPaneInFocus == NULL );
1634
1635 mpFrame->CaptureMouse();
1636
1637 mpPaneInFocus = toPane;
1638 }
1639
1640 void wxFrameLayout::ReleaseEventsFromPane( cbDockPane* fromPane )
1641 {
1642 // cannot release events without capturing them
1643 wxASSERT( mpPaneInFocus != NULL );
1644
1645 mpFrame->ReleaseMouse();
1646
1647 mpPaneInFocus = NULL;
1648 }
1649
1650 cbPluginBase& wxFrameLayout::GetTopPlugin()
1651 {
1652 if ( !mpTopPlugin )
1653
1654 PushDefaultPlugins(); // automatic configuration
1655
1656 return *mpTopPlugin;
1657 }
1658
1659 void wxFrameLayout::SetTopPlugin( cbPluginBase* pPlugin )
1660 {
1661 mpTopPlugin = pPlugin;
1662 }
1663
1664 bool wxFrameLayout::HasTopPlugin()
1665 {
1666 return ( mpTopPlugin != NULL );
1667 }
1668
1669 void wxFrameLayout::PushPlugin( cbPluginBase* pPlugin )
1670 {
1671 if ( !mpTopPlugin )
1672
1673 mpTopPlugin = pPlugin;
1674 else
1675 {
1676 pPlugin->SetNextHandler( mpTopPlugin );
1677
1678 mpTopPlugin->SetPreviousHandler( pPlugin );
1679
1680 mpTopPlugin = pPlugin;
1681 }
1682
1683 mpTopPlugin->OnInitPlugin(); // notification
1684 }
1685
1686 void wxFrameLayout::PopPlugin()
1687 {
1688 wxASSERT( mpTopPlugin ); // DBG:: at least one plugin should be present
1689
1690 cbPluginBase* pPopped = mpTopPlugin;
1691
1692 mpTopPlugin = (cbPluginBase*)mpTopPlugin->GetNextHandler();
1693
1694 delete pPopped;
1695 }
1696
1697 void wxFrameLayout::PopAllPlugins()
1698 {
1699 while( mpTopPlugin ) PopPlugin();
1700 }
1701
1702 void wxFrameLayout::PushDefaultPlugins()
1703 {
1704 // FIXME:: to much of the stuff for the default...
1705
1706 AddPlugin( CLASSINFO( cbRowLayoutPlugin ) );
1707 AddPlugin( CLASSINFO( cbBarDragPlugin ) );
1708 AddPlugin( CLASSINFO( cbPaneDrawPlugin ) );
1709 }
1710
1711 void wxFrameLayout::AddPlugin( wxClassInfo* pPlInfo, int paneMask )
1712 {
1713 if ( FindPlugin ( pPlInfo ) ) return; // same type of plugin cannot be added twice
1714
1715 cbPluginBase* pObj = (cbPluginBase*)pPlInfo->CreateObject();
1716
1717 wxASSERT(pObj); // DBG:: plugin's class should be dynamic
1718
1719 pObj->mPaneMask = paneMask;
1720 pObj->mpLayout = this;
1721
1722 PushPlugin( pObj );
1723 }
1724
1725 void wxFrameLayout::AddPluginBefore( wxClassInfo* pNextPlInfo, wxClassInfo* pPlInfo,
1726 int paneMask )
1727 {
1728 wxASSERT( pNextPlInfo != pPlInfo ); // DBG:: no sense
1729
1730 cbPluginBase* pNextPl = FindPlugin( pNextPlInfo );
1731
1732 if ( !pNextPl )
1733 {
1734 AddPlugin( pPlInfo, paneMask );
1735
1736 return;
1737 }
1738
1739 // remove existing one if present
1740
1741 cbPluginBase* pExistingPl = FindPlugin( pPlInfo );
1742
1743 if ( pExistingPl ) RemovePlugin( pPlInfo );
1744
1745 // create an instance
1746
1747 cbPluginBase* pNewPl = (cbPluginBase*)pPlInfo->CreateObject();
1748
1749 wxASSERT(pNewPl); // DBG:: plugin's class should be dynamic
1750
1751 // insert it to the chain
1752
1753 if ( pNextPl->GetPreviousHandler() )
1754
1755 pNextPl->GetPreviousHandler()->SetNextHandler( pNewPl );
1756 else
1757 mpTopPlugin = pNewPl;
1758
1759 pNewPl->SetNextHandler( pNextPl );
1760
1761 pNewPl->SetPreviousHandler( pNextPl->GetPreviousHandler() );
1762
1763 pNextPl->SetPreviousHandler( pNewPl );
1764
1765 // set it up
1766
1767 pNewPl->mPaneMask = paneMask;
1768 pNewPl->mpLayout = this;
1769
1770 pNewPl->OnInitPlugin();
1771 }
1772
1773 void wxFrameLayout::RemovePlugin( wxClassInfo* pPlInfo )
1774 {
1775 cbPluginBase* pPlugin = FindPlugin( pPlInfo );
1776
1777 if ( !pPlugin ) return; // it's OK to remove not-existing plugin ;-)
1778
1779 if ( pPlugin->GetPreviousHandler() == NULL )
1780
1781 mpTopPlugin = (cbPluginBase*)pPlugin->GetNextHandler();
1782
1783 delete pPlugin;
1784 }
1785
1786 cbPluginBase* wxFrameLayout::FindPlugin( wxClassInfo* pPlInfo )
1787 {
1788 cbPluginBase *pCur = mpTopPlugin;
1789
1790 while( pCur )
1791 {
1792 // NOTE:: it might appear useful matching plugin
1793 // classes "polymorphically":
1794
1795 if ( pCur->GetClassInfo()->IsKindOf( pPlInfo ) )
1796
1797 return pCur;
1798
1799 pCur = (cbPluginBase*)pCur->GetNextHandler();
1800 }
1801
1802 return NULL;
1803 }
1804
1805 /***** Implementation for class cbUpdateMgrData *****/
1806
1807 IMPLEMENT_DYNAMIC_CLASS( cbUpdateMgrData, wxObject )
1808
1809 cbUpdateMgrData::cbUpdateMgrData()
1810
1811 : mPrevBounds( -1,-1,0,0 ),
1812 mIsDirty( TRUE ) // inidicate initial change
1813 {}
1814
1815 void cbUpdateMgrData::StoreItemState( const wxRect& boundsInParent )
1816 {
1817 mPrevBounds = boundsInParent;
1818 }
1819
1820 void cbUpdateMgrData::SetDirty( bool isDirty )
1821 {
1822 mIsDirty = isDirty;
1823 }
1824
1825 void cbUpdateMgrData::SetCustomData( wxObject* pCustomData )
1826 {
1827 mpCustomData = pCustomData;
1828 }
1829
1830 /***** Implementation for class cbDockPane *****/
1831
1832 void wxBarIterator::Reset()
1833 {
1834 mpRow = ( mpRows->Count() ) ? (*mpRows)[0] : NULL;
1835 mpBar = NULL;
1836 }
1837
1838 wxBarIterator::wxBarIterator( RowArrayT& rows )
1839
1840 : mpRows( &rows ),
1841 mpRow ( NULL ),
1842 mpBar ( NULL )
1843 {
1844 Reset();
1845 }
1846
1847 bool wxBarIterator::Next()
1848 {
1849 if ( mpRow )
1850 {
1851 if ( mpBar )
1852 mpBar = mpBar->mpNext;
1853 else
1854 {
1855 if ( mpRow->mBars.GetCount() == 0 )
1856 {
1857 return FALSE;
1858 }
1859
1860 mpBar = mpRow->mBars[0];
1861 }
1862
1863 if ( !mpBar )
1864 {
1865 // skip to the next row
1866
1867 mpRow = mpRow->mpNext;
1868
1869 if ( mpRow )
1870
1871 mpBar = mpRow->mBars[0];
1872 else
1873 return FALSE;
1874 }
1875
1876 return TRUE;
1877 }
1878 else
1879 return FALSE;
1880 }
1881
1882 cbBarInfo& wxBarIterator::BarInfo()
1883 {
1884 return *mpBar;
1885 }
1886
1887 cbRowInfo& wxBarIterator::RowInfo()
1888 {
1889 return *mpRow;
1890 }
1891
1892 /***** Implementation for class cbBarDimHandlerBase *****/
1893
1894 IMPLEMENT_ABSTRACT_CLASS( cbBarDimHandlerBase, wxObject )
1895
1896 cbBarDimHandlerBase::cbBarDimHandlerBase()
1897 : mRefCount(0)
1898 {}
1899
1900 void cbBarDimHandlerBase::AddRef()
1901 {
1902 ++mRefCount;
1903 }
1904
1905 void cbBarDimHandlerBase::RemoveRef()
1906 {
1907 if ( --mRefCount <= 0 ) delete this;
1908 }
1909
1910 /***** Implementation for class cbDimInfo *****/
1911
1912 IMPLEMENT_DYNAMIC_CLASS( cbDimInfo, wxObject )
1913
1914 cbDimInfo::cbDimInfo()
1915
1916 : mVertGap ( 0 ),
1917 mHorizGap( 0 ),
1918
1919 mIsFixed(TRUE),
1920 mpHandler( NULL )
1921 {
1922 size_t i;
1923 for ( i = 0; i != MAX_BAR_STATES; ++i )
1924 {
1925 mSizes[i].x = 20;
1926 mSizes[i].y = 20;
1927
1928 mBounds[i] = wxRect( -1,-1,-1,-1 );
1929 }
1930 }
1931
1932 cbDimInfo::cbDimInfo( cbBarDimHandlerBase* pDimHandler,
1933 bool isFixed )
1934
1935 : mVertGap ( 0 ),
1936 mHorizGap( 0 ),
1937 mIsFixed ( isFixed ),
1938
1939 mpHandler( pDimHandler )
1940 {
1941 if ( mpHandler )
1942 {
1943 // int vtad = *((int*)mpHandler);
1944 mpHandler->AddRef();
1945 }
1946
1947 size_t i;
1948 for ( i = 0; i != MAX_BAR_STATES; ++i )
1949 {
1950 mSizes[i].x = -1;
1951 mSizes[i].y = -1;
1952
1953 mBounds[i] = wxRect( -1,-1,-1,-1 );
1954 }
1955 }
1956
1957 cbDimInfo::cbDimInfo( int dh_x, int dh_y,
1958 int dv_x, int dv_y,
1959 int f_x, int f_y,
1960
1961 bool isFixed,
1962 int horizGap,
1963 int vertGap,
1964
1965 cbBarDimHandlerBase* pDimHandler
1966 )
1967 : mVertGap ( vertGap ),
1968 mHorizGap ( horizGap ),
1969 mIsFixed ( isFixed ),
1970 mpHandler( pDimHandler )
1971 {
1972 if ( mpHandler )
1973 {
1974 // int vtad = *((int*)mpHandler);
1975 mpHandler->AddRef();
1976 }
1977
1978 mSizes[wxCBAR_DOCKED_HORIZONTALLY].x = dh_x;
1979 mSizes[wxCBAR_DOCKED_HORIZONTALLY].y = dh_y;
1980 mSizes[wxCBAR_DOCKED_VERTICALLY ].x = dv_x;
1981 mSizes[wxCBAR_DOCKED_VERTICALLY ].y = dv_y;
1982 mSizes[wxCBAR_FLOATING ].x = f_x;
1983 mSizes[wxCBAR_FLOATING ].y = f_y;
1984
1985 size_t i;
1986 for ( i = 0; i != MAX_BAR_STATES; ++i )
1987 mBounds[i] = wxRect( -1,-1,-1,-1 );
1988 }
1989
1990 cbDimInfo::cbDimInfo( int x, int y,
1991 bool isFixed, int gap,
1992 cbBarDimHandlerBase* pDimHandler)
1993 : mVertGap ( gap ),
1994 mHorizGap ( gap ),
1995 mIsFixed ( isFixed ),
1996 mpHandler( pDimHandler )
1997 {
1998 if ( mpHandler )
1999 {
2000 // int vtad = *((int*)mpHandler);
2001 mpHandler->AddRef();
2002 }
2003
2004 mSizes[wxCBAR_DOCKED_HORIZONTALLY].x = x;
2005 mSizes[wxCBAR_DOCKED_HORIZONTALLY].y = y;
2006 mSizes[wxCBAR_DOCKED_VERTICALLY ].x = x;
2007 mSizes[wxCBAR_DOCKED_VERTICALLY ].y = y;
2008 mSizes[wxCBAR_FLOATING ].x = x;
2009 mSizes[wxCBAR_FLOATING ].y = y;
2010
2011 size_t i;
2012 for ( i = 0; i != MAX_BAR_STATES; ++i )
2013 mBounds[i] = wxRect( -1,-1,-1,-1 );
2014 }
2015
2016 cbDimInfo::~cbDimInfo()
2017 {
2018 if ( mpHandler )
2019
2020 mpHandler->RemoveRef();
2021 }
2022
2023 const cbDimInfo& cbDimInfo::operator=( const cbDimInfo& other )
2024 {
2025 if ( this == &other )
2026 return *this;
2027
2028 int i;
2029 for ( i = 0; i != MAX_BAR_STATES; ++i )
2030 mSizes[i] = other.mSizes[i];
2031
2032 mIsFixed = other.mIsFixed;
2033 mpHandler = other.mpHandler;
2034
2035 mVertGap = other.mVertGap;
2036 mHorizGap = other.mHorizGap;
2037
2038 if ( mpHandler )
2039
2040 mpHandler->AddRef();
2041
2042 return *this;
2043 }
2044
2045 /***** Implementation for structure cbCommonPaneProperties *****/
2046
2047 IMPLEMENT_DYNAMIC_CLASS( cbCommonPaneProperties, wxObject )
2048
2049 cbCommonPaneProperties::cbCommonPaneProperties(void)
2050
2051 : mRealTimeUpdatesOn ( TRUE ),
2052 mOutOfPaneDragOn ( TRUE ),
2053 mExactDockPredictionOn( FALSE ),
2054 mNonDestructFrictionOn( FALSE ),
2055 mShow3DPaneBorderOn ( TRUE ),
2056 mBarFloatingOn ( FALSE ),
2057 mRowProportionsOn ( FALSE ),
2058 mColProportionsOn ( TRUE ),
2059 mBarCollapseIconsOn ( FALSE ),
2060 mBarDragHintsOn ( FALSE ),
2061
2062 mMinCBarDim( 16, 16 ),
2063 mResizeHandleSize( 4 )
2064 {}
2065
2066 cbCommonPaneProperties::cbCommonPaneProperties(const cbCommonPaneProperties& props)
2067
2068 : wxObject(),
2069 mRealTimeUpdatesOn (props.mRealTimeUpdatesOn),
2070 mOutOfPaneDragOn (props.mOutOfPaneDragOn),
2071 mExactDockPredictionOn(props.mExactDockPredictionOn),
2072 mNonDestructFrictionOn(props.mNonDestructFrictionOn),
2073 mShow3DPaneBorderOn (props.mShow3DPaneBorderOn),
2074 mBarFloatingOn (props.mBarFloatingOn),
2075 mRowProportionsOn (props.mRowProportionsOn),
2076 mColProportionsOn (props.mColProportionsOn),
2077 mBarCollapseIconsOn (props.mBarCollapseIconsOn),
2078 mBarDragHintsOn (props.mBarDragHintsOn),
2079
2080 mMinCBarDim(props.mMinCBarDim),
2081 mResizeHandleSize(props.mResizeHandleSize)
2082 {}
2083
2084 cbCommonPaneProperties& cbCommonPaneProperties::operator=(const cbCommonPaneProperties& props)
2085 {
2086 mRealTimeUpdatesOn = props.mRealTimeUpdatesOn;
2087 mOutOfPaneDragOn = props.mOutOfPaneDragOn;
2088 mExactDockPredictionOn = props.mExactDockPredictionOn;
2089 mNonDestructFrictionOn = props.mNonDestructFrictionOn;
2090 mShow3DPaneBorderOn = props.mShow3DPaneBorderOn;
2091 mBarFloatingOn = props.mBarFloatingOn;
2092 mRowProportionsOn = props.mRowProportionsOn;
2093 mColProportionsOn = props.mColProportionsOn;
2094 mBarCollapseIconsOn = props.mBarCollapseIconsOn;
2095 mBarDragHintsOn = props.mBarDragHintsOn;
2096
2097 mMinCBarDim = props.mMinCBarDim;
2098 mResizeHandleSize = props.mResizeHandleSize;
2099
2100 return *this;
2101 }
2102
2103 /***** Implementation for class cbRowInfo *****/
2104
2105 IMPLEMENT_DYNAMIC_CLASS( cbRowInfo, wxObject )
2106
2107 cbRowInfo::cbRowInfo(void)
2108
2109 : mNotFixedBarsCnt( FALSE ),
2110 mpNext ( NULL ),
2111 mpPrev ( NULL ),
2112 mpExpandedBar ( NULL )
2113 {}
2114
2115 cbRowInfo::~cbRowInfo()
2116 {
2117 // nothing! all bars are removed using global bar
2118 // list in wxFrameLayout class
2119 }
2120
2121 /***** Implementation for class cbBarInfo *****/
2122
2123 IMPLEMENT_DYNAMIC_CLASS( cbBarInfo, wxObject )
2124
2125 cbBarInfo::cbBarInfo(void)
2126
2127 : mpRow( NULL ),
2128 mpNext( NULL ),
2129 mpPrev( NULL ),
2130 mFloatingOn( TRUE )
2131 {}
2132
2133 cbBarInfo::~cbBarInfo()
2134 {
2135 // nothing
2136 }
2137
2138 /***** Implementation for class cbDockPane *****/
2139
2140 IMPLEMENT_DYNAMIC_CLASS( cbDockPane, wxObject )
2141
2142 // FIXME:: how to eliminate these cut&pasted constructors?
2143
2144 cbDockPane::cbDockPane(void)
2145 : mLeftMargin ( 1 ),
2146 mRightMargin ( 1 ),
2147 mTopMargin ( 1 ),
2148 mBottomMargin( 1 ),
2149 mPaneWidth ( 32768 ), // fake-up very large pane dims,
2150 // since the real dimensions of the pane may not
2151 // be known, while inserting bars initially
2152 mPaneHeight( 32768 ),
2153 mAlignment ( -1 ),
2154 mpLayout ( 0 ),
2155 mpStoredRow( NULL )
2156 {}
2157
2158 cbDockPane::cbDockPane( int alignment, wxFrameLayout* pPanel )
2159
2160 : mLeftMargin ( 1 ),
2161 mRightMargin ( 1 ),
2162 mTopMargin ( 1 ),
2163 mBottomMargin( 1 ),
2164 mPaneWidth ( 32768 ), // fake-up very large pane dims,
2165 // since the real dimensions of the pane may not
2166 // be known, while inserting bars initially
2167 mPaneHeight( 32768 ),
2168 mAlignment ( alignment ),
2169 mpLayout ( pPanel ),
2170 mpStoredRow( NULL )
2171 {}
2172
2173 cbDockPane::~cbDockPane()
2174 {
2175 size_t i;
2176 for ( i = 0; i != mRows.Count(); ++i )
2177 delete mRows[i];
2178
2179 mRowShapeData.DeleteContents( TRUE );
2180
2181 // NOTE:: control bar infromation structures are cleaned-up
2182 // in wxFrameLayout's destructor, using global control-bar list
2183 }
2184
2185 void cbDockPane::SetMargins( int top, int bottom, int left, int right )
2186 {
2187 mTopMargin = top;
2188 mBottomMargin = bottom;
2189 mLeftMargin = left;
2190 mRightMargin = right;
2191 }
2192
2193 /*** helpers of cbDockPane ***/
2194
2195 void cbDockPane::PaintBarDecorations( cbBarInfo* pBar, wxDC& dc )
2196 {
2197 cbDrawBarDecorEvent evt( pBar, dc, this );
2198
2199 mpLayout->FirePluginEvent( evt );
2200 }
2201
2202 void cbDockPane::PaintBarHandles( cbBarInfo* pBar, wxDC& dc )
2203 {
2204 cbDrawBarHandlesEvent evt( pBar, dc, this );
2205
2206 mpLayout->FirePluginEvent( evt );
2207 }
2208
2209 void cbDockPane::PaintBar( cbBarInfo* pBar, wxDC& dc )
2210 {
2211 PaintBarDecorations( pBar, dc );
2212 PaintBarHandles( pBar, dc );
2213 }
2214
2215 void cbDockPane::PaintRowHandles( cbRowInfo* pRow, wxDC& dc )
2216 {
2217 cbDrawRowHandlesEvent evt( pRow, dc, this );
2218
2219 mpLayout->FirePluginEvent( evt );
2220
2221 cbDrawRowDecorEvent evt1( pRow, dc, this );
2222
2223 mpLayout->FirePluginEvent( evt1 );
2224 }
2225
2226 void cbDockPane::PaintRowBackground ( cbRowInfo* pRow, wxDC& dc )
2227 {
2228 cbDrawRowBkGroundEvent evt( pRow, dc, this );
2229
2230 mpLayout->FirePluginEvent( evt );
2231 }
2232
2233 void cbDockPane::PaintRowDecorations( cbRowInfo* pRow, wxDC& dc )
2234 {
2235 size_t i = 0;
2236
2237 // decorations first
2238 for ( i = 0; i != pRow->mBars.Count(); ++i )
2239
2240 PaintBarDecorations( pRow->mBars[i], dc );
2241
2242 // then handles if present
2243 for ( i = 0; i != pRow->mBars.Count(); ++i )
2244
2245 PaintBarHandles( pRow->mBars[i], dc );
2246 }
2247
2248 void cbDockPane::PaintRow( cbRowInfo* pRow, wxDC& dc )
2249 {
2250 PaintRowBackground ( pRow, dc );
2251 PaintRowDecorations( pRow, dc );
2252 PaintRowHandles ( pRow, dc );
2253 }
2254
2255 void cbDockPane::PaintPaneBackground( wxDC& dc )
2256 {
2257 cbDrawPaneBkGroundEvent evt( dc, this );
2258
2259 mpLayout->FirePluginEvent( evt );
2260 }
2261
2262 void cbDockPane::PaintPaneDecorations( wxDC& dc )
2263 {
2264 cbDrawPaneDecorEvent evt( dc, this );
2265
2266 mpLayout->FirePluginEvent( evt );
2267 }
2268
2269 void cbDockPane::PaintPane( wxDC& dc )
2270 {
2271 PaintPaneBackground( dc );
2272
2273 size_t i = 0;
2274
2275 // first decorations
2276 for ( i = 0; i != mRows.Count(); ++i )
2277 {
2278 PaintRowBackground( mRows[i], dc );
2279 PaintRowDecorations( mRows[i], dc );
2280 }
2281
2282 // than handles
2283 for ( i = 0; i != mRows.Count(); ++i )
2284 PaintRowHandles( mRows[i], dc );
2285
2286 // and finally
2287 PaintPaneDecorations( dc );
2288 }
2289
2290 void cbDockPane::SizeBar( cbBarInfo* pBar )
2291 {
2292 cbSizeBarWndEvent evt( pBar, this );
2293
2294 mpLayout->FirePluginEvent( evt );
2295 return;
2296 }
2297
2298 void cbDockPane::SizeRowObjects( cbRowInfo* pRow )
2299 {
2300 size_t i;
2301 for ( i = 0; i != pRow->mBars.Count(); ++i )
2302 SizeBar( pRow->mBars[i] );
2303 }
2304
2305 void cbDockPane::SizePaneObjects()
2306 {
2307 size_t i;
2308 for ( i = 0; i != mRows.Count(); ++i )
2309 SizeRowObjects( mRows[i] );
2310 }
2311
2312 wxDC* cbDockPane::StartDrawInArea( const wxRect& area )
2313 {
2314 wxDC* pDc = 0;
2315
2316 cbStartDrawInAreaEvent evt( area, &pDc, this );
2317
2318 mpLayout->FirePluginEvent( evt );
2319
2320 return pDc;
2321 }
2322
2323 void cbDockPane::FinishDrawInArea( const wxRect& area )
2324 {
2325 cbFinishDrawInAreaEvent evt( area, this );
2326
2327 mpLayout->FirePluginEvent( evt );
2328 }
2329
2330 bool cbDockPane::IsFixedSize( cbBarInfo* pInfo )
2331 {
2332 return ( pInfo->mDimInfo.mIsFixed );
2333 }
2334
2335 int cbDockPane::GetNotFixedBarsCount( cbRowInfo* pRow )
2336 {
2337 int cnt = 0;
2338
2339 size_t i;
2340 for ( i = 0; i != pRow->mBars.Count(); ++i )
2341 {
2342 if ( !pRow->mBars[i]->IsFixed() )
2343 ++cnt;
2344 }
2345
2346 return cnt;
2347 }
2348
2349 void cbDockPane::RemoveBar( cbBarInfo* pBar )
2350 {
2351 bool needsRestoring = mProps.mNonDestructFrictionOn &&
2352 mpStoredRow == pBar->mpRow;
2353
2354 cbRemoveBarEvent evt( pBar, this );
2355
2356 mpLayout->FirePluginEvent( evt );
2357
2358 if ( needsRestoring )
2359 {
2360 SetRowShapeData( mpStoredRow, &mRowShapeData );
2361
2362 mpStoredRow = NULL;
2363 }
2364 }
2365
2366 void cbDockPane::SyncRowFlags( cbRowInfo* pRow )
2367 {
2368 // setup mHasOnlyFixedBars flag for the row information
2369 pRow->mHasOnlyFixedBars = TRUE;
2370
2371 pRow->mNotFixedBarsCnt = 0;
2372
2373 size_t i;
2374 for ( i = 0; i != pRow->mBars.Count(); ++i )
2375 {
2376 cbBarInfo& bar = *pRow->mBars[i];
2377
2378 bar.mpRow = pRow;
2379
2380 if ( !bar.IsFixed() )
2381 {
2382 pRow->mHasOnlyFixedBars = FALSE;
2383 ++pRow->mNotFixedBarsCnt;
2384 }
2385 }
2386 }
2387
2388 void cbDockPane::FrameToPane( int* x, int* y )
2389 {
2390 *x -= mLeftMargin;
2391 *y -= mTopMargin;
2392
2393 if ( mAlignment == FL_ALIGN_TOP ||
2394 mAlignment == FL_ALIGN_BOTTOM
2395 )
2396 {
2397 *x -= mBoundsInParent.x;
2398 *y -= mBoundsInParent.y;
2399 }
2400 else
2401 {
2402 int rx = *x, ry = *y;
2403
2404 *x = ry - mBoundsInParent.y;
2405
2406 *y = rx - mBoundsInParent.x;
2407 }
2408 }
2409
2410 void cbDockPane::PaneToFrame( int* x, int* y )
2411 {
2412 if ( mAlignment == FL_ALIGN_TOP ||
2413 mAlignment == FL_ALIGN_BOTTOM
2414 )
2415 {
2416 *x += mBoundsInParent.x;
2417 *y += mBoundsInParent.y;
2418 }
2419 else
2420 {
2421 int rx = *x, ry = *y;
2422
2423 *x = ry + mBoundsInParent.x;
2424
2425 *y = mBoundsInParent.y + rx;
2426 }
2427
2428 *x += mLeftMargin;
2429 *y += mTopMargin;
2430 }
2431
2432 void cbDockPane::FrameToPane( wxRect* pRect )
2433 {
2434 wxPoint upperLeft ( pRect->x, pRect->y );
2435 wxPoint lowerRight( pRect->x + pRect->width,
2436 pRect->y + pRect->height );
2437
2438 FrameToPane( &upperLeft.x, &upperLeft.y );
2439 FrameToPane( &lowerRight.x, &lowerRight.y );
2440
2441 pRect->x = wxMin(upperLeft.x,lowerRight.x);
2442 pRect->y = wxMin(upperLeft.y,lowerRight.y);
2443
2444 pRect->width = abs( lowerRight.x - upperLeft.x );
2445 pRect->height = abs( lowerRight.y - upperLeft.y );
2446 }
2447
2448 void cbDockPane::PaneToFrame( wxRect* pRect )
2449 {
2450 wxPoint upperLeft ( pRect->x, pRect->y );
2451 wxPoint lowerRight( pRect->x + pRect->width,
2452 pRect->y + pRect->height );
2453
2454 PaneToFrame( &upperLeft.x, &upperLeft.y );
2455 PaneToFrame( &lowerRight.x, &lowerRight.y );
2456
2457 //wxRect newRect = wxRect( upperLeft, lowerRight );
2458
2459 pRect->x = wxMin(upperLeft.x,lowerRight.x);
2460 pRect->y = wxMin(upperLeft.y,lowerRight.y);
2461
2462 pRect->width = abs( lowerRight.x - upperLeft.x );
2463 pRect->height = abs( lowerRight.y - upperLeft.y );
2464 }
2465
2466 int cbDockPane::GetRowAt( int paneY )
2467 {
2468 if ( paneY < 0 )
2469 return -1;
2470
2471 int curY = 0;
2472
2473 size_t i = 0;
2474
2475 for ( ; i != mRows.Count(); ++i )
2476 {
2477 int rowHeight = mRows[i]->mRowHeight;
2478
2479 int third = rowHeight/3;
2480
2481 if ( paneY >= curY && paneY < curY + third )
2482 return i-1;
2483
2484 if ( paneY >= curY + third && paneY < curY + rowHeight - third )
2485 return i;
2486
2487 curY += rowHeight;
2488 }
2489
2490 return i;
2491 }
2492
2493 int cbDockPane::GetRowAt( int upperY, int lowerY )
2494 {
2495 /*
2496 // OLD STUFF::
2497 int range = lowerY - upperY;
2498 int oneThird = range / 3;
2499
2500 wxNode* pRow = mRows.First();
2501 int row = 0;
2502 int curY = 0;
2503
2504 if ( lowerY <= 0 ) return -1;
2505
2506 while( pRow )
2507 {
2508 int rowHeight = GetRowHeight( (wxList*)pRow->Data() );
2509
2510 if ( upperY >= curY &&
2511 lowerY < curY ) return row;
2512
2513 if ( upperY <= curY &&
2514 lowerY >= curY &&
2515 curY - upperY >= oneThird ) return row-1;
2516
2517 if ( ( upperY < curY + rowHeight &&
2518 lowerY >= curY + rowHeight &&
2519 curY + rowHeight - lowerY >= oneThird )
2520 )
2521 return row+1;
2522
2523 if ( lowerY <= curY + rowHeight ) return row;
2524
2525 ++row;
2526 curY += rowHeight;
2527 pRow = pRow->Next();
2528 }
2529 */
2530
2531 int mid = upperY + (lowerY - upperY)/2;
2532
2533 if ( mid < 0 )
2534 return -1;
2535
2536 int curY = 0;
2537 size_t i = 0;
2538
2539 for ( ; i != mRows.Count(); ++i )
2540 {
2541 int rowHeight = mRows[i]->mRowHeight;
2542
2543 if ( mid >= curY && mid < curY + rowHeight ) return i;
2544
2545 curY += rowHeight;
2546 }
2547
2548 return i;
2549 }
2550
2551 int cbDockPane::GetRowY( cbRowInfo* pRow )
2552 {
2553 int curY = 0;
2554
2555 size_t i;
2556 for ( i = 0; i != mRows.Count(); ++i )
2557 {
2558 if ( mRows[i] == pRow )
2559 break;
2560
2561 curY += mRows[i]->mRowHeight;
2562 }
2563
2564 return curY;
2565 }
2566
2567 bool cbDockPane::HasNotFixedRowsAbove( cbRowInfo* pRow )
2568 {
2569 while ( pRow->mpPrev )
2570 {
2571 pRow = pRow->mpPrev;
2572
2573 if ( pRow->mHasOnlyFixedBars )
2574
2575 return TRUE;
2576 }
2577
2578 return FALSE;
2579 }
2580
2581 bool cbDockPane::HasNotFixedRowsBelow( cbRowInfo* pRow )
2582 {
2583 while( pRow->mpNext )
2584 {
2585 pRow = pRow->mpNext;
2586
2587 if ( pRow->mHasOnlyFixedBars )
2588
2589 return TRUE;
2590 }
2591
2592 return FALSE;
2593 }
2594
2595 bool cbDockPane::HasNotFixedBarsLeft( cbBarInfo* pBar )
2596 {
2597 while( pBar->mpPrev )
2598 {
2599 pBar = pBar->mpPrev;
2600
2601 if ( pBar->IsFixed() )
2602
2603 return TRUE;
2604 }
2605
2606 return FALSE;
2607 }
2608
2609 bool cbDockPane::HasNotFixedBarsRight( cbBarInfo* pBar )
2610 {
2611 while( pBar->mpNext )
2612 {
2613 pBar = pBar->mpNext;
2614
2615 if ( pBar->IsFixed() )
2616
2617 return TRUE;
2618 }
2619
2620 return FALSE;
2621 }
2622
2623 void cbDockPane::CalcLengthRatios( cbRowInfo* pInRow )
2624 {
2625 int totalWidth = 0;
2626
2627 size_t i = 0;
2628
2629 // calc current-maximal-total-length of all maximized bars
2630
2631 for ( i = 0; i != pInRow->mBars.GetCount(); ++i )
2632 {
2633 cbBarInfo& bar = *pInRow->mBars[i];
2634
2635 if ( !bar.IsFixed() )
2636 totalWidth += bar.mBounds.width;
2637 }
2638
2639 // set up percentages of occupied space for each maximized bar
2640
2641 for ( i = 0; i != pInRow->mBars.Count(); ++i )
2642 {
2643 cbBarInfo& bar = *pInRow->mBars[i];
2644
2645 if ( !bar.IsFixed() )
2646 bar.mLenRatio = double(bar.mBounds.width)/double(totalWidth);
2647 }
2648 }
2649
2650 void cbDockPane::RecalcRowLayout( cbRowInfo* pRow )
2651 {
2652 cbLayoutRowEvent evt( pRow, this );
2653
2654 mpLayout->FirePluginEvent( evt );
2655 }
2656
2657 void cbDockPane::ExpandBar( cbBarInfo* pBar )
2658 {
2659 mpLayout->GetUpdatesManager().OnStartChanges();
2660
2661 if ( !pBar->mpRow->mpExpandedBar )
2662 {
2663 // save ratios only when there arent any bars expanded yet
2664
2665 cbArrayFloat& ratios = pBar->mpRow->mSavedRatios;
2666
2667 ratios.Clear();
2668 ratios.Alloc( pBar->mpRow->mNotFixedBarsCnt );
2669
2670 cbBarInfo* pCur = pBar->mpRow->mBars[0];
2671
2672 while( pCur )
2673 {
2674 if ( !pCur->IsFixed() )
2675 {
2676 ratios.Add( 0.0 );
2677 ratios[ ratios.GetCount() - 1 ] = pCur->mLenRatio;
2678 }
2679
2680 pCur = pCur->mpNext;
2681 }
2682 }
2683
2684 cbBarInfo* pCur = pBar->mpRow->mBars[0];
2685
2686 while( pCur )
2687 {
2688 pCur->mLenRatio = 0.0; // minimize the rest
2689
2690 pCur = pCur->mpNext;
2691 }
2692
2693 pBar->mLenRatio = 1.0; // 100%
2694 pBar->mBounds.width = 0;
2695
2696 pBar->mpRow->mpExpandedBar = pBar;
2697
2698 mpLayout->RecalcLayout( FALSE );
2699
2700 mpLayout->GetUpdatesManager().OnFinishChanges();
2701 mpLayout->GetUpdatesManager().UpdateNow();
2702 }
2703
2704 void cbDockPane::ContractBar( cbBarInfo* pBar )
2705 {
2706 mpLayout->GetUpdatesManager().OnStartChanges();
2707
2708 // FIXME: What's the purpose of this???
2709 // double ratio = 1.0/ double( pBar->mpRow->mNotFixedBarsCnt );
2710
2711 // restore ratios which were present before expansion
2712
2713 cbBarInfo* pCur = pBar->mpRow->mBars[0];
2714
2715 cbArrayFloat& ratios = pBar->mpRow->mSavedRatios;
2716
2717 size_t i = 0;
2718
2719 while( pCur )
2720 {
2721 if ( !pCur->IsFixed() )
2722 {
2723 pCur->mLenRatio = ratios[i];
2724 ++i;
2725 }
2726
2727 pCur = pCur->mpNext;
2728 }
2729
2730 ratios.Clear();
2731 ratios.Shrink();
2732
2733 pBar->mpRow->mpExpandedBar = NULL;
2734
2735 mpLayout->RecalcLayout( FALSE );
2736
2737 mpLayout->GetUpdatesManager().OnFinishChanges();
2738 mpLayout->GetUpdatesManager().UpdateNow();
2739 }
2740
2741 void cbDockPane::InitLinksForRow( cbRowInfo* pRow )
2742 {
2743 size_t i;
2744 for ( i = 0; i != pRow->mBars.Count(); ++i )
2745 {
2746 cbBarInfo& bar = *pRow->mBars[i];
2747
2748 if ( i == 0 )
2749 bar.mpPrev = NULL;
2750 else
2751 bar.mpPrev = pRow->mBars[i-1];
2752
2753 if ( i == pRow->mBars.Count() - 1 )
2754 bar.mpNext = NULL;
2755 else
2756 bar.mpNext = pRow->mBars[i+1];
2757 }
2758 }
2759
2760 void cbDockPane::InitLinksForRows()
2761 {
2762 size_t i;
2763 for ( i = 0; i != mRows.Count(); ++i )
2764 {
2765 cbRowInfo& row = *mRows[i];
2766
2767 if ( i == 0 )
2768 row.mpPrev = NULL;
2769 else
2770 row.mpPrev = mRows[i-1];
2771
2772 if ( i == mRows.Count() - 1 )
2773 row.mpNext = NULL;
2774 else
2775 row.mpNext = mRows[i+1];
2776 }
2777 }
2778
2779 void cbDockPane::DoInsertBar( cbBarInfo* pBar, int rowNo )
2780 {
2781 cbRowInfo* pRow = NULL;
2782
2783 if ( rowNo == -1 || rowNo >= (int)mRows.Count() )
2784 {
2785 pRow = new cbRowInfo();
2786
2787 if ( rowNo == -1 && mRows.Count() )
2788
2789 mRows.Insert( pRow, 0 );
2790 else
2791 mRows.Add( pRow );
2792
2793 InitLinksForRows();
2794 }
2795 else
2796 {
2797 pRow = mRows[rowNo];
2798
2799 if ( mProps.mNonDestructFrictionOn == TRUE )
2800 {
2801 // store original shape of the row (before the bar is inserted)
2802
2803 mpStoredRow = pRow;
2804
2805 GetRowShapeData( mpStoredRow, &mRowShapeData );
2806 }
2807 }
2808
2809 if ( pRow->mBars.Count() )
2810
2811 pRow->mpExpandedBar = NULL;
2812
2813 cbInsertBarEvent insEvt( pBar, pRow, this );
2814
2815 mpLayout->FirePluginEvent( insEvt );
2816
2817 mpLayout->GetUpdatesManager().OnRowWillChange( pRow, this );
2818 }
2819
2820 void cbDockPane::InsertBar( cbBarInfo* pBarInfo, const wxRect& atRect )
2821 {
2822 wxRect rect = atRect;
2823 FrameToPane( &rect );
2824
2825 pBarInfo->mBounds.x = rect.x;
2826 pBarInfo->mBounds.width = rect.width;
2827 pBarInfo->mBounds.height = rect.height;
2828
2829 int row = GetRowAt( rect.y, rect.y + rect.height );
2830
2831 DoInsertBar( pBarInfo, row );
2832 }
2833
2834 void cbDockPane::InsertBar( cbBarInfo* pBar, cbRowInfo* pIntoRow )
2835 {
2836 cbInsertBarEvent insEvt( pBar, pIntoRow, this );
2837
2838 mpLayout->FirePluginEvent( insEvt );
2839
2840 mpLayout->GetUpdatesManager().OnRowWillChange( pIntoRow, this );
2841 }
2842
2843 void cbDockPane::InsertBar( cbBarInfo* pBarInfo )
2844 {
2845 // set transient properties
2846
2847 pBarInfo->mpRow = NULL;
2848 pBarInfo->mHasLeftHandle = FALSE;
2849 pBarInfo->mHasRightHandle = FALSE;
2850 pBarInfo->mLenRatio = 0.0;
2851
2852 // set preferred bar dimensions, according to the state in which
2853 // the bar is being inserted
2854
2855 pBarInfo->mBounds.width = pBarInfo->mDimInfo.mSizes[ pBarInfo->mState ].x;
2856 pBarInfo->mBounds.height = pBarInfo->mDimInfo.mSizes[ pBarInfo->mState ].y;
2857
2858 DoInsertBar( pBarInfo, pBarInfo->mRowNo );
2859 }
2860
2861 void cbDockPane::RemoveRow( cbRowInfo* pRow )
2862 {
2863 size_t i;
2864 // first, hide all bar-windows in the removed row
2865 for ( i = 0; i != pRow->mBars.Count(); ++i )
2866 {
2867 if ( pRow->mBars[i]->mpBarWnd )
2868 pRow->mBars[i]->mpBarWnd->Show( FALSE );
2869 }
2870
2871 mRows.Remove( pRow );
2872
2873 pRow->mUMgrData.SetDirty(TRUE);
2874 }
2875
2876 void cbDockPane::InsertRow( cbRowInfo* pRow, cbRowInfo* pBeforeRow )
2877 {
2878 if ( !pBeforeRow )
2879
2880 mRows.Add( pRow );
2881 else
2882 mRows.Insert( pRow, mRows.Index( pBeforeRow ) );
2883
2884 InitLinksForRows();
2885
2886 pRow->mUMgrData.SetDirty(TRUE);
2887
2888 size_t i;
2889 for ( i = 0; i != pRow->mBars.Count(); ++i )
2890 pRow->mBars[i]->mUMgrData.SetDirty( TRUE );
2891
2892 SyncRowFlags( pRow );
2893 }
2894
2895 void cbDockPane::SetPaneWidth(int width)
2896 {
2897 if ( IsHorizontal() )
2898 mPaneWidth = width - mLeftMargin - mRightMargin;
2899 else
2900 mPaneWidth = width - mTopMargin - mBottomMargin;
2901 }
2902
2903
2904 void cbDockPane::SetBoundsInParent( const wxRect& rect )
2905 {
2906 mBoundsInParent = rect;
2907
2908 // set pane dimensions in local coordinates
2909
2910 if ( IsHorizontal() )
2911 {
2912 mPaneWidth = mBoundsInParent.width - ( mRightMargin + mLeftMargin );
2913 mPaneHeight = mBoundsInParent.height - ( mTopMargin + mBottomMargin );
2914 }
2915 else
2916 {
2917 mPaneWidth = mBoundsInParent.height - ( mTopMargin + mBottomMargin );
2918 mPaneHeight = mBoundsInParent.width - ( mRightMargin + mLeftMargin );
2919 }
2920
2921 // convert bounding rectangles of all pane items into parent frame's coordinates
2922
2923 wxBarIterator i( mRows );
2924
2925 wxRect noMarginsRect = mBoundsInParent;
2926
2927 noMarginsRect.x += mLeftMargin;
2928 noMarginsRect.y += mTopMargin;
2929 noMarginsRect.width -= ( mLeftMargin + mRightMargin );
2930 noMarginsRect.height -= ( mTopMargin + mBottomMargin );
2931
2932 // hide the whole pane, if it's bounds became reverted (i.e. pane vanished)
2933
2934 if ( mBoundsInParent.width < 0 ||
2935 mBoundsInParent.height < 0 )
2936
2937 hide_rect( mBoundsInParent );
2938
2939 if ( noMarginsRect.width < 0 ||
2940 noMarginsRect.height < 0 )
2941
2942 hide_rect( noMarginsRect );
2943
2944 // calculate mBoundsInParent for each item in the pane
2945
2946 while( i.Next() )
2947 {
2948 cbBarInfo& bar = i.BarInfo();
2949
2950 cbRowInfo* pRowInfo = bar.mpRow;
2951
2952 // set up row info, if this is first bar in the row
2953
2954 if ( pRowInfo && bar.mpPrev == NULL )
2955 {
2956 pRowInfo->mBoundsInParent.y = pRowInfo->mRowY;
2957 pRowInfo->mBoundsInParent.x = 0;
2958 pRowInfo->mBoundsInParent.width = mPaneWidth;
2959 pRowInfo->mBoundsInParent.height = pRowInfo->mRowHeight;
2960
2961 PaneToFrame( &pRowInfo->mBoundsInParent );
2962
2963 clip_rect_against_rect( pRowInfo->mBoundsInParent, noMarginsRect );
2964 }
2965
2966 wxRect bounds = bar.mBounds;
2967
2968 // exclude dimensions of handles, when calculating
2969 // bar's bounds in parent (i.e. "visual bounds")
2970
2971 if ( bar.mHasLeftHandle )
2972 {
2973 bounds.x += mProps.mResizeHandleSize;
2974 bounds.width -= mProps.mResizeHandleSize;
2975 }
2976
2977 if ( bar.mHasRightHandle )
2978
2979 bounds.width -= mProps.mResizeHandleSize;
2980
2981 PaneToFrame( &bounds );
2982
2983 clip_rect_against_rect( bounds, noMarginsRect );
2984
2985 bar.mBoundsInParent = bounds;
2986 }
2987 }
2988
2989 bool cbDockPane::BarPresent( cbBarInfo* pBar )
2990 {
2991 wxBarIterator iter( mRows );
2992
2993 while( iter.Next() )
2994
2995 if ( &iter.BarInfo() == pBar ) return TRUE;
2996
2997 return FALSE;
2998 }
2999
3000 cbRowInfo* cbDockPane::GetRow( int row )
3001 {
3002 if ( row >= (int)mRows.Count() ) return NULL;
3003
3004 return mRows[ row ];
3005 }
3006
3007 int cbDockPane::GetRowIndex( cbRowInfo* pRow )
3008 {
3009 size_t i;
3010 for ( i = 0; i != mRows.Count(); ++i )
3011 {
3012 if ( mRows[i] == pRow )
3013 return i;
3014 }
3015
3016 wxFAIL_MSG("Row must be present to call cbDockPane::GetRowIndex()");
3017
3018 return 0;
3019 }
3020
3021 int cbDockPane::GetPaneHeight()
3022 {
3023 // first, recalculate row heights and the Y-positions
3024
3025 cbLayoutRowsEvent evt( this );
3026 mpLayout->FirePluginEvent( evt );
3027
3028 int height = 0;
3029
3030 if ( IsHorizontal() )
3031
3032 height += mTopMargin + mBottomMargin;
3033 else
3034 height += mLeftMargin + mRightMargin;
3035
3036 int count = mRows.Count();
3037
3038 if ( count )
3039
3040 height += mRows[count-1]->mRowY + mRows[count-1]->mRowHeight;
3041
3042 return height;
3043 }
3044
3045 int cbDockPane::GetAlignment()
3046 {
3047 return mAlignment;
3048 }
3049
3050 bool cbDockPane::MatchesMask( int paneMask )
3051 {
3052 int thisMask = 0;
3053
3054 // FIXME:: use array instead of switch()
3055
3056 switch (mAlignment)
3057 {
3058 case FL_ALIGN_TOP : thisMask = FL_ALIGN_TOP_PANE; break;
3059 case FL_ALIGN_BOTTOM : thisMask = FL_ALIGN_BOTTOM_PANE;break;
3060 case FL_ALIGN_LEFT : thisMask = FL_ALIGN_LEFT_PANE; break;
3061 case FL_ALIGN_RIGHT : thisMask = FL_ALIGN_RIGHT_PANE; break;
3062
3063 default:
3064 wxFAIL_MSG("Bad FL alignment type detected in cbDockPane::MatchesMask()");
3065 }
3066
3067 return ( thisMask & paneMask ) != 0;
3068 }
3069
3070 void cbDockPane::RecalcLayout()
3071 {
3072 // first, reposition rows and items vertically
3073
3074 cbLayoutRowsEvent evt( this );
3075 mpLayout->FirePluginEvent( evt );
3076
3077 // then horizontally in each row
3078
3079 size_t i;
3080 for ( i = 0; i != mRows.Count(); ++i )
3081 RecalcRowLayout( mRows[i] );
3082 }
3083
3084 int cbDockPane::GetDockingState()
3085 {
3086 if ( mAlignment == FL_ALIGN_TOP ||
3087 mAlignment == FL_ALIGN_BOTTOM )
3088 {
3089 return wxCBAR_DOCKED_HORIZONTALLY;
3090 }
3091 else
3092 return wxCBAR_DOCKED_VERTICALLY;
3093 }
3094
3095 inline bool cbDockPane::HasPoint( const wxPoint& pos, int x, int y,
3096 int width, int height )
3097 {
3098 return ( pos.x >= x &&
3099 pos.y >= y &&
3100 pos.x < x + width &&
3101 pos.y < y + height );
3102 }
3103
3104 int cbDockPane::HitTestPaneItems( const wxPoint& pos,
3105 cbRowInfo** ppRow,
3106 cbBarInfo** ppBar
3107 )
3108 {
3109 (*ppRow) = NULL;
3110 (*ppBar) = NULL;
3111
3112 size_t i;
3113 for ( i = 0; i != mRows.Count(); ++i )
3114 {
3115 cbRowInfo& row = *mRows[i];
3116
3117 *ppRow = &row;
3118
3119 // hit-test handles of the row, if present
3120
3121 if ( row.mHasUpperHandle )
3122 {
3123 if ( HasPoint( pos, 0, row.mRowY,
3124 row.mRowWidth, mProps.mResizeHandleSize ) )
3125
3126 return CB_UPPER_ROW_HANDLE_HITTED;
3127 }
3128 else
3129 if ( row.mHasLowerHandle )
3130 {
3131 if ( HasPoint( pos, 0, row.mRowY + row.mRowHeight - mProps.mResizeHandleSize,
3132 row.mRowWidth, mProps.mResizeHandleSize ) )
3133
3134 return CB_LOWER_ROW_HANDLE_HITTED;
3135 }
3136
3137 // hit-test bar handles and bar content
3138
3139 size_t k;
3140 for ( k = 0; k != row.mBars.Count(); ++k )
3141 {
3142 cbBarInfo& bar = *row.mBars[k];
3143 wxRect& bounds = bar.mBounds;
3144
3145 *ppBar = &bar;
3146
3147 if ( bar.mHasLeftHandle )
3148 {
3149 if ( HasPoint( pos, bounds.x, bounds.y,
3150 mProps.mResizeHandleSize, bounds.height ) )
3151
3152 return CB_LEFT_BAR_HANDLE_HITTED;
3153 }
3154 else
3155 if ( bar.mHasRightHandle )
3156 {
3157 if ( HasPoint( pos, bounds.x + bounds.width - mProps.mResizeHandleSize, bounds.y,
3158 mProps.mResizeHandleSize, bounds.height ) )
3159
3160 return CB_RIGHT_BAR_HANDLE_HITTED;
3161 }
3162
3163 if ( HasPoint( pos, bounds.x, bounds.y, bounds.width, bounds.height ) )
3164 return CB_BAR_CONTENT_HITTED;
3165
3166 } // hit-test next bar
3167
3168 } // next row
3169
3170 return CB_NO_ITEMS_HITTED;
3171 }
3172
3173 void cbDockPane::GetBarResizeRange( cbBarInfo* pBar, int* from, int *till,
3174 bool forLeftHandle )
3175 {
3176 cbBarInfo* pGivenBar = pBar;
3177
3178 int notFree = 0;
3179
3180 // calc unavailable space from the left
3181
3182 while( pBar->mpPrev )
3183 {
3184 pBar = pBar->mpPrev;
3185
3186 if ( !pBar->IsFixed() ) notFree += mProps.mMinCBarDim.x;
3187 else notFree += pBar->mBounds.width;
3188 }
3189
3190 *from = notFree;
3191
3192 pBar = pGivenBar;
3193
3194 notFree = 0;
3195
3196 // calc unavailable space from the right
3197
3198 while( pBar->mpNext )
3199 {
3200 pBar = pBar->mpNext;
3201
3202 if ( pBar->mBounds.x >= mPaneWidth ) break;
3203
3204 // treat not-fixed bars as minimized
3205
3206 if ( !pBar->IsFixed() )
3207
3208 notFree += mProps.mMinCBarDim.x;
3209 else
3210 {
3211 if ( pBar->mBounds.x + pBar->mBounds.width >= mPaneWidth )
3212 {
3213 notFree += mPaneWidth - pBar->mBounds.x;
3214 break;
3215 }
3216 else
3217 notFree += pBar->mBounds.width;
3218 }
3219
3220 }
3221
3222 *till = mPaneWidth - notFree;
3223
3224 // do not let resizing totally deform the bar itself
3225
3226 if ( forLeftHandle )
3227
3228 (*till) -= mProps.mMinCBarDim.x;
3229 else
3230
3231 (*from) += mProps.mMinCBarDim.x;
3232 }
3233
3234 int cbDockPane::GetMinimalRowHeight( cbRowInfo* pRow )
3235 {
3236 int height = mProps.mMinCBarDim.y;
3237
3238 size_t i;
3239 for ( i = 0; i != pRow->mBars.Count(); ++i )
3240 {
3241 if ( pRow->mBars[i]->IsFixed() )
3242 height = wxMax( height, pRow->mBars[i]->mBounds.height );
3243 }
3244
3245 if ( pRow->mHasUpperHandle )
3246 height += mProps.mResizeHandleSize;
3247
3248 if ( pRow->mHasLowerHandle )
3249 height += mProps.mResizeHandleSize;
3250
3251 return height;
3252 }
3253
3254 void cbDockPane::SetRowHeight( cbRowInfo* pRow, int newHeight )
3255 {
3256 if ( pRow->mHasUpperHandle )
3257
3258 newHeight -= mProps.mResizeHandleSize;
3259
3260 if ( pRow->mHasLowerHandle )
3261
3262 newHeight -= mProps.mResizeHandleSize;
3263
3264 size_t i;
3265 for ( i = 0; i != pRow->mBars.Count(); ++i )
3266 {
3267 if ( !pRow->mBars[i]->IsFixed() )
3268 pRow->mBars[i]->mBounds.height = newHeight;
3269 }
3270 }
3271
3272 void cbDockPane::GetRowResizeRange( cbRowInfo* pRow, int* from, int* till,
3273 bool forUpperHandle )
3274 {
3275 cbRowInfo* pGivenRow = pRow;
3276
3277 // calc unavailable space from above
3278
3279 int notFree = 0;
3280
3281 while( pRow->mpPrev )
3282 {
3283 pRow = pRow->mpPrev;
3284
3285 notFree += GetMinimalRowHeight( pRow );
3286
3287 };
3288
3289 *from = notFree;
3290
3291 // allow accupy the client window space by resizing pane rows
3292 if ( mAlignment == FL_ALIGN_BOTTOM )
3293
3294 *from -= mpLayout->GetClientHeight();
3295 else
3296 if ( mAlignment == FL_ALIGN_RIGHT )
3297
3298 *from -= mpLayout->GetClientWidth();
3299
3300 // calc unavailable space from below
3301
3302 pRow = pGivenRow;
3303
3304 notFree = 0;
3305
3306 while( pRow->mpNext )
3307 {
3308 pRow = pRow->mpNext;
3309
3310 notFree += GetMinimalRowHeight( pRow );
3311
3312 }
3313
3314 *till = mPaneHeight - notFree;
3315
3316 // allow adjustinig pane space vs. client window space by resizing pane row heights
3317
3318 if ( mAlignment == FL_ALIGN_TOP )
3319
3320 *till += mpLayout->GetClientHeight();
3321 else
3322 if ( mAlignment == FL_ALIGN_LEFT )
3323
3324 *till += mpLayout->GetClientWidth();
3325
3326 // do not let the resizing of the row totally squeeze the row itself
3327
3328 cbRowInfo& row = *pGivenRow;
3329
3330 if ( forUpperHandle )
3331 {
3332 *till = row.mRowY + row.mRowHeight - GetMinimalRowHeight( pGivenRow );
3333
3334 if ( row.mHasUpperHandle )
3335
3336 *till -= mProps.mResizeHandleSize;
3337 }
3338 else
3339 {
3340 *from += GetMinimalRowHeight( pGivenRow );
3341
3342 if ( row.mHasLowerHandle )
3343
3344 *from -= mProps.mResizeHandleSize;
3345 }
3346 }
3347
3348 void cbDockPane::ResizeRow( cbRowInfo* pRow, int ofs,
3349 bool forUpperHandle )
3350 {
3351 cbResizeRowEvent evt( pRow, ofs, forUpperHandle, this );
3352
3353 mpLayout->FirePluginEvent( evt );
3354 }
3355
3356 void cbDockPane::ResizeBar( cbBarInfo* pBar, int ofs,
3357 bool forLeftHandle )
3358 {
3359 pBar->mpRow->mpExpandedBar = NULL;
3360
3361 mpLayout->GetUpdatesManager().OnStartChanges();
3362
3363 wxRect& bounds = pBar->mBounds;
3364
3365 if ( forLeftHandle )
3366 {
3367 // do not allow bar width become less then minimal
3368 if ( bounds.x + ofs > bounds.x + bounds.width - mProps.mMinCBarDim.x )
3369 {
3370 bounds.width = mProps.mMinCBarDim.x;
3371 bounds.x += ofs;
3372 }
3373 else
3374 {
3375 bounds.x += ofs;
3376 bounds.width -= ofs;
3377 }
3378 }
3379 else
3380 {
3381 // move bar left if necessary
3382 if ( bounds.width + ofs < mProps.mMinCBarDim.x )
3383 {
3384 bounds.x = bounds.x + bounds.width + ofs - mProps.mMinCBarDim.x;
3385 bounds.width = mProps.mMinCBarDim.x;
3386 }
3387 else
3388 // resize right border only
3389 bounds.width += ofs;
3390 }
3391
3392
3393 cbRowInfo* pToRow = pBar->mpRow;
3394
3395 this->RemoveBar( pBar );
3396
3397 InsertBar( pBar, pToRow );
3398
3399 mpLayout->RecalcLayout(FALSE);
3400
3401 mpLayout->GetUpdatesManager().OnFinishChanges();
3402 mpLayout->GetUpdatesManager().UpdateNow();
3403 }
3404
3405
3406 /*** row/bar resizing related methods ***/
3407
3408 void cbDockPane::DrawVertHandle( wxDC& dc, int x, int y, int height )
3409 {
3410 int lower = y + height;
3411
3412 dc.SetPen( mpLayout->mLightPen );
3413 dc.DrawLine( x,y, x, lower );
3414
3415 dc.SetPen( mpLayout->mGrayPen );
3416 int i;
3417 for ( i = 0; i != mProps.mResizeHandleSize-1; ++i )
3418 {
3419 ++x;
3420 dc.DrawLine( x,y, x, lower );
3421 }
3422
3423 dc.SetPen( mpLayout->mDarkPen );
3424 ++x;
3425 dc.DrawLine( x,y, x, lower );
3426
3427 dc.SetPen( mpLayout->mBlackPen );
3428 ++x;
3429 dc.DrawLine( x,y, x, lower );
3430 }
3431
3432 void cbDockPane::DrawHorizHandle( wxDC& dc, int x, int y, int width )
3433 {
3434 int right = x + width;
3435
3436 dc.SetPen( mpLayout->mLightPen );
3437 dc.DrawLine( x,y, right, y );
3438
3439 dc.SetPen( mpLayout->mGrayPen );
3440
3441 int i;
3442 for ( i = 0; i != mProps.mResizeHandleSize-1; ++i )
3443 {
3444 ++y;
3445 dc.DrawLine( x,y, right, y );
3446 }
3447
3448 dc.SetPen( mpLayout->mDarkPen );
3449 dc.DrawLine( x,y, right, ++y );
3450
3451 dc.SetPen( mpLayout->mBlackPen );
3452 dc.DrawLine( x,y, right, ++y );
3453 }
3454
3455 cbBarInfo* cbDockPane::GetBarInfoByWindow( wxWindow* pBarWnd )
3456 {
3457 wxBarIterator i( mRows );
3458
3459 while( i.Next() )
3460
3461 if ( i.BarInfo().mpBarWnd == pBarWnd )
3462
3463 return &i.BarInfo();
3464
3465 return NULL;
3466 }
3467
3468 void cbDockPane::GetRowShapeData( cbRowInfo* pRow, wxList* pLst )
3469 {
3470 pLst->DeleteContents( TRUE );
3471 pLst->Clear();
3472
3473 size_t i;
3474 for ( i = 0; i != pRow->mBars.Count(); ++i )
3475 {
3476 cbBarInfo& bar = *pRow->mBars[i];
3477
3478 cbBarShapeData* pData = new cbBarShapeData();
3479
3480 pLst->Append( (wxObject*)pData );
3481
3482 pData->mBounds = bar.mBounds;
3483 pData->mLenRatio = bar.mLenRatio;
3484 }
3485 }
3486
3487 void cbDockPane::SetRowShapeData( cbRowInfo* pRow, wxList* pLst )
3488 {
3489 if ( pLst->First() == NULL )
3490 return;
3491
3492 wxNode* pData = pLst->First();
3493
3494 size_t i;
3495 for ( i = 0; i != pRow->mBars.Count(); ++i )
3496 {
3497 wxASSERT( pData ); // DBG::
3498
3499 cbBarInfo& bar = *pRow->mBars[i];;
3500
3501 cbBarShapeData& data = *((cbBarShapeData*)pData->Data());
3502
3503 bar.mBounds = data.mBounds;
3504 bar.mLenRatio = data.mLenRatio;
3505
3506 pData = pData->Next();
3507 }
3508 }
3509
3510 /***** Implementation for class cbUpdatesManagerBase *****/
3511
3512 IMPLEMENT_ABSTRACT_CLASS( cbUpdatesManagerBase, wxObject )
3513
3514 /***** Implementation for class cbPluginBase *****/
3515
3516 IMPLEMENT_ABSTRACT_CLASS( cbPluginBase, wxEvtHandler )
3517
3518 cbPluginBase::~cbPluginBase()
3519 {
3520 // nothing
3521 }
3522
3523 bool cbPluginBase::ProcessEvent(wxEvent& event)
3524 {
3525 if ( mPaneMask == wxALL_PANES )
3526
3527 return wxEvtHandler::ProcessEvent( event );
3528
3529 // extract mask info. from received event
3530
3531 cbPluginEvent& evt = *( (cbPluginEvent*)&event );
3532
3533 if ( evt.mpPane == 0 &&
3534 mPaneMask == wxALL_PANES )
3535
3536 return wxEvtHandler::ProcessEvent( event );
3537
3538 int mask = 0;
3539
3540 switch ( evt.mpPane->mAlignment )
3541 {
3542 case FL_ALIGN_TOP : mask = FL_ALIGN_TOP_PANE; break;
3543 case FL_ALIGN_BOTTOM : mask = FL_ALIGN_BOTTOM_PANE;break;
3544 case FL_ALIGN_LEFT : mask = FL_ALIGN_LEFT_PANE; break;
3545 case FL_ALIGN_RIGHT : mask = FL_ALIGN_RIGHT_PANE; break;
3546 }
3547
3548 // if event's pane maks matches the plugin's mask
3549
3550 if ( mPaneMask & mask )
3551
3552 return wxEvtHandler::ProcessEvent( event );
3553
3554 // otherwise pass to the next handler if present
3555
3556 if ( GetNextHandler() && GetNextHandler()->ProcessEvent( event ) )
3557
3558 return TRUE;
3559 else
3560 return FALSE;
3561 }
3562
wxWidgets (Impactor)