X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9d5ccdd3263d210ccc3b728e7b3f9680577b74df..0c1cc9483ecba053bc9a0983a4a8d48898e334f2:/src/mac/carbon/toolbar.cpp?ds=sidebyside diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp index 73667cb7e7..02778a1791 100644 --- a/src/mac/carbon/toolbar.cpp +++ b/src/mac/carbon/toolbar.cpp @@ -19,25 +19,18 @@ #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 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl) @@ -57,6 +50,17 @@ 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: @@ -71,8 +75,8 @@ public: const wxString& shortHelp, const wxString& longHelp ); - wxToolBarTool(wxToolBar *tbar, wxControl *control) - : wxToolBarToolBase(tbar, control) + wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label) + : wxToolBarToolBase(tbar, control, label) { Init(); if (control != NULL) @@ -82,11 +86,6 @@ public: virtual ~wxToolBarTool() { ClearControl(); - -#if wxMAC_USE_NATIVE_TOOLBAR - if ( m_toolbarItemRef ) - CFRelease( m_toolbarItemRef ); -#endif } WXWidget GetControlHandle() @@ -103,21 +102,36 @@ public: 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 + // 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 @@ -165,10 +179,19 @@ public: 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 ) ); } } @@ -213,12 +236,10 @@ private: static const EventTypeSpec eventList[] = { { kEventClassControl, kEventControlHit }, -#ifdef __WXMAC_OSX__ { kEventClassControl, kEventControlHitTest }, -#endif }; -static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef handler, EventRef event, void *data ) +static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef WXUNUSED(handler), EventRef event, void *data ) { OSStatus result = eventNotHandledErr; ControlRef controlRef; @@ -236,11 +257,7 @@ static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef { bool shouldToggle; -#ifdef __WXMAC_OSX__ shouldToggle = !tbartool->IsToggled(); -#else - shouldToggle = (GetControl32BitValue( (ControlRef)(tbartool->GetControlHandle()) ) != 0); -#endif tbar->ToggleTool( tbartool->GetId(), shouldToggle ); } @@ -251,7 +268,6 @@ static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef } break; -#ifdef __WXMAC_OSX__ case kEventControlHitTest: { HIPoint pt = cEvent.GetParameter(kEventParamMouseLocation); @@ -265,7 +281,6 @@ static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef result = noErr; } break; -#endif default: break; @@ -300,7 +315,7 @@ static const EventTypeSpec toolBarEventList[] = { 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; @@ -370,17 +385,10 @@ bool wxToolBarTool::DoEnable( bool enable ) if ( m_controlHandle != NULL ) { -#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 } } @@ -392,8 +400,6 @@ 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; @@ -407,7 +413,7 @@ void wxToolBarTool::SetPosition( const wxPoint& position ) 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() ) @@ -423,48 +429,18 @@ void wxToolBarTool::SetPosition( const wxPoint& position ) else { // separator -#ifdef __WXMAC_OSX__ 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) - { - OptionBits addAttrs, removeAttrs; - OSStatus result; - - if (toggle) - { - addAttrs = kHIToolbarItemSelected; - removeAttrs = kHIToolbarItemNoAttributes; - } - else - { - addAttrs = kHIToolbarItemNoAttributes; - removeAttrs = kHIToolbarItemSelected; - } - - result = HIToolbarItemChangeAttributes( m_toolbarItemRef, addAttrs, removeAttrs ); - } -#endif - -#ifdef __WXMAC_OSX__ if ( toggle ) { int w = m_bmpNormal.GetWidth(); @@ -473,14 +449,23 @@ void wxToolBarTool::UpdateToggleImage( bool toggle ) wxMemoryDC dc; dc.SelectObject( bmp ); - dc.SetPen( wxNullPen ); - dc.SetBackground( *wxWHITE ); + 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) + { + ControlButtonContentInfo info2; + wxMacCreateBitmapButton( &info2, bmp, kControlContentCGImageRef); + HIToolbarItemSetImage( m_toolbarItemRef, info2.u.imageRef ); + wxMacReleaseBitmapButton( &info2 ); + } +#endif wxMacReleaseBitmapButton( &info ); } else @@ -488,6 +473,15 @@ void wxToolBarTool::UpdateToggleImage( bool toggle ) 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 ); } @@ -497,9 +491,6 @@ void wxToolBarTool::UpdateToggleImage( bool toggle ) sizeof(transform), (Ptr)&transform ); HIViewSetNeedsDisplay( m_controlHandle, true ); -#else - ::SetControl32BitValue( m_controlHandle, toggle ); -#endif } wxToolBarTool::wxToolBarTool( @@ -538,9 +529,10 @@ wxToolBarToolBase *wxToolBar::CreateTool( 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() @@ -556,226 +548,254 @@ void wxToolBar::Init() #endif } -#define kControlToolbarItemClassID CFSTR( "org.wxwidgets.controltoolbaritem" ) +#define kControlToolbarItemClassID CFSTR( "org.wxwidgets.controltoolbaritem" ) -const EventTypeSpec kEvents[] = +const EventTypeSpec kEvents[] = { - { kEventClassHIObject, kEventHIObjectConstruct }, - { kEventClassHIObject, kEventHIObjectInitialize }, - { kEventClassHIObject, kEventHIObjectDestruct }, - - { kEventClassToolbarItem, kEventToolbarItemCreateCustomView } + { kEventClassHIObject, kEventHIObjectConstruct }, + { kEventClassHIObject, kEventHIObjectInitialize }, + { kEventClassHIObject, kEventHIObjectDestruct }, + + { kEventClassToolbarItem, kEventToolbarItemCreateCustomView } }; -const EventTypeSpec kViewEvents[] = -{ - { kEventClassControl, kEventControlGetSizeConstraints } +const EventTypeSpec kViewEvents[] = +{ + { kEventClassControl, kEventControlGetSizeConstraints } }; -struct ControlToolbarItem -{ - HIToolbarItemRef toolbarItem; +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, + 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 ); - + + SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof( void * ), &item ); + result = noErr ; - } - break; - + } + break; + case kEventHIObjectInitialize: result = CallNextEventHandler( inCallRef, inEvent ); - if ( result == noErr ) + 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 ) ; - result = noErr ; - } + verify_noerr(InstallEventHandler( GetControlEventTarget( viewRef ), ControlToolbarItemHandler, + GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL )); + result = noErr ; + } break; - case kEventHIObjectDestruct: - free( object ) ; - result = noErr; - break; - } - break; - - case kEventClassToolbarItem: - switch ( GetEventKind( inEvent ) ) - { - case kEventToolbarItemCreateCustomView: - { - HIViewRef viewRef = object->viewRef ; + 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) ; - InstallEventHandler( GetControlEventTarget( viewRef ), ControlToolbarItemHandler, - GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL ); - + CFRetain( viewRef ) ; result = SetEventParameter( inEvent, kEventParamControlRef, typeControlRef, sizeof( HIViewRef ), &viewRef ); - } - break; - } - break; - - case kEventClassControl: - switch ( GetEventKind( inEvent ) ) - { - case kEventControlGetSizeConstraints: - { + } + break; + } + break; + + case kEventClassControl: + switch ( GetEventKind( inEvent ) ) + { + case kEventControlGetSizeConstraints: + { wxWindow* wxwindow = wxFindControlFromMacControl(object->viewRef ) ; if ( wxwindow ) { - wxSize sz = wxwindow->GetSize() ; - sz.x -= wxwindow->MacGetLeftBorderSize() + wxwindow->MacGetRightBorderSize(); - sz.y -= wxwindow->MacGetTopBorderSize() + wxwindow->MacGetBottomBorderSize(); - // during toolbar layout the native window sometimes gets negative sizes - // so we always keep the last valid size here, to make sure we survive the - // shuffle ... - if ( sz.x > 0 && sz.y > 0 ) - object->lastValidSize = sz ; - else - sz = object->lastValidSize ; - + // 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; + } + break; + } + break; + } + + return result; } void RegisterControlToolbarItemClass() { - static bool sRegistered; - - if ( !sRegistered ) - { - HIObjectRegisterSubclass( kControlToolbarItemClassID, kHIToolbarItemClassID, 0, - ControlToolbarItemHandler, GetEventTypeCount( kEvents ), kEvents, 0, NULL ); - - sRegistered = true; - } + 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 ; + 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 }, + { kEventClassToolbar, kEventToolbarGetDefaultIdentifiers }, + { kEventClassToolbar, kEventToolbarGetAllowedIdentifiers }, + { kEventClassToolbar, kEventToolbarCreateItemWithIdentifier }, }; -static OSStatus ToolbarDelegateHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData ) +static OSStatus ToolbarDelegateHandler(EventHandlerCallRef WXUNUSED(inCallRef), + EventRef inEvent, + void* WXUNUSED(inUserData)) { - OSStatus result = eventNotHandledErr; + OSStatus result = eventNotHandledErr; // Not yet needed // wxToolBar* toolbar = (wxToolBar*) inUserData ; - CFMutableArrayRef array; + CFMutableArrayRef array; - switch ( GetEventKind( inEvent ) ) - { - case kEventToolbarGetDefaultIdentifiers: + switch ( GetEventKind( inEvent ) ) + { + case kEventToolbarGetDefaultIdentifiers: { GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL, - sizeof( CFMutableArrayRef ), NULL, &array ); + sizeof( CFMutableArrayRef ), NULL, &array ); // not implemented yet // GetToolbarDefaultItems( array ); result = noErr; } - break; - - case kEventToolbarGetAllowedIdentifiers: + break; + + case kEventToolbarGetAllowedIdentifiers: { GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL, - sizeof( CFMutableArrayRef ), NULL, &array ); + sizeof( CFMutableArrayRef ), NULL, &array ); // not implemented yet // GetToolbarAllowedItems( array ); result = noErr; } - break; - case kEventToolbarCreateItemWithIdentifier: - { - HIToolbarItemRef item = NULL; - CFTypeRef data = NULL; + 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 ); - + + 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 ); @@ -785,13 +805,14 @@ static OSStatus ToolbarDelegateHandler( EventHandlerCallRef inCallRef, EventRef sizeof( HIToolbarItemRef ), &item ); result = noErr; } - } - - } - break; + } + + } + 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 @@ -807,33 +828,38 @@ bool wxToolBar::Create( 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) { - InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler, - GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL ); + wxString labelStr = wxString::Format( wxT("%p"), this ); + err = HIToolbarCreate( + wxCFStringRef( labelStr, wxFont::GetDefaultEncoding() ), 0, + (HIToolbarRef*) &m_macHIToolbarRef ); - HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault; - HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall; + if (m_macHIToolbarRef != NULL) + { + InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler, + GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL ); - if ( style & wxTB_NOICONS ) - mode = kHIToolbarDisplayModeLabelOnly; - else if ( style & wxTB_TEXT ) - mode = kHIToolbarDisplayModeIconAndLabel; - else - mode = kHIToolbarDisplayModeIconOnly; + 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); } @@ -847,6 +873,15 @@ wxToolBar::~wxToolBar() if (m_macUsesNativeToolbar) MacInstallNativeToolbar( false ); + 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; } @@ -1067,7 +1102,7 @@ bool wxToolBar::Realize() // find the maximum tool width and height wxToolBarTool *tool; wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst(); - while ( node != NULL ) + while ( node ) { tool = (wxToolBarTool *) node->GetData(); if ( tool != NULL ) @@ -1085,15 +1120,16 @@ bool wxToolBar::Realize() bool lastIsRadio = false; bool curIsRadio = false; - bool setChoiceInGroup = false; #if wxMAC_USE_NATIVE_TOOLBAR CFIndex currentPosition = 0; bool insertAll = false; + + HIToolbarRef refTB = (HIToolbarRef)m_macHIToolbarRef; #endif node = m_tools.GetFirst(); - while ( node != NULL ) + while ( node ) { tool = (wxToolBarTool*) node->GetData(); if ( tool == NULL ) @@ -1129,9 +1165,9 @@ 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) ) @@ -1143,28 +1179,64 @@ bool wxToolBar::Realize() // 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 ); - } - - if (err != noErr) - { - wxString errMsg = wxString::Format( wxT("HIToolbarRemoveItemAtIndex failed [%ld]"), (long)err ); - wxFAIL_MSG( errMsg.c_str() ); + 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); + } } } - err = HIToolbarInsertItemAtIndex( (HIToolbarRef) m_macHIToolbarRef, hiItemRef, currentPosition ); + err = HIToolbarInsertItemAtIndex( refTB, hiItemRef, currentPosition ); if (err != noErr) { - wxString errMsg = wxString::Format( wxT("HIToolbarInsertItemAtIndex failed [%ld]"), (long)err ); - wxFAIL_MSG( errMsg.c_str() ); + wxLogDebug( wxT("HIToolbarInsertItemAtIndex failed [%ld]"), (long)err ); } 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++; @@ -1180,8 +1252,6 @@ bool wxToolBar::Realize() { if ( tool->IsToggled() ) DoToggleTool( tool, true ); - - setChoiceInGroup = false; } else { @@ -1190,7 +1260,6 @@ bool wxToolBar::Realize() if ( tool->Toggle( true ) ) { DoToggleTool( tool, true ); - setChoiceInGroup = true; } } else if ( tool->IsToggled() ) @@ -1199,7 +1268,7 @@ 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) ) @@ -1259,7 +1328,7 @@ bool wxToolBar::Realize() InvalidateBestSize(); #endif - SetBestFittingSize(); + SetInitialSize(); return true; } @@ -1312,11 +1381,38 @@ void wxToolBar::MacSuperChangedPosition() #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 ) { tool = (wxToolBarTool *)node->GetData(); if (tool != NULL) @@ -1365,6 +1461,17 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) 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()) { @@ -1378,21 +1485,24 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) 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; @@ -1400,11 +1510,15 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) { wxASSERT( tool->GetControlHandle() == NULL ); ControlButtonContentInfo info; - wxMacCreateBitmapButton( &info, tool->GetNormalBitmap(), kControlContentIconRef ); + wxMacCreateBitmapButton( &info, tool->GetNormalBitmap() ); if ( UMAGetSystemVersion() >= 0x1000) { + // 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 { @@ -1417,28 +1531,38 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) } #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 ); #if 0 SetBevelButtonTextPlacement( m_controlHandle, kControlBevelButtonPlaceBelowGraphic ); - UMASetControlTitle( m_controlHandle, label, wxFont::GetDefaultEncoding() ); + SetControlTitleWithCFString( m_controlHandle , wxCFStringRef( label, wxFont::GetDefaultEncoding() ); #endif InstallControlEventHandler( @@ -1452,16 +1576,14 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) case wxTOOL_STYLE_CONTROL: #if wxMAC_USE_NATIVE_TOOLBAR + if (m_macHIToolbarRef != NULL) { - wxASSERT( tool->GetControl() != NULL ); + wxCHECK_MSG( tool->GetControl(), false, _T("control must be non-NULL") ); HIToolbarItemRef item; HIViewRef viewRef = (HIViewRef) tool->GetControl()->GetHandle() ; - // as this control now is part of both the wxToolBar children and the native toolbar, we have to increase the - // reference count to make sure we are not dealing with zombie controls after the native toolbar has released its views - CFRetain( viewRef ) ; CFDataRef data = CFDataCreate( kCFAllocatorDefault , (UInt8*) &viewRef , sizeof(viewRef) ) ; - err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID, - data , &item ) ; + err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID, + data , &item ) ; if (err == noErr) { @@ -1469,7 +1591,11 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) } CFRelease( data ) ; } - + else + { + err = noErr; + break; + } #else // right now there's nothing to do here #endif @@ -1486,7 +1612,7 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) ControlRef container = (ControlRef) GetHandle(); wxASSERT_MSG( container != NULL, wxT("No valid Mac container control") ); - UMAShowControl( controlHandle ); + SetControlVisibility( controlHandle, true, true ); ::EmbedControl( controlHandle, container ); } @@ -1494,13 +1620,11 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) 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 ); - wxFAIL_MSG( errMsg.c_str() ); + wxFAIL_MSG( wxString::Format( wxT("wxToolBar::DoInsertTool - failure [%ld]"), (long)err ) ); } return (err == noErr); @@ -1535,34 +1659,32 @@ bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase) CFIndex removeIndex = tool->GetIndex(); #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() ) - { -#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 @@ -1579,8 +1701,11 @@ bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase) 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 } @@ -1605,10 +1730,8 @@ void wxToolBar::OnPaint(wxPaintEvent& event) GetSize( &w, &h ); bool drawMetalTheme = MacGetTopLevelWindow()->MacGetMetalAppearance(); - bool minimumUmaAvailable = (UMAGetSystemVersion() >= 0x1030); -#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3 - if ( !drawMetalTheme && minimumUmaAvailable ) + if ( !drawMetalTheme ) { HIThemePlacardDrawInfo info; memset( &info, 0, sizeof(info) ); @@ -1624,55 +1747,6 @@ void wxToolBar::OnPaint(wxPaintEvent& event) // leave the background as it is (striped or metal) } -#else - - const bool drawBorder = true; - - if (drawBorder) - { - wxMacPortSetter helper( &dc ); - - if ( !drawMetalTheme || !minimumUmaAvailable ) - { - Rect toolbarrect = { dc.YLOG2DEVMAC(0), dc.XLOG2DEVMAC(0), - dc.YLOG2DEVMAC(h), dc.XLOG2DEVMAC(w) }; - -#if 0 - if ( toolbarrect.left < 0 ) - toolbarrect.left = 0; - if ( toolbarrect.top < 0 ) - toolbarrect.top = 0; -#endif - - UMADrawThemePlacard( &toolbarrect, IsEnabled() ? kThemeStateActive : kThemeStateInactive ); - } - else - { -#if TARGET_API_MAC_OSX - 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 ); -#endif - } - } -#endif - event.Skip(); }