X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/991f71dcc80d5920d38de62fe0b449d5971e102a..0c1cc9483ecba053bc9a0983a4a8d48898e334f2:/src/mac/carbon/toolbar.cpp diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp index 01be924743..02778a1791 100644 --- a/src/mac/carbon/toolbar.cpp +++ b/src/mac/carbon/toolbar.cpp @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: toolbar.cpp +// Name: src/mac/carbon/toolbar.cpp // Purpose: wxToolBar // Author: Stefan Csomor // Modified by: @@ -13,29 +13,24 @@ #if wxUSE_TOOLBAR -#include "wx/wx.h" -#include "wx/bitmap.h" #include "wx/toolbar.h" +#ifndef WX_PRECOMP + #include "wx/wx.h" +#endif + +#include "wx/app.h" #include "wx/mac/uma.h" #include "wx/geometry.h" +#include "wx/sysopt.h" -#ifdef __WXMAC_OSX__ -const short kwxMacToolBarToolDefaultWidth = 16 ; -const short kwxMacToolBarToolDefaultHeight = 16 ; -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 +const short kwxMacToolBarToolDefaultWidth = 16; +const short kwxMacToolBarToolDefaultHeight = 16; +const short kwxMacToolBarTopMargin = 4; +const short kwxMacToolBarLeftMargin = 4; +const short kwxMacToolBorder = 0; +const short kwxMacToolSpacing = 6; IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl) @@ -55,181 +50,214 @@ END_EVENT_TABLE() // We have a dual implementation for each tool, ControlRef and HIToolbarItemRef +// when embedding native controls in the native toolbar we must make sure the +// control does not get deleted behind our backs, so the retain count gets increased +// (after creation it is 1), first be the creation of the custom HIToolbarItem wrapper +// object, and second by the code 'creating' the custom HIView (which is the same as the +// already existing native control, therefore we just increase the ref count) +// when this view is removed from the native toolbar its count gets decremented again +// and when the HITooolbarItem wrapper object gets destroyed it is decremented as well +// so in the end the control lives with a refcount of one and can be disposed of by the +// wxControl code. For embedded controls on a non-native toolbar this ref count is less +// so we can only test against a range, not a specific value of the refcount. + 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) + 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, const wxString& label) + : wxToolBarToolBase(tbar, control, label) { - Init() ; + Init(); if (control != NULL) - SetControlHandle( (ControlRef) control->GetHandle() ) ; + SetControlHandle( (ControlRef) control->GetHandle() ); } - ~wxToolBarTool() + virtual ~wxToolBarTool() { - ClearControl() ; - if ( m_controlHandle ) - DisposeControl( m_controlHandle ) ; - -#if wxMAC_USE_NATIVE_TOOLBAR - if ( m_toolbarItemRef ) - CFRelease( m_toolbarItemRef ) ; -#endif + ClearControl(); } WXWidget GetControlHandle() { - return (WXWidget) m_controlHandle ; + return (WXWidget) m_controlHandle; } void SetControlHandle( ControlRef handle ) { - m_controlHandle = handle ; + m_controlHandle = handle; } - void SetPosition( const wxPoint& position ) ; + void SetPosition( const wxPoint& position ); void ClearControl() { - m_control = NULL ; + if ( m_controlHandle ) + { + if ( !IsControl() ) + DisposeControl( m_controlHandle ); + else + { + // the embedded control is not under the responsibility of the tool, it gets disposed of in the + // proper wxControl destructor + } + m_controlHandle = NULL ; + } + m_control = NULL; #if wxMAC_USE_NATIVE_TOOLBAR - m_toolbarItemRef = NULL ; -#endif + if ( m_toolbarItemRef ) + { + CFIndex count = CFGetRetainCount( m_toolbarItemRef ) ; + // different behaviour under Leopard + if ( UMAGetSystemVersion() < 0x1050 ) + { + if ( count != 1 ) + { + wxFAIL_MSG("Reference count of native tool was not 1 in wxToolBarTool destructor"); + } + } + wxTheApp->MacAddToAutorelease(m_toolbarItemRef); + CFRelease(m_toolbarItemRef); + m_toolbarItemRef = NULL; + } +#endif // wxMAC_USE_NATIVE_TOOLBAR } wxSize GetSize() const { + wxSize curSize; + if ( IsControl() ) { - return GetControl()->GetSize() ; + curSize = GetControl()->GetSize(); } else if ( IsButton() ) { - return GetToolBar()->GetToolSize() ; + curSize = GetToolBar()->GetToolSize(); } else { // separator size - wxSize sz = GetToolBar()->GetToolSize() ; + curSize = GetToolBar()->GetToolSize(); if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL ) - sz.y /= 4 ; + curSize.y /= 4; else - sz.x /= 4 ; - - return sz ; + curSize.x /= 4; } + + return curSize; } wxPoint GetPosition() const { - return wxPoint(m_x, m_y); + return wxPoint( m_x, m_y ); } - bool DoEnable( bool enable ) ; + bool DoEnable( bool enable ); - void UpdateToggleImage( bool toggle ) ; + void UpdateToggleImage( bool toggle ); #if wxMAC_USE_NATIVE_TOOLBAR void SetToolbarItemRef( HIToolbarItemRef ref ) { if ( m_controlHandle ) - HideControl( m_controlHandle ) ; + HideControl( m_controlHandle ); if ( m_toolbarItemRef ) - CFRelease( m_toolbarItemRef ) ; + CFRelease( m_toolbarItemRef ); - m_toolbarItemRef = ref ; + m_toolbarItemRef = ref; if ( m_toolbarItemRef ) { + wxFont f; + wxFontEncoding enc; + if ( GetToolBar() ) + f = GetToolBar()->GetFont(); + if ( f.IsOk() ) + enc = f.GetEncoding(); + else + enc = wxFont::GetDefaultEncoding(); + HIToolbarItemSetHelpText( m_toolbarItemRef, - wxMacCFStringHolder( GetShortHelp(), GetToolBar()->GetFont().GetEncoding() ) , - wxMacCFStringHolder( GetLongHelp(), GetToolBar()->GetFont().GetEncoding() ) ) ; + wxCFStringRef( GetShortHelp(), enc ), + wxCFStringRef( GetLongHelp(), enc ) ); } } HIToolbarItemRef GetToolbarItemRef() const { - return m_toolbarItemRef ; + return m_toolbarItemRef; } void SetIndex( CFIndex idx ) { - m_index = idx ; + m_index = idx; } CFIndex GetIndex() const { - return m_index ; + return m_index; } #endif -private : +private: void Init() { - m_controlHandle = NULL ; + m_controlHandle = NULL; #if wxMAC_USE_NATIVE_TOOLBAR - m_toolbarItemRef = NULL ; - m_index = -1 ; + m_toolbarItemRef = NULL; + m_index = -1; #endif } - ControlRef m_controlHandle ; + ControlRef m_controlHandle; wxCoord m_x; wxCoord m_y; #if wxMAC_USE_NATIVE_TOOLBAR - HIToolbarItemRef m_toolbarItemRef ; + HIToolbarItemRef m_toolbarItemRef; // position in its toolbar, -1 means not inserted - CFIndex m_index ; + CFIndex m_index; #endif }; static const EventTypeSpec eventList[] = { - { kEventClassControl , kEventControlHit } , -#ifdef __WXMAC_OSX__ - { kEventClassControl , kEventControlHitTest } , -#endif -} ; + { kEventClassControl, kEventControlHit }, + { kEventClassControl, kEventControlHitTest }, +}; -static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data ) +static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef WXUNUSED(handler), EventRef event, void *data ) { - OSStatus result = eventNotHandledErr ; + OSStatus result = eventNotHandledErr; + ControlRef controlRef; + wxMacCarbonEvent cEvent( event ); - wxMacCarbonEvent cEvent( event ) ; - - ControlRef controlRef ; - - cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ; + cEvent.GetParameter( kEventParamDirectObject, &controlRef ); switch ( GetEventKind( event ) ) { - case kEventControlHit : + case kEventControlHit: { - wxToolBarTool* tbartool = (wxToolBarTool*)data ; - wxToolBar *tbar = tbartool != NULL ? (wxToolBar*) (tbartool->GetToolBar()) : NULL ; + wxToolBarTool *tbartool = (wxToolBarTool*)data; + wxToolBar *tbar = tbartool != NULL ? (wxToolBar*) (tbartool->GetToolBar()) : NULL; if ((tbartool != NULL) && tbartool->CanBeToggled()) { bool shouldToggle; -#ifdef __WXMAC_OSX__ shouldToggle = !tbartool->IsToggled(); -#else - shouldToggle = ( GetControl32BitValue((ControlRef) tbartool->GetControlHandle()) != 0 ); -#endif tbar->ToggleTool( tbartool->GetId(), shouldToggle ); } @@ -238,70 +266,64 @@ static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef tbar->OnLeftClick( tbartool->GetId(), tbartool->IsToggled() ); result = noErr; } - break ; + break; -#ifdef __WXMAC_OSX__ - case kEventControlHitTest : + case kEventControlHitTest: { - HIPoint pt = cEvent.GetParameter(kEventParamMouseLocation) ; - HIRect rect ; - HIViewGetBounds( controlRef , &rect ) ; - - ControlPartCode pc = kControlNoPart ; - if ( CGRectContainsPoint( rect , pt ) ) - pc = kControlIconPart ; - cEvent.SetParameter( kEventParamControlPart , typeControlPartCode, pc ) ; - result = noErr ; + HIPoint pt = cEvent.GetParameter(kEventParamMouseLocation); + HIRect rect; + HIViewGetBounds( controlRef, &rect ); + + ControlPartCode pc = kControlNoPart; + if ( CGRectContainsPoint( rect, pt ) ) + pc = kControlIconPart; + cEvent.SetParameter( kEventParamControlPart, typeControlPartCode, pc ); + result = noErr; } - break ; -#endif + break; - default : - break ; + default: + break; } - return result ; + return result; } -static pascal OSStatus wxMacToolBarToolEventHandler( EventHandlerCallRef handler , EventRef event , void *data ) +static pascal OSStatus wxMacToolBarToolEventHandler( EventHandlerCallRef handler, EventRef event, void *data ) { - OSStatus result = eventNotHandledErr ; + OSStatus result = eventNotHandledErr; switch ( GetEventClass( event ) ) { - case kEventClassControl : - result = wxMacToolBarToolControlEventHandler( handler, event, data ) ; - break ; + case kEventClassControl: + result = wxMacToolBarToolControlEventHandler( handler, event, data ); + break; - default : - break ; + default: + break; } - return result ; + return result; } DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarToolEventHandler ) #if wxMAC_USE_NATIVE_TOOLBAR -// -// native toolbar -// - static const EventTypeSpec toolBarEventList[] = { - { kEventClassToolbarItem , kEventToolbarItemPerformAction } , -} ; + { kEventClassToolbarItem, kEventToolbarItemPerformAction }, +}; -static pascal OSStatus wxMacToolBarCommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data ) +static pascal OSStatus wxMacToolBarCommandEventHandler( EventHandlerCallRef WXUNUSED(handler), EventRef event, void *data ) { - OSStatus result = eventNotHandledErr ; + OSStatus result = eventNotHandledErr; switch ( GetEventKind( event ) ) { - case kEventToolbarItemPerformAction : + case kEventToolbarItemPerformAction: { - wxToolBarTool* tbartool = (wxToolBarTool*) data ; + wxToolBarTool* tbartool = (wxToolBarTool*) data; if ( tbartool != NULL ) { wxToolBar *tbar = (wxToolBar*)(tbartool->GetToolBar()); @@ -309,212 +331,182 @@ static pascal OSStatus wxMacToolBarCommandEventHandler( EventHandlerCallRef hand if ( tbartool->CanBeToggled() ) { - if ( tbar ) + if ( tbar != NULL ) tbar->ToggleTool(toolID, !tbartool->IsToggled() ); } - if ( tbar ) - tbar->OnLeftClick( toolID , tbartool->IsToggled() ) ; + if ( tbar != NULL ) + tbar->OnLeftClick( toolID, tbartool->IsToggled() ); result = noErr; } } - break ; + break; - default : - break ; + default: + break; } - return result ; + return result; } static pascal OSStatus wxMacToolBarEventHandler( EventHandlerCallRef handler, EventRef event, void *data ) { - OSStatus result = eventNotHandledErr ; + OSStatus result = eventNotHandledErr; switch ( GetEventClass( event ) ) { - case kEventClassToolbarItem : - result = wxMacToolBarCommandEventHandler( handler, event, data ) ; - break ; + case kEventClassToolbarItem: + result = wxMacToolBarCommandEventHandler( handler, event, data ); + break; - default : - break ; + default: + break; } - return result ; + return result; } DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarEventHandler ) #endif -// ============================================================================ -// implementation -// ============================================================================ - -// ---------------------------------------------------------------------------- -// wxToolBarTool -// ---------------------------------------------------------------------------- - -bool wxToolBarTool::DoEnable(bool enable) +bool wxToolBarTool::DoEnable( bool enable ) { if ( IsControl() ) { - GetControl()->Enable( enable ) ; + GetControl()->Enable( enable ); } else if ( IsButton() ) { #if wxMAC_USE_NATIVE_TOOLBAR - if ( m_toolbarItemRef ) - HIToolbarItemSetEnabled( m_toolbarItemRef , enable ) ; + if ( m_toolbarItemRef != NULL ) + HIToolbarItemSetEnabled( m_toolbarItemRef, enable ); #endif - if ( m_controlHandle ) + if ( m_controlHandle != NULL ) { -#if TARGET_API_MAC_OSX if ( enable ) - EnableControl( m_controlHandle ) ; + EnableControl( m_controlHandle ); else - DisableControl( m_controlHandle ) ; -#else - if ( enable ) - ActivateControl( m_controlHandle ) ; - else - DeactivateControl( m_controlHandle ) ; -#endif + DisableControl( m_controlHandle ); } } - return true ; + return true; } -void wxToolBarTool::SetPosition(const wxPoint& position) +void wxToolBarTool::SetPosition( const wxPoint& position ) { m_x = position.x; m_y = position.y; - int x , y ; - x = y = 0 ; - int mac_x = position.x ; - int mac_y = position.y ; - - if ( ! GetToolBar()->MacGetTopLevelWindow()->MacUsesCompositing() ) - { - GetToolBar()->MacWindowToRootWindow( &x , &y ) ; - mac_x += x; - mac_y += y; - } + int mac_x = position.x; + int mac_y = position.y; if ( IsButton() ) { - Rect contrlRect ; - GetControlBounds( m_controlHandle , &contrlRect ) ; - int former_mac_x = contrlRect.left ; - int former_mac_y = contrlRect.top ; - GetToolBar()->GetToolSize() ; + 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 ) ; + ::MoveControl( m_controlHandle, mac_x, mac_y ); } } else if ( IsControl() ) { - GetControl()->Move( position ) ; + // embedded native controls are moved by the OS +#if wxMAC_USE_NATIVE_TOOLBAR + if ( ((wxToolBar*)GetToolBar())->MacWantsNativeToolbar() == false ) +#endif + { + GetControl()->Move( position ); + } } else { // separator -#ifdef __WXMAC_OSX__ - Rect contrlRect ; - GetControlBounds( m_controlHandle , &contrlRect ) ; - int former_mac_x = contrlRect.left ; - int former_mac_y = contrlRect.top ; + 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 + ::MoveControl( m_controlHandle, mac_x, mac_y ); } } void wxToolBarTool::UpdateToggleImage( bool toggle ) { -#if wxMAC_USE_NATIVE_TOOLBAR - -#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_4 -#define kHIToolbarItemSelected (1 << 7) -#endif - - // FIXME: this should be a OSX v10.4 runtime check - if (m_toolbarItemRef != NULL) + if ( toggle ) { - OptionBits addAttrs, removeAttrs; - OSStatus result; - - if (toggle) - { - addAttrs = kHIToolbarItemSelected; - removeAttrs = kHIToolbarItemNoAttributes; - } - else + int w = m_bmpNormal.GetWidth(); + int h = m_bmpNormal.GetHeight(); + wxBitmap bmp( w, h ); + wxMemoryDC dc; + + dc.SelectObject( bmp ); + dc.SetPen( wxPen(*wxBLACK) ); + dc.SetBrush( wxBrush( *wxLIGHT_GREY )); + 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 ); +#if wxMAC_USE_NATIVE_TOOLBAR + if (m_toolbarItemRef != NULL) { - addAttrs = kHIToolbarItemNoAttributes; - removeAttrs = kHIToolbarItemSelected; + ControlButtonContentInfo info2; + wxMacCreateBitmapButton( &info2, bmp, kControlContentCGImageRef); + HIToolbarItemSetImage( m_toolbarItemRef, info2.u.imageRef ); + wxMacReleaseBitmapButton( &info2 ); } - - result = HIToolbarItemChangeAttributes( m_toolbarItemRef, addAttrs, removeAttrs ); - } #endif - -#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 ) ; + wxMacReleaseBitmapButton( &info ); } else { - ControlButtonContentInfo info ; - wxMacCreateBitmapButton( &info , m_bmpNormal ) ; - SetControlData( m_controlHandle , 0, kControlIconContentTag, - sizeof( info ), (Ptr)&info ); - wxMacReleaseBitmapButton( &info ) ; + ControlButtonContentInfo info; + wxMacCreateBitmapButton( &info, m_bmpNormal ); + SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info ); +#if wxMAC_USE_NATIVE_TOOLBAR + if (m_toolbarItemRef != NULL) + { + ControlButtonContentInfo info2; + wxMacCreateBitmapButton( &info2, m_bmpNormal, kControlContentCGImageRef); + HIToolbarItemSetImage( m_toolbarItemRef, info2.u.imageRef ); + wxMacReleaseBitmapButton( &info2 ); + } +#endif + wxMacReleaseBitmapButton( &info ); } - IconTransformType transform = toggle ? kTransformSelected : kTransformNone ; - SetControlData( m_controlHandle, 0, kControlIconTransformTag, - sizeof( transform ), (Ptr)&transform ); - HIViewSetNeedsDisplay( m_controlHandle , true ) ; + IconTransformType transform = toggle ? kTransformSelected : kTransformNone; + SetControlData( + m_controlHandle, 0, kControlIconTransformTag, + sizeof(transform), (Ptr)&transform ); + HIViewSetNeedsDisplay( m_controlHandle, true ); -#else - ::SetControl32BitValue( m_controlHandle , toggle ) ; -#endif } -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) +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(); } @@ -522,22 +514,25 @@ wxToolBarTool::wxToolBarTool(wxToolBar *tbar, #pragma mark - #pragma mark Toolbar Implementation -wxToolBarToolBase *wxToolBar::CreateTool(int id, - const wxString& label, - const wxBitmap& bmpNormal, - const wxBitmap& bmpDisabled, - wxItemKind kind, - wxObject *clientData, - const wxString& shortHelp, - const wxString& longHelp) +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); + return new wxToolBarTool( + this, id, label, bmpNormal, bmpDisabled, kind, + clientData, shortHelp, longHelp ); } -wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control) +wxToolBarToolBase * +wxToolBar::CreateTool(wxControl *control, const wxString& label) { - return new wxToolBarTool(this, control); + return new wxToolBarTool(this, control, label); } void wxToolBar::Init() @@ -548,47 +543,323 @@ void wxToolBar::Init() m_defaultHeight = kwxMacToolBarToolDefaultHeight; #if wxMAC_USE_NATIVE_TOOLBAR - m_macHIToolbarRef = NULL ; - m_macUsesNativeToolbar = false ; + m_macHIToolbarRef = NULL; + m_macUsesNativeToolbar = false; #endif } +#define kControlToolbarItemClassID CFSTR( "org.wxwidgets.controltoolbaritem" ) + +const EventTypeSpec kEvents[] = +{ + { kEventClassHIObject, kEventHIObjectConstruct }, + { kEventClassHIObject, kEventHIObjectInitialize }, + { kEventClassHIObject, kEventHIObjectDestruct }, + + { kEventClassToolbarItem, kEventToolbarItemCreateCustomView } +}; + +const EventTypeSpec kViewEvents[] = +{ + { kEventClassControl, kEventControlGetSizeConstraints } +}; + +struct ControlToolbarItem +{ + HIToolbarItemRef toolbarItem; + HIViewRef viewRef; + wxSize lastValidSize ; +}; + +static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData ) +{ + OSStatus result = eventNotHandledErr; + ControlToolbarItem* object = (ControlToolbarItem*)inUserData; + + switch ( GetEventClass( inEvent ) ) + { + case kEventClassHIObject: + switch ( GetEventKind( inEvent ) ) + { + case kEventHIObjectConstruct: + { + HIObjectRef toolbarItem; + ControlToolbarItem* item; + + GetEventParameter( inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL, + sizeof( HIObjectRef ), NULL, &toolbarItem ); + + item = (ControlToolbarItem*) malloc(sizeof(ControlToolbarItem)) ; + item->toolbarItem = toolbarItem ; + item->lastValidSize = wxSize(-1,-1); + item->viewRef = NULL ; + + SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof( void * ), &item ); + + result = noErr ; + } + break; + + case kEventHIObjectInitialize: + result = CallNextEventHandler( inCallRef, inEvent ); + if ( result == noErr ) + { + CFDataRef data; + GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL, + sizeof( CFTypeRef ), NULL, &data ); + + HIViewRef viewRef ; + + wxASSERT_MSG( CFDataGetLength( data ) == sizeof( viewRef ) , wxT("Illegal Data passed") ) ; + memcpy( &viewRef , CFDataGetBytePtr( data ) , sizeof( viewRef ) ) ; + + object->viewRef = (HIViewRef) viewRef ; + // make sure we keep that control during our lifetime + CFRetain( object->viewRef ) ; + + verify_noerr(InstallEventHandler( GetControlEventTarget( viewRef ), ControlToolbarItemHandler, + GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL )); + result = noErr ; + } + break; + + case kEventHIObjectDestruct: + { + HIViewRef viewRef = object->viewRef ; + if( viewRef && IsValidControlHandle( viewRef) ) + { + // depending whether the wxControl corresponding to this HIView has already been destroyed or + // not, ref counts differ, so we cannot assert a special value + CFIndex count = CFGetRetainCount( viewRef ) ; + if ( count >= 1 ) + { + wxFAIL_MSG("Reference count of native tool was illegal before removal"); + + CFRelease( viewRef ) ; + } + } + free( object ) ; + result = noErr; + } + break; + } + break; + + case kEventClassToolbarItem: + switch ( GetEventKind( inEvent ) ) + { + case kEventToolbarItemCreateCustomView: + { + HIViewRef viewRef = object->viewRef ; + HIViewRemoveFromSuperview( viewRef ) ; + HIViewSetVisible(viewRef, true) ; + CFRetain( viewRef ) ; + result = SetEventParameter( inEvent, kEventParamControlRef, typeControlRef, sizeof( HIViewRef ), &viewRef ); + } + break; + } + break; + + case kEventClassControl: + switch ( GetEventKind( inEvent ) ) + { + case kEventControlGetSizeConstraints: + { + wxWindow* wxwindow = wxFindControlFromMacControl(object->viewRef ) ; + if ( wxwindow ) + { + // during toolbar layout the native window sometimes gets negative sizes, + // sometimes it just gets shrunk behind our back, so in order to avoid + // ever shrinking more, once a valid size is captured, we keep it + + wxSize sz = object->lastValidSize; + if ( sz.x <= 0 || sz.y <= 0 ) + { + sz = wxwindow->GetSize() ; + sz.x -= wxwindow->MacGetLeftBorderSize() + wxwindow->MacGetRightBorderSize(); + sz.y -= wxwindow->MacGetTopBorderSize() + wxwindow->MacGetBottomBorderSize(); + if ( sz.x > 0 && sz.y > 0 ) + object->lastValidSize = sz ; + else + sz = wxSize(0,0) ; + } + + // Extra width to avoid edge of combobox being cut off + sz.x += 3; + + HISize min, max; + min.width = max.width = sz.x ; + min.height = max.height = sz.y ; + + result = SetEventParameter( inEvent, kEventParamMinimumSize, typeHISize, + sizeof( HISize ), &min ); + + result = SetEventParameter( inEvent, kEventParamMaximumSize, typeHISize, + sizeof( HISize ), &max ); + result = noErr ; + } + } + break; + } + break; + } + + return result; +} + +void RegisterControlToolbarItemClass() +{ + static bool sRegistered; + + if ( !sRegistered ) + { + HIObjectRegisterSubclass( kControlToolbarItemClassID, kHIToolbarItemClassID, 0, + ControlToolbarItemHandler, GetEventTypeCount( kEvents ), kEvents, 0, NULL ); + + sRegistered = true; + } +} + +HIToolbarItemRef CreateControlToolbarItem(CFStringRef inIdentifier, CFTypeRef inConfigData) +{ + RegisterControlToolbarItemClass(); + + OSStatus err; + EventRef event; + UInt32 options = kHIToolbarItemAllowDuplicates; + HIToolbarItemRef result = NULL; + + err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event ); + require_noerr( err, CantCreateEvent ); + + SetEventParameter( event, kEventParamAttributes, typeUInt32, sizeof( UInt32 ), &options ); + SetEventParameter( event, kEventParamToolbarItemIdentifier, typeCFStringRef, sizeof( CFStringRef ), &inIdentifier ); + + if ( inConfigData ) + SetEventParameter( event, kEventParamToolbarItemConfigData, typeCFTypeRef, sizeof( CFTypeRef ), &inConfigData ); + + err = HIObjectCreate( kControlToolbarItemClassID, event, (HIObjectRef*)&result ); + check_noerr( err ); + + ReleaseEvent( event ); +CantCreateEvent : + return result ; +} + +#if wxMAC_USE_NATIVE_TOOLBAR +static const EventTypeSpec kToolbarEvents[] = +{ + { kEventClassToolbar, kEventToolbarGetDefaultIdentifiers }, + { kEventClassToolbar, kEventToolbarGetAllowedIdentifiers }, + { kEventClassToolbar, kEventToolbarCreateItemWithIdentifier }, +}; + +static OSStatus ToolbarDelegateHandler(EventHandlerCallRef WXUNUSED(inCallRef), + EventRef inEvent, + void* WXUNUSED(inUserData)) +{ + OSStatus result = eventNotHandledErr; + // Not yet needed + // wxToolBar* toolbar = (wxToolBar*) inUserData ; + CFMutableArrayRef array; + + switch ( GetEventKind( inEvent ) ) + { + case kEventToolbarGetDefaultIdentifiers: + { + GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL, + sizeof( CFMutableArrayRef ), NULL, &array ); + // not implemented yet + // GetToolbarDefaultItems( array ); + result = noErr; + } + break; + + case kEventToolbarGetAllowedIdentifiers: + { + GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL, + sizeof( CFMutableArrayRef ), NULL, &array ); + // not implemented yet + // GetToolbarAllowedItems( array ); + result = noErr; + } + break; + case kEventToolbarCreateItemWithIdentifier: + { + HIToolbarItemRef item = NULL; + CFTypeRef data = NULL; + CFStringRef identifier = NULL ; + + GetEventParameter( inEvent, kEventParamToolbarItemIdentifier, typeCFStringRef, NULL, + sizeof( CFStringRef ), NULL, &identifier ); + + GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL, + sizeof( CFTypeRef ), NULL, &data ); + + if ( CFStringCompare( kControlToolbarItemClassID, identifier, kCFCompareBackwards ) == kCFCompareEqualTo ) + { + item = CreateControlToolbarItem( kControlToolbarItemClassID, data ); + if ( item ) + { + SetEventParameter( inEvent, kEventParamToolbarItem, typeHIToolbarItemRef, + sizeof( HIToolbarItemRef ), &item ); + result = noErr; + } + } + + } + break; + } + return result ; +} +#endif // wxMAC_USE_NATIVE_TOOLBAR + // also for the toolbar we have the dual implementation: // only when MacInstallNativeToolbar is called is the native toolbar set as the window toolbar -// -bool wxToolBar::Create(wxWindow *parent, + +bool wxToolBar::Create( + wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, - const wxString& name) + const wxString& name ) { - if ( !wxToolBarBase::Create( parent , id , pos , size , style, wxDefaultValidator, name ) ) - return false ; + if ( !wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name ) ) + return false; + + FixupStyle(); OSStatus err = noErr; #if wxMAC_USE_NATIVE_TOOLBAR - wxString labelStr = wxString::Format(wxT("%xd"), (int)this); - err = HIToolbarCreate( wxMacCFStringHolder(labelStr, wxFont::GetDefaultEncoding() ) , 0 , - (HIToolbarRef*) &m_macHIToolbarRef ); - - if (m_macHIToolbarRef != NULL) + if (parent->IsKindOf(CLASSINFO(wxFrame)) && wxSystemOptions::GetOptionInt(wxT("mac.toolbar.no-native")) != 1) { - HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault ; - HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall ; + wxString labelStr = wxString::Format( wxT("%p"), this ); + err = HIToolbarCreate( + wxCFStringRef( labelStr, wxFont::GetDefaultEncoding() ), 0, + (HIToolbarRef*) &m_macHIToolbarRef ); - if ( style & wxTB_NOICONS ) - mode = kHIToolbarDisplayModeLabelOnly ; - else if ( style & wxTB_TEXT ) - mode = kHIToolbarDisplayModeIconAndLabel ; - else - mode = kHIToolbarDisplayModeIconOnly ; + if (m_macHIToolbarRef != NULL) + { + InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler, + GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL ); + + HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault; + HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall; + + if ( style & wxTB_NOICONS ) + mode = kHIToolbarDisplayModeLabelOnly; + else if ( style & wxTB_TEXT ) + mode = kHIToolbarDisplayModeIconAndLabel; + else + mode = kHIToolbarDisplayModeIconOnly; - HIToolbarSetDisplayMode( (HIToolbarRef) m_macHIToolbarRef , mode ) ; - HIToolbarSetDisplaySize( (HIToolbarRef) m_macHIToolbarRef , displaySize ) ; + HIToolbarSetDisplayMode( (HIToolbarRef) m_macHIToolbarRef, mode ); + HIToolbarSetDisplaySize( (HIToolbarRef) m_macHIToolbarRef, displaySize ); + } } -#endif +#endif // wxMAC_USE_NATIVE_TOOLBAR return (err == noErr); } @@ -596,13 +867,22 @@ bool wxToolBar::Create(wxWindow *parent, wxToolBar::~wxToolBar() { #if wxMAC_USE_NATIVE_TOOLBAR - if ( m_macHIToolbarRef ) + if (m_macHIToolbarRef != NULL) { // if this is the installed toolbar, then deinstall it if (m_macUsesNativeToolbar) MacInstallNativeToolbar( false ); - CFRelease( (HIToolbarRef) m_macHIToolbarRef ); + CFIndex count = CFGetRetainCount( m_macHIToolbarRef ) ; + // Leopard seems to have one refcount more, so we cannot check reliably at the moment + if ( UMAGetSystemVersion() < 0x1050 ) + { + if ( count != 1 ) + { + wxFAIL_MSG("Reference count of native control was not 1 in wxToolBar destructor"); + } + } + CFRelease( (HIToolbarRef)m_macHIToolbarRef ); m_macHIToolbarRef = NULL; } #endif @@ -610,10 +890,9 @@ wxToolBar::~wxToolBar() bool wxToolBar::Show( bool show ) { - bool bResult; WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef()); + bool bResult = (tlw != NULL); - bResult = (tlw != NULL); if (bResult) { #if wxMAC_USE_NATIVE_TOOLBAR @@ -621,14 +900,16 @@ bool wxToolBar::Show( bool show ) MacTopLevelHasNativeToolbar( &ownToolbarInstalled ); if (ownToolbarInstalled) { - bResult = ( IsWindowToolbarVisible(tlw) != show); + bResult = (IsWindowToolbarVisible( tlw ) != show); if ( bResult ) ShowHideWindowToolbar( tlw, show, false ); } else -#endif - bResult = wxToolBarBase::Show( show ); +#else + + bResult = wxToolBarBase::Show( show ); +#endif } return bResult; @@ -639,16 +920,20 @@ bool wxToolBar::IsShown() const bool bResult; #if wxMAC_USE_NATIVE_TOOLBAR - bool ownToolbarInstalled ; + bool ownToolbarInstalled; + MacTopLevelHasNativeToolbar( &ownToolbarInstalled ); if (ownToolbarInstalled) { WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef()); - bResult = IsWindowToolbarVisible(tlw) ; + bResult = IsWindowToolbarVisible( tlw ); } else -#endif bResult = wxToolBarBase::IsShown(); +#else + + bResult = wxToolBarBase::IsShown(); +#endif return bResult; } @@ -670,17 +955,20 @@ void wxToolBar::DoGetSize( int *width, int *height ) const *height = boundsR.bottom - boundsR.top; } else -#endif wxToolBarBase::DoGetSize( width, height ); + +#else + wxToolBarBase::DoGetSize( width, height ); +#endif } wxSize wxToolBar::DoGetBestSize() const { - int width , height ; + int width, height; - DoGetSize( &width , &height ) ; + DoGetSize( &width, &height ); - return wxSize( width , height ) ; + return wxSize( width, height ); } void wxToolBar::SetWindowStyleFlag( long style ) @@ -722,7 +1010,7 @@ bool wxToolBar::MacTopLevelHasNativeToolbar(bool *ownToolbarInstalled) const { HIToolbarRef curToolbarRef = NULL; OSStatus err = GetWindowToolbar( tlw, &curToolbarRef ); - bResultV = ((err == 0) && (curToolbarRef != NULL)); + bResultV = ((err == noErr) && (curToolbarRef != NULL)); if (bResultV && (ownToolbarInstalled != NULL)) *ownToolbarInstalled = (curToolbarRef == m_macHIToolbarRef); } @@ -734,16 +1022,16 @@ bool wxToolBar::MacInstallNativeToolbar(bool usesNative) { bool bResult = false; - WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef()); - if (tlw == NULL) - return bResult; - if (usesNative && (m_macHIToolbarRef == NULL)) return bResult; if (usesNative && ((GetWindowStyleFlag() & wxTB_VERTICAL) != 0)) return bResult; + WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef()); + if (tlw == NULL) + return bResult; + // check the existing toolbar HIToolbarRef curToolbarRef = NULL; OSStatus err = GetWindowToolbar( tlw, &curToolbarRef ); @@ -764,7 +1052,7 @@ bool wxToolBar::MacInstallNativeToolbar(bool usesNative) ChangeWindowAttributes( tlw, kWindowToolbarButtonAttribute, 0 ); SetAutomaticControlDragTrackingEnabledForWindow( tlw, true ); - Rect r = { 0 , 0 , 0 , 0 }; + Rect r = { 0, 0, 0, 0 }; m_peer->SetRect( &r ); SetSize( wxSIZE_AUTO_WIDTH, 0 ); m_peer->SetVisibility( false, true ); @@ -779,7 +1067,7 @@ bool wxToolBar::MacInstallNativeToolbar(bool usesNative) bResult = true; ShowHideWindowToolbar( tlw, false, false ); - ChangeWindowAttributes( tlw, 0 , kWindowToolbarButtonAttribute ); + ChangeWindowAttributes( tlw, 0, kWindowToolbarButtonAttribute ); SetWindowToolbar( tlw, NULL ); m_peer->SetVisibility( true, true ); @@ -812,11 +1100,11 @@ bool wxToolBar::Realize() GetSize( &tw, &th ); // find the maximum tool width and height - wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); - while ( node != NULL ) + wxToolBarTool *tool; + wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); + while ( node ) { - wxToolBarTool *tool = (wxToolBarTool *) node->GetData(); - + tool = (wxToolBarTool *) node->GetData(); if ( tool != NULL ) { wxSize sz = tool->GetSize(); @@ -832,18 +1120,18 @@ bool wxToolBar::Realize() bool lastIsRadio = false; bool curIsRadio = false; - bool setChoiceInGroup = false; #if wxMAC_USE_NATIVE_TOOLBAR - CFIndex currentPosition = 0 ; - bool insertAll = false ; + CFIndex currentPosition = 0; + bool insertAll = false; + + HIToolbarRef refTB = (HIToolbarRef)m_macHIToolbarRef; #endif node = m_tools.GetFirst(); - while ( node != NULL ) + while ( node ) { - wxToolBarTool *tool = (wxToolBarTool *) node->GetData(); - + tool = (wxToolBarTool*) node->GetData(); if ( tool == NULL ) { node = node->GetNext(); @@ -877,38 +1165,84 @@ bool wxToolBar::Realize() #if wxMAC_USE_NATIVE_TOOLBAR // install in native HIToolbar - if ( m_macHIToolbarRef != NULL ) + if ( refTB ) { - HIToolbarItemRef hiItemRef = tool->GetToolbarItemRef(); + HIToolbarItemRef hiItemRef = tool->GetToolbarItemRef(); if ( hiItemRef != NULL ) { if ( insertAll || (tool->GetIndex() != currentPosition) ) { - OSStatus err = noErr ; + OSStatus err = noErr; if ( !insertAll ) { + insertAll = true; + // if this is the first tool that gets newly inserted or repositioned // first remove all 'old' tools from here to the right, because of this - // all following tools will have to be reinserted (insertAll). i = 100 because there's - // no way to determine how many there are in a toolbar, so just a high number :-( - for ( CFIndex i = 100 ; i >= currentPosition ; --i ) + // all following tools will have to be reinserted (insertAll). + for ( wxToolBarToolsList::compatibility_iterator node2 = m_tools.GetLast(); + node2 != node; + node2 = node2->GetPrevious() ) { - err = HIToolbarRemoveItemAtIndex( (HIToolbarRef) m_macHIToolbarRef , i ) ; + wxToolBarTool *tool2 = (wxToolBarTool*) node2->GetData(); + + const long idx = tool2->GetIndex(); + if ( idx != -1 ) + { + if ( tool2->IsControl() ) + { + CFIndex count = CFGetRetainCount( tool2->GetControl()->GetPeer()->GetControlRef() ) ; + if ( count != 3 && count != 2 ) + { + wxFAIL_MSG("Reference count of native tool was illegal before removal"); + } + + wxASSERT( IsValidControlHandle(tool2->GetControl()->GetPeer()->GetControlRef() )) ; + } + err = HIToolbarRemoveItemAtIndex(refTB, idx); + if ( err != noErr ) + { + wxLogDebug(wxT("HIToolbarRemoveItemAtIndex(%ld) failed [%ld]"), + idx, (long)err); + } + if ( tool2->IsControl() ) + { + CFIndex count = CFGetRetainCount( tool2->GetControl()->GetPeer()->GetControlRef() ) ; + if ( count != 2 ) + { + wxFAIL_MSG("Reference count of native tool was not 2 after removal"); + } + + wxASSERT( IsValidControlHandle(tool2->GetControl()->GetPeer()->GetControlRef() )) ; + } + + tool2->SetIndex(-1); + } } - wxASSERT_MSG( err == noErr, _T("HIToolbarRemoveItemAtIndex failed") ); - insertAll = true ; } - err = HIToolbarInsertItemAtIndex( (HIToolbarRef) m_macHIToolbarRef, hiItemRef , currentPosition ) ; - wxASSERT_MSG( err == noErr, _T("HIToolbarInsertItemAtIndex failed") ); + err = HIToolbarInsertItemAtIndex( refTB, hiItemRef, currentPosition ); + if (err != noErr) + { + wxLogDebug( wxT("HIToolbarInsertItemAtIndex failed [%ld]"), (long)err ); + } - tool->SetIndex( currentPosition ) ; + tool->SetIndex( currentPosition ); + if ( tool->IsControl() ) + { + CFIndex count = CFGetRetainCount( tool->GetControl()->GetPeer()->GetControlRef() ) ; + if ( count != 3 && count != 2 ) + { + wxFAIL_MSG("Reference count of native tool was illegal before removal"); + } + wxASSERT( IsValidControlHandle(tool->GetControl()->GetPeer()->GetControlRef() )) ; + } } - currentPosition++ ; + currentPosition++; } } -#endif // wxMAC_USE_NATIVE_TOOLBAR +#endif // update radio button (and group) state lastIsRadio = curIsRadio; @@ -918,17 +1252,14 @@ bool wxToolBar::Realize() { if ( tool->IsToggled() ) DoToggleTool( tool, true ); - - setChoiceInGroup = false; } else { if ( !lastIsRadio ) { - if ( tool->Toggle(true) ) + if ( tool->Toggle( true ) ) { DoToggleTool( tool, true ); - setChoiceInGroup = true; } } else if ( tool->IsToggled() ) @@ -937,13 +1268,13 @@ bool wxToolBar::Realize() DoToggleTool( tool, true ); wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious(); - while ( nodePrev != NULL ) + while ( nodePrev ) { wxToolBarToolBase *toggleTool = nodePrev->GetData(); if ( (toggleTool == NULL) || !toggleTool->IsButton() || (toggleTool->GetKind() != wxITEM_RADIO) ) break; - if ( toggleTool->Toggle(false) ) + if ( toggleTool->Toggle( false ) ) DoToggleTool( toggleTool, false ); nodePrev = nodePrev->GetPrevious(); @@ -997,7 +1328,7 @@ bool wxToolBar::Realize() InvalidateBestSize(); #endif - SetBestFittingSize(); + SetInitialSize(); return true; } @@ -1011,13 +1342,13 @@ void wxToolBar::SetToolBitmapSize(const wxSize& size) if (m_macHIToolbarRef != NULL) { int maxs = wxMax( size.x, size.y ); - HIToolbarDisplaySize sizeSpec ; + HIToolbarDisplaySize sizeSpec; if ( maxs > 32 ) - sizeSpec = kHIToolbarDisplaySizeNormal ; + sizeSpec = kHIToolbarDisplaySizeNormal; else if ( maxs > 24 ) - sizeSpec = kHIToolbarDisplaySizeDefault ; + sizeSpec = kHIToolbarDisplaySizeDefault; else - sizeSpec = kHIToolbarDisplaySizeSmall ; + sizeSpec = kHIToolbarDisplaySizeSmall; HIToolbarSetDisplaySize( (HIToolbarRef) m_macHIToolbarRef, sizeSpec ); } @@ -1045,17 +1376,45 @@ void wxToolBar::MacSuperChangedPosition() if (! m_macUsesNativeToolbar ) Realize(); #else + Realize(); #endif } +void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap ) +{ + wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id)); + if ( tool ) + { + wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools.")); + + tool->SetNormalBitmap(bitmap); + + // a side-effect of the UpdateToggleImage function is that it always changes the bitmap used on the button. + tool->UpdateToggleImage( tool->CanBeToggled() && tool->IsToggled() ); + } +} + +void wxToolBar::SetToolDisabledBitmap( int id, const wxBitmap& bitmap ) +{ + wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id)); + if ( tool ) + { + wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools.")); + + tool->SetDisabledBitmap(bitmap); + + // TODO: what to do for this one? + } +} + wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const { + wxToolBarTool *tool; wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); - while ( node != NULL ) + while ( node ) { - wxToolBarTool *tool = (wxToolBarTool *)node->GetData() ; - + tool = (wxToolBarTool *)node->GetData(); if (tool != NULL) { wxRect2DInt r( tool->GetPosition(), tool->GetSize() ); @@ -1066,22 +1425,22 @@ wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const node = node->GetNext(); } - return (wxToolBarToolBase *)NULL; + return (wxToolBarToolBase*)NULL; } wxString wxToolBar::MacGetToolTipString( wxPoint &pt ) { - wxToolBarToolBase* tool = FindToolForPosition( pt.x , pt.y ) ; + wxToolBarToolBase *tool = FindToolForPosition( pt.x, pt.y ); if ( tool != NULL ) - return tool->GetShortHelp() ; + return tool->GetShortHelp(); - return wxEmptyString ; + return wxEmptyString; } void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable) { if ( t != NULL ) - ((wxToolBarTool*)t)->DoEnable( enable ) ; + ((wxToolBarTool*)t)->DoEnable( enable ); } void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle) @@ -1091,22 +1450,32 @@ void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle) tool->UpdateToggleImage( toggle ); } -bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), - wxToolBarToolBase *toolBase) +bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) { - wxToolBarTool* tool = wx_static_cast( wxToolBarTool* , toolBase ); + wxToolBarTool *tool = wx_static_cast( wxToolBarTool*, toolBase ); if (tool == NULL) return false; WindowRef window = (WindowRef) MacGetTopLevelWindowRef(); wxSize toolSize = GetToolSize(); - Rect toolrect = { 0, 0 , toolSize.y , toolSize.x }; + Rect toolrect = { 0, 0, toolSize.y, toolSize.x }; ControlRef controlHandle = NULL; OSStatus err = 0; + tool->Attach( this ); + +#if wxMAC_USE_NATIVE_TOOLBAR + wxString label = tool->GetLabel(); + if (m_macHIToolbarRef && !label.empty() ) + { + // strip mnemonics from the label for compatibility + // with the usual labels in wxStaticText sense + label = wxStripMenuCodes(label); + } +#endif // wxMAC_USE_NATIVE_TOOLBAR switch (tool->GetStyle()) { - case wxTOOL_STYLE_SEPARATOR : + case wxTOOL_STYLE_SEPARATOR: { wxASSERT( tool->GetControlHandle() == NULL ); toolSize.x /= 4; @@ -1116,107 +1485,123 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), else toolrect.right = toolSize.x; -#ifdef __WXMAC_OSX__ // in flat style we need a visual separator #if wxMAC_USE_NATIVE_TOOLBAR - HIToolbarItemRef item; - err = HIToolbarItemCreate( - kHIToolbarSeparatorIdentifier, - kHIToolbarItemCantBeRemoved | kHIToolbarItemIsSeparator | kHIToolbarItemAllowDuplicates, - &item ); - if (err == noErr) - tool->SetToolbarItemRef( item ); -#endif + if (m_macHIToolbarRef != NULL) + { + HIToolbarItemRef item; + err = HIToolbarItemCreate( + kHIToolbarSeparatorIdentifier, + kHIToolbarItemCantBeRemoved | kHIToolbarItemIsSeparator | kHIToolbarItemAllowDuplicates, + &item ); + if (err == noErr) + tool->SetToolbarItemRef( item ); + } + else + err = noErr; +#endif // wxMAC_USE_NATIVE_TOOLBAR CreateSeparatorControl( window, &toolrect, &controlHandle ); tool->SetControlHandle( controlHandle ); -#endif } break; - case wxTOOL_STYLE_BUTTON : + case wxTOOL_STYLE_BUTTON: { - wxASSERT( tool->GetControlHandle() == NULL ) ; - ControlButtonContentInfo info ; - wxMacCreateBitmapButton( &info , tool->GetNormalBitmap() , kControlContentIconRef ) ; + wxASSERT( tool->GetControlHandle() == NULL ); + ControlButtonContentInfo info; + wxMacCreateBitmapButton( &info, tool->GetNormalBitmap() ); if ( UMAGetSystemVersion() >= 0x1000) - CreateIconControl( window , &toolrect , &info , false , &controlHandle ) ; + { + // contrary to the docs this control only works with iconrefs + ControlButtonContentInfo info; + wxMacCreateBitmapButton( &info, tool->GetNormalBitmap(), kControlContentIconRef ); + CreateIconControl( window, &toolrect, &info, false, &controlHandle ); + wxMacReleaseBitmapButton( &info ); + } else { - SInt16 behaviour = kControlBehaviorOffsetContents ; + SInt16 behaviour = kControlBehaviorOffsetContents; if ( tool->CanBeToggled() ) - behaviour |= kControlBehaviorToggles ; - CreateBevelButtonControl( window , - &toolrect , CFSTR("") , kControlBevelButtonNormalBevel , - behaviour , &info , 0 , 0 , 0 , &controlHandle ) ; + behaviour |= kControlBehaviorToggles; + err = CreateBevelButtonControl( window, + &toolrect, CFSTR(""), kControlBevelButtonNormalBevel, + behaviour, &info, 0, 0, 0, &controlHandle ); } #if wxMAC_USE_NATIVE_TOOLBAR - HIToolbarItemRef item ; - wxString labelStr = wxString::Format(wxT("%xd"), (int)tool); - err = HIToolbarItemCreate( - wxMacCFStringHolder(labelStr, wxFont::GetDefaultEncoding()), - kHIToolbarItemCantBeRemoved | kHIToolbarItemAnchoredLeft | kHIToolbarItemAllowDuplicates, &item ); - if (err == noErr) + if (m_macHIToolbarRef != NULL) { - InstallEventHandler( HIObjectGetEventTarget(item), GetwxMacToolBarEventHandlerUPP(), - GetEventTypeCount(toolBarEventList), toolBarEventList, tool, NULL ); - HIToolbarItemSetLabel( item, wxMacCFStringHolder(tool->GetLabel(), m_font.GetEncoding()) ); - HIToolbarItemSetIconRef( item, info.u.iconRef ); - HIToolbarItemSetCommandID( item, kHIToolbarCommandPressAction ); - tool->SetToolbarItemRef( item ); + HIToolbarItemRef item; + wxString labelStr = wxString::Format(wxT("%p"), tool); + err = HIToolbarItemCreate( + wxCFStringRef(labelStr, wxFont::GetDefaultEncoding()), + kHIToolbarItemCantBeRemoved | kHIToolbarItemAnchoredLeft | kHIToolbarItemAllowDuplicates, &item ); + if (err == noErr) + { + ControlButtonContentInfo info2; + wxMacCreateBitmapButton( &info2, tool->GetNormalBitmap(), kControlContentCGImageRef); + + InstallEventHandler( + HIObjectGetEventTarget(item), GetwxMacToolBarEventHandlerUPP(), + GetEventTypeCount(toolBarEventList), toolBarEventList, tool, NULL ); + HIToolbarItemSetLabel( item, wxCFStringRef(label, GetFont().GetEncoding()) ); + HIToolbarItemSetImage( item, info2.u.imageRef ); + HIToolbarItemSetCommandID( item, kHIToolbarCommandPressAction ); + tool->SetToolbarItemRef( item ); + + wxMacReleaseBitmapButton( &info2 ); + } } -#endif + else + err = noErr; +#endif // wxMAC_USE_NATIVE_TOOLBAR + + wxMacReleaseBitmapButton( &info ); - wxMacReleaseBitmapButton( &info ) ; #if 0 - SetBevelButtonTextPlacement( m_controlHandle , kControlBevelButtonPlaceBelowGraphic ) ; - UMASetControlTitle( m_controlHandle , label , wxFont::GetDefaultEncoding() ) ; + SetBevelButtonTextPlacement( m_controlHandle, kControlBevelButtonPlaceBelowGraphic ); + SetControlTitleWithCFString( m_controlHandle , wxCFStringRef( label, wxFont::GetDefaultEncoding() ); #endif - InstallControlEventHandler( (ControlRef) controlHandle, GetwxMacToolBarToolEventHandlerUPP(), + InstallControlEventHandler( + (ControlRef) controlHandle, GetwxMacToolBarToolEventHandlerUPP(), GetEventTypeCount(eventList), eventList, tool, NULL ); tool->SetControlHandle( controlHandle ); } break; - case wxTOOL_STYLE_CONTROL : - wxASSERT( tool->GetControl() != NULL ); -#if 0 // wxMAC_USE_NATIVE_TOOLBAR - // FIXME: doesn't work yet... + case wxTOOL_STYLE_CONTROL: + +#if wxMAC_USE_NATIVE_TOOLBAR + if (m_macHIToolbarRef != NULL) { + wxCHECK_MSG( tool->GetControl(), false, _T("control must be non-NULL") ); HIToolbarItemRef item; - wxString labelStr = wxString::Format( wxT("%xd"), (int) tool ); - result = HIToolbarItemCreate( wxMacCFStringHolder(labelStr, wxFont::GetDefaultEncoding()), - kHIToolbarItemCantBeRemoved | kHIToolbarItemAnchoredLeft | kHIToolbarItemAllowDuplicates, - &item ); - if ( result == 0 ) + HIViewRef viewRef = (HIViewRef) tool->GetControl()->GetHandle() ; + CFDataRef data = CFDataCreate( kCFAllocatorDefault , (UInt8*) &viewRef , sizeof(viewRef) ) ; + err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID, + data , &item ) ; + + if (err == noErr) { - HIToolbarItemSetLabel( item, wxMacCFStringHolder(tool->GetLabel(), m_font.GetEncoding()) ); - HIToolbarItemSetCommandID( item, tool->GetId() ); tool->SetToolbarItemRef( item ); - - controlHandle = ( ControlRef ) tool->GetControlHandle(); - wxASSERT_MSG( controlHandle != NULL, wxT("NULL tool control") ); - - // FIXME: is this necessary ?? - ::GetControlBounds( controlHandle, &toolrect ); - UMAMoveControl( controlHandle, -toolrect.left, -toolrect.top ); - - // FIXME: is this necessary ?? - InstallControlEventHandler( controlHandle, GetwxMacToolBarToolEventHandlerUPP(), - GetEventTypeCount(eventList), eventList, tool, NULL ); } - } - + CFRelease( data ) ; + } + else + { + err = noErr; + break; + } #else - // FIXME: right now there's nothing to do here + // right now there's nothing to do here #endif break; - default : + default: break; } @@ -1225,9 +1610,9 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), if ( controlHandle ) { ControlRef container = (ControlRef) GetHandle(); - wxASSERT_MSG( container != NULL, wxT("No valid mac container control") ); + wxASSERT_MSG( container != NULL, wxT("No valid Mac container control") ); - UMAShowControl( controlHandle ); + SetControlVisibility( controlHandle, true, true ); ::EmbedControl( controlHandle, container ); } @@ -1235,13 +1620,11 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), tool->UpdateToggleImage( true ); // nothing special to do here - we relayout in Realize() later - tool->Attach(this); InvalidateBestSize(); } else { - wxString errMsg = wxString::Format( wxT("wxToolBar::DoInsertTool - failure [%ld]"), (long) err ); - wxASSERT_MSG( false, errMsg.c_str() ); + wxFAIL_MSG( wxString::Format( wxT("wxToolBar::DoInsertTool - failure [%ld]"), (long)err ) ); } return (err == noErr); @@ -1249,12 +1632,12 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle)) { - wxFAIL_MSG( _T("not implemented") ); + wxFAIL_MSG( wxT("not implemented") ); } bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase) { - wxToolBarTool* tool = wx_static_cast( wxToolBarTool* , toolbase ) ; + wxToolBarTool* tool = wx_static_cast( wxToolBarTool*, toolbase ); wxToolBarToolsList::compatibility_iterator node; for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) { @@ -1268,68 +1651,67 @@ bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase) } } - wxSize sz = ((wxToolBarTool*)tool)->GetSize() ; + wxSize sz = ((wxToolBarTool*)tool)->GetSize(); tool->Detach(); #if wxMAC_USE_NATIVE_TOOLBAR CFIndex removeIndex = tool->GetIndex(); -#endif +#endif +#if wxMAC_USE_NATIVE_TOOLBAR + if (m_macHIToolbarRef != NULL) + { + if ( removeIndex != -1 && m_macHIToolbarRef ) + { + HIToolbarRemoveItemAtIndex( (HIToolbarRef) m_macHIToolbarRef, removeIndex ); + tool->SetIndex( -1 ); + } + } +#endif switch ( tool->GetStyle() ) { case wxTOOL_STYLE_CONTROL: - { + if ( tool->GetControl() ) tool->GetControl()->Destroy(); - tool->ClearControl() ; - } break; case wxTOOL_STYLE_BUTTON: case wxTOOL_STYLE_SEPARATOR: - if ( tool->GetControlHandle() ) - { - DisposeControl( (ControlRef) tool->GetControlHandle() ) ; - -#if wxMAC_USE_NATIVE_TOOLBAR - if ( removeIndex != -1 && m_macHIToolbarRef ) - { - HIToolbarRemoveItemAtIndex( (HIToolbarRef) m_macHIToolbarRef , removeIndex ) ; - tool->SetIndex( -1 ) ; - } -#endif - - tool->ClearControl() ; - } + // nothing special break; default: break; } + tool->ClearControl(); // and finally reposition all the controls after this one - for ( /* node -> first after deleted */ ; node; node = node->GetNext() ) + for ( /* node -> first after deleted */; node; node = node->GetNext() ) { wxToolBarTool *tool2 = (wxToolBarTool*) node->GetData(); - wxPoint pt = tool2->GetPosition() ; + wxPoint pt = tool2->GetPosition(); if ( GetWindowStyleFlag() & wxTB_VERTICAL ) - pt.y -= sz.y ; + pt.y -= sz.y; else - pt.x -= sz.x ; + pt.x -= sz.x; - tool2->SetPosition( pt ) ; + tool2->SetPosition( pt ); #if wxMAC_USE_NATIVE_TOOLBAR - if ( removeIndex != -1 && tool2->GetIndex() > removeIndex ) - tool2->SetIndex( tool2->GetIndex() - 1 ) ; + if (m_macHIToolbarRef != NULL) + { + if ( removeIndex != -1 && tool2->GetIndex() > removeIndex ) + tool2->SetIndex( tool2->GetIndex() - 1 ); + } #endif } InvalidateBestSize(); - return true ; + return true; } void wxToolBar::OnPaint(wxPaintEvent& event) @@ -1337,89 +1719,35 @@ void wxToolBar::OnPaint(wxPaintEvent& event) #if wxMAC_USE_NATIVE_TOOLBAR if ( m_macUsesNativeToolbar ) { - event.Skip(true) ; - return ; + event.Skip(true); + return; } #endif - wxPaintDC dc(this) ; + wxPaintDC dc(this); - int w, h ; - GetSize( &w , &h ) ; + int w, h; + GetSize( &w, &h ); -#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3 - if ( !MacGetTopLevelWindow()->MacGetMetalAppearance() ) - { - if ( UMAGetSystemVersion() >= 0x1030 ) - { - HIThemePlacardDrawInfo info ; - memset( &info, 0, sizeof(info) ) ; - info.version = 0 ; - info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive ; - - CGContextRef cgContext = (CGContextRef) MacGetCGContextRef() ; - HIRect rect = CGRectMake( 0 , 0 , w , h ) ; - HIThemeDrawPlacard( &rect , & info , cgContext, kHIThemeOrientationNormal) ; - } - } - else - { - // leave the background as it is (striped or metal) - } + bool drawMetalTheme = MacGetTopLevelWindow()->MacGetMetalAppearance(); -#else - wxMacPortSetter helper(&dc) ; - - 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() ) + if ( !drawMetalTheme ) { - UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ; + HIThemePlacardDrawInfo info; + memset( &info, 0, sizeof(info) ); + info.version = 0; + info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive; + + CGContextRef cgContext = (CGContextRef) MacGetCGContextRef(); + HIRect rect = CGRectMake( 0, 0, w, h ); + HIThemeDrawPlacard( &rect, &info, cgContext, kHIThemeOrientationNormal ); } 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 + // leave the background as it is (striped or metal) } -#endif - event.Skip() ; + event.Skip(); } #endif // wxUSE_TOOLBAR -