contrib/src/fl/dyntbar.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        No names yet.
// Purpose:     Contrib. demo
// 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 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::GetSystemColour( 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::GetSystemColour( 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,
								int 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;

	if ( pSepartorWnd )
	{
		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
	{
		pInfo->mRealSize.x = mSepartorSize;
		pInfo->mRealSize.y = 0;

		pInfo->mRect.width  = mSepartorSize;
		pInfo->mRect.height = 0;
	}

	mTools.Add( pInfo );
}

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

void wxDynamicToolBar::OnSize( wxSizeEvent& event )
{
	//SetBackgroundColour( wxSystemSettings::GetSystemColour( 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()
{
    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 );
		}

		// TBD:: size separator window if present
	}
}

bool wxDynamicToolBar::Layout()
{
	if ( !mpLayoutMan )
        mpLayoutMan = CreateDefaulLayout();

	int x,y;
	GetSize( &x, &y );
	wxSize wndDim(x,y);
	wxSize result;

	wxLayoutItemArrayT items;

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

	mpLayoutMan->Layout( wndDim, result, items, mVertGap, mHorizGap );;

	SizeToolWindows();
    return TRUE;
}

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

	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: No names yet.
	3	// Purpose: Contrib. demo
	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
	20	#ifdef __BORLANDC__
	21	#pragma hdrstop
	22	#endif
	23
	24	#ifndef WX_PRECOMP
	25	#include "wx/wx.h"
	26	#endif
	27
	28	#include "wx/utils.h" // import wxMin,wxMax macros
	29
	30	#include "wx/fl/dyntbar.h"
	31	#include "wx/fl/newbmpbtn.h"
	32
	33	IMPLEMENT_DYNAMIC_CLASS(wxDynamicToolBar, wxControl )
	34
	35	BEGIN_EVENT_TABLE( wxDynamicToolBar, wxControl )
	36
	37	EVT_SIZE ( wxDynamicToolBar::OnSize )
	38	EVT_PAINT( wxDynamicToolBar::OnPaint )
	39	//EVT_ERASE_BACKGROUND( wxDynamicToolBar::OnEraseBackground )
	40
	41	END_EVENT_TABLE()
	42
	43	/*** Implementation for class wxDynToolInfo ***/
	44
	45	IMPLEMENT_DYNAMIC_CLASS(wxDynToolInfo, wxToolLayoutItem)
	46
	47	/*** Implementation for class wxDynamicToolBar ***/
	48
	49	wxDynamicToolBar::wxDynamicToolBar()
	50	: mpLayoutMan( NULL ),
	51	mSepartorSize( 8 ),
	52	mVertGap ( 0 ),
	53	mHorizGap( 0 )
	54	{
	55	}
	56
	57	wxDynamicToolBar::wxDynamicToolBar(wxWindow *parent, const wxWindowID id,
	58	const wxPoint& pos, const wxSize& size,
	59	const long style, const int orientation,
	60	const int RowsOrColumns, const wxString& name )
	61	: mpLayoutMan( NULL ),
	62	mSepartorSize( 8 ),
	63	mVertGap ( 0 ),
	64	mHorizGap( 0 )
	65	{
	66	Create(parent, id, pos, size, style, orientation, RowsOrColumns, name);
	67
	68	SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_3DFACE) );
	69	}
	70
	71	bool wxDynamicToolBar::Create(wxWindow *parent, const wxWindowID id,
	72	const wxPoint& pos,
	73	const wxSize& size,
	74	const long style,
	75	const int orientation, const int RowsOrColumns,
	76	const wxString& name)
	77	{
	78	// cut&pasted from wxtbatsmpl.h
	79
	80	if ( ! wxWindow::Create(parent, id, pos, size, style, name) )
	81	return FALSE;
	82
	83	SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_3DFACE ));
	84
	85	return TRUE;
	86	}
	87
	88	bool wxDynamicToolBar::Realize(void)
	89	{
	90	// FOR NOW:: nothing
	91	return TRUE;
	92	}
	93
	94	wxDynamicToolBar::~wxDynamicToolBar(void)
	95	{
	96	if ( mpLayoutMan )
	97	delete mpLayoutMan;
	98
	99	size_t i;
	100	for( i = 0; i != mTools.Count(); ++i )
	101	{
	102	delete mTools[i];
	103	}
	104	}
	105
	106	void wxDynamicToolBar::AddTool( int toolIndex,
	107	wxWindow* pToolWindow,
	108	const wxSize& size
	109	)
	110	{
	111	wxDynToolInfo* pInfo = new wxDynToolInfo();
	112
	113	pInfo->mpToolWnd = pToolWindow;
	114	pInfo->mIndex = toolIndex;
	115	pInfo->mIsSeparator = FALSE;
	116
	117	int x,y;
	118	pToolWindow->GetSize( &x, &y );
	119	pInfo->mRealSize.x = x;
	120	pInfo->mRealSize.y = y;
	121	pInfo->mRect.width = x;
	122	pInfo->mRect.height = y;
	123
	124	mTools.Add( pInfo );
	125	}
	126
	127	void wxDynamicToolBar::AddTool( int toolIndex,
	128	const wxString& imageFileName,
	129	int imageFileType,
	130	const wxString& labelText, bool alignTextRight,
	131	bool isFlat )
	132	{
	133	wxNewBitmapButton* pBtn =
	134
	135	new wxNewBitmapButton( imageFileName, imageFileType,
	136	labelText,
	137	( alignTextRight )
	138	? NB_ALIGN_TEXT_RIGHT
	139	: NB_ALIGN_TEXT_BOTTOM,
	140	isFlat
	141	);
	142
	143	pBtn->Create( this, toolIndex );
	144
	145	pBtn->Reshape();
	146
	147	AddTool( toolIndex, pBtn );
	148	}
	149	void wxDynamicToolBar::AddTool( int toolIndex, wxBitmap labelBmp,
	150	const wxString& labelText, bool alignTextRight,
	151	bool isFlat )
	152	{
	153	wxNewBitmapButton* pBtn =
	154
	155	new wxNewBitmapButton( labelBmp,
	156	labelText,
	157	( alignTextRight )
	158	? NB_ALIGN_TEXT_RIGHT
	159	: NB_ALIGN_TEXT_BOTTOM,
	160	isFlat
	161	);
	162
	163	pBtn->Create( this, toolIndex );
	164
	165	pBtn->Reshape();
	166
	167	AddTool( toolIndex, pBtn );
	168	}
	169
	170
	171	wxToolBarToolBase*
	172	wxDynamicToolBar::AddTool(const int toolIndex, const wxBitmap& bitmap,
	173	const wxBitmap& pushedBitmap,
	174	const bool toggle, const long xPos,
	175	const long yPos, wxObject *clientData,
	176	const wxString& helpString1, const wxString& helpString2)
	177	{
	178	wxNewBitmapButton* pBmpBtn = new wxNewBitmapButton( bitmap );
	179
	180	pBmpBtn->Create( this, toolIndex );
	181
	182	pBmpBtn->Reshape();
	183
	184	AddTool( toolIndex, pBmpBtn );
	185
	186	return NULL;
	187	}
	188
	189
	190	wxDynToolInfo* wxDynamicToolBar::GetToolInfo( int toolIndex )
	191	{
	192	size_t i;
	193	for( i = 0; i != mTools.Count(); ++i )
	194	{
	195	if ( mTools[i]->mIndex == toolIndex )
	196	return mTools[i];
	197	}
	198
	199	return NULL;
	200	}
	201
	202	void wxDynamicToolBar::RemveTool( int toolIndex )
	203	{
	204	size_t i;
	205	for( i = 0; i != mTools.Count(); ++i )
	206	{
	207	if ( mTools[i]->mIndex == toolIndex )
	208	{
	209	if ( mTools[i]->mpToolWnd )
	210	{
	211	mTools[i]->mpToolWnd->Destroy();
	212	}
	213	delete mTools[i]; // HVL To be tested!!!
	214	#if wxCHECK_VERSION(2,3,2)
	215	mTools.RemoveAt(i);
	216	#else
	217	mTools.Remove(i);
	218	#endif
	219	Layout();
	220
	221	return;
	222	}
	223	}
	224	// TODO:: if not found, should it be an assertion?
	225	}
	226
	227	void wxDynamicToolBar::AddSeparator( wxWindow* pSepartorWnd )
	228	{
	229	wxDynToolInfo* pInfo = new wxDynToolInfo();
	230
	231	pInfo->mpToolWnd = pSepartorWnd;
	232	pInfo->mIndex = -1;
	233	pInfo->mIsSeparator = TRUE;
	234
	235	if ( pSepartorWnd )
	236	{
	237	pSepartorWnd->Create( this, -1 );
	238
	239	int x,y;
	240	pSepartorWnd->GetSize( &x, &y );
	241	pInfo->mRealSize.x = x;
	242	pInfo->mRealSize.y = y;
	243
	244	pInfo->mRect.width = x;
	245	pInfo->mRect.height = y;
	246	}
	247	else
	248	{
	249	pInfo->mRealSize.x = mSepartorSize;
	250	pInfo->mRealSize.y = 0;
	251
	252	pInfo->mRect.width = mSepartorSize;
	253	pInfo->mRect.height = 0;
	254	}
	255
	256	mTools.Add( pInfo );
	257	}
	258
	259	void wxDynamicToolBar::OnEraseBackground( wxEraseEvent& event )
	260	{
	261	// FOR NOW:: nothing
	262	}
	263
	264	void wxDynamicToolBar::OnSize( wxSizeEvent& event )
	265	{
	266	//SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_3DFACE ) );
	267
	268	Layout();
	269	}
	270
	271	void wxDynamicToolBar::DrawSeparator( wxDynToolInfo& info, wxDC& dc )
	272	{
	273	// check the orientation of separator
	274	if ( info.mRect.width < info.mRect.height )
	275	{
	276	int midX = info.mRect.x + info.mRect.width/2 - 1;
	277
	278	dc.SetPen( *wxGREY_PEN );
	279	dc.DrawLine( midX, info.mRect.y,
	280	midX, info.mRect.y + info.mRect.height+1 );
	281
	282	dc.SetPen( *wxWHITE_PEN );
	283	dc.DrawLine( midX+1, info.mRect.y,
	284	midX+1, info.mRect.y + info.mRect.height+1 );
	285	}
	286	else
	287	{
	288	int midY = info.mRect.y + info.mRect.height/2 - 1;
	289
	290	dc.SetPen( *wxGREY_PEN );
	291	dc.DrawLine( info.mRect.x, midY,
	292	info.mRect.x + info.mRect.width+1, midY );
	293
	294	dc.SetPen( *wxWHITE_PEN );
	295	dc.DrawLine( info.mRect.x, midY + 1,
	296	info.mRect.x + info.mRect.width+1, midY + 1 );
	297	}
	298	}
	299
	300	void wxDynamicToolBar::OnPaint( wxPaintEvent& event )
	301	{
	302	// draw separators if any
	303
	304	wxPaintDC dc(this);
	305
	306	size_t i;
	307	for( i = 0; i != mTools.Count(); ++i )
	308
	309	if ( mTools[i]->mIsSeparator )
	310	{
	311	// check if separator doesn't have it's own window
	312	// if so, then draw it using built-in drawing method
	313
	314	if ( !mTools[i]->mpToolWnd )
	315
	316	DrawSeparator( *mTools[i], dc );
	317	}
	318	}
	319
	320	// FOR NOW:: quick fix
	321	#include "wx/choice.h"
	322
	323	void wxDynamicToolBar::SizeToolWindows()
	324	{
	325	size_t i;
	326	for( i = 0; i != mTools.Count(); ++i )
	327	{
	328	wxDynToolInfo& info = *mTools[i];
	329
	330	if ( !info.mIsSeparator )
	331	{
	332
	333	// center real rectangle within the rectangle
	334	// provided by the layout manager
	335
	336	int x = info.mRect.x;
	337	int y = info.mRect.y + (info.mRect.height - info.mRealSize.y)/2;
	338
	339	// FOR NOW FOR NOW:: quick & dirty fix
	340	if ( info.mpToolWnd->IsKindOf( CLASSINFO( wxChoice ) ) )
	341	{
	342	info.mpToolWnd->SetSize( x,y,
	343	info.mRealSize.x - 3,
	344	info.mRealSize.y);
	345	}
	346	else
	347	info.mpToolWnd->SetSize( x,y,
	348	info.mRealSize.x,
	349	info.mRealSize.y );
	350	}
	351
	352	// TBD:: size separator window if present
	353	}
	354	}
	355
	356	bool wxDynamicToolBar::Layout()
	357	{
	358	if ( !mpLayoutMan )
	359	mpLayoutMan = CreateDefaulLayout();
	360
	361	int x,y;
	362	GetSize( &x, &y );
	363	wxSize wndDim(x,y);
	364	wxSize result;
	365
	366	wxLayoutItemArrayT items;
	367
	368	// safe conversion
	369	size_t i;
	370	for( i = 0; i != mTools.Count(); ++i )
	371	items.Add( mTools[i] );
	372
	373	mpLayoutMan->Layout( wndDim, result, items, mVertGap, mHorizGap );;
	374
	375	SizeToolWindows();
	376	return TRUE;
	377	}
	378
	379	void wxDynamicToolBar::GetPreferredDim( const wxSize& givenDim, wxSize& prefDim )
	380	{
	381	if ( !mpLayoutMan )
	382	mpLayoutMan = CreateDefaulLayout();
	383
	384	wxLayoutItemArrayT items;
	385
	386	// safe conversion
	387	size_t i;
	388	for( i = 0; i != mTools.Count(); ++i )
	389	items.Add( mTools[i] );
	390
	391	mpLayoutMan->Layout( givenDim, prefDim, items, mVertGap, mHorizGap );;
	392	}
	393
	394	void wxDynamicToolBar::SetLayout( LayoutManagerBase* pLayout )
	395	{
	396	if ( mpLayoutMan )
	397	delete mpLayoutMan;
	398
	399	mpLayoutMan = pLayout;
	400
	401	Layout();
	402	}
	403
	404	void wxDynamicToolBar::EnableTool(const int toolIndex, const bool enable )
	405	{
	406	wxDynToolInfo* pInfo = GetToolInfo( toolIndex );
	407
	408	if ( !pInfo )
	409	return;
	410
	411	if ( pInfo->mIsSeparator \|\| !pInfo->mpToolWnd )
	412	return;
	413
	414	pInfo->mpToolWnd->Enable( enable );
	415	}
	416
	417	/*** Implementation for class BagLayout ***/
	418
	419	void BagLayout::Layout( const wxSize& parentDim,
	420	wxSize& resultingDim,
	421	wxLayoutItemArrayT& items,
	422	int horizGap,
	423	int vertGap
	424	)
	425	{
	426	int maxWidth = 0;
	427	int curY = 0;
	428	int nRows = 0;
	429
	430	size_t i = 0;
	431
	432	while( i < items.Count() )
	433	{
	434	int curX = 0;
	435	int height = 0;
	436	// int nItems = 0;
	437
	438	// int firstItem = i;
	439	int itemsInRow = 0;
	440
	441	if ( nRows > 0 )
	442	curY += vertGap;
	443
	444	// step #1 - arrange horizontal positions of items in the row
	445
	446	do
	447	{
	448	if ( itemsInRow > 0 )
	449	curX += horizGap;
	450
	451	wxRect& r = items[i]->mRect;
	452
	453	if ( curX + r.width > parentDim.x )
	454	{
	455	if ( itemsInRow > 0 )
	456	break;
	457	}
	458	r.x = curX;
	459	r.y = curY;
	460
	461	curX += r.width;
	462
	463	height = wxMax( height, r.height );
	464
	465	++itemsInRow;
	466	++i;
	467
	468	} while( i < items.Count() );
	469
	470	curY += height;
	471
	472	maxWidth = wxMax( maxWidth, curX );
	473	}
	474
	475	resultingDim.x = maxWidth;
	476	resultingDim.y = curY;
	477	}
	478
	479	//////// stuff from 2.1.15 ///////////
	480
	481	wxToolBarToolBase* wxDynamicToolBar::FindToolForPosition( wxCoord x, wxCoord y ) const
	482	{
	483	return NULL;
	484	}
	485
	486	bool wxDynamicToolBar::DoInsertTool( size_t pos, wxToolBarToolBase* tool )
	487	{
	488	return TRUE;
	489	}
	490
	491	bool wxDynamicToolBar::DoDeleteTool( size_t pos, wxToolBarToolBase* tool )
	492	{
	493	return TRUE;
	494	}
	495
	496	void wxDynamicToolBar::DoEnableTool( wxToolBarToolBase* tool, bool enable )
	497	{
	498	}
	499
	500	void wxDynamicToolBar::DoToggleTool( wxToolBarToolBase* tool, bool toggle )
	501	{
	502	}
	503
	504	void wxDynamicToolBar::DoSetToggle( wxToolBarToolBase* tool, bool toggle )
	505	{
	506	}
	507
	508	wxToolBarToolBase* wxDynamicToolBar::CreateTool( int id, const wxBitmap& bitmap1, const wxBitmap& bitmap2, bool toggle, wxObject* clientData, const wxString& shortHelpString, const wxString& longHelpString )
	509	{
	510	return NULL;
	511	}
	512
	513	wxToolBarToolBase* wxDynamicToolBar::CreateTool( wxControl* control )
	514	{
	515	return NULL;
	516	}
	517