src/mac/carbon/toolbar.cpp

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

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

#include "wx/wx.h"

#if wxUSE_TOOLBAR

#include "wx/toolbar.h"
#include "wx/notebook.h"
#include "wx/tabctrl.h"
#include "wx/bitmap.h"

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)

BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
    EVT_MOUSE_EVENTS( wxToolBar::OnMouse )
    EVT_PAINT( wxToolBar::OnPaint )
END_EVENT_TABLE()
#endif

#include "wx/mac/uma.h"
#include "wx/geometry.h"
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

class wxToolBarTool : public wxToolBarToolBase
{
public:
    wxToolBarTool(wxToolBar *tbar,
                  int id,
                  const wxString& label,
                  const wxBitmap& bmpNormal,
                  const wxBitmap& bmpDisabled,
                  wxItemKind kind,
                  wxObject *clientData,
                  const wxString& shortHelp,
                  const wxString& longHelp) ;

    wxToolBarTool(wxToolBar *tbar, wxControl *control)
        : wxToolBarToolBase(tbar, control)
    {
        Init() ;
    }

    ~wxToolBarTool()
    {
        if ( m_controlHandle )
            DisposeControl( m_controlHandle ) ;
    }

    ControlHandle   GetControlHandle() { return m_controlHandle ; }
    void SetControlHandle( ControlHandle handle ) { m_controlHandle = handle ; }

    void SetSize(const wxSize& size) ;
    void SetPosition( const wxPoint& position ) ;
    wxSize GetSize() const
    {
        if ( IsControl() )
        {
            return GetControl()->GetSize() ;
        }
        else if ( IsButton() )
        {
            return GetToolBar()->GetToolSize() ;
        }
        else
        {
            wxSize sz = GetToolBar()->GetToolSize() ;
            sz.x /= 4 ;
            sz.y /= 4 ;
            return sz ;
        }
    }
    wxPoint GetPosition() const
    {
        return wxPoint(m_x, m_y);
    }
private :
    void Init()
    {
        m_controlHandle = NULL ;
    }
    ControlHandle m_controlHandle ;

    wxCoord     m_x;
    wxCoord     m_y;
};

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

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

void wxToolBarTool::SetSize(const wxSize& size)
{
    if ( IsControl() )
    {
        GetControl()->SetSize( size ) ;
    }
}

void wxToolBarTool::SetPosition(const wxPoint& position)
{
    m_x = position.x;
    m_y = position.y;

    if ( IsButton() )
    {
        int x , y ;
        x = y = 0 ;
        WindowRef rootwindow = (WindowRef) GetToolBar()->MacGetRootWindow() ;
        GetToolBar()->MacWindowToRootWindow( &x , &y ) ;
        int mac_x = x + position.x ;
        int mac_y = y + position.y ;


        Rect contrlRect ;
        GetControlBounds( m_controlHandle , &contrlRect ) ;
        int former_mac_x = contrlRect.left ;
        int former_mac_y = contrlRect.top ;
        wxSize sz = GetToolBar()->GetToolSize() ;

        if ( mac_x != former_mac_x || mac_y != former_mac_y )
        {
            {
                Rect inval = { former_mac_y , former_mac_x , former_mac_y + sz.y , former_mac_x + sz.x } ;
                InvalWindowRect( rootwindow , &inval ) ;
            }
            UMAMoveControl( m_controlHandle , mac_x , mac_y ) ;
            {
                Rect inval = { mac_y , mac_x , mac_y + sz.y , mac_x + sz.x } ;
                InvalWindowRect( rootwindow , &inval ) ;
            }
        }
    }
    else if ( IsControl() )
    {
        GetControl()->Move( position ) ;
    }
}

const short kwxMacToolBarToolDefaultWidth = 24 ;
const short kwxMacToolBarToolDefaultHeight = 22 ;
const short kwxMacToolBarTopMargin = 2 ;
const short kwxMacToolBarLeftMargin = 2 ;

