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