reverted the fix for Unicode compilation with VC++ as it breaks other ports (and...

[wxWidgets.git] / contrib / src / fl / rowlayoutpl.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        No names yet.
// Purpose:     Contrib. demo
// Author:      Aleksandras Gluchovas
// Modified by:
// Created:     09/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Aleksandras Gluchovas
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////
 
#ifdef __GNUG__
    #pragma implementation "rowlayoutpl.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include "wx/fl/rowlayoutpl.h"

// exerimental "features" are still buggy
#undef __EXPERIMENTAL

/***** Implementation for class cbRowLayoutPlugin *****/

IMPLEMENT_DYNAMIC_CLASS( cbRowLayoutPlugin, cbPluginBase )

BEGIN_EVENT_TABLE( cbRowLayoutPlugin, cbPluginBase )

        EVT_PL_LAYOUT_ROW ( cbRowLayoutPlugin::OnLayoutRow  )
        EVT_PL_LAYOUT_ROWS( cbRowLayoutPlugin::OnLayoutRows )
        EVT_PL_RESIZE_ROW ( cbRowLayoutPlugin::OnResizeRow  )

        EVT_PL_INSERT_BAR ( cbRowLayoutPlugin::OnInsertBar  )
        EVT_PL_REMOVE_BAR ( cbRowLayoutPlugin::OnRemoveBar  )

END_EVENT_TABLE()

cbRowLayoutPlugin::cbRowLayoutPlugin(void)
        : mpPane( 0 )
{}

cbRowLayoutPlugin::cbRowLayoutPlugin( wxFrameLayout* pPanel, int paneMask )

        : cbPluginBase( pPanel, paneMask ),
          mpPane( 0 )
{}

void cbRowLayoutPlugin::CheckIfAtTheBoundary( cbBarInfo* pTheBar, cbRowInfo& rowInfo )
{
        // this method handles situation, when fixed bar is inserted
        // into the row, where among fixed bars not-fixed ones are present.
        // In this case we need to check if the pBarNode appears to be inserted
        // chain of fixed-bars on the very right or left side of the row,
        // then all the white-space, such chain should be eliminated,
        // and the resulting chain justified to the right or the left 
        // side of the row

        if ( !pTheBar->IsFixed() || rowInfo.mHasOnlyFixedBars ) 

                return;

        cbBarInfo* pBar = rowInfo.mBars[ rowInfo.mBars.Count() - 1 ];

        // slide fixed bars to the right on the right side relative to the pBarNode

        int prevX = mpPane->mPaneWidth;

        do
        {
                if ( !pBar->IsFixed() ) 
                        break;

                wxRect& bounds = pBar->mBounds;

                bounds.x = prevX - bounds.width;

                prevX = bounds.x;

                if ( pBar == pTheBar ) break;

                pBar = pBar->mpPrev;
        }
        while( 1 );

        // slide fixed bars to the left on the left side relative to the pBarNode   

        pBar = rowInfo.mBars[0];

        prevX = 0;
        
        do
        {
                if ( pBar->IsFixed() ) 

                        break;

                wxRect& bounds = pBar->mBounds;

                bounds.x = prevX;

                prevX = bounds.x + bounds.width;

                if ( pBar == pTheBar ) break;

                pBar = pBar->mpNext;
        }
        while( 1 );
}

void cbRowLayoutPlugin::ExpandNotFixedBars( cbRowInfo* pRow )
{
        ApplyLengthRatios( pRow );

                // FIXME:: something's wrong?
                return;

        double freeSpc = (double)GetRowFreeSpace( pRow );

        // calculate sum of precents

        double pcntSum = 0.0;

        size_t i = 0;

        for( i = 0; i != pRow->mBars.Count(); ++i )
        {
                if ( !pRow->mBars[i]->IsFixed() )
                        pcntSum += pRow->mBars[i]->mLenRatio;
        }

        // setup bar lengths

        int curX = 0;

        for( i = 0; i != pRow->mBars.Count(); ++i )
        {
                cbBarInfo& bar = *pRow->mBars[i];

                if ( !bar.IsFixed() )
                {
                        bar.mLenRatio = bar.mLenRatio/(pcntSum);

                        bar.mBounds.width = 
                                
                                wxMax( mpPane->mProps.mMinCBarDim.x, int( freeSpc*bar.mLenRatio ) );
                }
                
                bar.mBounds.x = curX;
                curX = bar.mBounds.x + bar.mBounds.width;
        }
}

void cbRowLayoutPlugin::AdjustLengthOfInserted( cbRowInfo* pRow, cbBarInfo* pTheBar )
{
        return;

        // pTheBar is not-fixed


        // FIXME:: what is this for??

#if 1

        int totalLen = 0;

    size_t i;
        for( i = 0; i != pRow->mBars.Count(); ++i )
    {
                if ( !pRow->mBars[i]->IsFixed() )
                        totalLen += pRow->mBars[i]->mBounds.width;
    }

        double curWidth = pTheBar->mBounds.width;

        if ( pRow->mBars.Count() )

                pTheBar->mBounds.width = int( mpPane->mPaneWidth * (curWidth / double(totalLen)) );

#else

        double freeSpc = (double)GetRowFreeSpace( pRow );

        double pcntSum = 0.0;

    size_t i;
        for( i = 0; i != pRow->mBars.Count(); ++i )
    {
                if ( !pRow->mBars[i]->IsFixed() )
                        pcntSum += pRow->mBars[i]->mLenRatio;
    }

        // if no longer "balanced", assume that `pTheBar' was previously
        // removed from this row (kind of AI...)

        if ( pcntSum < 0.98 )
        
                pTheBar->mBounds.width = freeSpc * (1.0 - pcntSum);
#endif
}

void cbRowLayoutPlugin::FitBarsToRange( int from, int till, 
                                                                                cbBarInfo* pTheBar, cbRowInfo* pRow )
{
        cbBarInfo* pFromBar = NULL;
        cbBarInfo* pTillBar = NULL;

        if ( pTheBar->mBounds.x > from )
        {
                // it's range from the left
                pFromBar = pRow->mBars[0];
                pTillBar = pTheBar;
        }
        else
        {
                pFromBar = pTheBar->mpNext;
                pTillBar = NULL;
        }

        // calc free space in the range

        cbBarInfo* pBar = pFromBar;
        int     freeSpc = till-from;
        double  pcntSum = 0;

        while( pBar != pTillBar )
        {
                if ( pBar->IsFixed() )

                        freeSpc -= pBar->mBounds.width;
                else
                        pcntSum += pBar->mLenRatio;

                pBar = pBar->mpNext;
        }

        // adjust not-fixed bar sizes in the range

        pBar = pFromBar;

        while( pBar != pTillBar )
        {
                if ( !pBar->IsFixed() )
                
                        pBar->mBounds.width = 

                                wxMax( mpPane->mProps.mMinCBarDim.x,
                                       int( double(freeSpc) * (pBar->mLenRatio/pcntSum) ) 
                                         );

                pBar = pBar->mpNext;
        }

        // layout range, starting from the left-most bar

        pBar      = pFromBar;
        int prevX = from;
        bool hasNotFixedBars = FALSE;

        while ( pBar != pTillBar )
        {
                wxRect& bounds = pBar->mBounds;

                if ( !pBar->IsFixed() )
                {
                        hasNotFixedBars = TRUE;

                        freeSpc -= bounds.width;
                }

                bounds.x = prevX;

                prevX = bounds.x + bounds.width;
                
                pBar = pBar->mpNext;
        }

        // make width adjustment for the right-most bar in the range, due to
        // lost precision when seting widths using f.p. length-ratios

        if ( hasNotFixedBars )
        {
                if ( pTheBar->mBounds.x > from )
                {
                        if ( pTillBar->mpPrev )
                        {
                                wxRect& tillBar = pTillBar->mpPrev->mBounds;

                                //tillBar.width = bar.mBounds.x - tillBar.x;
                                tillBar.width += freeSpc;
                        }
                }
                else
                {
                        cbBarInfo* pLast = pRow->mBars[ pRow->mBars.Count() - 1 ];

                        if ( pLast != pTheBar )
                        {
                                pTheBar->mBounds.width += freeSpc;

                                SlideRightSideBars( pTheBar );
                        }
                }
        }
}

void cbRowLayoutPlugin::MinimzeNotFixedBars( cbRowInfo* pRow, cbBarInfo* pBarToPreserve )
{
    size_t i;
        for( i = 0; i != pRow->mBars.Count(); ++i )
    {
                if ( !pRow->mBars[i]->IsFixed() && pRow->mBars[i] != pBarToPreserve )
                        pRow->mBars[i]->mBounds.width = mpPane->mProps.mMinCBarDim.x;
    }
}

int cbRowLayoutPlugin::GetRowFreeSpace( cbRowInfo* pRow )
{
        int freeSpc = mpPane->mPaneWidth;

    size_t i;
        for( i = 0; i != pRow->mBars.Count(); ++i )
    {
                // not-fixed bars variable length, thus their
                // dimensions are ignored
                if ( pRow->mBars[i]->IsFixed() )
                        freeSpc -= pRow->mBars[i]->mBounds.width;
    }

        return freeSpc;
}

void cbRowLayoutPlugin::RecalcLengthRatios( cbRowInfo* pRow )
{
        double freeSpc = double( GetRowFreeSpace( pRow ) );

        cbBarInfo* pBar          = pRow->mBars[0];
        cbBarInfo* pLastNotFixed = NULL;

        double pcntLeft = 1.0; // (100%)

#ifdef __EXPERIMENTAL

        int totalLen = 0;

    size_t i;
        for( i = 0; i != pRow->mBars.Count(); ++i )
    {
                if ( !pRow->mBars[i]->IsFixed() )
                        totalLen += pRow->mBars[i]->mBounds.width;
    }
#endif

    size_t i;
        for( i = 0; i != pRow->mBars.Count(); ++i )
        {
                cbBarInfo& bar = *pRow->mBars[i];

                if ( !bar.IsFixed() )
                {

#ifdef __EXPERIMENTAL

                        bar.mLenRatio = double(bar.mBounds.width)/double(totalLen);
#else
                        bar.mLenRatio = double(bar.mBounds.width)/freeSpc;
#endif

                        pcntLeft      -= bar.mLenRatio;
                        pLastNotFixed  = pBar;
                }
        }

        // attach remainder (the result of lost precision) to the
        // last not-fixed bar

#if !defined(__EXPERIMENTAL)    

        if ( pLastNotFixed )
                
                pLastNotFixed->mLenRatio += pcntLeft;
#endif

}

void cbRowLayoutPlugin::ApplyLengthRatios( cbRowInfo* pRow )
{
        double pcntSum = 0;

        // FOR NOW:: all-in-one

        size_t i = 0;
        for( i = 0; i != pRow->mBars.Count(); ++i )
    {
                if ( !pRow->mBars[i]->IsFixed() )
                        pcntSum += pRow->mBars[i]->mLenRatio;
    }

        /*
        pBar = node_to_first_bar_node( pRow );
        
        while( pBar )
        {
                cbBarInfo& bar = node_to_bar( pBar );

                if ( !bar.IsFixed() )
                
                        bar.mLenRatio = pcntSum / bar.mLenRatio;

                pBar = pBar->Next();
        }
        */

        int    prevX   = 0;
        double freeSpc = GetRowFreeSpace( pRow );

        // tricky stuff (improtant!):
        // when not-fixed bar is removed from the row and there are
        // still some other not-fixed ones left in that row, then
        // the sum of mLenRatio's is no longer 1.0 - this is left
        // intintionally to handle the case when the removed bar
        // is returned right back to the row - so that it would retain
        // it's original dimensions in this row (this is kind of AI...)
        //
        // The problem is - when it's remvoed, the sum of 
        // mLenRatio's is not in "balance", i.e. is < 1.0,
        // it's possible to restore balance, but instead of that
        // we artifically ajdust freeSpc value in a way that it would 
        // look like total of mLetRatio's is 1.0, thus original
        // len. ratios are _preserved_:

        double unit = freeSpc / pcntSum;

        bool haveSquished = FALSE;

        for( i = 0; i != pRow->mBars.Count(); ++i )
    {
                if ( !pRow->mBars[i]->IsFixed() )
                {
                        cbBarInfo& bar = *pRow->mBars[i];       
                        
                        if ( int( unit * bar.mLenRatio ) < mpPane->mProps.mMinCBarDim.x )
                        {
                                haveSquished = TRUE;

                                bar.mBounds.width = -1; // mark as "squished"

                                pcntSum -= bar.mLenRatio;

                                freeSpc -= mpPane->mProps.mMinCBarDim.x;
                        }
                }
    }  // for

        if ( haveSquished )
        
                unit = freeSpc / pcntSum;

        for( i = 0; i != pRow->mBars.Count(); ++i )
        {
                cbBarInfo& bar = *pRow->mBars[i];

                bar.mBounds.x = prevX;

                if ( !bar.IsFixed() )
                {
                        if ( bar.mBounds.width == -1 )

                                bar.mBounds.width = mpPane->mProps.mMinCBarDim.x;
                        else
                                bar.mBounds.width = int( unit * bar.mLenRatio );

                        // a little bit of AI: 
                        // memorize bar's height and width, when docked in 
                        // the current orientation - by making the current
                        // dimensions to be "preffered" ones for this docking state

                        if ( !bar.IsFixed() )
                        {
                                bar.mDimInfo.mSizes[ bar.mState ].x = bar.mBounds.width;
                                bar.mDimInfo.mSizes[ bar.mState ].y = bar.mBounds.height;
                        }
                }

                prevX = bar.mBounds.x + bar.mBounds.width;
        }
}

void cbRowLayoutPlugin::DetectBarHandles( cbRowInfo* pRow )
{
        // first pass from left to right (detect left-side handles)

        bool foundNotFixed = FALSE;

    size_t i;
        for( i = 0; i != pRow->mBars.Count(); ++i )
        {
                cbBarInfo& bar = *pRow->mBars[i];
                
                bar.mHasLeftHandle = FALSE;

                if ( !bar.IsFixed() )
                {
                        if ( foundNotFixed )
                
                                if ( bar.mpPrev &&
                                         bar.mpPrev->IsFixed() )
                                
                                        bar.mHasLeftHandle = TRUE;

                        foundNotFixed = TRUE;
                }
        }

        // pass from right to left (detect right-side handles)

        foundNotFixed = FALSE;

        cbBarInfo* pBar = pRow->mBars[ pRow->mBars.Count() - 1 ];

        while( pBar )
        {
                pBar->mHasRightHandle = FALSE;

                if ( !pBar->IsFixed() )
                {
                        if ( foundNotFixed )

                                if ( pBar->mpNext )

                                         pBar->mHasRightHandle = TRUE;

                        foundNotFixed = TRUE;
                }

                pBar = pBar->mpPrev;
        }
}

void cbRowLayoutPlugin::RelayoutNotFixedBarsAround( cbBarInfo* pTheBar, cbRowInfo* pRow )
{
        if ( !pTheBar->mpPrev )
        {
                if (  !pTheBar->IsFixed() )
                {
                        // this bar the first in the row, move it's 
                        // left edge to the very left
                        pTheBar->mBounds.width += pTheBar->mBounds.x;
                        pTheBar->mBounds.x      = 0;
                }
        }
        else
                FitBarsToRange( 0, pTheBar->mBounds.x, pTheBar, pRow );

        if ( !pTheBar->mpNext )
        {
                if ( !pTheBar->IsFixed() )
                {
                        // this bar is the last one, move it's 
                        // right edge to the very right

                        pTheBar->mBounds.width = mpPane->mPaneWidth - pTheBar->mBounds.x;
                }
        }
        else
                FitBarsToRange( pTheBar->mBounds.x + pTheBar->mBounds.width, mpPane->mPaneWidth,
                                pTheBar, pRow
                                          );
}

void cbRowLayoutPlugin::LayoutItemsVertically( cbRowInfo& row )
{
    size_t i;
        for( i = 0; i != row.mBars.Count(); ++i )
        {
                cbBarInfo& bar = *row.mBars[i];

                bar.mBounds.y = row.mRowY;

                if ( !bar.IsFixed() )

                        // make all not-fixed bars of equal height
                        bar.mBounds.height = row.mRowHeight;

                if ( row.mHasUpperHandle )

                        bar.mBounds.y += mpPane->mProps.mResizeHandleSize;
        }
}

int cbRowLayoutPlugin::CalcRowHeight( cbRowInfo& row )
{
        int maxHeight = 0;

    size_t i;
        for( i = 0; i != row.mBars.Count(); ++i )
        
                maxHeight = wxMax( maxHeight, row.mBars[i]->mBounds.height );

        return maxHeight;
}

void cbRowLayoutPlugin::StickRightSideBars( cbBarInfo* pToBar )
{
        cbBarInfo* pBar  = pToBar->mpNext;
        cbBarInfo* pPrev = pToBar;

        while( pBar )
        {
                wxRect& cur  = pBar->mBounds;
                wxRect& prev = pPrev->mBounds;

                cur.x = prev.x + prev.width;

                pPrev = pBar;
                pBar  = pBar->mpNext;
        }
}

void cbRowLayoutPlugin::SlideLeftSideBars( cbBarInfo* pTheBar )
{
        // shift left-side-bars to the left (with respect to "theBar"),
        // so that they would not obscured by each other

        cbBarInfo* pBar  = pTheBar->mpPrev;
        cbBarInfo* pPrev = pTheBar;

        while( pBar )
        {
                wxRect& cur  = pBar->mBounds;
                wxRect& prev = pPrev->mBounds;

                if ( cur.x + cur.width > prev.x )

                        cur.x = prev.x - cur.width;

                pPrev = pBar;
                pBar  = pBar->mpPrev;
        }
}

void cbRowLayoutPlugin::SlideRightSideBars( cbBarInfo* pTheBar )
{
        // shift right-side-bars to the right (with respect to "theBar"),
        // so that they would not be obscured by each other

        cbBarInfo* pBar  = pTheBar->mpNext;
        cbBarInfo* pPrev = pTheBar;

        while( pBar )
        {
                wxRect& cur  = pBar->mBounds;
                wxRect& prev = pPrev->mBounds;

                if ( cur.x < prev.x + prev.width )

                        cur.x = prev.x + prev.width;

                pPrev = pBar;
                pBar  = pBar->mpNext;
        }
}

void cbRowLayoutPlugin::ShiftLeftTrashold( cbBarInfo* pTheBar, cbRowInfo& row )
{
        wxRect& first = row.mBars[0]->mBounds;

        if ( first.x < 0 )
        {
                row.mBars[0]->mBounds.x = 0;

                SlideRightSideBars( row.mBars[0] );
        }
}

void cbRowLayoutPlugin::ShiftRightTrashold( cbBarInfo* pTheBar, cbRowInfo& row )
{
        wxRect& theBar = pTheBar->mBounds;

        do
        {
                cbBarInfo* pBar = pTheBar;

                // calculate free spece on the left side

                int leftFreeSpc = 0;

                while( pBar )
                {
                        wxRect& cur = pBar->mBounds;

                        if ( pBar->mpPrev )
                        {
                                wxRect& prev = pBar->mpPrev->mBounds;

                                leftFreeSpc += cur.x - prev.x - prev.width;
                        }
                        else
                                leftFreeSpc += cur.x;

                        if ( cur.x < 0 )
                        {
                                leftFreeSpc = 0;
                                break;
                        }

                        pBar = pBar->mpPrev;
                }

                pBar = pTheBar;

                int rightOverflow = 0;

                if ( pTheBar->IsFixed() )

                        while( pBar )
                        {
                                if ( !pBar->mpNext )
                                {
                                        wxRect& cur = pBar->mBounds;

                                        if ( cur.x + cur.width > mpPane->mPaneWidth )

                                                rightOverflow = cur.x + cur.width - mpPane->mPaneWidth;
                                }

                                pBar = pBar->mpNext;
                        }

                if ( rightOverflow > 0 )
                {
                        if ( leftFreeSpc <= 0 ) return;

                        if ( pTheBar->mpNext )
                        {
                                wxRect& next = pTheBar->mpNext->mBounds;

                                // if there's enough space on the left, move over one half-obscured
                                // bar from the right to the left side with respect to "theBar"

                                if ( next.width < leftFreeSpc )
                                {
                                        cbBarInfo* pNext = pTheBar->mpNext;

                                        row.mBars.Remove( pNext );

                                        row.mBars.Insert( pNext, row.mBars.Index( pTheBar ) );

                                        next.x = theBar.x - next.width;

                                        // re-setup mpPrev/mpNext references after insertion

                                        mpPane->InitLinksForRow( &row );

                                        // tighten things

                                        StickRightSideBars( pTheBar );
                                        SlideLeftSideBars ( pTheBar );

                                        continue;
                                }
                        }

                        int leftShift = ( rightOverflow > leftFreeSpc ) 
                                                        ? leftFreeSpc 
                                                        : rightOverflow;

                        theBar.x -= leftShift;

                        StickRightSideBars( pTheBar );
                        SlideLeftSideBars ( pTheBar );

                        break;

                } // end of if ( rightOverflow )
                else
                        break;

        } while(1);
}

void cbRowLayoutPlugin::InsertBefore( cbBarInfo* pBeforeBar, 
                                                                          cbBarInfo* pTheBar,
                                                                          cbRowInfo& row        )
{
        if ( pBeforeBar )

                row.mBars.Insert( pTheBar, row.mBars.Index( pBeforeBar ) );
        else
                row.mBars.Add( pTheBar );

        pTheBar->mpRow = &row;
}

void cbRowLayoutPlugin::DoInsertBar( cbBarInfo* pTheBar, cbRowInfo& row )
{
        wxRect& theBar = pTheBar->mBounds;

        /* OLD STUFF::
        if ( theBar.x < 0 && !node_to_bar( pTheBar ).IsFixed() )
        {
                // AI::
                theBar.width += theBar.x;
                theBar.x = 0;
        } */

    size_t i;
        for( i = 0; i != row.mBars.Count(); ++i )
        {
                cbBarInfo& bar = *row.mBars[i];

                wxRect& cur = bar.mBounds;

                // if bar hits the left edge
                if ( theBar.x <= cur.x )
                {
                        InsertBefore( &bar, pTheBar, row );
                        return;
                }
                
                else
                // if bar hits the right edge
                if ( theBar.x <= cur.x + cur.width )
                {
                        if ( theBar.x + theBar.width > cur.x + cur.width )
                        {
                                InsertBefore( bar.mpNext, pTheBar, row );
                                return;
                        }

                        // otherwise the bar lies within the bounds of current bar

                        int leftDist  = theBar.x - cur.x;
                        int rightDist = cur.x + cur.width - (theBar.x + theBar.width);

                        if ( leftDist < rightDist )

                                InsertBefore( &bar, pTheBar, row );
                        else
                                InsertBefore( bar.mpNext, pTheBar, row );

                        return;
                }
        }

        InsertBefore( NULL, pTheBar, row ); // insert at the end
}

// evnet handlers

void cbRowLayoutPlugin::OnInsertBar( cbInsertBarEvent& event )
{
        cbBarInfo* pBarToInsert = event.mpBar;
        cbRowInfo* pIntoRow     = event.mpRow;
        mpPane                  = event.mpPane;

        if ( !pBarToInsert->IsFixed() )

                AdjustLengthOfInserted( pIntoRow, pBarToInsert );

        DoInsertBar( pBarToInsert, *pIntoRow );

        mpPane->InitLinksForRow( pIntoRow ); // relink "mpNext/mpPrev"s

        // perform relayouting of the bars after insertion

        // init bar location info
        pBarToInsert->mAlignment = event.mpPane->mAlignment;
        pBarToInsert->mRowNo     = event.mpPane->GetRowIndex( pIntoRow );

#ifdef __EXPERIMENTAL

        if ( !pIntoRow->mHasOnlyFixedBars || !pBarToInsert->IsFixed() )

                RecalcLengthRatios( pIntoRow );

#endif

        MinimzeNotFixedBars( pIntoRow, pBarToInsert );

        SlideLeftSideBars ( pBarToInsert );
        SlideRightSideBars( pBarToInsert );

        ShiftLeftTrashold ( pBarToInsert, *pIntoRow );
        ShiftRightTrashold( pBarToInsert, *pIntoRow );

        mpPane->SyncRowFlags( pIntoRow );

        CheckIfAtTheBoundary( pBarToInsert, *pIntoRow );

        if ( event.mpPane->IsHorizontal() )

                pBarToInsert->mState = wxCBAR_DOCKED_HORIZONTALLY;
        else
                pBarToInsert->mState = wxCBAR_DOCKED_VERTICALLY;

        if ( !pIntoRow->mHasOnlyFixedBars )
        {

#ifdef __EXPERIMENTAL

                ExpandNotFixedBars( pIntoRow );
#else

                RelayoutNotFixedBarsAround( pBarToInsert, pIntoRow );
            RecalcLengthRatios( pIntoRow );

#endif

                DetectBarHandles( pIntoRow );

                // do proportional resizing of not-fixed bars 
                ApplyLengthRatios( pIntoRow );
        }

        // adjust the bar's docking state

        // a little bit of AI: 
        // memorize bar's height and width, when docked in 
        // the current orientation - by making the current
        // dimensions to be "preferred" ones for this docking state

        if ( !pBarToInsert->IsFixed() )
        {
                cbBarInfo& bar = *pBarToInsert;

                bar.mDimInfo.mSizes[ bar.mState ].x = bar.mBounds.width;
                bar.mDimInfo.mSizes[ bar.mState ].y = bar.mBounds.height;
        }
}

void cbRowLayoutPlugin::OnRemoveBar ( cbRemoveBarEvent& event )
{
        cbBarInfo* pBar = event.mpBar;
        mpPane          = event.mpPane;

        cbRowInfo* pRow = pBar->mpRow;

        mpLayout->GetUpdatesManager().OnBarWillChange( pBar, pRow, event.mpPane );

        // invalidate the whole row
        //pFirst->mpRowInfo->mMgrData.mPrevBounds.x = -1;

        pRow->mBars.Remove( pBar );

        // rest bar information after removing it from the row
        pBar->mpRow           = NULL;
        pBar->mHasLeftHandle  = FALSE;
        pBar->mHasRightHandle = FALSE;

        mpPane->InitLinksForRow( pRow ); // relink "mpNext/mpPrev"s

        if ( pRow->mBars.Count() == 0 )
        {
                // empty rows should not exist

                event.mpPane->GetRowList().Remove( pRow );

                delete pRow;

                mpPane->InitLinksForRows();
        }
        else
        {
                // force repainting of bars, in the row, from which the bar was removed

                // FIXME:: really needed?
                pRow->mBars[0]->mUMgrData.SetDirty(TRUE);

                // re-setup mHasOnlyFixedBars flag for the row information
                event.mpPane->SyncRowFlags( pRow );

                DetectBarHandles( pRow );

                if ( !pRow->mHasOnlyFixedBars )

                        ExpandNotFixedBars( pRow );
        }
}

void cbRowLayoutPlugin::OnLayoutRow( cbLayoutRowEvent& event )
{
        cbRowInfo* pRow = event.mpRow;
        mpPane          = event.mpPane;

        MinimzeNotFixedBars( pRow, NULL );

        if ( !pRow->mHasOnlyFixedBars )
        {
                // do proportional resizing of not-fixed bars 
                ApplyLengthRatios( pRow );
        }

        cbBarInfo& lastBar  = *pRow->mBars[ pRow->mBars.Count() - 1 ];
        cbBarInfo& firstBar = *pRow->mBars[ 0 ];

        // FIXME:: Next line not used
    // wxRect& bounds = lastBar.mBounds;

        if ( lastBar.mBounds.x + lastBar.mBounds.width > mpPane->mPaneWidth )
        {
                lastBar.mBounds.x = mpPane->mPaneWidth - lastBar.mBounds.width;

                // first simulate left-row-edge friction

                SlideLeftSideBars( &lastBar );

                if ( firstBar.mBounds.x < 0 )
            firstBar.mBounds.x = 0;

                // then left-row-edge function, though this
                // may cause some of the right-side bars going
                // out of row bounds, but left-side always
                // has the highest "priority"

                SlideRightSideBars( &firstBar );
        }

        event.Skip(); // pass event to the next handler
}

void cbRowLayoutPlugin::OnLayoutRows( cbLayoutRowsEvent& event )
{
        mpPane       = event.mpPane;

        int curY = 0;

    // FIXME:: Next line not used.
        // RowArrayT& arr = mpPane->GetRowList();

    size_t i;
        for( i = 0; i != mpPane->GetRowList().Count(); ++i )
        {
                cbRowInfo& row = *mpPane->GetRowList()[ i ];

                // setup "has-handle" flags for rows, which depend on the existance 
                // of not-fixed bars in the row

                if ( !row.mHasOnlyFixedBars )
                {
                        if ( mpPane->mAlignment == FL_ALIGN_TOP ||
                                 mpPane->mAlignment == FL_ALIGN_LEFT   )
                        {
                                row.mHasLowerHandle = TRUE;

                                row.mHasUpperHandle = FALSE; 
                        }
                        else
                        {
                                row.mHasUpperHandle = TRUE;

                                row.mHasLowerHandle = FALSE; 
                        }
                }
                else
                {
                        // otherwise, rows with fixed-bars only, have no height-resizing handles
                        row.mHasUpperHandle = FALSE; 
                        row.mHasLowerHandle = FALSE; 
                }

                // setup vertical positions for items in the row

                row.mRowY = curY;

                row.mRowWidth  = mpPane->mPaneWidth;
                row.mRowHeight = CalcRowHeight( row );

                LayoutItemsVertically( row );

                if ( row.mHasUpperHandle )
            row.mRowHeight += mpPane->mProps.mResizeHandleSize;
                if ( row.mHasLowerHandle )
            row.mRowHeight += mpPane->mProps.mResizeHandleSize;

                curY += row.mRowHeight;
        }

        event.Skip(); // pass event to the next handler - other hookeds plugin
                                  // may also add some "refinements" to the layout now
}

void cbRowLayoutPlugin::OnResizeRow( cbResizeRowEvent& event )
{
        // extract resize-event info
        int     ofs            = event.mHandleOfs;
        bool    forUpperHandle = event.mForUpperHandle;
        cbRowInfo* pTheRow     = event.mpRow;
                mpPane         = event.mpPane;

    // FIXME:: Next line not used.
        //int     newHeight      = pTheRow->mRowHeight;

        int     freeSpc        = 0;

        if ( forUpperHandle )
        {
                // calculate available free space from above,
                // which can be obtained by squeezing not-fixed height rows

                cbRowInfo* pRow = pTheRow->mpPrev;

                while( pRow ) 
                {
                        freeSpc += pRow->mRowHeight - event.mpPane->GetMinimalRowHeight( pRow );

                        pRow = pRow->mpPrev;
                }
        }
        else
        {
                // calculate available free space from below,
                // which can be obtained by squeezing not-fixed height rows

                cbRowInfo* pRow = pTheRow->mpNext;

                while( pRow ) 
                {
                        freeSpc += pRow->mRowHeight - mpPane->GetMinimalRowHeight( pRow );

                        pRow = pRow->mpNext;
                }
        }

        mpLayout->GetUpdatesManager().OnStartChanges();

        int clientSize;

        // allow user adjusting pane vs. client-area space, for upper-handle

        if ( mpPane->IsHorizontal() )

                clientSize = mpLayout->GetClientHeight();
        else
                clientSize = mpLayout->GetClientWidth();

        if ( forUpperHandle && ofs < -clientSize )
        {
                int needed = -(ofs + clientSize);

                cbRowInfo* pRow = mpPane->GetRowList()[ 0 ];

                // start squeezing rows from the top row towards bottom

                while( pRow != pTheRow && needed )
                {
                        // only not-fixed rows can be squeezed

                        if ( !pRow->mHasOnlyFixedBars )
                        {
                                int prevHeight = pRow->mRowHeight;

                                int newHeight  = wxMax( event.mpPane->GetMinimalRowHeight( pRow ), 
                                                                                prevHeight - needed );

                                if ( newHeight != prevHeight )
                                {
                                        event.mpPane->SetRowHeight( pRow, newHeight );

                                        needed -= prevHeight - pRow->mRowHeight;
                                }
                        }

                        pRow = pRow->mpNext;
                }
        }

        // allow user adjusting pane vs. client-area space, for lower-handle

        if ( !forUpperHandle && ofs > clientSize )
        {
                int needed = ofs - clientSize;

                cbRowInfo* pRow = mpPane->GetRowList()[ mpPane->GetRowList().Count() - 1 ];

                // start squeezing rows from the bottom towards the top row

                while( pRow && needed )
                {
                        // only not-fixed rows can be squeezed

                        if ( !pRow->mHasOnlyFixedBars )
                        {
                                int prevHeight = pRow->mRowHeight;

                                int newHeight  = wxMax( event.mpPane->GetMinimalRowHeight( pRow ), 
                                                                                prevHeight - needed );

                                if ( newHeight != prevHeight )
                                {
                                        event.mpPane->SetRowHeight( pRow, newHeight );

                                        needed -= prevHeight - pRow->mRowHeight;
                                }
                        }

                        pRow = pRow->mpPrev;
                }
        }

        if ( forUpperHandle )
        
                event.mpPane->SetRowHeight( pTheRow, pTheRow->mRowHeight + (-ofs) );
        else
                event.mpPane->SetRowHeight( pTheRow, pTheRow->mRowHeight +   ofs  );

        mpLayout->RecalcLayout(FALSE);

        mpLayout->GetUpdatesManager().OnFinishChanges();
        mpLayout->GetUpdatesManager().UpdateNow();
}