suppress warning about converting -1 to MenuItemIndex

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

diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp
index d3fcb494ac348e4fe6b75c7a637d64274324ede0..7f12f1cc6b282a244b41ccbc9e80f4d63b5fc96e 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"
 


@@ -71,8 +72,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)


@@ -115,7 +116,8 @@ public:
         {
             CFIndex count = CFGetRetainCount( m_toolbarItemRef ) ;
             wxASSERT_MSG( count == 1 , wxT("Reference Count of native tool was not 1 in wxToolBarTool destructor") );
         {
             CFIndex count = CFGetRetainCount( m_toolbarItemRef ) ;
             wxASSERT_MSG( count == 1 , wxT("Reference Count of native tool was not 1 in wxToolBarTool destructor") );

-            CFRelease( m_toolbarItemRef );
+            wxTheApp->MacAddToAutorelease(m_toolbarItemRef);
+            CFRelease(m_toolbarItemRef);

             m_toolbarItemRef = NULL;
         }
 #endif
             m_toolbarItemRef = NULL;
         }
 #endif


@@ -166,10 +168,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() ) );
+                wxMacCFStringHolder( GetShortHelp(), enc ),
+                wxMacCFStringHolder( GetLongHelp(), enc ) );

         }
     }
 
         }
     }
 


@@ -451,7 +462,7 @@ void wxToolBarTool::UpdateToggleImage( bool toggle )
         dc.DrawBitmap( m_bmpNormal, 0, 0, true );
         dc.SelectObject( wxNullBitmap );
         ControlButtonContentInfo info;
         dc.DrawBitmap( m_bmpNormal, 0, 0, true );
         dc.SelectObject( wxNullBitmap );
         ControlButtonContentInfo info;

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

         SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
 #if wxMAC_USE_NATIVE_TOOLBAR
         if (m_toolbarItemRef != NULL)
         SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
 #if wxMAC_USE_NATIVE_TOOLBAR
         if (m_toolbarItemRef != NULL)


@@ -464,7 +475,7 @@ void wxToolBarTool::UpdateToggleImage( bool toggle )
     else
     {
         ControlButtonContentInfo info;
     else
     {
         ControlButtonContentInfo info;

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

         SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
 #if wxMAC_USE_NATIVE_TOOLBAR
         if (m_toolbarItemRef != NULL)
         SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
 #if wxMAC_USE_NATIVE_TOOLBAR
         if (m_toolbarItemRef != NULL)


@@ -522,9 +533,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()


@@ -542,26 +554,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 )
 {


@@ -577,20 +589,20 @@ 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->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 ;
                     }
                     break;
                         result = noErr ;
                     }
                     break;

- 
+

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


@@ -598,12 +610,12 @@ 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 ;
 
                         result = noErr ;
                         object->viewRef = (HIViewRef) viewRef ;
 
                         result = noErr ;


@@ -615,9 +627,11 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                         // 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 ;
                         // 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 && CFGetRetainCount( viewRef ) > 1 )
+                        if( viewRef && IsValidControlHandle( viewRef)  )

                         {
                         {

-                            CFRelease( viewRef ) ;
+                            CFIndex count =  CFGetRetainCount( viewRef ) ;
+                            if ( count >= 1 )
+                                CFRelease( viewRef ) ;

                         }
                            free( object ) ;
                        result = noErr;
                         }
                            free( object ) ;
                        result = noErr;


@@ -625,10 +639,10 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                     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 ;


@@ -637,13 +651,13 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                     HIViewSetVisible(viewRef, true) ;
                     InstallEventHandler( GetControlEventTarget( viewRef ), ControlToolbarItemHandler,
                                             GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL );
                     HIViewSetVisible(viewRef, true) ;
                     InstallEventHandler( GetControlEventTarget( viewRef ), ControlToolbarItemHandler,
                                             GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL );

