X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4362c7052b045f2ae743057d0fe8a17e053894cd..85d3d198c2fa866d39763ace3eebf14c0d164ba7:/src/mac/carbon/toolbar.cpp?ds=sidebyside

diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp
index 5c7934010e..7614e62312 100644
--- a/src/mac/carbon/toolbar.cpp
+++ b/src/mac/carbon/toolbar.cpp
@@ -13,10 +13,12 @@
 
 #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/mac/uma.h"
 #include "wx/geometry.h"
 
@@ -77,7 +79,7 @@ public:
             SetControlHandle( (ControlRef) control->GetHandle() );
     }
 
-    ~wxToolBarTool()
+    virtual ~wxToolBarTool()
     {
         ClearControl();
 
@@ -104,7 +106,12 @@ 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 ;
         }
 
@@ -385,18 +392,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;
@@ -412,7 +410,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
     {
@@ -431,33 +435,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 )
     {
@@ -467,14 +444,20 @@ 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)
+        {
+            HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef );
+        }
+#endif
         wxMacReleaseBitmapButton( &info );
     }
     else
@@ -482,6 +465,12 @@ 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)
+        {
+            HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef );
+        }
+#endif
         wxMacReleaseBitmapButton( &info );
     }
 
@@ -550,9 +539,248 @@ 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:
+                    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,
@@ -564,6 +792,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
@@ -574,6 +804,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;
 
@@ -839,7 +1072,6 @@ bool wxToolBar::Realize()
 
     bool lastIsRadio = false;
     bool curIsRadio = false;
-    bool setChoiceInGroup = false;
 
 #if wxMAC_USE_NATIVE_TOOLBAR
     CFIndex currentPosition = 0;
@@ -934,8 +1166,6 @@ bool wxToolBar::Realize()
         {
             if ( tool->IsToggled() )
                 DoToggleTool( tool, true );
-
-            setChoiceInGroup = false;
         }
         else
         {
@@ -944,7 +1174,6 @@ bool wxToolBar::Realize()
                 if ( tool->Toggle( true ) )
                 {
                     DoToggleTool( tool, true );
-                    setChoiceInGroup = true;
                 }
             }
             else if ( tool->IsToggled() )
@@ -1013,7 +1242,7 @@ bool wxToolBar::Realize()
     InvalidateBestSize();
 #endif
 
-    SetBestFittingSize();
+    SetInitialSize();
 
     return true;
 }
@@ -1204,39 +1433,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;
 
@@ -1432,7 +1650,9 @@ void wxToolBar::OnPaint(wxPaintEvent& event)
             drawInfo.kind = kThemeBackgroundMetal;
             HIThemeApplyBackground( &hiToolbarrect, &drawInfo, cgContext, kHIThemeOrientationNormal );
 
+#ifndef __LP64__
             QDEndCGContext( (CGrafPtr) dc.m_macPort, &cgContext );
+#endif
 #endif
         }
     }