wxToolBarTool::wxToolBarTool(wxToolBar *tbar,
  int id,
  const wxString& label,
  const wxBitmap& bmpNormal,
  const wxBitmap& bmpDisabled,
  wxItemKind kind,
  wxObject *clientData,
  const wxString& shortHelp,
  const wxString& longHelp)
        : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
                            clientData, shortHelp, longHelp)
{
    Init() ;

    WindowRef window = (WindowRef) tbar->MacGetRootWindow() ;
    wxSize toolSize = tbar->GetToolSize() ;
    Rect toolrect = { 0, 0 , toolSize.y , toolSize.x } ;

    ControlButtonContentInfo info ;
    wxMacCreateBitmapButton( &info , GetNormalBitmap() ) ;

    SInt16 behaviour = kControlBehaviorOffsetContents ;
    if ( CanBeToggled() )
        behaviour += kControlBehaviorToggles ;

    if ( info.contentType != kControlNoContent )
    {
        m_controlHandle = ::NewControl( window , &toolrect , "\p" , false , 0 ,
                                        behaviour + info.contentType , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;

        ::SetControlData( m_controlHandle , kControlButtonPart , kControlBevelButtonContentTag , sizeof(info) , (char*) &info ) ;
    }
    else
    {
        m_controlHandle = ::NewControl( window , &toolrect , "\p" , false , 0 ,
                                        behaviour  , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
    }
    UMAShowControl( m_controlHandle ) ;
    if ( !IsEnabled() )
    {
        UMADeactivateControl( m_controlHandle ) ;
    }
    if ( CanBeToggled() && IsToggled() )
    {
        ::SetControl32BitValue( m_controlHandle , 1 ) ;
    }
    else
    {
        ::SetControl32BitValue( m_controlHandle , 0 ) ;
    }

    ControlHandle container = (ControlHandle) tbar->MacGetContainerForEmbedding() ;
    wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
    ::EmbedControl( m_controlHandle , container ) ;
}


wxToolBarToolBase *wxToolBar::CreateTool(int id,
                                         const wxString& label,
                                         const wxBitmap& bmpNormal,
                                         const wxBitmap& bmpDisabled,
                                         wxItemKind kind,
                                         wxObject *clientData,
                                         const wxString& shortHelp,
                                         const wxString& longHelp)
{
    return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
                             clientData, shortHelp, longHelp);
}

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

void wxToolBar::Init()
{
    m_maxWidth = -1;
    m_maxHeight = -1;
    m_defaultWidth = kwxMacToolBarToolDefaultWidth;
    m_defaultHeight = kwxMacToolBarToolDefaultHeight;
}

bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
            long style, const wxString& name)
{
    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;

    SetName(name);

    m_windowStyle = style;
    parent->AddChild(this);

    m_backgroundColour = parent->GetBackgroundColour() ;
    m_foregroundColour = parent->GetForegroundColour() ;

    if (id == -1)
        m_windowId = NewControlId();
    else
        m_windowId = id;

    {
        m_width = size.x ;
        m_height = size.y ;
        int x = pos.x ;
        int y = pos.y ;
        AdjustForParentClientOrigin(x, y, wxSIZE_USE_EXISTING);
        m_x = x ;
        m_y = y ;
    }

    return TRUE;
}

wxToolBar::~wxToolBar()
{
    // we must refresh the frame size when the toolbar is deleted but the frame
    // is not - otherwise toolbar leaves a hole in the place it used to occupy
}

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

    int x = m_xMargin + kwxMacToolBarLeftMargin ;
    int y = m_yMargin + kwxMacToolBarTopMargin ;

    int tw, th;
    GetSize(& tw, & th);

    int maxWidth = 0 ;
    int maxHeight = 0 ;

    int maxToolWidth = 0;
    int maxToolHeight = 0;

    // Find the maximum tool width and height
    wxToolBarToolsList::Node *node = m_tools.GetFirst();
    while ( node )
    {
        wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
        wxSize sz = tool->GetSize() ;

        if ( sz.x > maxToolWidth )
            maxToolWidth = sz.x ;
        if (sz.y> maxToolHeight)
            maxToolHeight = sz.y;

        node = node->GetNext();
    }

    node = m_tools.GetFirst();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
        wxSize cursize = tool->GetSize() ;

        // for the moment we just do a single row/column alignement
        if ( x + cursize.x > maxWidth )
            maxWidth = x + cursize.x ;
        if ( y + cursize.y > maxHeight )
            maxHeight = y + cursize.y ;

        tool->SetPosition( wxPoint( x , y ) ) ;

        if ( GetWindowStyleFlag() & wxTB_VERTICAL )
        {
            y += cursize.y ;
        }
        else
        {
            x += cursize.x ;
        }

        node = node->GetNext();
    }

    if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
    {
        if ( m_maxRows == 0 )
        {
            // if not set yet, only one row
            SetRows(1);
        }
        maxWidth = tw ;
        maxHeight += m_yMargin + kwxMacToolBarTopMargin;
        m_maxHeight = maxHeight ;
    }
    else
    {
        if ( GetToolsCount() > 0 && m_maxRows == 0 )
        {
            // if not set yet, have one column
            SetRows(GetToolsCount());
        }
        maxHeight = th ;
        maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
        m_maxWidth = maxWidth ;
    }

    SetSize(maxWidth, maxHeight);

    return TRUE;
}

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

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