-                    
+

                     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 ) )
             {


@@ -662,14 +676,14 @@ static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef,
                             object->lastValidSize = sz ;
                         else
                             sz = object->lastValidSize ;
                             object->lastValidSize = sz ;
                         else
                             sz = object->lastValidSize ;

-                            
+

                         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 ;


@@ -679,19 +693,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;
     }
 }


@@ -699,26 +713,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 ;
 }
 


@@ -748,7 +762,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,


@@ -763,13 +777,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 );


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

-                
+

             }
             break;
     }
             }
             break;
     }


@@ -830,7 +844,7 @@ bool wxToolBar::Create(
         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);
 }


@@ -1308,6 +1322,33 @@ 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;
 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
 {
     wxToolBarTool *tool;


@@ -1361,6 +1402,11 @@ 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
+    HIToolbarItemRef item;
+#endif

 
     switch (tool->GetStyle())
     {
 
     switch (tool->GetStyle())
     {


@@ -1374,21 +1420,18 @@ 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 );
                 err = HIToolbarItemCreate(
                     kHIToolbarSeparatorIdentifier,
                     kHIToolbarItemCantBeRemoved | kHIToolbarItemIsSeparator | kHIToolbarItemAllowDuplicates,
                     &item );
                 if (err == noErr)
                     tool->SetToolbarItemRef( item );

-#endif
+#endif // wxMAC_USE_NATIVE_TOOLBAR

 
                 CreateSeparatorControl( window, &toolrect, &controlHandle );
                 tool->SetControlHandle( controlHandle );
 
                 CreateSeparatorControl( window, &toolrect, &controlHandle );
                 tool->SetControlHandle( controlHandle );

-#endif

             }
             break;
 
             }
             break;
 


@@ -1413,7 +1456,6 @@ 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()),
                 wxString labelStr = wxString::Format(wxT("%xd"), (int)tool);
                 err = HIToolbarItemCreate(
                     wxMacCFStringHolder(labelStr, wxFont::GetDefaultEncoding()),


@@ -1423,12 +1465,12 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
                     InstallEventHandler(
                         HIObjectGetEventTarget(item), GetwxMacToolBarEventHandlerUPP(),
                         GetEventTypeCount(toolBarEventList), toolBarEventList, tool, 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 );
                 }
                     HIToolbarItemSetIconRef( item, info.u.iconRef );
                     HIToolbarItemSetCommandID( item, kHIToolbarCommandPressAction );
                     tool->SetToolbarItemRef( item );
                 }

-#endif
+#endif // wxMAC_USE_NATIVE_TOOLBAR

 
                 wxMacReleaseBitmapButton( &info );
 
 
                 wxMacReleaseBitmapButton( &info );
 


@@ -1456,8 +1498,8 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
                 // 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) ) ;
                 // reference count to make sure we are not dealing with zombie controls after the native toolbar has released its views
                 CFRetain( viewRef ) ;
                 CFDataRef data = CFDataCreate( kCFAllocatorDefault , (UInt8*) &viewRef , sizeof(viewRef) ) ;

-                 err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID,
-                   data , &item ) ;
+                err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID,
+                    data , &item ) ;

 
                 if (err  == noErr)
                 {
 
                 if (err  == noErr)
                 {


@@ -1475,6 +1517,19 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
             break;
     }
 
             break;
     }
 

+#if wxMAC_USE_NATIVE_TOOLBAR
+    wxString label = tool->GetLabel();
+    if ( !label.empty() )
+    {
+        // strip mnemonics from the label for compatibility
+        // with the usual labels in wxStaticText sense
+        label = wxStripMenuCodes(label);
+
+        HIToolbarItemSetLabel(item,
+                              wxMacCFStringHolder(label, m_font.GetEncoding()));
+    }
+#endif // wxMAC_USE_NATIVE_TOOLBAR
+

     if ( err == noErr )
     {
         if ( controlHandle )
     if ( err == noErr )
     {
         if ( controlHandle )


@@ -1490,7 +1545,6 @@ 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