contrib/src/fl/controlbar.cpp

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