correct hhp2cached path

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

diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp
index 7614e623124c412aec03d1abf1f5b3a91f02613a..02778a1791c5dc59914f0436f535bbf336e38049 100644 (file)
--- a/src/mac/carbon/toolbar.cpp
+++ b/src/mac/carbon/toolbar.cpp
@@ -19,25 +19,18 @@
     #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"

+#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;
 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)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)


@@ -57,6 +50,17 @@ END_EVENT_TABLE()
 
 // We have a dual implementation for each tool, ControlRef and HIToolbarItemRef
 
 
 // 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:
 class wxToolBarTool : public wxToolBarToolBase
 {
 public:


@@ -71,8 +75,8 @@ public:
         const wxString& shortHelp,
         const wxString& longHelp );
 
         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)
     {
         Init();
         if (control != NULL)


@@ -82,11 +86,6 @@ public:
     virtual ~wxToolBarTool()
     {
         ClearControl();
     virtual ~wxToolBarTool()
     {
         ClearControl();

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

     }
 
     WXWidget GetControlHandle()
     }
 
     WXWidget GetControlHandle()


@@ -103,21 +102,36 @@ public:
 
     void ClearControl()
     {
 
     void ClearControl()
     {

-        m_control = NULL;

         if ( m_controlHandle )
         {
             if ( !IsControl() )
                 DisposeControl( m_controlHandle );
             else
             {
         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_controlHandle = NULL ;
         }

+        m_control = NULL;

 
 #if wxMAC_USE_NATIVE_TOOLBAR
 
 #if wxMAC_USE_NATIVE_TOOLBAR

-        m_toolbarItemRef = NULL;
-#endif
+        if ( m_toolbarItemRef )
+        {
+            CFIndex count = CFGetRetainCount( m_toolbarItemRef ) ;
+            // different behaviour under Leopard
+            if ( UMAGetSystemVersion() < 0x1050 )
+            {
+                if ( count != 1 )
+                {
+                    wxFAIL_MSG("Reference count of native tool was not 1 in wxToolBarTool destructor");
+                }
+            }
+            wxTheApp->MacAddToAutorelease(m_toolbarItemRef);
+            CFRelease(m_toolbarItemRef);
+            m_toolbarItemRef = NULL;
+        }
+#endif // wxMAC_USE_NATIVE_TOOLBAR

     }
 
     wxSize GetSize() const
     }
 
     wxSize GetSize() const


@@ -165,10 +179,19 @@ public:
         m_toolbarItemRef = ref;
         if ( m_toolbarItemRef )
         {
         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,
             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 },
 static const EventTypeSpec eventList[] =
 {
     { kEventClassControl, kEventControlHit },

-#ifdef __WXMAC_OSX__

     { kEventClassControl, kEventControlHitTest },
     { 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;
 {
     OSStatus result = eventNotHandledErr;
     ControlRef controlRef;


@@ -236,11 +257,7 @@ static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef
                 {
                     bool    shouldToggle;
 
                 {
                     bool    shouldToggle;
 

-#ifdef __WXMAC_OSX__

                     shouldToggle = !tbartool->IsToggled();
                     shouldToggle = !tbartool->IsToggled();

-#else
-                    shouldToggle = (GetControl32BitValue( (ControlRef)(tbartool->GetControlHandle()) ) != 0);
-#endif

 
                     tbar->ToggleTool( tbartool->GetId(), shouldToggle );
                 }
 
                     tbar->ToggleTool( tbartool->GetId(), shouldToggle );
                 }


@@ -251,7 +268,6 @@ static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef
             }
             break;
 
             }
             break;
 

-#ifdef __WXMAC_OSX__

         case kEventControlHitTest:
             {
                 HIPoint pt = cEvent.GetParameter<HIPoint>(kEventParamMouseLocation);
         case kEventControlHitTest:
             {
                 HIPoint pt = cEvent.GetParameter<HIPoint>(kEventParamMouseLocation);


@@ -265,7 +281,6 @@ static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef
                 result = noErr;
             }
             break;
                 result = noErr;
             }
             break;

-#endif

 
         default:
             break;
 
         default:
             break;


@@ -300,7 +315,7 @@ static const EventTypeSpec toolBarEventList[] =
     { kEventClassToolbarItem, kEventToolbarItemPerformAction },
 };
 
     { kEventClassToolbarItem, kEventToolbarItemPerformAction },
 };
 

-static pascal OSStatus wxMacToolBarCommandEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
+static pascal OSStatus wxMacToolBarCommandEventHandler( EventHandlerCallRef WXUNUSED(handler), EventRef event, void *data )

 {
     OSStatus result = eventNotHandledErr;
 
 {
     OSStatus result = eventNotHandledErr;
 


@@ -370,17 +385,10 @@ bool wxToolBarTool::DoEnable( bool enable )
 
         if ( m_controlHandle != NULL )
         {
 
         if ( m_controlHandle != NULL )
         {

-#if TARGET_API_MAC_OSX

             if ( enable )
                 EnableControl( m_controlHandle );
             else
                 DisableControl( m_controlHandle );
             if ( enable )
                 EnableControl( m_controlHandle );
             else
                 DisableControl( m_controlHandle );

-#else
-            if ( enable )
-                ActivateControl( m_controlHandle );
-            else
-                DeactivateControl( m_controlHandle );
-#endif

         }
     }
 
         }
     }
 


@@ -405,7 +413,7 @@ void wxToolBarTool::SetPosition( const wxPoint& position )
 
         if ( mac_x != former_mac_x || mac_y != former_mac_y )
         {
 
         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() )
         }
     }
     else if ( IsControl() )


