contrib/src/fl/dyntbar.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dyntbar.cpp
// Purpose:     wxDynamicToolBar implementation
// Author:      Aleksandras Gluchovas
// Modified by:
// Created:     ??/10/98
// RCS-ID:      $Id$
// Copyright:   (c) Aleksandras Gluchovas
// Licence:       wxWindows license
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
    #pragma implementation "dyntbar.h"
#endif

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

#ifdef __BORLANDC__
#pragma hdrstop
#endif

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

#include "wx/utils.h"     // import wxMin,wxMax macros

#include "wx/fl/dyntbar.h"
#include "wx/fl/newbmpbtn.h"

IMPLEMENT_DYNAMIC_CLASS(wxDynamicToolBar, wxControl )

BEGIN_EVENT_TABLE( wxDynamicToolBar, wxControl )

    EVT_SIZE ( wxDynamicToolBar::OnSize  )
    EVT_PAINT( wxDynamicToolBar::OnPaint )
    //EVT_ERASE_BACKGROUND( wxDynamicToolBar::OnEraseBackground )

END_EVENT_TABLE()

/***** Implementation for class wxToolLayoutItem *****/

IMPLEMENT_DYNAMIC_CLASS(wxToolLayoutItem, wxObject)


/***** Implementation for class wxDynToolInfo *****/

IMPLEMENT_DYNAMIC_CLASS(wxDynToolInfo, wxToolLayoutItem)

/***** Implementation for class wxDynamicToolBar *****/

wxDynamicToolBar::wxDynamicToolBar()
    : mpLayoutMan( NULL ),
      mSepartorSize( 8 ),
      mVertGap ( 0 ),
      mHorizGap( 0 )
{
}

wxDynamicToolBar::wxDynamicToolBar(wxWindow *parent, const wxWindowID id,
                                   const wxPoint& pos, const wxSize& size,
                                   const long style, const int orientation,
                                   const int RowsOrColumns, const wxString& name )
    : mpLayoutMan( NULL ),
      mSepartorSize( 8 ),
      mVertGap ( 0 ),
      mHorizGap( 0 )
{
    Create(parent, id, pos, size, style, orientation, RowsOrColumns, name);

    SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE) );
}

bool wxDynamicToolBar::Create(wxWindow *parent, const wxWindowID id,
                              const wxPoint& pos,
                              const wxSize& size,
                              const long style,
                              const int orientation, const int RowsOrColumns,
                              const wxString& name)
{
    // cut&pasted from wxtbatsmpl.h

    if ( ! wxWindow::Create(parent, id, pos, size, style, name) )
        return FALSE;

    SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ));

    return TRUE;
}

bool wxDynamicToolBar::Realize(void)
{
    // FOR NOW:: nothing
    return TRUE;
}

wxDynamicToolBar::~wxDynamicToolBar(void)
{
    if ( mpLayoutMan )
        delete mpLayoutMan;

    size_t i;
    for( i = 0; i != mTools.Count(); ++i )
    {
        delete mTools[i];
    }
}

void wxDynamicToolBar::AddTool( int toolIndex,
                                wxWindow* pToolWindow,
                                const wxSize& size
                              )
{
    wxDynToolInfo* pInfo = new wxDynToolInfo();

    pInfo->mpToolWnd    = pToolWindow;
    pInfo->mIndex       = toolIndex;
    pInfo->mIsSeparator    = FALSE;

    int x,y;
    pToolWindow->GetSize( &x, &y );
    pInfo->mRealSize.x = x;
    pInfo->mRealSize.y = y;
    pInfo->mRect.width = x;
    pInfo->mRect.height = y;

    mTools.Add( pInfo );
}

void wxDynamicToolBar::AddTool( int toolIndex,
                                const wxString& imageFileName,
                                wxBitmapType imageFileType,
                                const wxString& labelText, bool alignTextRight,
                                bool isFlat )
{
    wxNewBitmapButton* pBtn =

      new wxNewBitmapButton( imageFileName, imageFileType,
                             labelText,
                             ( alignTextRight )
                             ? NB_ALIGN_TEXT_RIGHT
                             : NB_ALIGN_TEXT_BOTTOM,
                             isFlat
                           );

    pBtn->Create( this, toolIndex );

    pBtn->Reshape();

    AddTool( toolIndex, pBtn );
}
void wxDynamicToolBar::AddTool( int toolIndex, wxBitmap labelBmp,
                                const wxString& labelText, bool alignTextRight,
                                bool isFlat )
{
    wxNewBitmapButton* pBtn =

      new wxNewBitmapButton( labelBmp,
                             labelText,
                             ( alignTextRight )
                             ? NB_ALIGN_TEXT_RIGHT
                             : NB_ALIGN_TEXT_BOTTOM,
                             isFlat
                           );

    pBtn->Create( this, toolIndex );

    pBtn->Reshape();

    AddTool( toolIndex, pBtn );
}


