[wxWidgets.git] / src / mac / toolbar.cpp

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

#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"

// ----------------------------------------------------------------------------
// 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)
        : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
                            clientData, shortHelp, longHelp)
    {
        m_nSepCount = 0;
        m_index = -1 ;
    }

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

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

    int     m_index ;
private:
    size_t m_nSepCount;
};


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

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

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


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.Number() == 0)
        return FALSE;

    Point localOrigin ;
    //    Rect clipRect ;
    WindowRef window = (WindowRef) MacGetRootWindow() ;
    //    wxWindow *win ;
    
    int lx , ly ;
    lx = ly = 0 ;
    MacWindowToRootWindow( &lx , &ly ) ;
    localOrigin.v = ly ;
    localOrigin.h = lx ;
    
//    GetParent()->MacGetPortParams( &localOrigin , &clipRect , &window , &win ) ;

    Rect toolbarrect = { localOrigin.v ,localOrigin.h , 
        m_height + localOrigin.v  , m_width + localOrigin.h} ;
    ControlFontStyleRec                controlstyle ;

    controlstyle.flags = kControlUseFontMask ;
    controlstyle.font = kControlFontSmallSystemFont ;
    
    wxNode *node = m_tools.First();
    int noButtons = 0;
    int x = 0 ;
    int y = 0 ;
    wxSize toolSize = GetToolSize() ;
    int tw, th;
    GetSize(& tw, & th);
    
    int maxWidth = 0 ;
    int maxHeight = 0 ;
    
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
        wxBitmapRefData * bmap = (wxBitmapRefData*) ( tool->GetNormalBitmap().GetRefData()) ;
        
        if(  !tool->IsSeparator()  )
        {
            Rect toolrect = { toolbarrect.top + y + m_yMargin + kwxMacToolBarTopMargin,
                              toolbarrect.left + x + m_xMargin + kwxMacToolBarLeftMargin , 0 , 0 } ;
            toolrect.right = toolrect.left + toolSize.x ;
            toolrect.bottom = toolrect.top + toolSize.y ;
            
            ControlButtonContentInfo info ;
            wxMacCreateBitmapButton( &info , tool->GetNormalBitmap() ) ;
            ControlHandle m_macToolHandle ;
            
            SInt16 behaviour = kControlBehaviorOffsetContents ;
            if ( tool->CanBeToggled() )
                behaviour += kControlBehaviorToggles ;
            
            if ( info.contentType != kControlNoContent ) 
            {
                m_macToolHandle = ::NewControl( window , &toolrect , "\p" , false , 0 , 
                                                behaviour + info.contentType , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
                
                ::SetControlData( m_macToolHandle , kControlButtonPart , kControlBevelButtonContentTag , sizeof(info) , (char*) &info ) ;
            }
            else
            {
                m_macToolHandle = ::NewControl( window , &toolrect , "\p" , false , 0 , 
                                                behaviour  , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ;
            }
            UMAShowControl( m_macToolHandle ) ;
            m_macToolHandles.Add( m_macToolHandle ) ;
            tool->m_index = m_macToolHandles.Count() -1 ;
            if ( !tool->IsEnabled() )
            {
                UMADeactivateControl( m_macToolHandle ) ;
            }
            if ( tool->CanBeToggled() && tool->IsToggled() )
            {
                ::SetControlValue( m_macToolHandle , 1 ) ;
            }
            else
            {
                ::SetControlValue( m_macToolHandle , 0 ) ;
            }
            /*
              ::SetControlFontStyle( m_macToolHandle , &controlstyle ) ;
            */
            ControlHandle container = (ControlHandle) GetParent()->MacGetContainerForEmbedding() ;
            wxASSERT_MSG( container != NULL , "No valid mac container control" ) ;
            ::EmbedControl( m_macToolHandle , container ) ;
            
            if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
            {
                x += (int)toolSize.x;
            }
            else
            {
                y += (int)toolSize.y;
            }
            noButtons ++;
        }
        else
        {
            m_macToolHandles.Add( NULL ) ;
            if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
            {
                x += (int)toolSize.x / 4;
            }
            else
            {
                y += (int)toolSize.y / 4;
            }
        }
        if ( toolbarrect.left + x + m_xMargin + kwxMacToolBarLeftMargin - m_x - localOrigin.h > maxWidth) {
            maxWidth = toolbarrect.left + x + m_xMargin + kwxMacToolBarLeftMargin - m_x - localOrigin.h;
        }
        if (toolbarrect.top + y + m_yMargin + kwxMacToolBarTopMargin - m_y - localOrigin.v > maxHeight) {
            maxHeight = toolbarrect.top + y + m_yMargin + kwxMacToolBarTopMargin - m_y - localOrigin.v ;
        }
        node = node->Next();
    }
    
    if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
    {
        if ( m_maxRows == 0 )
        {
            // if not set yet, only one row
            SetRows(1);
        }
        maxWidth = tw ; 
        maxHeight += toolSize.y;
        maxHeight += m_yMargin + kwxMacToolBarTopMargin;
        m_maxHeight = maxHeight ;
    }
    else
    {
        if ( noButtons > 0 && m_maxRows == 0 )
        {
            // if not set yet, have one column
            SetRows(noButtons);
        }
        maxHeight = th ;
        maxWidth += toolSize.x;
        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 ) 
{
    int index = 0 ;
    for ( index = 0 ; index < m_macToolHandles.Count() ; ++index )
    {
        if ( m_macToolHandles[index] == (void*) control )
        {
            wxToolBarTool *tool = (wxToolBarTool *)m_tools.Nth( index )->Data();
            if ( tool->CanBeToggled() )
            {
                tool->Toggle( GetControlValue( (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() 
{
  if (m_tools.Number() > 0)
  {

    Point localOrigin ;
    //    Rect clipRect ;
    //    WindowRef window ;
    //    wxWindow *win ;
    int lx , ly ;
    lx = ly = 0 ;
    MacWindowToRootWindow( &lx , &ly ) ;
    localOrigin.v = ly ;
    localOrigin.h = lx ;
    
//    GetParent()->MacGetPortParams( &localOrigin , &clipRect , &window , &win ) ;

    Rect toolbarrect = { localOrigin.v ,localOrigin.h , 
        m_height + localOrigin.v  , m_width + localOrigin.h} ;
    ControlFontStyleRec     controlstyle ;

    controlstyle.flags = kControlUseFontMask ;
    controlstyle.font = kControlFontSmallSystemFont ;
    
    wxNode *node = m_tools.First();
    int noButtons = 0;
    int x = 0 ;
    wxSize toolSize = GetToolSize() ;
    int tw, th;
    GetSize(& tw, & th);
    
    int maxWidth = 0 ;
    int maxHeight = 0 ;
    int toolcount = 0 ;
    {
      WindowRef rootwindow = (WindowRef) MacGetRootWindow() ;
    	while (node)
    	{
    		wxToolBarTool *tool = (wxToolBarTool *)node->Data();
    		wxBitmapRefData * bmap = (wxBitmapRefData*) ( tool->GetNormalBitmap().GetRefData()) ;
    		
    		if(  !tool->IsSeparator()  )
    		{
    			Rect toolrect = { toolbarrect.top + m_yMargin + kwxMacToolBarTopMargin, toolbarrect.left + x + m_xMargin + kwxMacToolBarLeftMargin , 0 , 0 } ;
    			toolrect.right = toolrect.left + toolSize.x ;
    			toolrect.bottom = toolrect.top + toolSize.y ;
    						
    			ControlHandle m_macToolHandle = (ControlHandle) m_macToolHandles[toolcount++] ;
    			
            	{
            		Rect contrlRect ;		
            		GetControlBounds( m_macToolHandle , &contrlRect ) ; 
            		int former_mac_x = contrlRect.left ;
            		int former_mac_y = contrlRect.top ;
            		int mac_x = toolrect.left ;
            		int mac_y = toolrect.top ;
             		        	
            		if ( mac_x != former_mac_x || mac_y != former_mac_y )
            		{
            			{
            				Rect inval = { former_mac_y , former_mac_x , former_mac_y + toolSize.y , former_mac_x + toolSize.y } ;
            				InvalWindowRect( rootwindow , &inval ) ;
            			}
            	  		UMAMoveControl( m_macToolHandle , mac_x , mac_y ) ;
            			{
            				Rect inval = { mac_y , mac_x , mac_y + toolSize.y , mac_x + toolSize.y } ;
            				InvalWindowRect( rootwindow , &inval ) ;
            			}
            		}
            	}
    			
    			x += (int)toolSize.x;
    			noButtons ++;
    		}
    		else
    		{
                toolcount++ ;
                x += (int)toolSize.x / 4;
            }
            if ( toolbarrect.left + x + m_xMargin  + kwxMacToolBarLeftMargin- m_x - localOrigin.h > maxWidth)
                maxWidth = toolbarrect.left + x  + kwxMacToolBarLeftMargin+ m_xMargin - m_x - localOrigin.h;
            if (toolbarrect.top + m_yMargin  + kwxMacToolBarTopMargin - m_y - localOrigin.v > maxHeight)
                maxHeight = toolbarrect.top  + kwxMacToolBarTopMargin + m_yMargin - m_y - localOrigin.v ;

            node = node->Next();
        }
    }

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

     SetSize(maxWidth, maxHeight);
    }

    wxWindow::MacSuperChangedPosition() ;
}

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

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

    return (wxToolBarToolBase *)NULL;
}

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

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

    wxToolBarTool *tool = (wxToolBarTool *)t;
    if ( tool->m_index < 0 )
        return ;
           
    ControlHandle control = (ControlHandle) m_macToolHandles[ tool->m_index ] ;

    if ( enable )
        UMAActivateControl( control ) ;
    else
        UMADeactivateControl( control ) ;
}

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

    wxToolBarTool *tool = (wxToolBarTool *)t;
    if ( tool->m_index < 0 )
        return ;
        
    ControlHandle control = (ControlHandle) m_macToolHandles[ tool->m_index ] ;
        ::SetControlValue( control , toggle ) ;
}

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

    return TRUE;
}

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

bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
{
        return TRUE ;
}

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) ;
	{
		int index = 0 ;
		for ( index = 0 ; index < m_macToolHandles.Count() ; ++index )
		{
			if ( m_macToolHandles[index] )
			{
				UMADrawControl( (ControlHandle) m_macToolHandles[index] ) ;
			}
		}
	}
}

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 ;
		GrafPtr		port ;
		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 ) )
			{
				{
					if ( controlpart == kControlIndicatorPart && !UMAHasAppearance() )
						controlpart = ::HandleControlClick( control , localwhere , modifiers , (ControlActionUPP) NULL ) ;
					else
						controlpart = ::HandleControlClick( control , localwhere , modifiers , (ControlActionUPP) -1 ) ;
					wxTheApp->s_lastMouseDown = 0 ;
					if ( controlpart && ! ( ( UMAHasAppearance() || (controlpart != kControlIndicatorPart) ) 
						&& (IsKindOf( CLASSINFO( wxScrollBar ) ) ) ) ) // otherwise we will get the event twice
					{
						MacHandleControlClick( control , controlpart ) ;
					}
				}
			}
		}
	}
}

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