#include "wx/wx.h"
#endif
+#include "wx/app.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;
-#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)
// 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:
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)
SetControlHandle( (ControlRef) control->GetHandle() );
}
- ~wxToolBarTool()
+ virtual ~wxToolBarTool()
{
ClearControl();
-
-#if wxMAC_USE_NATIVE_TOOLBAR
- if ( m_toolbarItemRef )
- CFRelease( m_toolbarItemRef );
-#endif
}
WXWidget GetControlHandle()
void ClearControl()
{
- 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, it gets disposed of in the
+ // proper wxControl destructor
+ }
m_controlHandle = NULL ;
}
+ m_control = NULL;
#if wxMAC_USE_NATIVE_TOOLBAR
- m_toolbarItemRef = NULL;
+ if ( m_toolbarItemRef )
+ {
+ CFIndex count = CFGetRetainCount( m_toolbarItemRef ) ;
+ // different behaviour under Leopard
+ if ( UMAGetSystemVersion() < 0x1050 )
+ {
+ 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
}
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,
- wxMacCFStringHolder( GetShortHelp(), GetToolBar()->GetFont().GetEncoding() ),
- wxMacCFStringHolder( GetLongHelp(), GetToolBar()->GetFont().GetEncoding() ) );
+ wxCFStringRef( GetShortHelp(), enc ),
+ wxCFStringRef( GetLongHelp(), enc ) );
}
}
static const EventTypeSpec eventList[] =
{
{ kEventClassControl, kEventControlHit },
-#ifdef __WXMAC_OSX__
{ 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;
{
bool shouldToggle;
-#ifdef __WXMAC_OSX__
shouldToggle = !tbartool->IsToggled();
-#else
- shouldToggle = (GetControl32BitValue( (ControlRef)(tbartool->GetControlHandle()) ) != 0);
-#endif
tbar->ToggleTool( tbartool->GetId(), shouldToggle );
}
}
break;
-#ifdef __WXMAC_OSX__
case kEventControlHitTest:
{
HIPoint pt = cEvent.GetParameter<HIPoint>(kEventParamMouseLocation);
result = noErr;
}
break;
-#endif
default:
break;
{ 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;
if ( m_controlHandle != NULL )
{
-#if TARGET_API_MAC_OSX
if ( enable )
EnableControl( m_controlHandle );
else
DisableControl( m_controlHandle );
-#else
- if ( enable )
- ActivateControl( m_controlHandle );
- else
- DeactivateControl( m_controlHandle );
-#endif
}
}
m_x = position.x;
m_y = position.y;
- int x, y;
- x = y = 0;
int mac_x = position.x;
int mac_y = position.y;
- if ( ! GetToolBar()->MacGetTopLevelWindow()->MacUsesCompositing() )
- {
- GetToolBar()->MacWindowToRootWindow( &x, &y );
- mac_x += x;
- mac_y += y;
- }
-
if ( IsButton() )
{
Rect contrlRect;
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() )
{
- 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
{
// 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 )
- UMAMoveControl( m_controlHandle, mac_x, mac_y );
-#endif
+ ::MoveControl( m_controlHandle, mac_x, mac_y );
}
}
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 )
{
int w = m_bmpNormal.GetWidth();
wxMemoryDC dc;
dc.SelectObject( bmp );
- dc.SetPen( wxNullPen );
- dc.SetBackground( *wxWHITE );
+ dc.SetPen( wxPen(*wxBLACK) );
+ dc.SetBrush( wxBrush( *wxLIGHT_GREY ));
dc.DrawRectangle( 0, 0, w, h );
dc.DrawBitmap( m_bmpNormal, 0, 0, true );
dc.SelectObject( wxNullBitmap );
ControlButtonContentInfo info;
wxMacCreateBitmapButton( &info, bmp );
SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if (m_toolbarItemRef != NULL)
+ {
+ ControlButtonContentInfo info2;
+ wxMacCreateBitmapButton( &info2, bmp, kControlContentCGImageRef);
+ HIToolbarItemSetImage( m_toolbarItemRef, info2.u.imageRef );
+ wxMacReleaseBitmapButton( &info2 );
+ }
+#endif
wxMacReleaseBitmapButton( &info );
}
else
ControlButtonContentInfo info;
wxMacCreateBitmapButton( &info, m_bmpNormal );
SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if (m_toolbarItemRef != NULL)
+ {
+ ControlButtonContentInfo info2;
+ wxMacCreateBitmapButton( &info2, m_bmpNormal, kControlContentCGImageRef);
+ HIToolbarItemSetImage( m_toolbarItemRef, info2.u.imageRef );
+ wxMacReleaseBitmapButton( &info2 );
+ }
+#endif
wxMacReleaseBitmapButton( &info );
}
sizeof(transform), (Ptr)&transform );
HIViewSetNeedsDisplay( m_controlHandle, true );
-#else
- ::SetControl32BitValue( m_controlHandle, toggle );
-#endif
}
wxToolBarTool::wxToolBarTool(
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()
#endif
}
+#define kControlToolbarItemClassID CFSTR( "org.wxwidgets.controltoolbaritem" )
+
+const EventTypeSpec kEvents[] =
+{
+ { kEventClassHIObject, kEventHIObjectConstruct },
+ { kEventClassHIObject, kEventHIObjectInitialize },
+ { kEventClassHIObject, kEventHIObjectDestruct },
+
+ { kEventClassToolbarItem, kEventToolbarItemCreateCustomView }
+};
+
+const EventTypeSpec kViewEvents[] =
+{
+ { kEventClassControl, kEventControlGetSizeConstraints }
+};
+
+struct ControlToolbarItem
+{
+ HIToolbarItemRef toolbarItem;
+ HIViewRef viewRef;
+ wxSize lastValidSize ;
+};
+
+static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
+{
+ OSStatus result = eventNotHandledErr;
+ ControlToolbarItem* object = (ControlToolbarItem*)inUserData;
+
+ switch ( GetEventClass( inEvent ) )
+ {
+ case kEventClassHIObject:
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventHIObjectConstruct:
+ {
+ HIObjectRef toolbarItem;
+ ControlToolbarItem* item;
+
+ GetEventParameter( inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL,
+ sizeof( HIObjectRef ), NULL, &toolbarItem );
+
+ item = (ControlToolbarItem*) malloc(sizeof(ControlToolbarItem)) ;
+ item->toolbarItem = toolbarItem ;
+ item->lastValidSize = wxSize(-1,-1);
+ item->viewRef = NULL ;
+
+ SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof( void * ), &item );
+
+ result = noErr ;
+ }
+ break;
+
+ case kEventHIObjectInitialize:
+ result = CallNextEventHandler( inCallRef, inEvent );
+ if ( result == noErr )
+ {
+ CFDataRef data;
+ GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
+ sizeof( CFTypeRef ), NULL, &data );
+
+ HIViewRef viewRef ;
+
+ wxASSERT_MSG( CFDataGetLength( data ) == sizeof( viewRef ) , wxT("Illegal Data passed") ) ;
+ memcpy( &viewRef , CFDataGetBytePtr( data ) , sizeof( viewRef ) ) ;
+
+ object->viewRef = (HIViewRef) viewRef ;
+ // 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:
+ {
+ 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 ) ;
+ wxASSERT_MSG( count >=1 , wxT("Reference Count of native tool was illegal before removal") );
+ if ( count >= 1 )
+ CFRelease( viewRef ) ;
+ }
+ free( object ) ;
+ result = noErr;
+ }
+ break;
+ }
+ break;
+
+ case kEventClassToolbarItem:
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventToolbarItemCreateCustomView:
+ {
+ HIViewRef viewRef = object->viewRef ;
+ HIViewRemoveFromSuperview( viewRef ) ;
+ HIViewSetVisible(viewRef, true) ;
+ CFRetain( viewRef ) ;
+ result = SetEventParameter( inEvent, kEventParamControlRef, typeControlRef, sizeof( HIViewRef ), &viewRef );
+ }
+ break;
+ }
+ break;
+
+ case kEventClassControl:
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventControlGetSizeConstraints:
+ {
+ wxWindow* wxwindow = wxFindControlFromMacControl(object->viewRef ) ;
+ if ( wxwindow )
+ {
+ // 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 ;
+
+ result = SetEventParameter( inEvent, kEventParamMinimumSize, typeHISize,
+ sizeof( HISize ), &min );
+
+ result = SetEventParameter( inEvent, kEventParamMaximumSize, typeHISize,
+ sizeof( HISize ), &max );
+ result = noErr ;
+ }
+ }
+ break;
+ }
+ break;
+ }
+
+ return result;
+}
+
+void RegisterControlToolbarItemClass()
+{
+ static bool sRegistered;
+
+ if ( !sRegistered )
+ {
+ HIObjectRegisterSubclass( kControlToolbarItemClassID, kHIToolbarItemClassID, 0,
+ ControlToolbarItemHandler, GetEventTypeCount( kEvents ), kEvents, 0, NULL );
+
+ sRegistered = true;
+ }
+}
+
+HIToolbarItemRef CreateControlToolbarItem(CFStringRef inIdentifier, CFTypeRef inConfigData)
+{
+ RegisterControlToolbarItemClass();
+
+ OSStatus err;
+ EventRef event;
+ UInt32 options = kHIToolbarItemAllowDuplicates;
+ HIToolbarItemRef result = NULL;
+
+ err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event );
+ require_noerr( err, CantCreateEvent );
+
+ SetEventParameter( event, kEventParamAttributes, typeUInt32, sizeof( UInt32 ), &options );
+ SetEventParameter( event, kEventParamToolbarItemIdentifier, typeCFStringRef, sizeof( CFStringRef ), &inIdentifier );
+
+ if ( inConfigData )
+ SetEventParameter( event, kEventParamToolbarItemConfigData, typeCFTypeRef, sizeof( CFTypeRef ), &inConfigData );
+
+ err = HIObjectCreate( kControlToolbarItemClassID, event, (HIObjectRef*)&result );
+ check_noerr( err );
+
+ ReleaseEvent( event );
+CantCreateEvent :
+ return result ;
+}
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+static const EventTypeSpec kToolbarEvents[] =
+{
+ { kEventClassToolbar, kEventToolbarGetDefaultIdentifiers },
+ { kEventClassToolbar, kEventToolbarGetAllowedIdentifiers },
+ { kEventClassToolbar, kEventToolbarCreateItemWithIdentifier },
+};
+
+static OSStatus ToolbarDelegateHandler(EventHandlerCallRef WXUNUSED(inCallRef),
+ EventRef inEvent,
+ void* WXUNUSED(inUserData))
+{
+ OSStatus result = eventNotHandledErr;
+ // Not yet needed
+ // wxToolBar* toolbar = (wxToolBar*) inUserData ;
+ CFMutableArrayRef array;
+
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventToolbarGetDefaultIdentifiers:
+ {
+ GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
+ sizeof( CFMutableArrayRef ), NULL, &array );
+ // not implemented yet
+ // GetToolbarDefaultItems( array );
+ result = noErr;
+ }
+ break;
+
+ case kEventToolbarGetAllowedIdentifiers:
+ {
+ GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
+ sizeof( CFMutableArrayRef ), NULL, &array );
+ // not implemented yet
+ // GetToolbarAllowedItems( array );
+ result = noErr;
+ }
+ break;
+ case kEventToolbarCreateItemWithIdentifier:
+ {
+ HIToolbarItemRef item = NULL;
+ CFTypeRef data = NULL;
+ CFStringRef identifier = NULL ;
+
+ GetEventParameter( inEvent, kEventParamToolbarItemIdentifier, typeCFStringRef, NULL,
+ sizeof( CFStringRef ), NULL, &identifier );
+
+ GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
+ sizeof( CFTypeRef ), NULL, &data );
+
+ if ( CFStringCompare( kControlToolbarItemClassID, identifier, kCFCompareBackwards ) == kCFCompareEqualTo )
+ {
+ item = CreateControlToolbarItem( kControlToolbarItemClassID, data );
+ if ( item )
+ {
+ SetEventParameter( inEvent, kEventParamToolbarItem, typeHIToolbarItemRef,
+ sizeof( HIToolbarItemRef ), &item );
+ result = noErr;
+ }
+ }
+
+ }
+ break;
+ }
+ return result ;
+}
+#endif // wxMAC_USE_NATIVE_TOOLBAR
+
// also for the toolbar we have the dual implementation:
// only when MacInstallNativeToolbar is called is the native toolbar set as the window toolbar
-//
+
bool wxToolBar::Create(
wxWindow *parent,
wxWindowID id,
if ( !wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name ) )
return false;
+ FixupStyle();
+
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)
{
- HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault;
- HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall;
+ wxString labelStr = wxString::Format( wxT("%p"), this );
+ err = HIToolbarCreate(
+ wxCFStringRef( labelStr, wxFont::GetDefaultEncoding() ), 0,
+ (HIToolbarRef*) &m_macHIToolbarRef );
- if ( style & wxTB_NOICONS )
- mode = kHIToolbarDisplayModeLabelOnly;
- else if ( style & wxTB_TEXT )
- mode = kHIToolbarDisplayModeIconAndLabel;
- else
- mode = kHIToolbarDisplayModeIconOnly;
+ if (m_macHIToolbarRef != NULL)
+ {
+ InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler,
+ GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL );
- HIToolbarSetDisplayMode( (HIToolbarRef) m_macHIToolbarRef, mode );
- HIToolbarSetDisplaySize( (HIToolbarRef) m_macHIToolbarRef, displaySize );
+ 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 );
+ }
}
-#endif
+#endif // wxMAC_USE_NATIVE_TOOLBAR
return (err == noErr);
}
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 )
+ {
+ wxASSERT_MSG( count == 1 , wxT("Reference Count of native control was not 1 in wxToolBar destructor") );
+ }
CFRelease( (HIToolbarRef)m_macHIToolbarRef );
m_macHIToolbarRef = NULL;
}
// 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 )
bool lastIsRadio = false;
bool curIsRadio = false;
- bool setChoiceInGroup = false;
#if wxMAC_USE_NATIVE_TOOLBAR
CFIndex currentPosition = 0;
bool insertAll = false;
+
+ HIToolbarRef refTB = (HIToolbarRef)m_macHIToolbarRef;
#endif
node = m_tools.GetFirst();
- while ( node != NULL )
+ while ( node )
{
tool = (wxToolBarTool*) node->GetData();
if ( tool == NULL )
#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 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() ) ;
+ wxASSERT_MSG( count == 3 || count == 2 , wxT("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() ) ;
+ wxASSERT_MSG( count == 2 , wxT("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)
{
- 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 );
+ if ( tool->IsControl() )
+ {
+ CFIndex count = CFGetRetainCount( tool->GetControl()->GetPeer()->GetControlRef() ) ;
+ wxASSERT_MSG( count == 3 || count == 2, wxT("Reference Count of native tool was illegal after insertion") );
+ wxASSERT( IsValidControlHandle(tool->GetControl()->GetPeer()->GetControlRef() )) ;
+ }
}
currentPosition++;
{
if ( tool->IsToggled() )
DoToggleTool( tool, true );
-
- setChoiceInGroup = false;
}
else
{
if ( tool->Toggle( true ) )
{
DoToggleTool( tool, true );
- setChoiceInGroup = true;
}
}
else if ( tool->IsToggled() )
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) )
InvalidateBestSize();
#endif
- SetBestFittingSize();
+ SetInitialSize();
return true;
}
#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();
- while ( node != NULL )
+ while ( node )
{
tool = (wxToolBarTool *)node->GetData();
if (tool != NULL)
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())
{
else
toolrect.right = toolSize.x;
-#ifdef __WXMAC_OSX__
// 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 );
-#endif
}
break;
{
wxASSERT( tool->GetControlHandle() == NULL );
ControlButtonContentInfo info;
- wxMacCreateBitmapButton( &info, tool->GetNormalBitmap(), kControlContentIconRef );
+ wxMacCreateBitmapButton( &info, tool->GetNormalBitmap() );
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 );
+ wxMacReleaseBitmapButton( &info );
}
else
{
}
#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, m_font.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 );
- UMASetControlTitle( m_controlHandle, label, wxFont::GetDefaultEncoding() );
+ SetControlTitleWithCFString( m_controlHandle , wxCFStringRef( label, wxFont::GetDefaultEncoding() );
#endif
InstallControlEventHandler(
break;
case wxTOOL_STYLE_CONTROL:
- wxASSERT( tool->GetControl() != NULL );
-#if 0 // wxMAC_USE_NATIVE_TOOLBAR
- // FIXME: doesn't work yet...
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if (m_macHIToolbarRef != NULL)
{
+ wxCHECK_MSG( tool->GetControl(), false, _T("control must be non-NULL") );
HIToolbarItemRef item;
- wxString labelStr = wxString::Format( wxT("%xd"), (int)tool );
- result = HIToolbarItemCreate(
- wxMacCFStringHolder( labelStr, wxFont::GetDefaultEncoding() ),
- kHIToolbarItemCantBeRemoved | kHIToolbarItemAnchoredLeft | kHIToolbarItemAllowDuplicates,
- &item );
- if ( result == noErr )
+ HIViewRef viewRef = (HIViewRef) tool->GetControl()->GetHandle() ;
+ CFDataRef data = CFDataCreate( kCFAllocatorDefault , (UInt8*) &viewRef , sizeof(viewRef) ) ;
+ err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID,
+ data , &item ) ;
+
+ if (err == noErr)
{
- HIToolbarItemSetLabel( item, wxMacCFStringHolder( tool->GetLabel(), m_font.GetEncoding() ) );
- HIToolbarItemSetCommandID( item, tool->GetId() );
tool->SetToolbarItemRef( item );
-
- controlHandle = ( ControlRef ) tool->GetControlHandle();
- wxASSERT_MSG( controlHandle != NULL, wxT("NULL tool control") );
-
- // FIXME: is this necessary ??
- ::GetControlBounds( controlHandle, &toolrect );
- UMAMoveControl( controlHandle, -toolrect.left, -toolrect.top );
-
- // FIXME: is this necessary ??
- InstallControlEventHandler(
- controlHandle, GetwxMacToolBarToolEventHandlerUPP(),
- GetEventTypeCount(eventList), eventList, tool, NULL );
}
- }
-
+ CFRelease( data ) ;
+ }
+ else
+ {
+ err = noErr;
+ break;
+ }
#else
- // FIXME: right now there's nothing to do here
+ // right now there's nothing to do here
#endif
break;
ControlRef container = (ControlRef) GetHandle();
wxASSERT_MSG( container != NULL, wxT("No valid Mac container control") );
- UMAShowControl( controlHandle );
+ SetControlVisibility( controlHandle, true, true );
::EmbedControl( controlHandle, container );
}
tool->UpdateToggleImage( true );
// nothing special to do here - we relayout in Realize() later
- tool->Attach( this );
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);
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:
- {
+ if ( tool->GetControl() )
tool->GetControl()->Destroy();
- tool->ClearControl();
- }
break;
case wxTOOL_STYLE_BUTTON:
case wxTOOL_STYLE_SEPARATOR:
- if ( tool->GetControlHandle() )
- {
-#if wxMAC_USE_NATIVE_TOOLBAR
- if ( removeIndex != -1 && m_macHIToolbarRef )
- {
- HIToolbarRemoveItemAtIndex( (HIToolbarRef) m_macHIToolbarRef, removeIndex );
- tool->SetIndex( -1 );
- }
-#endif
-
- tool->ClearControl();
- }
+ // nothing special
break;
default:
break;
}
+ tool->ClearControl();
// and finally reposition all the controls after this one
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
}
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) );
// 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 );
-
- QDEndCGContext( (CGrafPtr) dc.m_macPort, &cgContext );
-#endif
- }
- }
-#endif
-
event.Skip();
}
projects / wxWidgets.git / blobdiff