wxToolBarToolBase*
      wxDynamicToolBar::AddTool(const int toolIndex, const wxBitmap& bitmap,
                                const wxBitmap& pushedBitmap,
                                const bool toggle, const long xPos,
                                const long yPos, wxObject *clientData,
                                const wxString& helpString1, const wxString& helpString2)
{
    wxNewBitmapButton* pBmpBtn = new wxNewBitmapButton( bitmap );

    pBmpBtn->Create( this, toolIndex );

    pBmpBtn->Reshape();

    AddTool( toolIndex, pBmpBtn );

    return NULL;
}


wxDynToolInfo* wxDynamicToolBar::GetToolInfo( int toolIndex )
{
    size_t i;
    for( i = 0; i != mTools.Count(); ++i )
    {
        if ( mTools[i]->mIndex == toolIndex )
            return mTools[i];
    }

    return NULL;
}

void wxDynamicToolBar::RemveTool( int toolIndex )
{
    size_t i;
    for( i = 0; i != mTools.Count(); ++i )
    {
        if ( mTools[i]->mIndex == toolIndex )
        {
            if ( mTools[i]->mpToolWnd )
            {
                mTools[i]->mpToolWnd->Destroy();
            }
            delete mTools[i]; // HVL To be tested!!!
#if wxCHECK_VERSION(2,3,2)
            mTools.RemoveAt(i);
#else
            mTools.Remove(i);
#endif
            Layout();

            return;
        }
    }
    // TODO:: if not found, should it be an assertion?
}

void wxDynamicToolBar::AddSeparator( wxWindow* pSepartorWnd )
{
    wxDynToolInfo* pInfo = new wxDynToolInfo();

    pInfo->mpToolWnd    = pSepartorWnd;
    pInfo->mIndex       = -1;
    pInfo->mIsSeparator = TRUE;

    // Do we draw a separator or is a other object?
    if ( pSepartorWnd )
    {
        // hvl => Is there a way to know if it was already created?
        // hvl => shouldn't the pSepartorWnd be created? (like one should expect?)
        // pSepartorWnd->Create( this, -1 );

        int x,y;
        pSepartorWnd->GetSize( &x, &y );
        pInfo->mRealSize.x = x;
        pInfo->mRealSize.y = y;

        pInfo->mRect.width = x;
        pInfo->mRect.height = y;
    }
    else
    {
        // Init x and y to the default.
        pInfo->mRealSize.x = 0;
        pInfo->mRealSize.y = 0;

        // Init height and width to the normal size of a separator.
        pInfo->mRect.width  = mSepartorSize;
        pInfo->mRect.height = mSepartorSize;
    }

    mTools.Add( pInfo );
}

void wxDynamicToolBar::OnEraseBackground( wxEraseEvent& event )
{
    // FOR NOW:: nothing
}

void wxDynamicToolBar::OnSize( wxSizeEvent& event )
{
    //SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );

    Layout();
}

void wxDynamicToolBar::DrawSeparator( wxDynToolInfo& info, wxDC& dc )
{
    // check the orientation of separator
    if ( info.mRect.width < info.mRect.height )
    {
        int midX = info.mRect.x + info.mRect.width/2 - 1;

        dc.SetPen( *wxGREY_PEN );
        dc.DrawLine( midX, info.mRect.y,
                     midX, info.mRect.y + info.mRect.height+1 );

        dc.SetPen( *wxWHITE_PEN );
        dc.DrawLine( midX+1, info.mRect.y,
                     midX+1, info.mRect.y + info.mRect.height+1 );
    }
    else
    {
        int midY = info.mRect.y + info.mRect.height/2 - 1;

        dc.SetPen( *wxGREY_PEN );
        dc.DrawLine( info.mRect.x, midY,
                     info.mRect.x + info.mRect.width+1, midY );

        dc.SetPen( *wxWHITE_PEN );
        dc.DrawLine( info.mRect.x, midY + 1,
                     info.mRect.x + info.mRect.width+1, midY + 1 );
    }
}