@@ -421,21 +429,18 @@ void wxToolBarTool::SetPosition( const wxPoint& position )
     else
     {
         // separator
     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 )
         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 )
 {
     }
 }
 
 void wxToolBarTool::UpdateToggleImage( bool toggle )
 {

-#ifdef __WXMAC_OSX__

     if ( toggle )
     {
         int w = m_bmpNormal.GetWidth();
     if ( toggle )
     {
         int w = m_bmpNormal.GetWidth();


@@ -455,7 +460,10 @@ void wxToolBarTool::UpdateToggleImage( bool toggle )
 #if wxMAC_USE_NATIVE_TOOLBAR
         if (m_toolbarItemRef != NULL)
         {
 #if wxMAC_USE_NATIVE_TOOLBAR
         if (m_toolbarItemRef != NULL)
         {

-            HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef );
+            ControlButtonContentInfo info2;
+            wxMacCreateBitmapButton( &info2, bmp, kControlContentCGImageRef);
+            HIToolbarItemSetImage( m_toolbarItemRef, info2.u.imageRef );
+            wxMacReleaseBitmapButton( &info2 );

         }
 #endif
         wxMacReleaseBitmapButton( &info );
         }
 #endif
         wxMacReleaseBitmapButton( &info );


@@ -468,7 +476,10 @@ void wxToolBarTool::UpdateToggleImage( bool toggle )
 #if wxMAC_USE_NATIVE_TOOLBAR
         if (m_toolbarItemRef != NULL)
         {
 #if wxMAC_USE_NATIVE_TOOLBAR
         if (m_toolbarItemRef != NULL)
         {

-            HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef );
+            ControlButtonContentInfo info2;
+            wxMacCreateBitmapButton( &info2, m_bmpNormal, kControlContentCGImageRef);
+            HIToolbarItemSetImage( m_toolbarItemRef, info2.u.imageRef );
+            wxMacReleaseBitmapButton( &info2 );

         }
 #endif
         wxMacReleaseBitmapButton( &info );
         }
 #endif
         wxMacReleaseBitmapButton( &info );


@@ -480,9 +491,6 @@ void wxToolBarTool::UpdateToggleImage( bool toggle )
         sizeof(transform), (Ptr)&transform );
     HIViewSetNeedsDisplay( m_controlHandle, true );
 
         sizeof(transform), (Ptr)&transform );
     HIViewSetNeedsDisplay( m_controlHandle, true );
 

-#else
-    ::SetControl32BitValue( m_controlHandle, toggle );
-#endif

 }
 
 wxToolBarTool::wxToolBarTool(
 }
 
 wxToolBarTool::wxToolBarTool(


@@ -521,9 +529,10 @@ wxToolBarToolBase *wxToolBar::CreateTool(
         clientData, shortHelp, longHelp );
 }
 
         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()
 }
 
 void wxToolBar::Init()


@@ -541,26 +550,26 @@ void wxToolBar::Init()
 
 #define kControlToolbarItemClassID      CFSTR( "org.wxwidgets.controltoolbaritem" )
 
 
 #define kControlToolbarItemClassID      CFSTR( "org.wxwidgets.controltoolbaritem" )
 