void wxToolBar::MacHandleControlClick( WXWidget control , wxInt16 controlpart , bool WXUNUSED( mouseStillDown ) )
{
    wxToolBarToolsList::Node *node;
    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
    {
        wxToolBarTool* tool = (wxToolBarTool*) node->GetData() ;
        if ( tool->IsButton() )
        {
           if( tool->GetControlHandle() == control )
           {
                if ( tool->CanBeToggled() )
                {
                    tool->Toggle( GetControl32BitValue( (ControlHandle) control ) ) ;
                }
                OnLeftClick( tool->GetId() , tool -> IsToggled() ) ;
                break ;
           }
        }
    }
}

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

    m_maxRows = nRows;
}

void wxToolBar::MacSuperChangedPosition()
{
    wxWindow::MacSuperChangedPosition() ;
    Realize() ;
}

wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
{
    wxToolBarToolsList::Node *node = m_tools.GetFirst();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool *)node->GetData() ;
        wxRect2DInt r( tool->GetPosition() , tool->GetSize() ) ;
        if ( r.Contains( wxPoint( x , y ) ) )
        {
            return tool;
        }

        node = node->GetNext();
    }

    return (wxToolBarToolBase *)NULL;
}

wxString wxToolBar::MacGetToolTipString( wxPoint &pt )
{
    wxToolBarToolBase* tool = FindToolForPosition( pt.x , pt.y ) ;
    if ( tool )
    {
        return tool->GetShortHelp() ;
    }
    return wxEmptyString ;
}

void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
{
    if (!IsShown())
        return ;

    wxToolBarTool *tool = (wxToolBarTool *)t;
    if ( tool->IsControl() )
    {
        tool->GetControl()->Enable( enable ) ;
    }
    else if ( tool->IsButton() )
    {
        if ( enable )
            UMAActivateControl( tool->GetControlHandle() ) ;
        else
            UMADeactivateControl( tool->GetControlHandle() ) ;
    }
}

void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
{
    if (!IsShown())
        return ;

    wxToolBarTool *tool = (wxToolBarTool *)t;
    if ( tool->IsButton() )
    {
        ::SetControl32BitValue( tool->GetControlHandle() , toggle ) ;
    }
}

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

    return TRUE;
}

void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
{
    wxFAIL_MSG( _T("not implemented") );
}

bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
{
    wxToolBarToolsList::Node *node;
    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
    {
        wxToolBarToolBase *tool2 = node->GetData();
        if ( tool2 == tool )
        {
            // let node point to the next node in the list
            node = node->GetNext();

            break;
        }
    }

    wxSize sz = ((wxToolBarTool*)tool)->GetSize() ;

    tool->Detach();

    // and finally reposition all the controls after this one

    for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
    {
        wxToolBarTool *tool2 = (wxToolBarTool*) node->GetData();
        wxPoint pt = tool2->GetPosition() ;

        if ( GetWindowStyleFlag() & wxTB_VERTICAL )
        {
            pt.y -= sz.y ;
        }
        else
        {
            pt.x -= sz.x ;
        }
        tool2->SetPosition( pt ) ;
    }

    return TRUE ;
}

void wxToolBar::OnPaint(wxPaintEvent& event)
{
    wxPaintDC dc(this) ;
    wxMacPortSetter helper(&dc) ;

    Rect toolbarrect = { dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) ,
        dc.YLOG2DEVMAC(m_height) , dc.XLOG2DEVMAC(m_width) } ;
    UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
    {
        wxToolBarToolsList::Node *node;
        for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
        {
            wxToolBarTool* tool = (wxToolBarTool*) node->GetData() ;
            if ( tool->IsButton() )
            {
               UMADrawControl( tool->GetControlHandle() ) ;
            }
        }
    }
}