void wxDynamicToolBar::OnPaint( wxPaintEvent& event )
{
    // draw separators if any
    wxPaintDC dc(this);

    size_t i;
    for( i = 0; i != mTools.Count(); ++i )
    {
        if ( mTools[i]->mIsSeparator )
        {
            // check if separator doesn't have it's own window
            // if so, then draw it using built-in drawing method
            if ( !mTools[i]->mpToolWnd )
                DrawSeparator( *mTools[i], dc );
        }
    }
}

// FOR NOW:: quick fix
#include "wx/choice.h"

void wxDynamicToolBar::SizeToolWindows()
{
    bool bStateCheckDone = FALSE;
    bool bHorzSeparator  = FALSE;
    int maxWidth         = 0;
    int maxHeight        = 0;

    size_t i;
    for( i = 0; i != mTools.Count(); ++i )
    {
        wxDynToolInfo& info = *mTools[i];

        if ( !info.mIsSeparator )
        {
            // center real rectangle within the rectangle
            // provided by the layout manager

            int x = info.mRect.x;
            int y = info.mRect.y + (info.mRect.height - info.mRealSize.y)/2;

            // FOR NOW FOR NOW:: quick & dirty fix
            if ( info.mpToolWnd->IsKindOf( CLASSINFO( wxChoice ) ) )
            {
                info.mpToolWnd->SetSize( x, y,
                                         info.mRealSize.x - 3,
                                         info.mRealSize.y);
            }
            else
            {
                info.mpToolWnd->SetSize( x, y,
                                         info.mRealSize.x,
                                         info.mRealSize.y );
            }
        }
        else
        {
            // We performer this code here, so we only execute it when we have
            // separators and we do it only once (all to do with performance...)
            if (!bStateCheckDone)
            {
                bStateCheckDone = TRUE;

                size_t j;
                wxDynToolInfo *pInfo = NULL;
                wxDynToolInfo *pPrevInfo = NULL;
                int nVertSeparators = 0;

                for( j = 0; j != mTools.Count(); ++j )
                {
                    pInfo = mTools[j];

                    // Count all Vert Separators.
                    if ( pInfo->mIsSeparator )
                        nVertSeparators++;

                    // Check if the new row starts with a Separator.
                    if ( pPrevInfo && pInfo->mIsSeparator &&
                         // pPrevInfo->mRect.x >= pInfo->mRect.x &&
                         pPrevInfo->mRect.y < pInfo->mRect.y)
                    {
                        // If the Separator is shown on the next row and it's
                        // the only object on the row it would mean that the
                        // Separator should be shown as Horizontal one.
                        if (j+1 != mTools.Count())
                        {
                            if (pInfo->mRect.y < mTools[j+1]->mRect.y)
                                nVertSeparators--;
                        }
                        else
                        {
                            nVertSeparators--;
                        }
                    }

                    pPrevInfo = pInfo;

                    maxWidth = wxMax(pInfo->mRect.width, maxWidth);
                    maxHeight = wxMax(pInfo->mRect.height, maxHeight);
                }

                bHorzSeparator = nVertSeparators == 0;
            }

            // Check if we should draw Horz or Vert...
            if ( !bHorzSeparator )
            {
                info.mRect.width = mSepartorSize;
                info.mRect.height = maxHeight;
            }
            else
            {
                info.mRect.width = maxWidth;
                info.mRect.height = mSepartorSize;
            }

            // Do we need to set a new size to a seperator object?
            if ( info.mpToolWnd )
            {
                info.mpToolWnd->SetSize( info.mRect.x,
                                         info.mRect.y,
                                         info.mRect.width,
                                         info.mRect.height);
            }

        }
    }
}

bool wxDynamicToolBar::Layout()
{
    int x,y;
    GetSize( &x, &y );
    wxSize wndDim(x,y);
    wxSize result;
    size_t i;
    wxDynToolInfo *pInfo;

    // Reset the size of separators...
    for( i = 0; i != mTools.Count(); ++i )
    {
        pInfo = mTools[i];

        if ( pInfo->mIsSeparator )
        {
            pInfo->mRect.width  = mSepartorSize;
            pInfo->mRect.height = mSepartorSize;
        }
    }

    // Calc and set the best layout
    GetPreferredDim( wndDim, result );

    SizeToolWindows();
    return TRUE;
}

void wxDynamicToolBar::GetPreferredDim( const wxSize& givenDim, wxSize& prefDim )
{
    if ( !mpLayoutMan )
        mpLayoutMan = CreateDefaultLayout();

    wxLayoutItemArrayT items;

    // safe conversion
    size_t i;
    for( i = 0; i != mTools.Count(); ++i )
        items.Add( mTools[i] );

    mpLayoutMan->Layout( givenDim, prefDim, items, mVertGap, mHorizGap );
}