-const EventTypeSpec kEvents[] = 
+const EventTypeSpec kEvents[] =

 {
     { kEventClassHIObject, kEventHIObjectConstruct },
     { kEventClassHIObject, kEventHIObjectInitialize },
     { kEventClassHIObject, kEventHIObjectDestruct },
 {
     { kEventClassHIObject, kEventHIObjectConstruct },
     { kEventClassHIObject, kEventHIObjectInitialize },
     { kEventClassHIObject, kEventHIObjectDestruct },

-    
+

     { kEventClassToolbarItem, kEventToolbarItemCreateCustomView }
 };
 
     { kEventClassToolbarItem, kEventToolbarItemCreateCustomView }
 };
 

-const EventTypeSpec kViewEvents[] = 
-{ 
-    { kEventClassControl, kEventControlGetSizeConstraints } 
+const EventTypeSpec kViewEvents[] =
+{
+    { kEventClassControl, kEventControlGetSizeConstraints }

 };
 
 };
 

-struct ControlToolbarItem 
-{ 
-    HIToolbarItemRef    toolbarItem; 
+struct ControlToolbarItem
+{
+    HIToolbarItemRef    toolbarItem;

     HIViewRef           viewRef;
     wxSize              lastValidSize ;
     HIViewRef           viewRef;
     wxSize              lastValidSize ;

-}; 
+};

 
 static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
 {
 
 static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
 {


@@ -576,20 +585,21 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                     {
                         HIObjectRef         toolbarItem;
                         ControlToolbarItem* item;
                     {
                         HIObjectRef         toolbarItem;
                         ControlToolbarItem* item;

-                        
+

                         GetEventParameter( inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL,
                             sizeof( HIObjectRef ), NULL, &toolbarItem );
                         GetEventParameter( inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL,
                             sizeof( HIObjectRef ), NULL, &toolbarItem );

-                        
+

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

+                        item->lastValidSize = wxSize(-1,-1);

                         item->viewRef = NULL ;
                         item->viewRef = NULL ;

-                        
+

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

-                        
+

                         result = noErr ;
                     }
                     break;
                         result = noErr ;
                     }
                     break;

- 
+

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


@@ -597,43 +607,59 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                         CFDataRef           data;
                         GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
                             sizeof( CFTypeRef ), NULL, &data );
                         CFDataRef           data;
                         GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
                             sizeof( CFTypeRef ), NULL, &data );

-                    
+

                         HIViewRef viewRef ;
                         HIViewRef viewRef ;

-                        
+

                         wxASSERT_MSG( CFDataGetLength( data ) == sizeof( viewRef ) , wxT("Illegal Data passed") ) ;
                         memcpy( &viewRef , CFDataGetBytePtr( data ) , sizeof( viewRef ) ) ;
                         wxASSERT_MSG( CFDataGetLength( data ) == sizeof( viewRef ) , wxT("Illegal Data passed") ) ;
                         memcpy( &viewRef , CFDataGetBytePtr( data ) , sizeof( viewRef ) ) ;

-                    
+

                         object->viewRef = (HIViewRef) viewRef ;
                         object->viewRef = (HIViewRef) viewRef ;

+                        // make sure we keep that control during our lifetime
+                        CFRetain( object->viewRef ) ;

 
 

+                        verify_noerr(InstallEventHandler( GetControlEventTarget( viewRef ), ControlToolbarItemHandler,
+                                            GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL ));

                         result = noErr ;
                     }
                     break;
 
                 case kEventHIObjectDestruct:
                         result = noErr ;
                     }
                     break;
 
                 case kEventHIObjectDestruct:

-                    free( object ) ;
-                    result = noErr;
+                    {
+                        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;
                     break;
             }
             break;

-        
+

         case kEventClassToolbarItem:
             switch ( GetEventKind( inEvent ) )
         case kEventClassToolbarItem:
             switch ( GetEventKind( inEvent ) )

