fixed wxGetTranslation() prototype in the !wxUSE_INTL case

[wxWidgets.git] / src / mac / carbon / toolbar.cpp

diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp
index 958f7127f7f614e4bc848a05bef0eaa3bd2f7069..60e0a5cf9fccc300778f7656699138b46a813daa 100644 (file)
--- a/src/mac/carbon/toolbar.cpp
+++ b/src/mac/carbon/toolbar.cpp
@@ -19,6 +19,7 @@
     #include "wx/wx.h"
 #endif
 
     #include "wx/wx.h"
 #endif
 

+#include "wx/app.h"

 #include "wx/mac/uma.h"
 #include "wx/geometry.h"
 
 #include "wx/mac/uma.h"
 #include "wx/geometry.h"
 


@@ -79,14 +80,9 @@ public:
             SetControlHandle( (ControlRef) control->GetHandle() );
     }
 
             SetControlHandle( (ControlRef) control->GetHandle() );
     }
 

-    ~wxToolBarTool()
+    virtual ~wxToolBarTool()

     {
         ClearControl();
     {
         ClearControl();

-
-#if wxMAC_USE_NATIVE_TOOLBAR
-        if ( m_toolbarItemRef )
-            CFRelease( m_toolbarItemRef );
-#endif

     }
 
     WXWidget GetControlHandle()
     }
 
     WXWidget GetControlHandle()


@@ -106,12 +102,24 @@ public:
         m_control = NULL;
         if ( m_controlHandle )
         {
         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_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
     }
 
 #endif
     }
 


@@ -387,8 +395,6 @@ void wxToolBarTool::SetPosition( const wxPoint& position )
     m_x = position.x;
     m_y = position.y;
 
     m_x = position.x;
     m_y = position.y;
 

-    int x, y;
-    x = y = 0;

     int mac_x = position.x;
     int mac_y = position.y;
 
     int mac_x = position.x;
     int mac_y = position.y;
 


@@ -407,7 +413,13 @@ void wxToolBarTool::SetPosition( const wxPoint& position )
     }
     else if ( IsControl() )
     {
     }
     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
     {
     }
     else
     {


@@ -426,33 +438,6 @@ void wxToolBarTool::SetPosition( const wxPoint& position )
 
 void wxToolBarTool::UpdateToggleImage( bool toggle )
 {
 
 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 )
     {
 #ifdef __WXMAC_OSX__
     if ( toggle )
     {


@@ -462,21 +447,33 @@ void wxToolBarTool::UpdateToggleImage( bool toggle )
         wxMemoryDC dc;
 
         dc.SelectObject( bmp );
         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;
         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 );
         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;
         wxMacReleaseBitmapButton( &info );
     }
     else
     {
         ControlButtonContentInfo info;

-        wxMacCreateBitmapButton( &info, m_bmpNormal );
+        wxMacCreateBitmapButton( &info, m_bmpNormal, kControlContentIconRef );

         SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
         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 );
     }
 
         wxMacReleaseBitmapButton( &info );
     }
 


@@ -545,15 +542,15 @@ void wxToolBar::Init()
 #endif
 }
 
 #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[] = 
 };
 
 const EventTypeSpec kViewEvents[] = 


@@ -570,40 +567,40 @@ struct ControlToolbarItem
 
 static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
 {
 
 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 );
                             sizeof( HIObjectRef ), NULL, &toolbarItem );

-                                               
+                        

                         item = (ControlToolbarItem*) malloc(sizeof(ControlToolbarItem)) ;
                         item->toolbarItem = toolbarItem ;
                         item->viewRef = NULL ;
                         
                         item = (ControlToolbarItem*) malloc(sizeof(ControlToolbarItem)) ;
                         item->toolbarItem = toolbarItem ;
                         item->viewRef = NULL ;
                         

-                                               SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof( void * ), &item );
+                        SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof( void * ), &item );

                         
                         result = noErr ;
                         
                         result = noErr ;

-                                       }
-                                       break;
+                    }
+                    break;

  
                 case kEventHIObjectInitialize:
                     result = CallNextEventHandler( inCallRef, inEvent );
  
                 case kEventHIObjectInitialize:
                     result = CallNextEventHandler( inCallRef, inEvent );

-                                       if ( result == noErr )
+                    if ( result == noErr )

                     {
                         CFDataRef           data;
                         GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
                             sizeof( CFTypeRef ), NULL, &data );
                     {
                         CFDataRef           data;
                         GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
                             sizeof( CFTypeRef ), NULL, &data );