void wxDynamicToolBar::SetLayout( LayoutManagerBase* pLayout )
{
    if ( mpLayoutMan )
        delete mpLayoutMan;

    mpLayoutMan = pLayout;

    Layout();
}

void wxDynamicToolBar::EnableTool(const int toolIndex, const bool enable )
{
    wxDynToolInfo* pInfo = GetToolInfo( toolIndex );

    if ( !pInfo )
        return;

    if ( pInfo->mIsSeparator || !pInfo->mpToolWnd )
        return;

    pInfo->mpToolWnd->Enable( enable );
}

/***** Implementation for class BagLayout *****/

void BagLayout::Layout(  const wxSize&       parentDim,
                         wxSize&             resultingDim,
                         wxLayoutItemArrayT& items,
                         int                 horizGap,
                         int                 vertGap
                      )
{
    int maxWidth = 0;
    int curY  = 0;
    int nRows = 0;

    size_t i = 0;

    while( i < items.Count() )
    {
        int curX   = 0;
        int height = 0;
        // int nItems = 0;

        // int firstItem  = i;
        int itemsInRow = 0;

        if ( nRows > 0 )
            curY += vertGap;

        // step #1 - arrange horizontal positions of items in the row

        do
        {
            if ( itemsInRow > 0 )
                curX += horizGap;

            wxRect& r = items[i]->mRect;

            if ( curX + r.width > parentDim.x )
            {
                if ( itemsInRow > 0 )
                    break;
            }
            r.x = curX;
            r.y = curY;

            curX += r.width;

            height = wxMax( height, r.height );

            ++itemsInRow;
            ++i;

        } while( i < items.Count() );

        curY += height;

        maxWidth = wxMax( maxWidth, curX );
    }

    resultingDim.x = maxWidth;
    resultingDim.y = curY;
}

//////// stuff from 2.1.15 ///////////

wxToolBarToolBase* wxDynamicToolBar::FindToolForPosition( wxCoord x, wxCoord y ) const
{
    return NULL;
}

bool wxDynamicToolBar::DoInsertTool( size_t pos, wxToolBarToolBase* tool )
{
    return TRUE;
}

bool wxDynamicToolBar::DoDeleteTool( size_t pos, wxToolBarToolBase* tool )
{
    return TRUE;
}

void wxDynamicToolBar::DoEnableTool( wxToolBarToolBase* tool, bool enable )
{
}

void wxDynamicToolBar::DoToggleTool( wxToolBarToolBase* tool, bool toggle )
{
}

void wxDynamicToolBar::DoSetToggle( wxToolBarToolBase* tool, bool toggle )
{
}

wxToolBarToolBase* wxDynamicToolBar::CreateTool( int id, const wxBitmap& bitmap1, const wxBitmap& bitmap2, bool toggle, wxObject* clientData, const wxString& shortHelpString, const wxString& longHelpString )
{
    return NULL;
}