void  wxToolBar::OnMouse( wxMouseEvent &event )
{
    if (event.GetEventType() == wxEVT_LEFT_DOWN || event.GetEventType() == wxEVT_LEFT_DCLICK )
    {

        int x = event.m_x ;
        int y = event.m_y ;

        MacClientToRootWindow( &x , &y ) ;

        ControlHandle   control ;
        Point       localwhere ;
        SInt16      controlpart ;
        WindowRef   window = (WindowRef) MacGetRootWindow() ;

        localwhere.h = x ;
        localwhere.v = y ;

        short modifiers = 0;

        if ( !event.m_leftDown && !event.m_rightDown )
            modifiers  |= btnState ;

        if ( event.m_shiftDown )
            modifiers |= shiftKey ;

        if ( event.m_controlDown )
            modifiers |= controlKey ;

        if ( event.m_altDown )
            modifiers |= optionKey ;

        if ( event.m_metaDown )
            modifiers |= cmdKey ;

        controlpart = ::FindControl( localwhere , window , &control ) ;
        {
            if ( control && ::IsControlActive( control ) )
            {
                {
                    controlpart = ::HandleControlClick( control , localwhere , modifiers , (ControlActionUPP) -1 ) ;
                    wxTheApp->s_lastMouseDown = 0 ;
                    if ( control && controlpart != kControlNoPart ) // otherwise we will get the event twice
                    {
                        MacHandleControlClick( control , controlpart , false /* not down anymore */ ) ;
                    }
                }
            }
        }
    }
}