-                                       
+                    

                         HIViewRef viewRef ;
                         
                         wxASSERT_MSG( CFDataGetLength( data ) == sizeof( viewRef ) , wxT("Illegal Data passed") ) ;
                         HIViewRef viewRef ;
                         
                         wxASSERT_MSG( CFDataGetLength( data ) == sizeof( viewRef ) , wxT("Illegal Data passed") ) ;


@@ -611,22 +608,33 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                     
                         object->viewRef = (HIViewRef) viewRef ;
 
                     
                         object->viewRef = (HIViewRef) viewRef ;
 

-                                               result = noErr ;
-                                       }
+                        result = noErr ;
+                    }

                     break;
 
                     break;
 

-                               case kEventHIObjectDestruct:
-                    free( object ) ;
-                                       result = noErr;
-                                       break;
-                       }
-                       break;
-               
-               case kEventClassToolbarItem:
-                       switch ( GetEventKind( inEvent ) )
-                       {                               
-                               case kEventToolbarItemCreateCustomView:
-                               {
+                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 ) ;
                     HIViewRef viewRef = object->viewRef ;
 
                     HIViewRemoveFromSuperview( viewRef ) ;


@@ -635,20 +643,22 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                                             GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL );
                     
                     result = SetEventParameter( inEvent, kEventParamControlRef, typeControlRef, sizeof( HIViewRef ), &viewRef );
                                             GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL );
                     
                     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() ;
                     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 ...
                         // 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 ...


@@ -668,100 +678,102 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                                                         sizeof( HISize ), &max );
                         result = noErr ;
                     }
                                                         sizeof( HISize ), &max );
                         result = noErr ;
                     }

-                               }
-                               break;
-                       }
-                       break;
-       }
-       
-       return result;
+                }
+                break;
+            }
+            break;
+    }
+    
+    return result;

 }
 
 void RegisterControlToolbarItemClass()
 {
 }
 
 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)
 {
 }
 
 HIToolbarItemRef CreateControlToolbarItem(CFStringRef inIdentifier, CFTypeRef inConfigData)
 {

-       RegisterControlToolbarItemClass();
+    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 ;
+    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[] =
 {
 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 inCallRef, EventRef inEvent, void* inUserData )
 {

-       OSStatus result = eventNotHandledErr;
-    wxToolBar* toolbar = (wxToolBar*) inUserData ;
-       CFMutableArrayRef       array;
+    OSStatus result = eventNotHandledErr;
+    // Not yet needed
+    // wxToolBar* toolbar = (wxToolBar*) inUserData ;
+    CFMutableArrayRef   array;

 
 

-       switch ( GetEventKind( inEvent ) )
-       {
-               case kEventToolbarGetDefaultIdentifiers:
+    switch ( GetEventKind( inEvent ) )
+    {
+        case kEventToolbarGetDefaultIdentifiers:

             {
                 GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
             {
                 GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,

-                                       sizeof( CFMutableArrayRef ), NULL, &array );
+                    sizeof( CFMutableArrayRef ), NULL, &array );

                 // not implemented yet
                 // GetToolbarDefaultItems( array );
                 result = noErr;
             }
                 // not implemented yet
                 // GetToolbarDefaultItems( array );
                 result = noErr;
             }

-                       break;
-                       
-               case kEventToolbarGetAllowedIdentifiers:
+            break;
+            
+        case kEventToolbarGetAllowedIdentifiers:

             {
                 GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
             {
                 GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,

-                                       sizeof( CFMutableArrayRef ), NULL, &array );
+                    sizeof( CFMutableArrayRef ), NULL, &array );

                 // not implemented yet
                 // GetToolbarAllowedItems( array );
                 result = noErr;
             }
                 // 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 ;
                 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 );
                 if ( CFStringCompare( kControlToolbarItemClassID, identifier, kCFCompareBackwards ) == kCFCompareEqualTo )
                 {
                     item = CreateControlToolbarItem( kControlToolbarItemClassID, data );


@@ -771,13 +783,14 @@ static OSStatus ToolbarDelegateHandler( EventHandlerCallRef inCallRef, EventRef
                             sizeof( HIToolbarItemRef ), &item );
                         result = noErr;
                     }
                             sizeof( HIToolbarItemRef ), &item );
                         result = noErr;
                     }

-                               }
+                }

                 
                 

-                       }
-                       break;
+            }
+            break;

     }
     return result ;
 }
     }
     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
 
 // also for the toolbar we have the dual implementation:
 // only when MacInstallNativeToolbar is called is the native toolbar set as the window toolbar


