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
/////////////////////////////////////////////////////////////////////////////

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "toolbar.h"
#endif

#include "wx/wxprec.h"

#if wxUSE_TOOLBAR

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

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)

BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
    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 ) ;
    }

    WXWidget GetControlHandle() { return (WXWidget) m_controlHandle ; }
    void SetControlHandle( ControlRef 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);
    }
    bool DoEnable( bool enable ) ;
private :
    void Init()
    {
        m_controlHandle = NULL ;
    }
    ControlRef m_controlHandle ;

    wxCoord     m_x;
    wxCoord     m_y;
};

static const EventTypeSpec eventList[] =
{
	{ kEventClassControl , kEventControlHit } ,
} ;

static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
    OSStatus result = eventNotHandledErr ;

    wxMacCarbonEvent cEvent( event ) ;

    ControlRef controlRef ;

    cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;

    switch( GetEventKind( event ) )
    {
        case kEventControlHit :
            {
                wxToolBarTool* tbartool = (wxToolBarTool*)data ;
                if ( tbartool->CanBeToggled() )
                {
                    ((wxToolBar*)tbartool->GetToolBar())->ToggleTool(tbartool->GetId(), GetControl32BitValue((ControlRef)tbartool->GetControlHandle()));
                }
                ((wxToolBar*)tbartool->GetToolBar())->OnLeftClick( tbartool->GetId() , tbartool -> IsToggled() ) ;
                result = noErr;
            }
            break ;
        default :
            break ;
    }
    return result ;
}

pascal OSStatus wxMacToolBarToolEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
    OSStatus result = eventNotHandledErr ;

    switch ( GetEventClass( event ) )
    {
        case kEventClassControl :
            result = wxMacToolBarToolControlEventHandler( handler, event, data ) ;
            break ;
        default :
            break ;
    }
    return result ;
}

DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarToolEventHandler )

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

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

bool wxToolBarTool::DoEnable(bool enable)
{
    if ( IsControl() )
    {
        GetControl()->Enable( enable ) ;
    }
    else if ( IsButton() )
    {
#if TARGET_API_MAC_OSX
        if ( enable )
            EnableControl( m_controlHandle ) ;
        else
            DisableControl( m_controlHandle ) ;
#else
        if ( enable )
            ActivateControl( m_controlHandle ) ;
        else
            DeactivateControl( m_controlHandle ) ;
#endif
    }
    return true ;
}
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 ;
        int mac_x = position.x ;
        int mac_y = position.y ;
#if !TARGET_API_MAC_OSX
        WindowRef rootwindow = (WindowRef) GetToolBar()->MacGetTopLevelWindowRef() ;
        GetToolBar()->MacWindowToRootWindow( &x , &y ) ;
        mac_x += x;
        mac_y += y;
#endif
        Rect contrlRect ;
        GetControlBounds( m_controlHandle , &contrlRect ) ;
        int former_mac_x = contrlRect.left ;
        int former_mac_y = contrlRect.top ;
        GetToolBar()->GetToolSize() ;

        if ( mac_x != former_mac_x || mac_y != former_mac_y )
        {
            UMAMoveControl( m_controlHandle , mac_x , mac_y ) ;
        }
    }
    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();

    if (id == wxID_SEPARATOR) return;

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

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

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

    CreateBevelButtonControl( window , &toolrect , CFSTR("") , kControlBevelButtonNormalBevel , behaviour , &info ,
        0 , 0 , 0 , &m_controlHandle ) ;

    wxMacReleaseBitmapButton( &info ) ;

    InstallControlEventHandler( (ControlRef) m_controlHandle, GetwxMacToolBarToolEventHandlerUPP(),
        GetEventTypeCount(eventList), eventList, this,NULL);

    UMAShowControl( m_controlHandle ) ;

    if ( CanBeToggled() && IsToggled() )
        ::SetControl32BitValue( m_controlHandle , 1 ) ;
    else
        ::SetControl32BitValue( m_controlHandle , 0 ) ;

    ControlRef container = (ControlRef) tbar->GetHandle() ;
    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)
{
    if ( !wxToolBarBase::Create( parent , id , pos , size , style ) )
        return FALSE ;

    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::compatibility_iterator 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();
    }

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

        bool isRadio = FALSE;

        if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO )
        {
            if ( !lastWasRadio )
            {
                if (tool->Toggle(true))
                {
                    DoToggleTool(tool, true);
                }
            }
            isRadio = TRUE;
        }
        else
        {
            isRadio = FALSE;
        }
        lastWasRadio = isRadio;

        // 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);
        }
        m_minWidth = maxWidth;
        maxWidth = tw ;
        maxHeight += m_yMargin + kwxMacToolBarTopMargin;
        m_minHeight = m_maxHeight = maxHeight ;
    }
    else
    {
        if ( GetToolsCount() > 0 && m_maxRows == 0 )
        {
            // if not set yet, have one column
            SetRows(GetToolsCount());
        }
        m_minHeight = maxHeight;
        maxHeight = th ;
        maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
        m_minWidth = m_maxWidth = maxWidth ;
    }

    SetSize( maxWidth, maxHeight );
    InvalidateBestSize();

    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::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::compatibility_iterator 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)
{
    ((wxToolBarTool*)t)->DoEnable( enable ) ;
}