-            {               
+            {

                 case kEventToolbarItemCreateCustomView:
                 {
                     HIViewRef viewRef = object->viewRef ;
                 case kEventToolbarItemCreateCustomView:
                 {
                     HIViewRef viewRef = object->viewRef ;

-

                     HIViewRemoveFromSuperview( viewRef ) ;
                     HIViewSetVisible(viewRef, true) ;
                     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;
                     result = SetEventParameter( inEvent, kEventParamControlRef, typeControlRef, sizeof( HIViewRef ), &viewRef );
                 }
                 break;
             }
             break;

-        
+

         case kEventClassControl:
             switch ( GetEventKind( inEvent ) )
             {
         case kEventClassControl:
             switch ( GetEventKind( inEvent ) )
             {


@@ -642,24 +668,32 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                     wxWindow* wxwindow = wxFindControlFromMacControl(object->viewRef ) ;
                     if ( wxwindow )
                     {
                     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 ;
                         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, kEventParamMinimumSize, typeHISize,
                                                         sizeof( HISize ), &min );

-                        
+

                         result = SetEventParameter( inEvent, kEventParamMaximumSize, typeHISize,
                                                         sizeof( HISize ), &max );
                         result = noErr ;
                         result = SetEventParameter( inEvent, kEventParamMaximumSize, typeHISize,
                                                         sizeof( HISize ), &max );
                         result = noErr ;


@@ -669,19 +703,19 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
             }
             break;
     }
             }
             break;
     }

-    
+

     return result;
 }
 
 void RegisterControlToolbarItemClass()
 {
     static bool sRegistered;
     return result;
 }
 
 void RegisterControlToolbarItemClass()
 {
     static bool sRegistered;

-    
+

     if ( !sRegistered )
     {
         HIObjectRegisterSubclass( kControlToolbarItemClassID, kHIToolbarItemClassID, 0,
                 ControlToolbarItemHandler, GetEventTypeCount( kEvents ), kEvents, 0, NULL );
     if ( !sRegistered )
     {
         HIObjectRegisterSubclass( kControlToolbarItemClassID, kHIToolbarItemClassID, 0,
                 ControlToolbarItemHandler, GetEventTypeCount( kEvents ), kEvents, 0, NULL );

-        
+

         sRegistered = true;
     }
 }
         sRegistered = true;
     }
 }


@@ -689,26 +723,26 @@ void RegisterControlToolbarItemClass()
 HIToolbarItemRef CreateControlToolbarItem(CFStringRef inIdentifier, CFTypeRef inConfigData)
 {
     RegisterControlToolbarItemClass();
 HIToolbarItemRef CreateControlToolbarItem(CFStringRef inIdentifier, CFTypeRef inConfigData)
 {
     RegisterControlToolbarItemClass();

-    
+

     OSStatus            err;
     EventRef            event;
     UInt32              options = kHIToolbarItemAllowDuplicates;
     HIToolbarItemRef    result = NULL;
     OSStatus            err;
     EventRef            event;
     UInt32              options = kHIToolbarItemAllowDuplicates;
     HIToolbarItemRef    result = NULL;

-    
+

     err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event );
     require_noerr( err, CantCreateEvent );
     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 );
     SetEventParameter( event, kEventParamAttributes, typeUInt32, sizeof( UInt32 ), &options );
     SetEventParameter( event, kEventParamToolbarItemIdentifier, typeCFStringRef, sizeof( CFStringRef ), &inIdentifier );

-    
+

     if ( inConfigData )
         SetEventParameter( event, kEventParamToolbarItemConfigData, typeCFTypeRef, sizeof( CFTypeRef ), &inConfigData );
     if ( inConfigData )
         SetEventParameter( event, kEventParamToolbarItemConfigData, typeCFTypeRef, sizeof( CFTypeRef ), &inConfigData );

-    
+

     err = HIObjectCreate( kControlToolbarItemClassID, event, (HIObjectRef*)&result );
     check_noerr( err );
     err = HIObjectCreate( kControlToolbarItemClassID, event, (HIObjectRef*)&result );
     check_noerr( err );

-    
+

     ReleaseEvent( event );
     ReleaseEvent( event );

-CantCreateEvent :   
+CantCreateEvent :

     return result ;
 }
 
     return result ;
 }
 