@@ -793,6 +806,8 @@ bool wxToolBar::Create(
     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
     OSStatus err = noErr;
 
 #if wxMAC_USE_NATIVE_TOOLBAR


@@ -803,8 +818,8 @@ bool wxToolBar::Create(
 
     if (m_macHIToolbarRef != NULL)
     {
 
     if (m_macHIToolbarRef != NULL)
     {

-               InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler,
-                               GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL );
+        InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler,
+                GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL );

 
         HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault;
         HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall;
 
         HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault;
         HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall;


@@ -833,6 +848,9 @@ wxToolBar::~wxToolBar()
         if (m_macUsesNativeToolbar)
             MacInstallNativeToolbar( false );
 
         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;
     }
         CFRelease( (HIToolbarRef)m_macHIToolbarRef );
         m_macHIToolbarRef = NULL;
     }


@@ -1071,7 +1089,6 @@ bool wxToolBar::Realize()
 
     bool lastIsRadio = false;
     bool curIsRadio = false;
 
     bool lastIsRadio = false;
     bool curIsRadio = false;

-    bool setChoiceInGroup = false;

 
 #if wxMAC_USE_NATIVE_TOOLBAR
     CFIndex currentPosition = 0;
 
 #if wxMAC_USE_NATIVE_TOOLBAR
     CFIndex currentPosition = 0;


@@ -1166,8 +1183,6 @@ bool wxToolBar::Realize()
         {
             if ( tool->IsToggled() )
                 DoToggleTool( tool, true );
         {
             if ( tool->IsToggled() )
                 DoToggleTool( tool, true );

-
-            setChoiceInGroup = false;

         }
         else
         {
         }
         else
         {


@@ -1176,7 +1191,6 @@ bool wxToolBar::Realize()
                 if ( tool->Toggle( true ) )
                 {
                     DoToggleTool( tool, true );
                 if ( tool->Toggle( true ) )
                 {
                     DoToggleTool( tool, true );

-                    setChoiceInGroup = true;

                 }
             }
             else if ( tool->IsToggled() )
                 }
             }
             else if ( tool->IsToggled() )


@@ -1245,7 +1259,7 @@ bool wxToolBar::Realize()
     InvalidateBestSize();
 #endif
 
     InvalidateBestSize();
 #endif
 

-    SetBestFittingSize();
+    SetInitialSize();

 
     return true;
 }
 
     return true;
 }


@@ -1439,9 +1453,12 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
 
 #if wxMAC_USE_NATIVE_TOOLBAR
             {
 
 #if wxMAC_USE_NATIVE_TOOLBAR
             {

-                   wxASSERT( tool->GetControl() != NULL );
+                wxASSERT( tool->GetControl() != NULL );

                 HIToolbarItemRef    item;
                 HIViewRef viewRef = (HIViewRef) tool->GetControl()->GetHandle() ;
                 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 ) ;
                 CFDataRef data = CFDataCreate( kCFAllocatorDefault , (UInt8*) &viewRef , sizeof(viewRef) ) ;
                  err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID,
                    data , &item ) ;


@@ -1518,34 +1535,29 @@ bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase)
     CFIndex removeIndex = tool->GetIndex();
 #endif
 
     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:
     switch ( tool->GetStyle() )
     {
         case wxTOOL_STYLE_CONTROL:

-            {
+            if ( tool->GetControl() )

                 tool->GetControl()->Destroy();
                 tool->GetControl()->Destroy();

-                tool->ClearControl();
-            }

             break;
 
         case wxTOOL_STYLE_BUTTON:
         case wxTOOL_STYLE_SEPARATOR:
             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;
     }
             break;
 
         default:
             break;
     }

+    tool->ClearControl();

 
     // and finally reposition all the controls after this one
 
 
     // and finally reposition all the controls after this one
 


@@ -1650,7 +1662,9 @@ void wxToolBar::OnPaint(wxPaintEvent& event)
             drawInfo.kind = kThemeBackgroundMetal;
             HIThemeApplyBackground( &hiToolbarrect, &drawInfo, cgContext, kHIThemeOrientationNormal );
 
             drawInfo.kind = kThemeBackgroundMetal;
             HIThemeApplyBackground( &hiToolbarrect, &drawInfo, cgContext, kHIThemeOrientationNormal );
 

+#ifndef __LP64__

             QDEndCGContext( (CGrafPtr) dc.m_macPort, &cgContext );
             QDEndCGContext( (CGrafPtr) dc.m_macPort, &cgContext );

+#endif

 #endif
         }
     }
 #endif
         }
     }