void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
{
    wxToolBarTool *tool = (wxToolBarTool *)t;
    if ( tool->IsButton() )
    {
        ::SetControl32BitValue( (ControlRef) 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);
    InvalidateBestSize();

    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::compatibility_iterator 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 ) ;
    }

    InvalidateBestSize();
    return TRUE ;
}

void wxToolBar::OnPaint(wxPaintEvent& event)
{
    wxPaintDC dc(this) ;
#if wxMAC_USE_CORE_GRAPHICS
#else
    wxMacPortSetter helper(&dc) ;
    int w, h ;
    GetSize( &w , &h ) ;

    Rect toolbarrect = { dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) ,
        dc.YLOG2DEVMAC(h) , dc.XLOG2DEVMAC(w) } ;
/*
    if( toolbarrect.left < 0 )
        toolbarrect.left = 0 ;
    if ( toolbarrect.top < 0 )
        toolbarrect.top = 0 ;
*/
    if ( !MacGetTopLevelWindow()->MacGetMetalAppearance() )
    {
        UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
    }
    else
    {
#if TARGET_API_MAC_OSX
#if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
        if ( UMAGetSystemVersion() >= 0x1030 )
        {
            HIRect hiToolbarrect = CGRectMake( dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) ,
            dc.YLOG2DEVREL(h) , dc.XLOG2DEVREL(w) );
            CGContextRef cgContext ;
            Rect bounds ;
            GetPortBounds( (CGrafPtr) dc.m_macPort , &bounds ) ;
            QDBeginCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
            CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ;
            CGContextScaleCTM( cgContext , 1 , -1 ) ;

            {
                HIThemeBackgroundDrawInfo drawInfo ;
                drawInfo.version = 0 ;
                drawInfo.state = kThemeStateActive ;
                drawInfo.kind = kThemeBackgroundMetal ;
                HIThemeApplyBackground( &hiToolbarrect, &drawInfo , cgContext,kHIThemeOrientationNormal) ;
            }
            QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
        }
        else
#endif
        {
            UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
        }
#endif
    }
#endif

    event.Skip() ;
}

