[wxWidgets.git] / src / mac / classic / 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
/////////////////////////////////////////////////////////////////////////////

#include "wx/wx.h"

#if wxUSE_TOOLBAR

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

IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)

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

#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();
    
    if (id == wxID_SEPARATOR) return;
    
    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);
    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::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( (WXWidget) 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);
    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::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 ) ;
    }
    
    InvalidateBestSize();
    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( (WXWidget) control , controlpart , false /* not down anymore */ ) ;
                    }
                }
            }
        }
    }
}

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