src/mac/toolbar.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        toolbar.cpp
// Purpose:     wxToolBar
// Author:      AUTHOR
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) AUTHOR
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#include "wx/wx.h"

#if wxUSE_TOOLBAR

#include "wx/toolbar.h"

IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)

BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
END_EVENT_TABLE()

#include <wx/mac/uma.h>

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

class wxToolBarTool : public wxToolBarToolBase
{
public:
    wxToolBarTool(wxToolBar *tbar,
                  int id,
                  const wxBitmap& bitmap1,
                  const wxBitmap& bitmap2,
                  bool toggle,
                  wxObject *clientData,
                  const wxString& shortHelpString,
                  const wxString& longHelpString)
        : wxToolBarToolBase(tbar, id, bitmap1, bitmap2, toggle,
                            clientData, shortHelpString, longHelpString)
    {
        m_nSepCount = 0;
        m_index = 0 ;
    }

    wxToolBarTool(wxToolBar *tbar, wxControl *control)
        : wxToolBarToolBase(tbar, control)
    {
        m_nSepCount = 1;
        m_index = 0 ;
    }

    // set/get the number of separators which we use to cover the space used by
    // a control in the toolbar
    void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
    size_t GetSeparatorsCount() const { return m_nSepCount; }

    int		m_index ;
private:
    size_t m_nSepCount;
};


// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxToolBarTool
// ----------------------------------------------------------------------------

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

wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
{
    return new wxToolBarTool(this, control);
}

// ----------------------------------------------------------------------------
// wxToolBar construction
// ----------------------------------------------------------------------------

void wxToolBar::Init()
{
  m_maxWidth = -1;
  m_maxHeight = -1;
  m_defaultWidth = 24;
  m_defaultHeight = 22;
  // TODO
}

bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
            long style, const wxString& name)
{
  m_maxWidth = m_maxHeight = 0;

  m_defaultWidth = 24;
  m_defaultHeight = 22;

  int x = pos.x;
  int y = pos.y;
  int width = size.x;
  int height = size.y;

  if (width <= 0)
    width = 100;
  if (height <= 0)
    height = 30;
  if (x < 0)
    x = 0;
  if (y < 0)
    y = 0;

	Rect bounds ;
	Str255 title ;

	MacPreControlCreate( parent , id ,  "" , wxPoint( x , y ) , wxSize( width , height ) ,style, *((wxValidator*)NULL) , name , &bounds , title ) ;

	m_macControl = UMANewControl( parent->GetMacRootWindow() , &bounds , "\p" , true , 0 , 0 , 1,
	  	kControlPlacardProc , (long) this ) ;
	MacPostControlCreate() ;

  return TRUE;
}

wxToolBar::~wxToolBar()
{
    // TODO
}

PicHandle MakePict(GWorldPtr wp)
{
	CGrafPtr		origPort ;
	GDHandle		origDev ;

	PicHandle		pict;				// this is the Picture we give back

	RGBColor		gray = { 0xCCCC ,0xCCCC , 0xCCCC } ;

	GetGWorld( &origPort , &origDev ) ;
	SetGWorld( wp , NULL ) ;

	pict = OpenPicture(&wp->portRect);	// open a picture, this disables drawing
	if(!pict)
		return NULL;

	RGBBackColor( &gray ) ;
	EraseRect(&wp->portRect) ;
	CopyBits((BitMap*)*wp->portPixMap,			// src PixMap	- we copy image over itself -
				(BitMap*)*wp->portPixMap,		// dst PixMap	- no drawing occurs -
				&wp->portRect,			// srcRect		- it will be recorded and compressed -
				&wp->portRect,			// dstRect		- into the picture that is open -
				srcCopy,NULL);			// copyMode and no clip region

	ClosePicture();						// We are done recording the picture
	SetGWorld( origPort , origDev ) ;
	return pict;						// return our groovy pict handle
}