#endif // wxUSE_TOOLBAR
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: toolbar.cpp
	3	// Purpose: wxToolBar
	4	// Author: Stefan Csomor
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Stefan Csomor
	9	// Licence: The 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	#include "wx/notebook.h"
	22	#include "wx/tabctrl.h"
	23	#include "wx/bitmap.h"
	24
	25	#if !USE_SHARED_LIBRARY
	26	IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
	27
	28	BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
	29	EVT_MOUSE_EVENTS( wxToolBar::OnMouse )
	30	EVT_PAINT( wxToolBar::OnPaint )
	31	END_EVENT_TABLE()
	32	#endif
	33
	34	#include "wx/mac/uma.h"
	35	#include "wx/geometry.h"
	36	// ----------------------------------------------------------------------------
	37	// private classes
	38	// ----------------------------------------------------------------------------
	39
	40	class wxToolBarTool : public wxToolBarToolBase
	41	{
	42	public:
	43	wxToolBarTool(wxToolBar *tbar,
	44	int id,
	45	const wxString& label,
	46	const wxBitmap& bmpNormal,
	47	const wxBitmap& bmpDisabled,
	48	wxItemKind kind,
	49	wxObject *clientData,
	50	const wxString& shortHelp,
	51	const wxString& longHelp) ;
	52
	53	wxToolBarTool(wxToolBar tbar, wxControl control)
	54	: wxToolBarToolBase(tbar, control)
	55	{
	56	Init() ;
	57	}
	58
	59	~wxToolBarTool()
	60	{
	61	if ( m_controlHandle )
	62	DisposeControl( m_controlHandle ) ;
	63	}
	64
	65	ControlHandle GetControlHandle() { return m_controlHandle ; }
	66	void SetControlHandle( ControlHandle handle ) { m_controlHandle = handle ; }
	67
	68	void SetSize(const wxSize& size) ;
	69	void SetPosition( const wxPoint& position ) ;
	70	wxSize GetSize() const
	71	{
	72	if ( IsControl() )
	73	{
	74	return GetControl()->GetSize() ;
	75	}
	76	else if ( IsButton() )
	77	{
	78	return GetToolBar()->GetToolSize() ;
	79	}
	80	else
	81	{
	82	wxSize sz = GetToolBar()->GetToolSize() ;
	83	sz.x /= 4 ;
	84	sz.y /= 4 ;
	85	return sz ;
	86	}
	87	}
	88	wxPoint GetPosition() const
	89	{
	90	return wxPoint(m_x, m_y);
	91	}
	92	private :
	93	void Init()
	94	{
	95	m_controlHandle = NULL ;
	96	}
	97	ControlHandle m_controlHandle ;
	98
	99	wxCoord m_x;
	100	wxCoord m_y;
	101	};
	102
	103	// ============================================================================
	104	// implementation
	105	// ============================================================================
	106
	107	// ----------------------------------------------------------------------------
	108	// wxToolBarTool
	109	// ----------------------------------------------------------------------------
	110
	111	void wxToolBarTool::SetSize(const wxSize& size)
	112	{
	113	if ( IsControl() )
	114	{
	115	GetControl()->SetSize( size ) ;
	116	}
	117	}
	118
	119	void wxToolBarTool::SetPosition(const wxPoint& position)
	120	{
	121	m_x = position.x;
	122	m_y = position.y;
	123
	124	if ( IsButton() )
	125	{
	126	int x , y ;
	127	x = y = 0 ;
	128	WindowRef rootwindow = (WindowRef) GetToolBar()->MacGetRootWindow() ;
	129	GetToolBar()->MacWindowToRootWindow( &x , &y ) ;
	130	int mac_x = x + position.x ;
	131	int mac_y = y + position.y ;
	132
	133
	134	Rect contrlRect ;
	135	GetControlBounds( m_controlHandle , &contrlRect ) ;
	136	int former_mac_x = contrlRect.left ;
	137	int former_mac_y = contrlRect.top ;
	138	wxSize sz = GetToolBar()->GetToolSize() ;
	139
	140	if ( mac_x != former_mac_x \|\| mac_y != former_mac_y )
	141	{
	142	{
	143	Rect inval = { former_mac_y , former_mac_x , former_mac_y + sz.y , former_mac_x + sz.x } ;
	144	InvalWindowRect( rootwindow , &inval ) ;
	145	}
	146	UMAMoveControl( m_controlHandle , mac_x , mac_y ) ;
	147	{
	148	Rect inval = { mac_y , mac_x , mac_y + sz.y , mac_x + sz.x } ;
	149	InvalWindowRect( rootwindow , &inval ) ;
	150	}
	151	}
	152	}
	153	else if ( IsControl() )
	154	{
	155	GetControl()->Move( position ) ;
	156	}
	157	}
	158
	159	const short kwxMacToolBarToolDefaultWidth = 24 ;
	160	const short kwxMacToolBarToolDefaultHeight = 22 ;
	161	const short kwxMacToolBarTopMargin = 2 ;
	162	const short kwxMacToolBarLeftMargin = 2 ;
	163
	164	wxToolBarTool::wxToolBarTool(wxToolBar *tbar,
	165	int id,
	166	const wxString& label,
	167	const wxBitmap& bmpNormal,
	168	const wxBitmap& bmpDisabled,
	169	wxItemKind kind,
	170	wxObject *clientData,
	171	const wxString& shortHelp,
	172	const wxString& longHelp)
	173	: wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
	174	clientData, shortHelp, longHelp)
	175	{
	176	Init() ;
	177
	178	WindowRef window = (WindowRef) tbar->MacGetRootWindow() ;
	179	wxSize toolSize = tbar->GetToolSize() ;
	180	Rect toolrect = { 0, 0 , toolSize.y , toolSize.x } ;
	181
	182	ControlButtonContentInfo info ;
	183	wxMacCreateBitmapButton( &info , GetNormalBitmap() ) ;
	184
	185	SInt16 behaviour = kControlBehaviorOffsetContents ;
	186	if ( CanBeToggled() )
	187	behaviour += kControlBehaviorToggles ;
	188
	189	if ( info.contentType != kControlNoContent )
	190	{
	191	m_controlHandle = ::NewControl( window , &toolrect , "\p" , false , 0 ,
	192	behaviour + info.contentType , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
	193
	194	::SetControlData( m_controlHandle , kControlButtonPart , kControlBevelButtonContentTag , sizeof(info) , (char*) &info ) ;
	195	}
	196	else
	197	{
	198	m_controlHandle = ::NewControl( window , &toolrect , "\p" , false , 0 ,
	199	behaviour , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
	200	}
	201	UMAShowControl( m_controlHandle ) ;
	202	if ( !IsEnabled() )
	203	{
	204	UMADeactivateControl( m_controlHandle ) ;
	205	}
	206	if ( CanBeToggled() && IsToggled() )
	207	{
	208	::SetControl32BitValue( m_controlHandle , 1 ) ;
	209	}
	210	else
	211	{
	212	::SetControl32BitValue( m_controlHandle , 0 ) ;
	213	}
	214
	215	ControlHandle container = (ControlHandle) tbar->MacGetContainerForEmbedding() ;
	216	wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
	217	::EmbedControl( m_controlHandle , container ) ;
	218	}
	219
	220
	221	wxToolBarToolBase *wxToolBar::CreateTool(int id,
	222	const wxString& label,
	223	const wxBitmap& bmpNormal,
	224	const wxBitmap& bmpDisabled,
	225	wxItemKind kind,
	226	wxObject *clientData,
	227	const wxString& shortHelp,
	228	const wxString& longHelp)
	229	{
	230	return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
	231	clientData, shortHelp, longHelp);
	232	}
	233
	234	wxToolBarToolBase wxToolBar::CreateTool(wxControl control)
	235	{
	236	return new wxToolBarTool(this, control);
	237	}
	238
	239	void wxToolBar::Init()
	240	{
	241	m_maxWidth = -1;
	242	m_maxHeight = -1;
	243	m_defaultWidth = kwxMacToolBarToolDefaultWidth;
	244	m_defaultHeight = kwxMacToolBarToolDefaultHeight;
	245	}
	246
	247	bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
	248	long style, const wxString& name)
	249	{
	250	int x = pos.x;
	251	int y = pos.y;
	252	int width = size.x;
	253	int height = size.y;
	254
	255	if (width <= 0)
	256	width = 100;
	257	if (height <= 0)
	258	height = 30;
	259	if (x < 0)
	260	x = 0;
	261	if (y < 0)
	262	y = 0;
	263
	264	SetName(name);
	265
	266	m_windowStyle = style;
	267	parent->AddChild(this);
	268
	269	m_backgroundColour = parent->GetBackgroundColour() ;
	270	m_foregroundColour = parent->GetForegroundColour() ;
	271
	272	if (id == -1)
	273	m_windowId = NewControlId();
	274	else
	275	m_windowId = id;
	276
	277	{
	278	m_width = size.x ;
	279	m_height = size.y ;
	280	int x = pos.x ;
	281	int y = pos.y ;
	282	AdjustForParentClientOrigin(x, y, wxSIZE_USE_EXISTING);
	283	m_x = x ;
	284	m_y = y ;
	285	}
	286
	287	return TRUE;
	288	}
	289
	290	wxToolBar::~wxToolBar()
	291	{
	292	// we must refresh the frame size when the toolbar is deleted but the frame
	293	// is not - otherwise toolbar leaves a hole in the place it used to occupy
	294	}
	295
	296	bool wxToolBar::Realize()
	297	{
	298	if (m_tools.GetCount() == 0)
	299	return FALSE;
	300
	301	int x = m_xMargin + kwxMacToolBarLeftMargin ;
	302	int y = m_yMargin + kwxMacToolBarTopMargin ;
	303
	304	int tw, th;
	305	GetSize(& tw, & th);
	306
	307	int maxWidth = 0 ;
	308	int maxHeight = 0 ;
	309
	310	int maxToolWidth = 0;
	311	int maxToolHeight = 0;
	312
	313	// Find the maximum tool width and height
	314	wxToolBarToolsList::Node *node = m_tools.GetFirst();
	315	while ( node )
	316	{
	317	wxToolBarTool tool = (wxToolBarTool )node->GetData();
	318	wxSize sz = tool->GetSize() ;
	319
	320	if ( sz.x > maxToolWidth )
	321	maxToolWidth = sz.x ;
	322	if (sz.y> maxToolHeight)
	323	maxToolHeight = sz.y;
	324
	325	node = node->GetNext();
	326	}
	327
	328	node = m_tools.GetFirst();
	329	while (node)
	330	{
	331	wxToolBarTool tool = (wxToolBarTool )node->GetData();
	332	wxSize cursize = tool->GetSize() ;
	333
	334	// for the moment we just do a single row/column alignement
	335	if ( x + cursize.x > maxWidth )
	336	maxWidth = x + cursize.x ;
	337	if ( y + cursize.y > maxHeight )
	338	maxHeight = y + cursize.y ;
	339
	340	tool->SetPosition( wxPoint( x , y ) ) ;
	341
	342	if ( GetWindowStyleFlag() & wxTB_VERTICAL )
	343	{
	344	y += cursize.y ;
	345	}
	346	else
	347	{
	348	x += cursize.x ;
	349	}
	350
	351	node = node->GetNext();
	352	}
	353
	354	if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
	355	{
	356	if ( m_maxRows == 0 )
	357	{
	358	// if not set yet, only one row
	359	SetRows(1);
	360	}
	361	maxWidth = tw ;
	362	maxHeight += m_yMargin + kwxMacToolBarTopMargin;
	363	m_maxHeight = maxHeight ;
	364	}
	365	else
	366	{
	367	if ( GetToolsCount() > 0 && m_maxRows == 0 )
	368	{
	369	// if not set yet, have one column
	370	SetRows(GetToolsCount());
	371	}
	372	maxHeight = th ;
	373	maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
	374	m_maxWidth = maxWidth ;
	375	}
	376
	377	SetSize(maxWidth, maxHeight);
	378
	379	return TRUE;
	380	}
	381
	382	void wxToolBar::SetToolBitmapSize(const wxSize& size)
	383	{
	384	m_defaultWidth = size.x+4; m_defaultHeight = size.y+4;
	385	}
	386
	387	// The button size is bigger than the bitmap size
	388	wxSize wxToolBar::GetToolSize() const
	389	{
	390	return wxSize(m_defaultWidth + 4, m_defaultHeight + 4);
	391	}
	392
	393	void wxToolBar::MacHandleControlClick( WXWidget control , wxInt16 controlpart , bool WXUNUSED( mouseStillDown ) )
	394	{
	395	wxToolBarToolsList::Node *node;
	396	for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
	397	{
	398	wxToolBarTool* tool = (wxToolBarTool*) node->GetData() ;
	399	if ( tool->IsButton() )
	400	{
	401	if( tool->GetControlHandle() == control )
	402	{
	403	if ( tool->CanBeToggled() )
	404	{
	405	tool->Toggle( GetControl32BitValue( (ControlHandle) control ) ) ;
	406	}
	407	OnLeftClick( tool->GetId() , tool -> IsToggled() ) ;
	408	break ;
	409	}
	410	}
	411	}
	412	}
	413
	414	void wxToolBar::SetRows(int nRows)
	415	{
	416	if ( nRows == m_maxRows )
	417	{
	418	// avoid resizing the frame uselessly
	419	return;
	420	}
	421
	422	m_maxRows = nRows;
	423	}
	424
	425	void wxToolBar::MacSuperChangedPosition()
	426	{
	427	wxWindow::MacSuperChangedPosition() ;
	428	Realize() ;
	429	}
	430
	431	wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
	432	{
	433	wxToolBarToolsList::Node *node = m_tools.GetFirst();
	434	while (node)
	435	{
	436	wxToolBarTool tool = (wxToolBarTool )node->GetData() ;
	437	wxRect2DInt r( tool->GetPosition() , tool->GetSize() ) ;
	438	if ( r.Contains( wxPoint( x , y ) ) )
	439	{
	440	return tool;
	441	}
	442
	443	node = node->GetNext();
	444	}
	445
	446	return (wxToolBarToolBase *)NULL;
	447	}
	448
	449	wxString wxToolBar::MacGetToolTipString( wxPoint &pt )
	450	{
	451	wxToolBarToolBase* tool = FindToolForPosition( pt.x , pt.y ) ;
	452	if ( tool )
	453	{
	454	return tool->GetShortHelp() ;
	455	}
	456	return wxEmptyString ;
	457	}
	458
	459	void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
	460	{
	461	if (!IsShown())
	462	return ;
	463
	464	wxToolBarTool tool = (wxToolBarTool )t;
	465	if ( tool->IsControl() )
	466	{
	467	tool->GetControl()->Enable( enable ) ;
	468	}
	469	else if ( tool->IsButton() )
	470	{
	471	if ( enable )
	472	UMAActivateControl( tool->GetControlHandle() ) ;
	473	else
	474	UMADeactivateControl( tool->GetControlHandle() ) ;
	475	}
	476	}
	477
	478	void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
	479	{
	480	if (!IsShown())
	481	return ;
	482
	483	wxToolBarTool tool = (wxToolBarTool )t;
	484	if ( tool->IsButton() )
	485	{
	486	::SetControl32BitValue( tool->GetControlHandle() , toggle ) ;
	487	}
	488	}
	489
	490	bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
	491	wxToolBarToolBase *tool)
	492	{
	493	// nothing special to do here - we relayout in Realize() later
	494	tool->Attach(this);
	495
	496	return TRUE;
	497	}
	498
	499	void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
	500	{
	501	wxFAIL_MSG( _T("not implemented") );
	502	}
	503
	504	bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
	505	{
	506	wxToolBarToolsList::Node *node;
	507	for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
	508	{
	509	wxToolBarToolBase *tool2 = node->GetData();
	510	if ( tool2 == tool )
	511	{
	512	// let node point to the next node in the list
	513	node = node->GetNext();
	514
	515	break;
	516	}
	517	}
	518
	519	wxSize sz = ((wxToolBarTool*)tool)->GetSize() ;
	520
	521	tool->Detach();
	522
	523	// and finally reposition all the controls after this one
	524
	525	for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
	526	{
	527	wxToolBarTool tool2 = (wxToolBarTool) node->GetData();
	528	wxPoint pt = tool2->GetPosition() ;
	529
	530	if ( GetWindowStyleFlag() & wxTB_VERTICAL )
	531	{
	532	pt.y -= sz.y ;
	533	}
	534	else
	535	{
	536	pt.x -= sz.x ;
	537	}
	538	tool2->SetPosition( pt ) ;
	539	}
	540
	541	return TRUE ;
	542	}
	543
	544	void wxToolBar::OnPaint(wxPaintEvent& event)
	545	{
	546	wxPaintDC dc(this) ;
	547	wxMacPortSetter helper(&dc) ;
	548
	549	Rect toolbarrect = { dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) ,
	550	dc.YLOG2DEVMAC(m_height) , dc.XLOG2DEVMAC(m_width) } ;
	551	UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
	552	{
	553	wxToolBarToolsList::Node *node;
	554	for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
	555	{
	556	wxToolBarTool* tool = (wxToolBarTool*) node->GetData() ;
	557	if ( tool->IsButton() )
	558	{
	559	UMADrawControl( tool->GetControlHandle() ) ;
	560	}
	561	}
	562	}
	563	}
	564
	565	void wxToolBar::OnMouse( wxMouseEvent &event )
	566	{
	567	if (event.GetEventType() == wxEVT_LEFT_DOWN \|\| event.GetEventType() == wxEVT_LEFT_DCLICK )
	568	{
	569
	570	int x = event.m_x ;
	571	int y = event.m_y ;
	572
	573	MacClientToRootWindow( &x , &y ) ;
	574
	575	ControlHandle control ;
	576	Point localwhere ;
	577	SInt16 controlpart ;
	578	WindowRef window = (WindowRef) MacGetRootWindow() ;
	579
	580	localwhere.h = x ;
	581	localwhere.v = y ;
	582
	583	short modifiers = 0;
	584
	585	if ( !event.m_leftDown && !event.m_rightDown )
	586	modifiers \|= btnState ;
	587
	588	if ( event.m_shiftDown )
	589	modifiers \|= shiftKey ;
	590
	591	if ( event.m_controlDown )
	592	modifiers \|= controlKey ;
	593
	594	if ( event.m_altDown )
	595	modifiers \|= optionKey ;
	596
	597	if ( event.m_metaDown )
	598	modifiers \|= cmdKey ;
	599
	600	controlpart = ::FindControl( localwhere , window , &control ) ;
	601	{
	602	if ( control && ::IsControlActive( control ) )
	603	{
	604	{
	605	controlpart = ::HandleControlClick( control , localwhere , modifiers , (ControlActionUPP) -1 ) ;
	606	wxTheApp->s_lastMouseDown = 0 ;
	607	if ( control && controlpart != kControlNoPart ) // otherwise we will get the event twice
	608	{
	609	MacHandleControlClick( control , controlpart , false /* not down anymore */ ) ;
	610	}
	611	}
	612	}
	613	}
	614	}
	615	}
	616
	617	#endif // wxUSE_TOOLBAR
	618