@@ -720,7 +754,9 @@ static const EventTypeSpec kToolbarEvents[] =
     { kEventClassToolbar, kEventToolbarCreateItemWithIdentifier },
 };
 
     { 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;
     // Not yet needed
 {
     OSStatus result = eventNotHandledErr;
     // Not yet needed


@@ -738,7 +774,7 @@ static OSStatus ToolbarDelegateHandler( EventHandlerCallRef inCallRef, EventRef
                 result = noErr;
             }
             break;
                 result = noErr;
             }
             break;

-            
+

         case kEventToolbarGetAllowedIdentifiers:
             {
                 GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
         case kEventToolbarGetAllowedIdentifiers:
             {
                 GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,


@@ -753,13 +789,13 @@ static OSStatus ToolbarDelegateHandler( EventHandlerCallRef inCallRef, EventRef
                 HIToolbarItemRef        item = NULL;
                 CFTypeRef               data = NULL;
                 CFStringRef             identifier = NULL ;
                 HIToolbarItemRef        item = NULL;
                 CFTypeRef               data = NULL;
                 CFStringRef             identifier = NULL ;

-                
+

                 GetEventParameter( inEvent, kEventParamToolbarItemIdentifier, typeCFStringRef, NULL,
                         sizeof( CFStringRef ), NULL, &identifier );
                 GetEventParameter( inEvent, kEventParamToolbarItemIdentifier, typeCFStringRef, NULL,
                         sizeof( CFStringRef ), NULL, &identifier );

-                
+

                 GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
                         sizeof( CFTypeRef ), NULL, &data );
                 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 );


@@ -770,7 +806,7 @@ static OSStatus ToolbarDelegateHandler( EventHandlerCallRef inCallRef, EventRef
                         result = noErr;
                     }
                 }
                         result = noErr;
                     }
                 }

-                
+

             }
             break;
     }
             }
             break;
     }


@@ -797,30 +833,33 @@ bool wxToolBar::Create(
     OSStatus err = noErr;
 
 #if wxMAC_USE_NATIVE_TOOLBAR
     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);
 }
 
     return (err == noErr);
 }


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


@@ -1054,7 +1102,7 @@ bool wxToolBar::Realize()
     // find the maximum tool width and height
     wxToolBarTool *tool;
     wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
     // 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 )
     {
         tool = (wxToolBarTool *) node->GetData();
         if ( tool != NULL )


@@ -1076,10 +1124,12 @@ bool wxToolBar::Realize()
 #if wxMAC_USE_NATIVE_TOOLBAR
     CFIndex currentPosition = 0;
     bool insertAll = false;
 #if wxMAC_USE_NATIVE_TOOLBAR
     CFIndex currentPosition = 0;
     bool insertAll = false;

+
+    HIToolbarRef refTB = (HIToolbarRef)m_macHIToolbarRef;

 #endif
 
     node = m_tools.GetFirst();
 #endif
 
     node = m_tools.GetFirst();

-    while ( node != NULL )
+    while ( node )

     {
         tool = (wxToolBarTool*) node->GetData();
         if ( tool == NULL )
     {
         tool = (wxToolBarTool*) node->GetData();
         if ( tool == NULL )


@@ -1115,9 +1165,9 @@ bool wxToolBar::Realize()
 
 #if wxMAC_USE_NATIVE_TOOLBAR
         // install in native HIToolbar
 
 #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) )
             if ( hiItemRef != NULL )
             {
                 if ( insertAll || (tool->GetIndex() != currentPosition) )


@@ -1129,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
 
                         // 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 )
-                        {
-                            err = HIToolbarRemoveItemAtIndex( (HIToolbarRef) m_macHIToolbarRef, i );
-                        }
-
-                        if (err != noErr)
+                        // all following tools will have to be reinserted (insertAll).
+                        for ( wxToolBarToolsList::compatibility_iterator node2 = m_tools.GetLast();
+                              node2 != node;
+                              node2 = node2->GetPrevious() )

                         {
                         {

-                            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)
                     {
                     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 );
                     }
 
                     tool->SetIndex( currentPosition );

+                    if ( tool->IsControl() )
+                    {
+                        CFIndex count = CFGetRetainCount( tool->GetControl()->GetPeer()->GetControlRef() ) ;
+                        if ( count != 3 && count != 2 )
+                        {
+                            wxFAIL_MSG("Reference count of native tool was illegal before removal");
+                        }
+                        wxASSERT( IsValidControlHandle(tool->GetControl()->GetPeer()->GetControlRef() )) ;
+                    }

                 }
 
                 currentPosition++;
                 }
 
                 currentPosition++;


@@ -1182,7 +1268,7 @@ bool wxToolBar::Realize()
                     DoToggleTool( tool, true );
 
                 wxToolBarToolsList::compatibility_iterator  nodePrev = node->GetPrevious();
                     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) )
                 {
                     wxToolBarToolBase   *toggleTool = nodePrev->GetData();
                     if ( (toggleTool == NULL) || !toggleTool->IsButton() || (toggleTool->GetKind() != wxITEM_RADIO) )


@@ -1295,11 +1381,38 @@ void wxToolBar::MacSuperChangedPosition()
 #endif
 }
 
 #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();
 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)
     {
         tool = (wxToolBarTool *)node->GetData();
         if (tool != NULL)


@@ -1348,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;
     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())
     {
 
     switch (tool->GetStyle())
     {


@@ -1361,21 +1485,24 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
                 else
                     toolrect.right = toolSize.x;
 
                 else
                     toolrect.right = toolSize.x;
 

-#ifdef __WXMAC_OSX__

                 // in flat style we need a visual separator
 #if wxMAC_USE_NATIVE_TOOLBAR
                 // 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 );
 
                 CreateSeparatorControl( window, &toolrect, &controlHandle );
                 tool->SetControlHandle( controlHandle );

-#endif

             }
             break;
 
             }
             break;
 


