X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0bca03736369e836cce9297509505c5972e775dd..33046a8283bcb192ffe717dea944cb4ef262e9da:/src/mac/carbon/toolbar.cpp diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp index b4702c6daf..60e0a5cf9f 100644 --- a/src/mac/carbon/toolbar.cpp +++ b/src/mac/carbon/toolbar.cpp @@ -19,6 +19,7 @@ #include "wx/wx.h" #endif +#include "wx/app.h" #include "wx/mac/uma.h" #include "wx/geometry.h" @@ -79,14 +80,9 @@ public: SetControlHandle( (ControlRef) control->GetHandle() ); } - ~wxToolBarTool() + virtual ~wxToolBarTool() { ClearControl(); - -#if wxMAC_USE_NATIVE_TOOLBAR - if ( m_toolbarItemRef ) - CFRelease( m_toolbarItemRef ); -#endif } WXWidget GetControlHandle() @@ -106,12 +102,24 @@ public: m_control = NULL; if ( m_controlHandle ) { - DisposeControl( m_controlHandle ); + if ( !IsControl() ) + DisposeControl( m_controlHandle ); + else + { + // the embedded control is not under the responsibility of the tool + } m_controlHandle = NULL ; } #if wxMAC_USE_NATIVE_TOOLBAR - m_toolbarItemRef = NULL; + if ( m_toolbarItemRef ) + { + CFIndex count = CFGetRetainCount( m_toolbarItemRef ) ; + wxASSERT_MSG( count == 1 , wxT("Reference Count of native tool was not 1 in wxToolBarTool destructor") ); + wxTheApp->MacAddToAutorelease(m_toolbarItemRef); + CFRelease(m_toolbarItemRef); + m_toolbarItemRef = NULL; + } #endif } @@ -387,18 +395,9 @@ 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; - } - if ( IsButton() ) { Rect contrlRect; @@ -414,7 +413,13 @@ void wxToolBarTool::SetPosition( const wxPoint& position ) } 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 { @@ -433,33 +438,6 @@ void wxToolBarTool::SetPosition( const wxPoint& position ) 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 ) { @@ -469,21 +447,33 @@ 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 ); + wxMacCreateBitmapButton( &info, bmp, kControlContentIconRef ); SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info ); +#if wxMAC_USE_NATIVE_TOOLBAR + if (m_toolbarItemRef != NULL) + { + HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef ); + } +#endif wxMacReleaseBitmapButton( &info ); } else { ControlButtonContentInfo info; - wxMacCreateBitmapButton( &info, m_bmpNormal ); + wxMacCreateBitmapButton( &info, m_bmpNormal, kControlContentIconRef ); SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info ); +#if wxMAC_USE_NATIVE_TOOLBAR + if (m_toolbarItemRef != NULL) + { + HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef ); + } +#endif wxMacReleaseBitmapButton( &info ); } @@ -552,9 +542,259 @@ void wxToolBar::Init() #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->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 ; + + result = noErr ; + } + break; + + case kEventHIObjectDestruct: + { + // we've increased the ref count when creating this, so we decrease manually again in case + // it was never really installed and deinstalled + HIViewRef viewRef = object->viewRef ; + if( viewRef && IsValidControlHandle( viewRef) ) + { + CFIndex count = CFGetRetainCount( viewRef ) ; + if ( count >= 1 ) + 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 ); + + result = SetEventParameter( inEvent, kEventParamControlRef, typeControlRef, sizeof( HIViewRef ), &viewRef ); + } + 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 ; + + 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 inCallRef, EventRef inEvent, void* 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, wxWindowID id, @@ -566,6 +806,8 @@ bool wxToolBar::Create( if ( !wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name ) ) return false; + FixupStyle(); + OSStatus err = noErr; #if wxMAC_USE_NATIVE_TOOLBAR @@ -576,6 +818,9 @@ bool wxToolBar::Create( if (m_macHIToolbarRef != NULL) { + InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler, + GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL ); + HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault; HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall; @@ -603,6 +848,9 @@ wxToolBar::~wxToolBar() if (m_macUsesNativeToolbar) MacInstallNativeToolbar( false ); + CFIndex count = CFGetRetainCount( m_macHIToolbarRef ) ; + wxASSERT_MSG( count == 1 , wxT("Reference Count of native control was not 1 in wxToolBar destructor") ); + CFRelease( (HIToolbarRef)m_macHIToolbarRef ); m_macHIToolbarRef = NULL; } @@ -841,7 +1089,6 @@ bool wxToolBar::Realize() bool lastIsRadio = false; bool curIsRadio = false; - bool setChoiceInGroup = false; #if wxMAC_USE_NATIVE_TOOLBAR CFIndex currentPosition = 0; @@ -936,8 +1183,6 @@ bool wxToolBar::Realize() { if ( tool->IsToggled() ) DoToggleTool( tool, true ); - - setChoiceInGroup = false; } else { @@ -946,7 +1191,6 @@ bool wxToolBar::Realize() if ( tool->Toggle( true ) ) { DoToggleTool( tool, true ); - setChoiceInGroup = true; } } else if ( tool->IsToggled() ) @@ -1015,7 +1259,7 @@ bool wxToolBar::Realize() InvalidateBestSize(); #endif - SetBestFittingSize(); + SetInitialSize(); return true; } @@ -1206,39 +1450,28 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase) break; case wxTOOL_STYLE_CONTROL: - wxASSERT( tool->GetControl() != NULL ); -#if 0 // wxMAC_USE_NATIVE_TOOLBAR - // FIXME: doesn't work yet... +#if wxMAC_USE_NATIVE_TOOLBAR { + wxASSERT( tool->GetControl() != NULL ); HIToolbarItemRef item; - wxString labelStr = wxString::Format( wxT("%xd"), (int)tool ); - result = HIToolbarItemCreate( - wxMacCFStringHolder( labelStr, wxFont::GetDefaultEncoding() ), - kHIToolbarItemCantBeRemoved | kHIToolbarItemAnchoredLeft | kHIToolbarItemAllowDuplicates, - &item ); - if ( result == noErr ) + 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 ) ; + + 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 - // FIXME: right now there's nothing to do here + // right now there's nothing to do here #endif break; @@ -1302,34 +1535,29 @@ bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase) CFIndex removeIndex = tool->GetIndex(); #endif +#if wxMAC_USE_NATIVE_TOOLBAR + 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 @@ -1434,7 +1662,9 @@ void wxToolBar::OnPaint(wxPaintEvent& event) drawInfo.kind = kThemeBackgroundMetal; HIThemeApplyBackground( &hiToolbarrect, &drawInfo, cgContext, kHIThemeOrientationNormal ); +#ifndef __LP64__ QDEndCGContext( (CGrafPtr) dc.m_macPort, &cgContext ); +#endif #endif } }