wxToolBarToolBase* wxDynamicToolBar::CreateTool( wxControl* control )
{
    return NULL;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: dyntbar.cpp
	3	// Purpose: wxDynamicToolBar implementation
	4	// Author: Aleksandras Gluchovas
	5	// Modified by:
	6	// Created: ??/10/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Aleksandras Gluchovas
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "dyntbar.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx/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 "wx/utils.h" // import wxMin,wxMax macros
	28
	29	#include "wx/fl/dyntbar.h"
	30	#include "wx/fl/newbmpbtn.h"
	31
	32	IMPLEMENT_DYNAMIC_CLASS(wxDynamicToolBar, wxControl )
	33
	34	BEGIN_EVENT_TABLE( wxDynamicToolBar, wxControl )
	35
	36	EVT_SIZE ( wxDynamicToolBar::OnSize )
	37	EVT_PAINT( wxDynamicToolBar::OnPaint )
	38	//EVT_ERASE_BACKGROUND( wxDynamicToolBar::OnEraseBackground )
	39
	40	END_EVENT_TABLE()
	41
	42	/*** Implementation for class wxToolLayoutItem ***/
	43
	44	IMPLEMENT_DYNAMIC_CLASS(wxToolLayoutItem, wxObject)
	45
	46
	47	/*** Implementation for class wxDynToolInfo ***/
	48
	49	IMPLEMENT_DYNAMIC_CLASS(wxDynToolInfo, wxToolLayoutItem)
	50
	51	/*** Implementation for class wxDynamicToolBar ***/
	52
	53	wxDynamicToolBar::wxDynamicToolBar()
	54	: mpLayoutMan( NULL ),
	55	mSepartorSize( 8 ),
	56	mVertGap ( 0 ),
	57	mHorizGap( 0 )
	58	{
	59	}
	60
	61	wxDynamicToolBar::wxDynamicToolBar(wxWindow *parent, const wxWindowID id,
	62	const wxPoint& pos, const wxSize& size,
	63	const long style, const int orientation,
	64	const int RowsOrColumns, const wxString& name )
	65	: mpLayoutMan( NULL ),
	66	mSepartorSize( 8 ),
	67	mVertGap ( 0 ),
	68	mHorizGap( 0 )
	69	{
	70	Create(parent, id, pos, size, style, orientation, RowsOrColumns, name);
	71
	72	SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE) );
	73	}
	74
	75	bool wxDynamicToolBar::Create(wxWindow *parent, const wxWindowID id,
	76	const wxPoint& pos,
	77	const wxSize& size,
	78	const long style,
	79	const int orientation, const int RowsOrColumns,
	80	const wxString& name)
	81	{
	82	// cut&pasted from wxtbatsmpl.h
	83
	84	if ( ! wxWindow::Create(parent, id, pos, size, style, name) )
	85	return FALSE;
	86
	87	SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ));
	88
	89	return TRUE;
	90	}
	91
	92	bool wxDynamicToolBar::Realize(void)
	93	{
	94	// FOR NOW:: nothing
	95	return TRUE;
	96	}
	97
	98	wxDynamicToolBar::~wxDynamicToolBar(void)
	99	{
	100	if ( mpLayoutMan )
	101	delete mpLayoutMan;
	102
	103	size_t i;
	104	for( i = 0; i != mTools.Count(); ++i )
	105	{
	106	delete mTools[i];
	107	}
	108	}
	109
	110	void wxDynamicToolBar::AddTool( int toolIndex,
	111	wxWindow* pToolWindow,
	112	const wxSize& size
	113	)
	114	{
	115	wxDynToolInfo* pInfo = new wxDynToolInfo();
	116
	117	pInfo->mpToolWnd = pToolWindow;
	118	pInfo->mIndex = toolIndex;
	119	pInfo->mIsSeparator = FALSE;
	120
	121	int x,y;
	122	pToolWindow->GetSize( &x, &y );
	123	pInfo->mRealSize.x = x;
	124	pInfo->mRealSize.y = y;
	125	pInfo->mRect.width = x;
	126	pInfo->mRect.height = y;
	127
	128	mTools.Add( pInfo );
	129	}
	130
	131	void wxDynamicToolBar::AddTool( int toolIndex,
	132	const wxString& imageFileName,
	133	wxBitmapType imageFileType,
	134	const wxString& labelText, bool alignTextRight,
	135	bool isFlat )
	136	{
	137	wxNewBitmapButton* pBtn =
	138
	139	new wxNewBitmapButton( imageFileName, imageFileType,
	140	labelText,
	141	( alignTextRight )
	142	? NB_ALIGN_TEXT_RIGHT
	143	: NB_ALIGN_TEXT_BOTTOM,
	144	isFlat
	145	);
	146
	147	pBtn->Create( this, toolIndex );
	148
	149	pBtn->Reshape();
	150
	151	AddTool( toolIndex, pBtn );
	152	}
	153	void wxDynamicToolBar::AddTool( int toolIndex, wxBitmap labelBmp,
	154	const wxString& labelText, bool alignTextRight,
	155	bool isFlat )
	156	{
	157	wxNewBitmapButton* pBtn =
	158
	159	new wxNewBitmapButton( labelBmp,
	160	labelText,
	161	( alignTextRight )
	162	? NB_ALIGN_TEXT_RIGHT
	163	: NB_ALIGN_TEXT_BOTTOM,
	164	isFlat
	165	);
	166
	167	pBtn->Create( this, toolIndex );
	168
	169	pBtn->Reshape();
	170
	171	AddTool( toolIndex, pBtn );
	172	}
	173
	174
	175	wxToolBarToolBase*
	176	wxDynamicToolBar::AddTool(const int toolIndex, const wxBitmap& bitmap,
	177	const wxBitmap& pushedBitmap,
	178	const bool toggle, const long xPos,
	179	const long yPos, wxObject *clientData,
	180	const wxString& helpString1, const wxString& helpString2)
	181	{
	182	wxNewBitmapButton* pBmpBtn = new wxNewBitmapButton( bitmap );
	183
	184	pBmpBtn->Create( this, toolIndex );
	185
	186	pBmpBtn->Reshape();
	187
	188	AddTool( toolIndex, pBmpBtn );
	189
	190	return NULL;
	191	}
	192
	193
	194	wxDynToolInfo* wxDynamicToolBar::GetToolInfo( int toolIndex )
	195	{
	196	size_t i;
	197	for( i = 0; i != mTools.Count(); ++i )
	198	{
	199	if ( mTools[i]->mIndex == toolIndex )
	200	return mTools[i];
	201	}
	202
	203	return NULL;
	204	}
	205
	206	void wxDynamicToolBar::RemveTool( int toolIndex )
	207	{
	208	size_t i;
	209	for( i = 0; i != mTools.Count(); ++i )
	210	{
	211	if ( mTools[i]->mIndex == toolIndex )
	212	{
	213	if ( mTools[i]->mpToolWnd )
	214	{
	215	mTools[i]->mpToolWnd->Destroy();
	216	}
	217	delete mTools[i]; // HVL To be tested!!!
	218	#if wxCHECK_VERSION(2,3,2)
	219	mTools.RemoveAt(i);
	220	#else
	221	mTools.Remove(i);
	222	#endif
	223	Layout();
	224
	225	return;
	226	}
	227	}
	228	// TODO:: if not found, should it be an assertion?
	229	}
	230
	231	void wxDynamicToolBar::AddSeparator( wxWindow* pSepartorWnd )
	232	{
	233	wxDynToolInfo* pInfo = new wxDynToolInfo();
	234
	235	pInfo->mpToolWnd = pSepartorWnd;
	236	pInfo->mIndex = -1;
	237	pInfo->mIsSeparator = TRUE;
	238
	239	// Do we draw a separator or is a other object?
	240	if ( pSepartorWnd )
	241	{
	242	// hvl => Is there a way to know if it was already created?
	243	// hvl => shouldn't the pSepartorWnd be created? (like one should expect?)
	244	// pSepartorWnd->Create( this, -1 );
	245
	246	int x,y;
	247	pSepartorWnd->GetSize( &x, &y );
	248	pInfo->mRealSize.x = x;
	249	pInfo->mRealSize.y = y;
	250
	251	pInfo->mRect.width = x;
	252	pInfo->mRect.height = y;
	253	}
	254	else
	255	{
	256	// Init x and y to the default.
	257	pInfo->mRealSize.x = 0;
	258	pInfo->mRealSize.y = 0;
	259
	260	// Init height and width to the normal size of a separator.
	261	pInfo->mRect.width = mSepartorSize;
	262	pInfo->mRect.height = mSepartorSize;
	263	}
	264
	265	mTools.Add( pInfo );
	266	}
	267
	268	void wxDynamicToolBar::OnEraseBackground( wxEraseEvent& event )
	269	{
	270	// FOR NOW:: nothing
	271	}
	272
	273	void wxDynamicToolBar::OnSize( wxSizeEvent& event )
	274	{
	275	//SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );
	276
	277	Layout();
	278	}
	279
	280	void wxDynamicToolBar::DrawSeparator( wxDynToolInfo& info, wxDC& dc )
	281	{
	282	// check the orientation of separator
	283	if ( info.mRect.width < info.mRect.height )
	284	{
	285	int midX = info.mRect.x + info.mRect.width/2 - 1;
	286
	287	dc.SetPen( *wxGREY_PEN );
	288	dc.DrawLine( midX, info.mRect.y,
	289	midX, info.mRect.y + info.mRect.height+1 );
	290
	291	dc.SetPen( *wxWHITE_PEN );
	292	dc.DrawLine( midX+1, info.mRect.y,
	293	midX+1, info.mRect.y + info.mRect.height+1 );
	294	}
	295	else
	296	{
	297	int midY = info.mRect.y + info.mRect.height/2 - 1;
	298
	299	dc.SetPen( *wxGREY_PEN );
	300	dc.DrawLine( info.mRect.x, midY,
	301	info.mRect.x + info.mRect.width+1, midY );
	302
	303	dc.SetPen( *wxWHITE_PEN );
	304	dc.DrawLine( info.mRect.x, midY + 1,
	305	info.mRect.x + info.mRect.width+1, midY + 1 );
	306	}
	307	}
	308
	309	void wxDynamicToolBar::OnPaint( wxPaintEvent& event )
	310	{
	311	// draw separators if any
	312	wxPaintDC dc(this);
	313
	314	size_t i;
	315	for( i = 0; i != mTools.Count(); ++i )
	316	{
	317	if ( mTools[i]->mIsSeparator )
	318	{
	319	// check if separator doesn't have it's own window
	320	// if so, then draw it using built-in drawing method
	321	if ( !mTools[i]->mpToolWnd )
	322	DrawSeparator( *mTools[i], dc );
	323	}
	324	}
	325	}
	326
	327	// FOR NOW:: quick fix
	328	#include "wx/choice.h"
	329
	330	void wxDynamicToolBar::SizeToolWindows()
	331	{
	332	bool bStateCheckDone = FALSE;
	333	bool bHorzSeparator = FALSE;
	334	int maxWidth = 0;
	335	int maxHeight = 0;
	336
	337	size_t i;
	338	for( i = 0; i != mTools.Count(); ++i )
	339	{
	340	wxDynToolInfo& info = *mTools[i];
	341
	342	if ( !info.mIsSeparator )
	343	{
	344	// center real rectangle within the rectangle
	345	// provided by the layout manager
	346
	347	int x = info.mRect.x;
	348	int y = info.mRect.y + (info.mRect.height - info.mRealSize.y)/2;
	349
	350	// FOR NOW FOR NOW:: quick & dirty fix
	351	if ( info.mpToolWnd->IsKindOf( CLASSINFO( wxChoice ) ) )
	352	{
	353	info.mpToolWnd->SetSize( x, y,
	354	info.mRealSize.x - 3,
	355	info.mRealSize.y);
	356	}
	357	else
	358	{
	359	info.mpToolWnd->SetSize( x, y,
	360	info.mRealSize.x,
	361	info.mRealSize.y );
	362	}
	363	}
	364	else
	365	{
	366	// We performer this code here, so we only execute it when we have
	367	// separators and we do it only once (all to do with performance...)
	368	if (!bStateCheckDone)
	369	{
	370	bStateCheckDone = TRUE;
	371
	372	size_t j;
	373	wxDynToolInfo *pInfo = NULL;
	374	wxDynToolInfo *pPrevInfo = NULL;
	375	int nVertSeparators = 0;
	376
	377	for( j = 0; j != mTools.Count(); ++j )
	378	{
	379	pInfo = mTools[j];
	380
	381	// Count all Vert Separators.
	382	if ( pInfo->mIsSeparator )
	383	nVertSeparators++;
	384
	385	// Check if the new row starts with a Separator.
	386	if ( pPrevInfo && pInfo->mIsSeparator &&
	387	// pPrevInfo->mRect.x >= pInfo->mRect.x &&
	388	pPrevInfo->mRect.y < pInfo->mRect.y)
	389	{
	390	// If the Separator is shown on the next row and it's
	391	// the only object on the row it would mean that the
	392	// Separator should be shown as Horizontal one.
	393	if (j+1 != mTools.Count())
	394	{
	395	if (pInfo->mRect.y < mTools[j+1]->mRect.y)
	396	nVertSeparators--;
	397	}
	398	else
	399	{
	400	nVertSeparators--;
	401	}
	402	}
	403
	404	pPrevInfo = pInfo;
	405
	406	maxWidth = wxMax(pInfo->mRect.width, maxWidth);
	407	maxHeight = wxMax(pInfo->mRect.height, maxHeight);
	408	}
	409
	410	bHorzSeparator = nVertSeparators == 0;
	411	}
	412
	413	// Check if we should draw Horz or Vert...
	414	if ( !bHorzSeparator )
	415	{
	416	info.mRect.width = mSepartorSize;
	417	info.mRect.height = maxHeight;
	418	}
	419	else
	420	{
	421	info.mRect.width = maxWidth;
	422	info.mRect.height = mSepartorSize;
	423	}
	424
	425	// Do we need to set a new size to a seperator object?
	426	if ( info.mpToolWnd )
	427	{
	428	info.mpToolWnd->SetSize( info.mRect.x,
	429	info.mRect.y,
	430	info.mRect.width,
	431	info.mRect.height);
	432	}
	433
	434	}
	435	}
	436	}
	437
	438	bool wxDynamicToolBar::Layout()
	439	{
	440	int x,y;
	441	GetSize( &x, &y );
	442	wxSize wndDim(x,y);
	443	wxSize result;
	444	size_t i;
	445	wxDynToolInfo *pInfo;
	446
	447	// Reset the size of separators...
	448	for( i = 0; i != mTools.Count(); ++i )
	449	{
	450	pInfo = mTools[i];
	451
	452	if ( pInfo->mIsSeparator )
	453	{
	454	pInfo->mRect.width = mSepartorSize;
	455	pInfo->mRect.height = mSepartorSize;
	456	}
	457	}
	458
	459	// Calc and set the best layout
	460	GetPreferredDim( wndDim, result );
	461
	462	SizeToolWindows();
	463	return TRUE;
	464	}
	465
	466	void wxDynamicToolBar::GetPreferredDim( const wxSize& givenDim, wxSize& prefDim )
	467	{
	468	if ( !mpLayoutMan )
	469	mpLayoutMan = CreateDefaultLayout();
	470
	471	wxLayoutItemArrayT items;
	472
	473	// safe conversion
	474	size_t i;
	475	for( i = 0; i != mTools.Count(); ++i )
	476	items.Add( mTools[i] );
	477
	478	mpLayoutMan->Layout( givenDim, prefDim, items, mVertGap, mHorizGap );
	479	}
	480
	481	void wxDynamicToolBar::SetLayout( LayoutManagerBase* pLayout )
	482	{
	483	if ( mpLayoutMan )
	484	delete mpLayoutMan;
	485
	486	mpLayoutMan = pLayout;
	487
	488	Layout();
	489	}
	490
	491	void wxDynamicToolBar::EnableTool(const int toolIndex, const bool enable )
	492	{
	493	wxDynToolInfo* pInfo = GetToolInfo( toolIndex );
	494
	495	if ( !pInfo )
	496	return;
	497
	498	if ( pInfo->mIsSeparator \|\| !pInfo->mpToolWnd )
	499	return;
	500
	501	pInfo->mpToolWnd->Enable( enable );
	502	}
	503
	504	/*** Implementation for class BagLayout ***/
	505
	506	void BagLayout::Layout( const wxSize& parentDim,
	507	wxSize& resultingDim,
	508	wxLayoutItemArrayT& items,
	509	int horizGap,
	510	int vertGap
	511	)
	512	{
	513	int maxWidth = 0;
	514	int curY = 0;
	515	int nRows = 0;
	516
	517	size_t i = 0;
	518
	519	while( i < items.Count() )
	520	{
	521	int curX = 0;
	522	int height = 0;
	523	// int nItems = 0;
	524
	525	// int firstItem = i;
	526	int itemsInRow = 0;
	527
	528	if ( nRows > 0 )
	529	curY += vertGap;
	530
	531	// step #1 - arrange horizontal positions of items in the row
	532
	533	do
	534	{
	535	if ( itemsInRow > 0 )
	536	curX += horizGap;
	537
	538	wxRect& r = items[i]->mRect;
	539
	540	if ( curX + r.width > parentDim.x )
	541	{
	542	if ( itemsInRow > 0 )
	543	break;
	544	}
	545	r.x = curX;
	546	r.y = curY;
	547
	548	curX += r.width;
	549
	550	height = wxMax( height, r.height );
	551
	552	++itemsInRow;
	553	++i;
	554
	555	} while( i < items.Count() );
	556
	557	curY += height;
	558
	559	maxWidth = wxMax( maxWidth, curX );
	560	}
	561
	562	resultingDim.x = maxWidth;
	563	resultingDim.y = curY;
	564	}
	565
	566	//////// stuff from 2.1.15 ///////////
	567
	568	wxToolBarToolBase* wxDynamicToolBar::FindToolForPosition( wxCoord x, wxCoord y ) const
	569	{
	570	return NULL;
	571	}
	572
	573	bool wxDynamicToolBar::DoInsertTool( size_t pos, wxToolBarToolBase* tool )
	574	{
	575	return TRUE;
	576	}
	577
	578	bool wxDynamicToolBar::DoDeleteTool( size_t pos, wxToolBarToolBase* tool )
	579	{
	580	return TRUE;
	581	}
	582
	583	void wxDynamicToolBar::DoEnableTool( wxToolBarToolBase* tool, bool enable )
	584	{
	585	}
	586
	587	void wxDynamicToolBar::DoToggleTool( wxToolBarToolBase* tool, bool toggle )
	588	{
	589	}
	590
	591	void wxDynamicToolBar::DoSetToggle( wxToolBarToolBase* tool, bool toggle )
	592	{
	593	}
	594
	595	wxToolBarToolBase* wxDynamicToolBar::CreateTool( int id, const wxBitmap& bitmap1, const wxBitmap& bitmap2, bool toggle, wxObject* clientData, const wxString& shortHelpString, const wxString& longHelpString )
	596	{
	597	return NULL;
	598	}
	599
	600	wxToolBarToolBase* wxDynamicToolBar::CreateTool( wxControl* control )
	601	{
	602	return NULL;
	603	}
	604