@@ -1383,11 +1510,15 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
             {
                 wxASSERT( tool->GetControlHandle() == NULL );
                 ControlButtonContentInfo info;
             {
                 wxASSERT( tool->GetControlHandle() == NULL );
                 ControlButtonContentInfo info;

-                wxMacCreateBitmapButton( &info, tool->GetNormalBitmap(), kControlContentIconRef );
+                wxMacCreateBitmapButton( &info, tool->GetNormalBitmap() );

 
                 if ( UMAGetSystemVersion() >= 0x1000)
                 {
 
                 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 );
                     CreateIconControl( window, &toolrect, &info, false, &controlHandle );

+                    wxMacReleaseBitmapButton( &info );

                 }
                 else
                 {
                 }
                 else
                 {


@@ -1400,28 +1531,38 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
                 }
 
 #if wxMAC_USE_NATIVE_TOOLBAR
                 }
 
 #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 );
 
                 wxMacReleaseBitmapButton( &info );
 
 #if 0
                 SetBevelButtonTextPlacement( m_controlHandle, kControlBevelButtonPlaceBelowGraphic );

-                UMASetControlTitle( m_controlHandle, label, wxFont::GetDefaultEncoding() );
+                SetControlTitleWithCFString( m_controlHandle , wxCFStringRef( label, wxFont::GetDefaultEncoding() );

 #endif
 
                 InstallControlEventHandler(
 #endif
 
                 InstallControlEventHandler(


@@ -1435,16 +1576,14 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
         case wxTOOL_STYLE_CONTROL:
 
 #if wxMAC_USE_NATIVE_TOOLBAR
         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() ;
                 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) ) ;
                 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)
                 {
 
                 if (err  == noErr)
                 {


@@ -1452,7 +1591,11 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
                 }
                 CFRelease( data ) ;
            }
                 }
                 CFRelease( data ) ;
            }

-
+           else
+           {
+               err = noErr;
+               break;
+           }

 #else
                 // right now there's nothing to do here
 #endif
 #else
                 // right now there's nothing to do here
 #endif


@@ -1469,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") );
 
             ControlRef container = (ControlRef) GetHandle();
             wxASSERT_MSG( container != NULL, wxT("No valid Mac container control") );
 

-            UMAShowControl( controlHandle );
+            SetControlVisibility( controlHandle, true, true );

             ::EmbedControl( controlHandle, container );
         }
 
             ::EmbedControl( controlHandle, container );
         }
 


@@ -1477,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->UpdateToggleImage( true );
 
         // nothing special to do here - we relayout in Realize() later

-        tool->Attach( this );

         InvalidateBestSize();
     }
     else
     {
         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);
     }
 
     return (err == noErr);


@@ -1518,34 +1659,32 @@ 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 (m_macHIToolbarRef != NULL)
+    {
+        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
 


@@ -1562,8 +1701,11 @@ bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase)
         tool2->SetPosition( pt );
 
 #if wxMAC_USE_NATIVE_TOOLBAR
         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
     }
 
 #endif
     }
 


@@ -1588,10 +1730,8 @@ void wxToolBar::OnPaint(wxPaintEvent& event)
     GetSize( &w, &h );
 
     bool drawMetalTheme = MacGetTopLevelWindow()->MacGetMetalAppearance();
     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) );
     {
         HIThemePlacardDrawInfo info;
         memset( &info, 0, sizeof(info) );


@@ -1607,57 +1747,6 @@ void wxToolBar::OnPaint(wxPaintEvent& event)
         // leave the background as it is (striped or metal)
     }
 
         // 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 );
-
-#ifndef __LP64__
-            QDEndCGContext( (CGrafPtr) dc.m_macPort, &cgContext );
-#endif
-#endif
-        }
-    }
-#endif
-

     event.Skip();
 }
 
     event.Skip();
 }