X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/37e2cb08cd1910ec5a14b38f0addfc6e2e8e172e..b905d6cc083a38d46ae48712f5221236247a39ce:/src/mac/carbon/toolbar.cpp diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp index 26f3a748cb..cdefd9ccbb 100644 --- a/src/mac/carbon/toolbar.cpp +++ b/src/mac/carbon/toolbar.cpp @@ -1,30 +1,54 @@ ///////////////////////////////////////////////////////////////////////////// // Name: toolbar.cpp // Purpose: wxToolBar -// Author: AUTHOR +// Author: Stefan Csomor // Modified by: // Created: 04/01/98 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR -// Licence: wxWindows licence +// Copyright: (c) Stefan Csomor +// Licence: The wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "toolbar.h" #endif -#include "wx/wx.h" +#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" -IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase) +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl) BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase) + EVT_PAINT( wxToolBar::OnPaint ) END_EVENT_TABLE() +#endif -#include +#include "wx/mac/uma.h" +#include "wx/geometry.h" + +#ifdef __WXMAC_OSX__ +const short kwxMacToolBarToolDefaultWidth = 24 ; +const short kwxMacToolBarToolDefaultHeight = 24 ; +const short kwxMacToolBarTopMargin = 4 ; +const short kwxMacToolBarLeftMargin = 4 ; +const short kwxMacToolBorder = 0 ; +const short kwxMacToolSpacing = 6 ; +#else +const short kwxMacToolBarToolDefaultWidth = 24 ; +const short kwxMacToolBarToolDefaultHeight = 22 ; +const short kwxMacToolBarTopMargin = 2 ; +const short kwxMacToolBarLeftMargin = 2 ; +const short kwxMacToolBorder = 4 ; +const short kwxMacToolSpacing = 0 ; +#endif // ---------------------------------------------------------------------------- // private classes @@ -35,36 +59,143 @@ class wxToolBarTool : public wxToolBarToolBase public: wxToolBarTool(wxToolBar *tbar, int id, - const wxBitmap& bitmap1, - const wxBitmap& bitmap2, - bool toggle, + const wxString& label, + const wxBitmap& bmpNormal, + const wxBitmap& bmpDisabled, + wxItemKind kind, wxObject *clientData, - const wxString& shortHelpString, - const wxString& longHelpString) - : wxToolBarToolBase(tbar, id, bitmap1, bitmap2, toggle, - clientData, shortHelpString, longHelpString) + const wxString& shortHelp, + const wxString& longHelp) ; + + wxToolBarTool(wxToolBar *tbar, wxControl *control) + : wxToolBarToolBase(tbar, control) + { + Init() ; + } + + ~wxToolBarTool() { - m_nSepCount = 0; - m_index = 0 ; + 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 + { + // separator size + wxSize sz = GetToolBar()->GetToolSize() ; + if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL ) + sz.y /= 4 ; + else + sz.x /= 4 ; + return sz ; + } + } + wxPoint GetPosition() const + { + return wxPoint(m_x, m_y); + } + bool DoEnable( bool enable ) ; + + void UpdateToggleImage( bool toggle ) ; +private : + void Init() + { + m_controlHandle = NULL ; + } + ControlRef m_controlHandle ; - wxToolBarTool(wxToolBar *tbar, wxControl *control) - : wxToolBarToolBase(tbar, control) + wxCoord m_x; + wxCoord m_y; +}; + +static const EventTypeSpec eventList[] = +{ + { kEventClassControl , kEventControlHit } , +#ifdef __WXMAC_OSX__ + { kEventClassControl , kEventControlHitTest } , +#endif +} ; + +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 ) ) { - m_nSepCount = 1; - m_index = 0 ; + case kEventControlHit : + { + wxToolBarTool* tbartool = (wxToolBarTool*)data ; + if ( tbartool->CanBeToggled() ) + { +#ifdef __WXMAC_OSX__ + ((wxToolBar*)tbartool->GetToolBar())->ToggleTool(tbartool->GetId(), !tbartool->IsToggled() ); +#else + ((wxToolBar*)tbartool->GetToolBar())->ToggleTool(tbartool->GetId(), GetControl32BitValue((ControlRef)tbartool->GetControlHandle())); +#endif + } + ((wxToolBar*)tbartool->GetToolBar())->OnLeftClick( tbartool->GetId() , tbartool -> IsToggled() ) ; + result = noErr; + } + break ; +#ifdef __WXMAC_OSX__ + case kEventControlHitTest : + { + HIPoint pt = cEvent.GetParameter(kEventParamMouseLocation) ; + HIRect rect ; + HIViewGetBounds( controlRef , &rect ) ; + + ControlPartCode pc = kControlNoPart ; + if ( CGRectContainsPoint( rect , pt ) ) + pc = kControlButtonPart ; + cEvent.SetParameter( kEventParamControlPart , typeControlPartCode, pc ) ; + result = noErr ; + } + break ; +#endif + default : + break ; } + return result ; +} - // 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; } +pascal OSStatus wxMacToolBarToolEventHandler( EventHandlerCallRef handler , EventRef event , void *data ) +{ + OSStatus result = eventNotHandledErr ; - int m_index ; -private: - size_t m_nSepCount; -}; + switch ( GetEventClass( event ) ) + { + case kEventClassControl : + result = wxMacToolBarToolControlEventHandler( handler, event, data ) ; + break ; + default : + break ; + } + return result ; +} +DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarToolEventHandler ) // ============================================================================ // implementation @@ -74,252 +205,376 @@ private: // wxToolBarTool // ---------------------------------------------------------------------------- -wxToolBarToolBase *wxToolBar::CreateTool(int id, - const wxBitmap& bitmap1, - const wxBitmap& bitmap2, - bool toggle, - wxObject *clientData, - const wxString& shortHelpString, - const wxString& longHelpString) +bool wxToolBarTool::DoEnable(bool enable) { - return new wxToolBarTool(this, id, bitmap1, bitmap2, toggle, - clientData, shortHelpString, longHelpString); + 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 ; } - -wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control) +void wxToolBarTool::SetSize(const wxSize& size) { - return new wxToolBarTool(this, control); + if ( IsControl() ) + { + GetControl()->SetSize( size ) ; + } } -// ---------------------------------------------------------------------------- -// wxToolBar construction -// ---------------------------------------------------------------------------- +void wxToolBarTool::SetPosition(const wxPoint& position) +{ + m_x = position.x; + m_y = position.y; -void wxToolBar::Init() + if ( IsButton() ) + { + int x , y ; + x = y = 0 ; + int mac_x = position.x ; + int mac_y = position.y ; +#ifdef __WXMAC_OSX__ + // already correctly set up +#else + 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 ) ; + } + else + { + // separator +#ifdef __WXMAC_OSX__ + int x , y ; + x = y = 0 ; + int mac_x = position.x ; + int mac_y = position.y ; + + Rect contrlRect ; + GetControlBounds( m_controlHandle , &contrlRect ) ; + int former_mac_x = contrlRect.left ; + int former_mac_y = contrlRect.top ; + + if ( mac_x != former_mac_x || mac_y != former_mac_y ) + { + UMAMoveControl( m_controlHandle , mac_x , mac_y ) ; + } +#endif + } +} + +void wxToolBarTool::UpdateToggleImage( bool toggle ) { - m_maxWidth = -1; - m_maxHeight = -1; - m_defaultWidth = 24; - m_defaultHeight = 22; - // TODO +#ifdef __WXMAC_OSX__ + if ( toggle ) + { + int w = m_bmpNormal.GetWidth() ; + int h = m_bmpNormal.GetHeight() ; + wxBitmap bmp( w , h ) ; + wxMemoryDC dc ; + dc.SelectObject( bmp ) ; + dc.SetPen( wxNullPen ) ; + dc.SetBackground( *wxWHITE ) ; + dc.DrawRectangle( 0 , 0 , w , h ) ; + dc.DrawBitmap( m_bmpNormal , 0 , 0 , true) ; + dc.SelectObject( wxNullBitmap ) ; + ControlButtonContentInfo info ; + wxMacCreateBitmapButton( &info , bmp ) ; + SetControlData( m_controlHandle , 0, kControlIconContentTag, sizeof( info ), + (Ptr)&info ); + wxMacReleaseBitmapButton( &info ) ; + } + else + { + ControlButtonContentInfo info ; + wxMacCreateBitmapButton( &info , m_bmpNormal ) ; + SetControlData( m_controlHandle , 0, kControlIconContentTag, sizeof( info ), + (Ptr)&info ); + wxMacReleaseBitmapButton( &info ) ; + } + + IconTransformType transform = toggle ? kTransformSelected : kTransformNone ; + SetControlData( m_controlHandle, 0, kControlIconTransformTag, sizeof( transform ), + (Ptr)&transform ); + HIViewSetNeedsDisplay( m_controlHandle , true ) ; + +#else + ::SetControl32BitValue( m_controlHandle , toggle ) ; +#endif } -bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, - long style, const wxString& name) +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) { - m_maxWidth = m_maxHeight = 0; - - m_defaultWidth = 24; - m_defaultHeight = 22; - - int x = pos.x; - int y = pos.y; - int width = size.x; - int height = size.y; - - if (width <= 0) - width = 100; - if (height <= 0) - height = 30; - if (x < 0) - x = 0; - if (y < 0) - y = 0; - - Rect bounds ; - Str255 title ; - - MacPreControlCreate( parent , id , "" , wxPoint( x , y ) , wxSize( width , height ) ,style, *((wxValidator*)NULL) , name , &bounds , title ) ; - - m_macControl = UMANewControl( parent->GetMacRootWindow() , &bounds , "\p" , true , 0 , 0 , 1, - kControlPlacardProc , (long) this ) ; - MacPostControlCreate() ; - - return TRUE; + Init(); + + WindowRef window = (WindowRef) tbar->MacGetTopLevelWindowRef() ; + wxSize toolSize = tbar->GetToolSize() ; + Rect toolrect = { 0, 0 , toolSize.y , toolSize.x } ; + + if ( id == wxID_SEPARATOR ) + { + toolSize.x /= 4 ; + toolSize.y /= 4 ; + if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL ) + { + toolrect.bottom = toolSize.y ; + } + else + { + toolrect.right = toolSize.x ; + } +#ifdef __WXMAC_OSX__ + // in flat style we need a visual separator + CreateSeparatorControl( window , &toolrect , &m_controlHandle ) ; +#endif + } + else + { + ControlButtonContentInfo info ; + wxMacCreateBitmapButton( &info , GetNormalBitmap() ) ; + +#ifdef __WXMAC_OSX__ + CreateIconControl( window , &toolrect , &info , false , &m_controlHandle ) ; +#else + SInt16 behaviour = kControlBehaviorOffsetContents ; + if ( CanBeToggled() ) + behaviour += kControlBehaviorToggles ; + CreateBevelButtonControl( window , &toolrect , CFSTR("") , kControlBevelButtonNormalBevel , behaviour , &info , + 0 , 0 , 0 , &m_controlHandle ) ; +#endif + + wxMacReleaseBitmapButton( &info ) ; + /* + SetBevelButtonTextPlacement( m_controlHandle , kControlBevelButtonPlaceBelowGraphic ) ; + UMASetControlTitle( m_controlHandle , label , wxFont::GetDefaultEncoding() ) ; + */ + + InstallControlEventHandler( (ControlRef) m_controlHandle, GetwxMacToolBarToolEventHandlerUPP(), + GetEventTypeCount(eventList), eventList, this,NULL); + + } + ControlRef container = (ControlRef) tbar->GetHandle() ; + wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ; + if ( m_controlHandle ) + { + UMAShowControl( m_controlHandle ) ; + ::EmbedControl( m_controlHandle , container ) ; + } + if ( CanBeToggled() && IsToggled() ) + { + UpdateToggleImage( true ) ; + } } -wxToolBar::~wxToolBar() + +wxToolBarToolBase *wxToolBar::CreateTool(int id, + const wxString& label, + const wxBitmap& bmpNormal, + const wxBitmap& bmpDisabled, + wxItemKind kind, + wxObject *clientData, + const wxString& shortHelp, + const wxString& longHelp) { - // TODO + return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind, + clientData, shortHelp, longHelp); } -PicHandle MakePict(GWorldPtr wp) +wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control) { - CGrafPtr origPort ; - GDHandle origDev ; - - PicHandle pict; // this is the Picture we give back - - RGBColor gray = { 0xCCCC ,0xCCCC , 0xCCCC } ; - - GetGWorld( &origPort , &origDev ) ; - SetGWorld( wp , NULL ) ; - - pict = OpenPicture(&wp->portRect); // open a picture, this disables drawing - if(!pict) - return NULL; - - RGBBackColor( &gray ) ; - EraseRect(&wp->portRect) ; - CopyBits((BitMap*)*wp->portPixMap, // src PixMap - we copy image over itself - - (BitMap*)*wp->portPixMap, // dst PixMap - no drawing occurs - - &wp->portRect, // srcRect - it will be recorded and compressed - - &wp->portRect, // dstRect - into the picture that is open - - srcCopy,NULL); // copyMode and no clip region - - ClosePicture(); // We are done recording the picture - SetGWorld( origPort , origDev ) ; - return pict; // return our groovy pict handle + return new wxToolBarTool(this, control); } -PicHandle MakePictWhite(GWorldPtr wp) +void wxToolBar::Init() { - CGrafPtr origPort ; - GDHandle origDev ; - - PicHandle pict; // this is the Picture we give back - - RGBColor white = { 0xFFFF ,0xFFFF , 0xFFFF } ; - - GetGWorld( &origPort , &origDev ) ; - SetGWorld( wp , NULL ) ; - - pict = OpenPicture(&wp->portRect); // open a picture, this disables drawing - if(!pict) - return NULL; - - RGBBackColor( &white ) ; - EraseRect(&wp->portRect) ; - CopyBits((BitMap*)*wp->portPixMap, // src PixMap - we copy image over itself - - (BitMap*)*wp->portPixMap, // dst PixMap - no drawing occurs - - &wp->portRect, // srcRect - it will be recorded and compressed - - &wp->portRect, // dstRect - into the picture that is open - - srcCopy,NULL); // copyMode and no clip region - - ClosePicture(); // We are done recording the picture - SetGWorld( origPort , origDev ) ; - return pict; // return our groovy pict handle + m_maxWidth = -1; + m_maxHeight = -1; + m_defaultWidth = kwxMacToolBarToolDefaultWidth; + m_defaultHeight = kwxMacToolBarToolDefaultHeight; } -const short kwxMacToolBarTopMargin = 2 ; -const short kwxMacToolBarLeftMargin = 2 ; +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.Number() == 0) - return FALSE; - - Rect toolbarrect = { m_y , m_x , m_y + m_height , m_x + m_width } ; - ControlFontStyleRec controlstyle ; - WindowPtr window = GetMacRootWindow() ; - controlstyle.flags = kControlUseFontMask ; - controlstyle.font = kControlFontSmallSystemFont ; - - wxNode *node = m_tools.First(); - int noButtons = 0; - int x = 0 ; - wxSize toolSize = GetToolSize() ; + if (m_tools.GetCount() == 0) + return FALSE; + + int x = m_xMargin + kwxMacToolBarLeftMargin ; + int y = m_yMargin + kwxMacToolBarTopMargin ; + int tw, th; GetSize(& tw, & th); - while (node) - { - wxToolBarTool *tool = (wxToolBarTool *)node->Data(); - wxBitmapRefData * bmap = (wxBitmapRefData*) ( tool->GetBitmap1().GetRefData()) ; - - if( !tool->IsSeparator() ) - { - Rect toolrect = { toolbarrect.top + kwxMacToolBarTopMargin , toolbarrect.left + x + kwxMacToolBarLeftMargin , 0 , 0 } ; - toolrect.right = toolrect.left + toolSize.x ; - toolrect.bottom = toolrect.top + toolSize.y ; - - PicHandle icon = NULL ; - if ( bmap ) - { - if ( bmap->m_bitmapType == kMacBitmapTypePict ) - icon = bmap->m_hPict ; - else if ( bmap->m_bitmapType == kMacBitmapTypeGrafWorld ) - { - icon = MakePict( bmap->m_hBitmap ) ; - } - } - - ControlHandle m_macToolHandle ; - - if ( icon ) - { - m_macToolHandle = UMANewControl( window , &toolrect , "\p" , true , 0 , - kControlBehaviorOffsetContents + kControlContentPictHandle , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ; - ControlButtonContentInfo info ; - - info.contentType = kControlContentPictHandle ; - info.u.picture = icon ; - - UMASetControlData( m_macToolHandle , kControlButtonPart , kControlBevelButtonContentTag , sizeof(info) , (char*) &info ) ; - } - else - { - m_macToolHandle = UMANewControl( window , &toolrect , "\p" , true , 0 , - kControlBehaviorOffsetContents , 0 , kControlBevelButtonNormalBevelProc , (long) this ) ; - } - m_macToolHandles.Add( m_macToolHandle ) ; - UMASetControlFontStyle( m_macToolHandle , &controlstyle ) ; - UMAEmbedControl( m_macToolHandle , m_macControl ) ; - - x += (int)toolSize.x; - noButtons ++; - } - else - { - m_macToolHandles.Add( NULL ) ; - x += (int)toolSize.x / 4; - } - if ( toolbarrect.left + x + kwxMacToolBarLeftMargin > m_maxWidth) - m_maxWidth = toolbarrect.left + x + kwxMacToolBarLeftMargin; - if (toolbarrect.top + kwxMacToolBarTopMargin + toolSize.y > m_maxHeight) - m_maxHeight = toolbarrect.top + kwxMacToolBarTopMargin ; - - node = node->Next(); - } - - if ( GetWindowStyleFlag() & wxTB_HORIZONTAL ) - { - m_maxWidth = tw ; // +=toolSize.x; - m_maxHeight += toolSize.y; - m_maxHeight += m_yMargin; - } - else - { - m_maxHeight = th ;// += toolSize.y; - m_maxWidth += toolSize.x; - m_maxWidth += m_xMargin; - } - - SetSize(m_maxWidth, m_maxHeight); - - return TRUE; + + 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 ; + + if ( GetWindowStyleFlag() & wxTB_VERTICAL ) + { + int x1 = x + (maxToolWidth - cursize.x)/2 ; + tool->SetPosition( wxPoint( x1 , y ) ) ; + } + else + { + int y1 = y + (maxToolHeight - cursize.y)/2 ; + tool->SetPosition( wxPoint( x , y1 ) ) ; + } + if ( GetWindowStyleFlag() & wxTB_VERTICAL ) + { + y += cursize.y ; + y += kwxMacToolSpacing ; + } + else + { + x += cursize.x ; + x += kwxMacToolSpacing ; + } + + 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; m_defaultHeight = size.y; + m_defaultWidth = size.x+kwxMacToolBorder; m_defaultHeight = size.y+kwxMacToolBorder; } // The button size is bigger than the bitmap size wxSize wxToolBar::GetToolSize() const { - return wxSize(m_defaultWidth + 8, m_defaultHeight + 7); -} - -void wxToolBar::MacHandleControlClick( ControlHandle control , SInt16 controlpart ) -{ - int index = 0 ; - for ( index = 0 ; index < m_macToolHandles.Count() ; ++index ) - { - if ( m_macToolHandles[index] == (void*) control ) - { - OnLeftClick( ( (wxToolBarTool*) (m_tools.Nth( index )->Data() ) ) ->m_index , ( (wxToolBarTool*) (m_tools.Nth( index )->Data() ) ) ->IsToggled() ) ; - } - } + return wxSize(m_defaultWidth + kwxMacToolBorder, m_defaultHeight + kwxMacToolBorder); } void wxToolBar::SetRows(int nRows) @@ -333,53 +588,167 @@ void wxToolBar::SetRows(int nRows) m_maxRows = nRows; } +void wxToolBar::MacSuperChangedPosition() +{ + wxWindow::MacSuperChangedPosition() ; + Realize() ; +} + wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const { - MacClientToRootWindow( &x , &y ) ; - Point pt = { x ,y } ; - - int index = 0 ; - for ( index = 0 ; index < m_macToolHandles.Count() ; ++index ) - { - if ( PtInRect( pt , &(**(ControlHandle)(m_macToolHandles[index])).contrlRect) ) - { - return (wxToolBarTool*) (m_tools.Nth( index )->Data() ) ; - } - } + 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 *tool = (wxToolBarTool *)t; + ((wxToolBarTool*)t)->DoEnable( enable ) ; } void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle) { - wxToolBarTool *tool = (wxToolBarTool *)t; - // TODO: set toggle state + wxToolBarTool *tool = (wxToolBarTool *)t; + if ( tool->IsButton() ) + { + tool->UpdateToggleImage( toggle ) ; + } } bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool) { - // nothing special to do here - we really create the toolbar buttons in - // Realize() later + // nothing special to do here - we relayout in Realize() later tool->Attach(this); + InvalidateBestSize(); return TRUE; } -void wxToolBar::DoSetToggle(wxToolBarToolBase *t, bool toggle) +void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle)) +{ + wxFAIL_MSG( _T("not implemented") ); +} + +bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool) { - wxToolBarTool *tool = (wxToolBarTool *)t; - // TODO: set toggle state + 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 ; } -bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool) +void wxToolBar::OnPaint(wxPaintEvent& event) { - return TRUE ; + wxPaintDC dc(this) ; +#if wxMAC_USE_CORE_GRAPHICS + // leave the background as it is (striped or metal) +#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