#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	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	13	#pragma implementation "toolbar.h"
	14	#endif
	15
	16	#include "wx/wxprec.h"
	17
	18	#if wxUSE_TOOLBAR
	19
	20	#include "wx/wx.h"
	21	#include "wx/toolbar.h"
	22	#include "wx/notebook.h"
	23	#include "wx/tabctrl.h"
	24	#include "wx/bitmap.h"
	25
	26	#if !USE_SHARED_LIBRARY
	27	IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
	28
	29	BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
	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	WXWidget GetControlHandle() { return (WXWidget) m_controlHandle ; }
	66	void SetControlHandle( ControlRef handle ) { m_controlHandle = handle ; }
	67
	68	void SetSize(const wxSize& size) ;
	69	void SetPosition( const wxPoint& position ) ;
	70
	71	wxSize GetSize() const
	72	{
	73	if ( IsControl() )
	74	{
	75	return GetControl()->GetSize() ;
	76	}
	77	else if ( IsButton() )
	78	{
	79	return GetToolBar()->GetToolSize() ;
	80	}
	81	else
	82	{
	83	wxSize sz = GetToolBar()->GetToolSize() ;
	84	sz.x /= 4 ;
	85	sz.y /= 4 ;
	86	return sz ;
	87	}
	88	}
	89	wxPoint GetPosition() const
	90	{
	91	return wxPoint(m_x, m_y);
	92	}
	93	bool DoEnable( bool enable ) ;
	94	private :
	95	void Init()
	96	{
	97	m_controlHandle = NULL ;
	98	}
	99	ControlRef m_controlHandle ;
	100
	101	wxCoord m_x;
	102	wxCoord m_y;
	103	};
	104
	105	static const EventTypeSpec eventList[] =
	106	{
	107	{ kEventClassControl , kEventControlHit } ,
	108	} ;
	109
	110	static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
	111	{
	112	OSStatus result = eventNotHandledErr ;
	113
	114	wxMacCarbonEvent cEvent( event ) ;
	115
	116	ControlRef controlRef ;
	117
	118	cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
	119
	120	switch( GetEventKind( event ) )
	121	{
	122	case kEventControlHit :
	123	{
	124	wxToolBarTool* tbartool = (wxToolBarTool*)data ;
	125	if ( tbartool->CanBeToggled() )
	126	{
	127	((wxToolBar*)tbartool->GetToolBar())->ToggleTool(tbartool->GetId(), GetControl32BitValue((ControlRef)tbartool->GetControlHandle()));
	128	}
	129	((wxToolBar*)tbartool->GetToolBar())->OnLeftClick( tbartool->GetId() , tbartool -> IsToggled() ) ;
	130	result = noErr;
	131	}
	132	break ;
	133	default :
	134	break ;
	135	}
	136	return result ;
	137	}
	138
	139	pascal OSStatus wxMacToolBarToolEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
	140	{
	141	OSStatus result = eventNotHandledErr ;
	142
	143	switch ( GetEventClass( event ) )
	144	{
	145	case kEventClassControl :
	146	result = wxMacToolBarToolControlEventHandler( handler, event, data ) ;
	147	break ;
	148	default :
	149	break ;
	150	}
	151	return result ;
	152	}
	153
	154	DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarToolEventHandler )
	155
	156	// ============================================================================
	157	// implementation
	158	// ============================================================================
	159
	160	// ----------------------------------------------------------------------------
	161	// wxToolBarTool
	162	// ----------------------------------------------------------------------------
	163
	164	bool wxToolBarTool::DoEnable(bool enable)
	165	{
	166	if ( IsControl() )
	167	{
	168	GetControl()->Enable( enable ) ;
	169	}
	170	else if ( IsButton() )
	171	{
	172	#if TARGET_API_MAC_OSX
	173	if ( enable )
	174	EnableControl( m_controlHandle ) ;
	175	else
	176	DisableControl( m_controlHandle ) ;
	177	#else
	178	if ( enable )
	179	ActivateControl( m_controlHandle ) ;
	180	else
	181	DeactivateControl( m_controlHandle ) ;
	182	#endif
	183	}
	184	return true ;
	185	}
	186	void wxToolBarTool::SetSize(const wxSize& size)
	187	{
	188	if ( IsControl() )
	189	{
	190	GetControl()->SetSize( size ) ;
	191	}
	192	}
	193
	194	void wxToolBarTool::SetPosition(const wxPoint& position)
	195	{
	196	m_x = position.x;
	197	m_y = position.y;
	198
	199	if ( IsButton() )
	200	{
	201	int x , y ;
	202	x = y = 0 ;
	203	int mac_x = position.x ;
	204	int mac_y = position.y ;
	205	#if !TARGET_API_MAC_OSX
	206	WindowRef rootwindow = (WindowRef) GetToolBar()->MacGetTopLevelWindowRef() ;
	207	GetToolBar()->MacWindowToRootWindow( &x , &y ) ;
	208	mac_x += x;
	209	mac_y += y;
	210	#endif
	211	Rect contrlRect ;
	212	GetControlBounds( m_controlHandle , &contrlRect ) ;
	213	int former_mac_x = contrlRect.left ;
	214	int former_mac_y = contrlRect.top ;
	215	GetToolBar()->GetToolSize() ;
	216
	217	if ( mac_x != former_mac_x \|\| mac_y != former_mac_y )
	218	{
	219	UMAMoveControl( m_controlHandle , mac_x , mac_y ) ;
	220	}
	221	}
	222	else if ( IsControl() )
	223	{
	224	GetControl()->Move( position ) ;
	225	}
	226	}
	227
	228	const short kwxMacToolBarToolDefaultWidth = 24 ;
	229	const short kwxMacToolBarToolDefaultHeight = 22 ;
	230	const short kwxMacToolBarTopMargin = 2 ;
	231	const short kwxMacToolBarLeftMargin = 2 ;
	232
	233	wxToolBarTool::wxToolBarTool(wxToolBar *tbar,
	234	int id,
	235	const wxString& label,
	236	const wxBitmap& bmpNormal,
	237	const wxBitmap& bmpDisabled,
	238	wxItemKind kind,
	239	wxObject *clientData,
	240	const wxString& shortHelp,
	241	const wxString& longHelp)
	242	: wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
	243	clientData, shortHelp, longHelp)
	244	{
	245	Init();
	246
	247	if (id == wxID_SEPARATOR) return;
	248
	249	WindowRef window = (WindowRef) tbar->MacGetTopLevelWindowRef() ;
	250	wxSize toolSize = tbar->GetToolSize() ;
	251	Rect toolrect = { 0, 0 , toolSize.y , toolSize.x } ;
	252
	253	ControlButtonContentInfo info ;
	254	wxMacCreateBitmapButton( &info , GetNormalBitmap() ) ;
	255
	256	SInt16 behaviour = kControlBehaviorOffsetContents ;
	257	if ( CanBeToggled() )
	258	behaviour += kControlBehaviorToggles ;
	259
	260	CreateBevelButtonControl( window , &toolrect , CFSTR("") , kControlBevelButtonNormalBevel , behaviour , &info ,
	261	0 , 0 , 0 , &m_controlHandle ) ;
	262
	263	wxMacReleaseBitmapButton( &info ) ;
	264
	265	InstallControlEventHandler( (ControlRef) m_controlHandle, GetwxMacToolBarToolEventHandlerUPP(),
	266	GetEventTypeCount(eventList), eventList, this,NULL);
	267
	268	UMAShowControl( m_controlHandle ) ;
	269
	270	if ( CanBeToggled() && IsToggled() )
	271	::SetControl32BitValue( m_controlHandle , 1 ) ;
	272	else
	273	::SetControl32BitValue( m_controlHandle , 0 ) ;
	274
	275	ControlRef container = (ControlRef) tbar->GetHandle() ;
	276	wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
	277	::EmbedControl( m_controlHandle , container ) ;
	278	}
	279
	280
	281	wxToolBarToolBase *wxToolBar::CreateTool(int id,
	282	const wxString& label,
	283	const wxBitmap& bmpNormal,
	284	const wxBitmap& bmpDisabled,
	285	wxItemKind kind,
	286	wxObject *clientData,
	287	const wxString& shortHelp,
	288	const wxString& longHelp)
	289	{
	290	return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
	291	clientData, shortHelp, longHelp);
	292	}
	293
	294	wxToolBarToolBase wxToolBar::CreateTool(wxControl control)
	295	{
	296	return new wxToolBarTool(this, control);
	297	}
	298
	299	void wxToolBar::Init()
	300	{
	301	m_maxWidth = -1;
	302	m_maxHeight = -1;
	303	m_defaultWidth = kwxMacToolBarToolDefaultWidth;
	304	m_defaultHeight = kwxMacToolBarToolDefaultHeight;
	305	}
	306
	307	bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
	308	long style, const wxString& name)
	309	{
	310	if ( !wxToolBarBase::Create( parent , id , pos , size , style ) )
	311	return FALSE ;
	312
	313	return TRUE;
	314	}
	315
	316	wxToolBar::~wxToolBar()
	317	{
	318	// we must refresh the frame size when the toolbar is deleted but the frame
	319	// is not - otherwise toolbar leaves a hole in the place it used to occupy
	320	}
	321
	322	bool wxToolBar::Realize()
	323	{
	324	if (m_tools.GetCount() == 0)
	325	return FALSE;
	326
	327	int x = m_xMargin + kwxMacToolBarLeftMargin ;
	328	int y = m_yMargin + kwxMacToolBarTopMargin ;
	329
	330	int tw, th;
	331	GetSize(& tw, & th);
	332
	333	int maxWidth = 0 ;
	334	int maxHeight = 0 ;
	335
	336	int maxToolWidth = 0;
	337	int maxToolHeight = 0;
	338
	339	// Find the maximum tool width and height
	340	wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
	341	while ( node )
	342	{
	343	wxToolBarTool tool = (wxToolBarTool )node->GetData();
	344	wxSize sz = tool->GetSize() ;
	345
	346	if ( sz.x > maxToolWidth )
	347	maxToolWidth = sz.x ;
	348	if (sz.y> maxToolHeight)
	349	maxToolHeight = sz.y;
	350
	351	node = node->GetNext();
	352	}
	353
	354	bool lastWasRadio = FALSE;
	355	node = m_tools.GetFirst();
	356	while (node)
	357	{
	358	wxToolBarTool tool = (wxToolBarTool )node->GetData();
	359	wxSize cursize = tool->GetSize() ;
	360
	361	bool isRadio = FALSE;
	362
	363	if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO )
	364	{
	365	if ( !lastWasRadio )
	366	{
	367	if (tool->Toggle(true))
	368	{
	369	DoToggleTool(tool, true);
	370	}
	371	}
	372	isRadio = TRUE;
	373	}
	374	else
	375	{
	376	isRadio = FALSE;
	377	}
	378	lastWasRadio = isRadio;
	379
	380	// for the moment we just do a single row/column alignement
	381	if ( x + cursize.x > maxWidth )
	382	maxWidth = x + cursize.x ;
	383	if ( y + cursize.y > maxHeight )
	384	maxHeight = y + cursize.y ;
	385
	386	tool->SetPosition( wxPoint( x , y ) ) ;
	387
	388	if ( GetWindowStyleFlag() & wxTB_VERTICAL )
	389	{
	390	y += cursize.y ;
	391	}
	392	else
	393	{
	394	x += cursize.x ;
	395	}
	396
	397	node = node->GetNext();
	398	}
	399
	400	if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
	401	{
	402	if ( m_maxRows == 0 )
	403	{
	404	// if not set yet, only one row
	405	SetRows(1);
	406	}
	407	m_minWidth = maxWidth;
	408	maxWidth = tw ;
	409	maxHeight += m_yMargin + kwxMacToolBarTopMargin;
	410	m_minHeight = m_maxHeight = maxHeight ;
	411	}
	412	else
	413	{
	414	if ( GetToolsCount() > 0 && m_maxRows == 0 )
	415	{
	416	// if not set yet, have one column
	417	SetRows(GetToolsCount());
	418	}
	419	m_minHeight = maxHeight;
	420	maxHeight = th ;
	421	maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
	422	m_minWidth = m_maxWidth = maxWidth ;
	423	}
	424
	425	SetSize( maxWidth, maxHeight );
	426	InvalidateBestSize();
	427
	428	return TRUE;
	429	}
	430
	431	void wxToolBar::SetToolBitmapSize(const wxSize& size)
	432	{
	433	m_defaultWidth = size.x+4; m_defaultHeight = size.y+4;
	434	}
	435
	436	// The button size is bigger than the bitmap size
	437	wxSize wxToolBar::GetToolSize() const
	438	{
	439	return wxSize(m_defaultWidth + 4, m_defaultHeight + 4);
	440	}
	441
	442	void wxToolBar::SetRows(int nRows)
	443	{
	444	if ( nRows == m_maxRows )
	445	{
	446	// avoid resizing the frame uselessly
	447	return;
	448	}
	449
	450	m_maxRows = nRows;
	451	}
	452
	453	void wxToolBar::MacSuperChangedPosition()
	454	{
	455	wxWindow::MacSuperChangedPosition() ;
	456	Realize() ;
	457	}
	458
	459	wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
	460	{
	461	wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
	462	while (node)
	463	{
	464	wxToolBarTool tool = (wxToolBarTool )node->GetData() ;
	465	wxRect2DInt r( tool->GetPosition() , tool->GetSize() ) ;
	466	if ( r.Contains( wxPoint( x , y ) ) )
	467	{
	468	return tool;
	469	}
	470
	471	node = node->GetNext();
	472	}
	473
	474	return (wxToolBarToolBase *)NULL;
	475	}
	476
	477	wxString wxToolBar::MacGetToolTipString( wxPoint &pt )
	478	{
	479	wxToolBarToolBase* tool = FindToolForPosition( pt.x , pt.y ) ;
	480	if ( tool )
	481	{
	482	return tool->GetShortHelp() ;
	483	}
	484	return wxEmptyString ;
	485	}
	486
	487	void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
	488	{
	489	((wxToolBarTool*)t)->DoEnable( enable ) ;
	490	}
	491
	492	void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
	493	{
	494	wxToolBarTool tool = (wxToolBarTool )t;
	495	if ( tool->IsButton() )
	496	{
	497	::SetControl32BitValue( (ControlRef) tool->GetControlHandle() , toggle ) ;
	498	}
	499	}
	500
	501	bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
	502	wxToolBarToolBase *tool)
	503	{
	504	// nothing special to do here - we relayout in Realize() later
	505	tool->Attach(this);
	506	InvalidateBestSize();
	507
	508	return TRUE;
	509	}
	510
	511	void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
	512	{
	513	wxFAIL_MSG( _T("not implemented") );
	514	}
	515
	516	bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
	517	{
	518	wxToolBarToolsList::compatibility_iterator node;
	519	for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
	520	{
	521	wxToolBarToolBase *tool2 = node->GetData();
	522	if ( tool2 == tool )
	523	{
	524	// let node point to the next node in the list
	525	node = node->GetNext();
	526
	527	break;
	528	}
	529	}
	530
	531	wxSize sz = ((wxToolBarTool*)tool)->GetSize() ;
	532
	533	tool->Detach();
	534
	535	// and finally reposition all the controls after this one
	536
	537	for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
	538	{
	539	wxToolBarTool tool2 = (wxToolBarTool) node->GetData();
	540	wxPoint pt = tool2->GetPosition() ;
	541
	542	if ( GetWindowStyleFlag() & wxTB_VERTICAL )
	543	{
	544	pt.y -= sz.y ;
	545	}
	546	else
	547	{
	548	pt.x -= sz.x ;
	549	}
	550	tool2->SetPosition( pt ) ;
	551	}
	552
	553	InvalidateBestSize();
	554	return TRUE ;
	555	}
	556
	557	void wxToolBar::OnPaint(wxPaintEvent& event)
	558	{
	559	wxPaintDC dc(this) ;
	560	#if wxMAC_USE_CORE_GRAPHICS
	561	#else
	562	wxMacPortSetter helper(&dc) ;
	563	int w, h ;
	564	GetSize( &w , &h ) ;
	565
	566	Rect toolbarrect = { dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) ,
	567	dc.YLOG2DEVMAC(h) , dc.XLOG2DEVMAC(w) } ;
	568	/*
	569	if( toolbarrect.left < 0 )
	570	toolbarrect.left = 0 ;
	571	if ( toolbarrect.top < 0 )
	572	toolbarrect.top = 0 ;
	573	*/
	574	if ( !MacGetTopLevelWindow()->MacGetMetalAppearance() )
	575	{
	576	UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
	577	}
	578	else
	579	{
	580	#if TARGET_API_MAC_OSX
	581	#if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
	582	if ( UMAGetSystemVersion() >= 0x1030 )
	583	{
	584	HIRect hiToolbarrect = CGRectMake( dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) ,
	585	dc.YLOG2DEVREL(h) , dc.XLOG2DEVREL(w) );
	586	CGContextRef cgContext ;
	587	Rect bounds ;
	588	GetPortBounds( (CGrafPtr) dc.m_macPort , &bounds ) ;
	589	QDBeginCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
	590	CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ;
	591	CGContextScaleCTM( cgContext , 1 , -1 ) ;
	592
	593	{
	594	HIThemeBackgroundDrawInfo drawInfo ;
	595	drawInfo.version = 0 ;
	596	drawInfo.state = kThemeStateActive ;
	597	drawInfo.kind = kThemeBackgroundMetal ;
	598	HIThemeApplyBackground( &hiToolbarrect, &drawInfo , cgContext,kHIThemeOrientationNormal) ;
	599	}
	600	QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
	601	}
	602	else
	603	#endif
	604	{
	605	UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
	606	}
	607	#endif
	608	}
	609	#endif
	610
	611	event.Skip() ;
	612	}
	613
	614	#endif // wxUSE_TOOLBAR
	615