PicHandle MakePictWhite(GWorldPtr wp)
{
	CGrafPtr		origPort ;
	GDHandle		origDev ;

	PicHandle		pict;				// this is the Picture we give back

	RGBColor		white = { 0xFFFF ,0xFFFF  , 0xFFFF  } ;

	GetGWorld( &origPort , &origDev ) ;
	SetGWorld( wp , NULL ) ;

	pict = OpenPicture(&wp->portRect);	// open a picture, this disables drawing
	if(!pict)
		return NULL;

	RGBBackColor( &white ) ;
	EraseRect(&wp->portRect) ;
	CopyBits((BitMap*)*wp->portPixMap,			// src PixMap	- we copy image over itself -
				(BitMap*)*wp->portPixMap,		// dst PixMap	- no drawing occurs -
				&wp->portRect,			// srcRect		- it will be recorded and compressed -
				&wp->portRect,			// dstRect		- into the picture that is open -
				srcCopy,NULL);			// copyMode and no clip region

	ClosePicture();						// We are done recording the picture
	SetGWorld( origPort , origDev ) ;
	return pict;						// return our groovy pict handle
}

const short kwxMacToolBarTopMargin = 2 ;
const short kwxMacToolBarLeftMargin = 2 ;

bool wxToolBar::Realize()
{
  if (m_tools.Number() == 0)
      return FALSE;

	Rect toolbarrect = { m_y , m_x , m_y + m_height , m_x + m_width } ;
	ControlFontStyleRec		controlstyle ;
	WindowPtr				window = GetMacRootWindow() ;
	controlstyle.flags = kControlUseFontMask ;
	controlstyle.font = kControlFontSmallSystemFont ;

	wxNode *node = m_tools.First();
	int noButtons = 0;
	int x = 0 ;
	wxSize toolSize = GetToolSize() ;
    int tw, th;
    GetSize(& tw, & th);
	while (node)
	{
		wxToolBarTool *tool = (wxToolBarTool *)node->Data();
		wxBitmapRefData * bmap = (wxBitmapRefData*) ( tool->GetBitmap1().GetRefData()) ;

		if( !tool->IsSeparator() )
		{
			Rect toolrect = { toolbarrect.top + kwxMacToolBarTopMargin , toolbarrect.left + x + kwxMacToolBarLeftMargin , 0 , 0 } ;
			toolrect.right = toolrect.left + toolSize.x ;
			toolrect.bottom = toolrect.top + toolSize.y ;

			PicHandle	icon = NULL ;
			if ( bmap )
			{
				if ( bmap->m_bitmapType == kMacBitmapTypePict )
					icon = bmap->m_hPict ;
				else if ( bmap->m_bitmapType == kMacBitmapTypeGrafWorld )
				{
					icon = MakePict( bmap->m_hBitmap ) ;
				}
			}

			ControlHandle m_macToolHandle ;

			SInt16 behaviour = kControlBehaviorOffsetContents ;
			if ( tool->CanBeToggled() )
				behaviour += kControlBehaviorToggles ;

			if ( icon )
			{
				m_macToolHandle = UMANewControl( window , &toolrect , "\p" , true , 0 ,
					behaviour + kControlContentPictHandle , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
				ControlButtonContentInfo info ;

				info.contentType = kControlContentPictHandle ;
				info.u.picture = icon ;

				UMASetControlData( m_macToolHandle , kControlButtonPart , kControlBevelButtonContentTag , sizeof(info) , (char*) &info ) ;
			}
			else
			{
						m_macToolHandle = UMANewControl( window , &toolrect , "\p" , true , 0 ,
						behaviour  , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
			}
			m_macToolHandles.Add( m_macToolHandle ) ;
			UMASetControlFontStyle( m_macToolHandle , &controlstyle ) ;
			UMAEmbedControl( m_macToolHandle , m_macControl ) ;

			x += (int)toolSize.x;
			noButtons ++;
		}
		else
		{
			m_macToolHandles.Add( NULL ) ;
			x += (int)toolSize.x / 4;
		}
	    if ( toolbarrect.left + x + kwxMacToolBarLeftMargin > m_maxWidth)
    	  	m_maxWidth = toolbarrect.left + x + kwxMacToolBarLeftMargin;
    	if (toolbarrect.top + kwxMacToolBarTopMargin + toolSize.y > m_maxHeight)
      		m_maxHeight = toolbarrect.top + kwxMacToolBarTopMargin ;

		node = node->Next();
	}

  if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
  {
    m_maxWidth = tw ; // +=toolSize.x;
    m_maxHeight += toolSize.y;
  	m_maxHeight += m_yMargin;
  }
  else
  {
    m_maxHeight = th ;// += toolSize.y;
    m_maxWidth += toolSize.x;
  	m_maxWidth += m_xMargin;
  }

  SetSize(m_maxWidth, m_maxHeight);

  return TRUE;
}

void wxToolBar::SetToolBitmapSize(const wxSize& size)
{
    m_defaultWidth = size.x; m_defaultHeight = size.y;
}

// The button size is bigger than the bitmap size
wxSize wxToolBar::GetToolSize() const
{
    return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
}

void wxToolBar::MacHandleControlClick( ControlHandle control , SInt16 controlpart )
{
	int index = 0 ;
	for ( index = 0 ; index < m_macToolHandles.Count() ; ++index )
	{
		if ( m_macToolHandles[index] == (void*) control )
		{
			OnLeftClick( ( (wxToolBarTool*) (m_tools.Nth( index )->Data() ) ) ->m_index , ( (wxToolBarTool*) (m_tools.Nth( index )->Data() ) ) ->IsToggled() ) ;
		}
	}
}

void wxToolBar::SetRows(int nRows)
{
    if ( nRows == m_maxRows )
    {
        // avoid resizing the frame uselessly
        return;
    }

    m_maxRows = nRows;
}

wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
{
    MacClientToRootWindow( &x , &y ) ;
    Point pt = { x ,y } ;

	int index = 0 ;
	for ( index = 0 ; index < m_macToolHandles.Count() ; ++index )
	{
		if ( PtInRect( pt , &(**(ControlHandle)(m_macToolHandles[index])).contrlRect) )
		{
			return  (wxToolBarTool*) (m_tools.Nth( index )->Data() ) ;
		}
	}

    return (wxToolBarToolBase *)NULL;
}

void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
{
        wxToolBarTool *tool = (wxToolBarTool *)t;
        ControlHandle control = (ControlHandle) m_macToolHandles[ tool->m_index ] ;
		if ( UMAHasAppearance() )
		{
			if ( enable )
				::ActivateControl( control ) ;
			else
				::DeactivateControl( control ) ;
		}
		else
		{
			if ( enable )
				::HiliteControl( control , 0 ) ;
			else
				::HiliteControl( control , 255 ) ;
		}
}

void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
{
       wxToolBarTool *tool = (wxToolBarTool *)t;

       ControlHandle control = (ControlHandle) m_macToolHandles[ tool->m_index ] ;
   		::SetControlValue( control , toggle ) ;
}

bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
                             wxToolBarToolBase *tool)
{
    // nothing special to do here - we really create the toolbar buttons in
    // Realize() later
    tool->Attach(this);

    return TRUE;
}

void wxToolBar::DoSetToggle(wxToolBarToolBase *t, bool toggle)
{
       wxToolBarTool *tool = (wxToolBarTool *)t;
       // TODO: set toggle state
}

bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
{
		return TRUE ;
}
#endif // wxUSE_TOOLBAR
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: toolbar.cpp
	3	// Purpose: wxToolBar
	4	// Author: AUTHOR
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) AUTHOR
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "toolbar.h"
	14	#endif
	15
	16	#include "wx/wx.h"
	17
	18	#if wxUSE_TOOLBAR
	19
	20	#include "wx/toolbar.h"
	21
	22	IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
	23
	24	BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
	25	END_EVENT_TABLE()
	26
	27	#include <wx/mac/uma.h>
	28
	29	// ----------------------------------------------------------------------------
	30	// private classes
	31	// ----------------------------------------------------------------------------
	32
	33	class wxToolBarTool : public wxToolBarToolBase
	34	{
	35	public:
	36	wxToolBarTool(wxToolBar *tbar,
	37	int id,
	38	const wxBitmap& bitmap1,
	39	const wxBitmap& bitmap2,
	40	bool toggle,
	41	wxObject *clientData,
	42	const wxString& shortHelpString,
	43	const wxString& longHelpString)
	44	: wxToolBarToolBase(tbar, id, bitmap1, bitmap2, toggle,
	45	clientData, shortHelpString, longHelpString)
	46	{
	47	m_nSepCount = 0;
	48	m_index = 0 ;
	49	}
	50
	51	wxToolBarTool(wxToolBar tbar, wxControl control)
	52	: wxToolBarToolBase(tbar, control)
	53	{
	54	m_nSepCount = 1;
	55	m_index = 0 ;
	56	}
	57
	58	// set/get the number of separators which we use to cover the space used by
	59	// a control in the toolbar
	60	void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
	61	size_t GetSeparatorsCount() const { return m_nSepCount; }
	62
	63	int m_index ;
	64	private:
	65	size_t m_nSepCount;
	66	};
	67
	68
	69	// ============================================================================
	70	// implementation
	71	// ============================================================================
	72
	73	// ----------------------------------------------------------------------------
	74	// wxToolBarTool
	75	// ----------------------------------------------------------------------------
	76
	77	wxToolBarToolBase *wxToolBar::CreateTool(int id,
	78	const wxBitmap& bitmap1,
	79	const wxBitmap& bitmap2,
	80	bool toggle,
	81	wxObject *clientData,
	82	const wxString& shortHelpString,
	83	const wxString& longHelpString)
	84	{
	85	return new wxToolBarTool(this, id, bitmap1, bitmap2, toggle,
	86	clientData, shortHelpString, longHelpString);
	87	}
	88
	89	wxToolBarToolBase wxToolBar::CreateTool(wxControl control)
	90	{
	91	return new wxToolBarTool(this, control);
	92	}
	93
	94	// ----------------------------------------------------------------------------
	95	// wxToolBar construction
	96	// ----------------------------------------------------------------------------
	97
	98	void wxToolBar::Init()
	99	{
	100	m_maxWidth = -1;
	101	m_maxHeight = -1;
	102	m_defaultWidth = 24;
	103	m_defaultHeight = 22;
	104	// TODO
	105	}
	106
	107	bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
	108	long style, const wxString& name)
	109	{
	110	m_maxWidth = m_maxHeight = 0;
	111
	112	m_defaultWidth = 24;
	113	m_defaultHeight = 22;
	114
	115	int x = pos.x;
	116	int y = pos.y;
	117	int width = size.x;
	118	int height = size.y;
	119
	120	if (width <= 0)
	121	width = 100;
	122	if (height <= 0)
	123	height = 30;
	124	if (x < 0)
	125	x = 0;
	126	if (y < 0)
	127	y = 0;
	128
	129	Rect bounds ;
	130	Str255 title ;
	131
	132	MacPreControlCreate( parent , id , "" , wxPoint( x , y ) , wxSize( width , height ) ,style, ((wxValidator)NULL) , name , &bounds , title ) ;
	133
	134	m_macControl = UMANewControl( parent->GetMacRootWindow() , &bounds , "\p" , true , 0 , 0 , 1,
	135	kControlPlacardProc , (long) this ) ;
	136	MacPostControlCreate() ;
	137
	138	return TRUE;
	139	}
	140
	141	wxToolBar::~wxToolBar()
	142	{
	143	// TODO
	144	}
	145
	146	PicHandle MakePict(GWorldPtr wp)
	147	{
	148	CGrafPtr origPort ;
	149	GDHandle origDev ;
	150
	151	PicHandle pict; // this is the Picture we give back
	152
	153	RGBColor gray = { 0xCCCC ,0xCCCC , 0xCCCC } ;
	154
	155	GetGWorld( &origPort , &origDev ) ;
	156	SetGWorld( wp , NULL ) ;
	157
	158	pict = OpenPicture(&wp->portRect); // open a picture, this disables drawing
	159	if(!pict)
	160	return NULL;
	161
	162	RGBBackColor( &gray ) ;
	163	EraseRect(&wp->portRect) ;
	164	CopyBits((BitMap)wp->portPixMap, // src PixMap - we copy image over itself -
	165	(BitMap)wp->portPixMap, // dst PixMap - no drawing occurs -
	166	&wp->portRect, // srcRect - it will be recorded and compressed -
	167	&wp->portRect, // dstRect - into the picture that is open -
	168	srcCopy,NULL); // copyMode and no clip region
	169
	170	ClosePicture(); // We are done recording the picture
	171	SetGWorld( origPort , origDev ) ;
	172	return pict; // return our groovy pict handle
	173	}
	174
	175	PicHandle MakePictWhite(GWorldPtr wp)
	176	{
	177	CGrafPtr origPort ;
	178	GDHandle origDev ;
	179
	180	PicHandle pict; // this is the Picture we give back
	181
	182	RGBColor white = { 0xFFFF ,0xFFFF , 0xFFFF } ;
	183
	184	GetGWorld( &origPort , &origDev ) ;
	185	SetGWorld( wp , NULL ) ;
	186
	187	pict = OpenPicture(&wp->portRect); // open a picture, this disables drawing
	188	if(!pict)
	189	return NULL;
	190
	191	RGBBackColor( &white ) ;
	192	EraseRect(&wp->portRect) ;
	193	CopyBits((BitMap)wp->portPixMap, // src PixMap - we copy image over itself -
	194	(BitMap)wp->portPixMap, // dst PixMap - no drawing occurs -
	195	&wp->portRect, // srcRect - it will be recorded and compressed -
	196	&wp->portRect, // dstRect - into the picture that is open -
	197	srcCopy,NULL); // copyMode and no clip region
	198
	199	ClosePicture(); // We are done recording the picture
	200	SetGWorld( origPort , origDev ) ;
	201	return pict; // return our groovy pict handle
	202	}
	203
	204	const short kwxMacToolBarTopMargin = 2 ;
	205	const short kwxMacToolBarLeftMargin = 2 ;
	206
	207	bool wxToolBar::Realize()
	208	{
	209	if (m_tools.Number() == 0)
	210	return FALSE;
	211
	212	Rect toolbarrect = { m_y , m_x , m_y + m_height , m_x + m_width } ;
	213	ControlFontStyleRec controlstyle ;
	214	WindowPtr window = GetMacRootWindow() ;
	215	controlstyle.flags = kControlUseFontMask ;
	216	controlstyle.font = kControlFontSmallSystemFont ;
	217
	218	wxNode *node = m_tools.First();
	219	int noButtons = 0;
	220	int x = 0 ;
	221	wxSize toolSize = GetToolSize() ;
	222	int tw, th;
	223	GetSize(& tw, & th);
	224	while (node)
	225	{
	226	wxToolBarTool tool = (wxToolBarTool )node->Data();
	227	wxBitmapRefData * bmap = (wxBitmapRefData*) ( tool->GetBitmap1().GetRefData()) ;
	228
	229	if( !tool->IsSeparator() )
	230	{
	231	Rect toolrect = { toolbarrect.top + kwxMacToolBarTopMargin , toolbarrect.left + x + kwxMacToolBarLeftMargin , 0 , 0 } ;
	232	toolrect.right = toolrect.left + toolSize.x ;
	233	toolrect.bottom = toolrect.top + toolSize.y ;
	234
	235	PicHandle icon = NULL ;
	236	if ( bmap )
	237	{
	238	if ( bmap->m_bitmapType == kMacBitmapTypePict )
	239	icon = bmap->m_hPict ;
	240	else if ( bmap->m_bitmapType == kMacBitmapTypeGrafWorld )
	241	{
	242	icon = MakePict( bmap->m_hBitmap ) ;
	243	}
	244	}
	245
	246	ControlHandle m_macToolHandle ;
	247
	248	SInt16 behaviour = kControlBehaviorOffsetContents ;
	249	if ( tool->CanBeToggled() )
	250	behaviour += kControlBehaviorToggles ;
	251
	252	if ( icon )
	253	{
	254	m_macToolHandle = UMANewControl( window , &toolrect , "\p" , true , 0 ,
	255	behaviour + kControlContentPictHandle , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
	256	ControlButtonContentInfo info ;
	257
	258	info.contentType = kControlContentPictHandle ;
	259	info.u.picture = icon ;
	260
	261	UMASetControlData( m_macToolHandle , kControlButtonPart , kControlBevelButtonContentTag , sizeof(info) , (char*) &info ) ;
	262	}
	263	else
	264	{
	265	m_macToolHandle = UMANewControl( window , &toolrect , "\p" , true , 0 ,
	266	behaviour , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
	267	}
	268	m_macToolHandles.Add( m_macToolHandle ) ;
	269	UMASetControlFontStyle( m_macToolHandle , &controlstyle ) ;
	270	UMAEmbedControl( m_macToolHandle , m_macControl ) ;
	271
	272	x += (int)toolSize.x;
	273	noButtons ++;
	274	}
	275	else
	276	{
	277	m_macToolHandles.Add( NULL ) ;
	278	x += (int)toolSize.x / 4;
	279	}
	280	if ( toolbarrect.left + x + kwxMacToolBarLeftMargin > m_maxWidth)
	281	m_maxWidth = toolbarrect.left + x + kwxMacToolBarLeftMargin;
	282	if (toolbarrect.top + kwxMacToolBarTopMargin + toolSize.y > m_maxHeight)
	283	m_maxHeight = toolbarrect.top + kwxMacToolBarTopMargin ;
	284
	285	node = node->Next();
	286	}
	287
	288	if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
	289	{
	290	m_maxWidth = tw ; // +=toolSize.x;
	291	m_maxHeight += toolSize.y;
	292	m_maxHeight += m_yMargin;
	293	}
	294	else
	295	{
	296	m_maxHeight = th ;// += toolSize.y;
	297	m_maxWidth += toolSize.x;
	298	m_maxWidth += m_xMargin;
	299	}
	300
	301	SetSize(m_maxWidth, m_maxHeight);
	302
	303	return TRUE;
	304	}
	305
	306	void wxToolBar::SetToolBitmapSize(const wxSize& size)
	307	{
	308	m_defaultWidth = size.x; m_defaultHeight = size.y;
	309	}
	310
	311	// The button size is bigger than the bitmap size
	312	wxSize wxToolBar::GetToolSize() const
	313	{
	314	return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
	315	}
	316
	317	void wxToolBar::MacHandleControlClick( ControlHandle control , SInt16 controlpart )
	318	{
	319	int index = 0 ;
	320	for ( index = 0 ; index < m_macToolHandles.Count() ; ++index )
	321	{
	322	if ( m_macToolHandles[index] == (void*) control )
	323	{
	324	OnLeftClick( ( (wxToolBarTool) (m_tools.Nth( index )->Data() ) ) ->m_index , ( (wxToolBarTool) (m_tools.Nth( index )->Data() ) ) ->IsToggled() ) ;
	325	}
	326	}
	327	}
	328
	329	void wxToolBar::SetRows(int nRows)
	330	{
	331	if ( nRows == m_maxRows )
	332	{
	333	// avoid resizing the frame uselessly
	334	return;
	335	}
	336
	337	m_maxRows = nRows;
	338	}
	339
	340	wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
	341	{
	342	MacClientToRootWindow( &x , &y ) ;
	343	Point pt = { x ,y } ;
	344
	345	int index = 0 ;
	346	for ( index = 0 ; index < m_macToolHandles.Count() ; ++index )
	347	{
	348	if ( PtInRect( pt , &(**(ControlHandle)(m_macToolHandles[index])).contrlRect) )
	349	{
	350	return (wxToolBarTool*) (m_tools.Nth( index )->Data() ) ;
	351	}
	352	}
	353
	354	return (wxToolBarToolBase *)NULL;
	355	}
	356
	357	void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
	358	{
	359	wxToolBarTool tool = (wxToolBarTool )t;
	360	ControlHandle control = (ControlHandle) m_macToolHandles[ tool->m_index ] ;
	361	if ( UMAHasAppearance() )
	362	{
	363	if ( enable )
	364	::ActivateControl( control ) ;
	365	else
	366	::DeactivateControl( control ) ;
	367	}
	368	else
	369	{
	370	if ( enable )
	371	::HiliteControl( control , 0 ) ;
	372	else
	373	::HiliteControl( control , 255 ) ;
	374	}
	375	}
	376
	377	void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
	378	{
	379	wxToolBarTool tool = (wxToolBarTool )t;
	380
	381	ControlHandle control = (ControlHandle) m_macToolHandles[ tool->m_index ] ;
	382	::SetControlValue( control , toggle ) ;
	383	}
	384
	385	bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
	386	wxToolBarToolBase *tool)
	387	{
	388	// nothing special to do here - we really create the toolbar buttons in
	389	// Realize() later
	390	tool->Attach(this);
	391
	392	return TRUE;
	393	}
	394
	395	void wxToolBar::DoSetToggle(wxToolBarToolBase *t, bool toggle)
	396	{
	397	wxToolBarTool tool = (wxToolBarTool )t;
	398	// TODO: set toggle state
	399	}
	400
	401	bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
	402	{
	403	return TRUE ;
	404	}
	405	#endif // wxUSE_TOOLBAR
	406