#if wxUSE_TOOLBAR
-#include "wx/wx.h"
-#include "wx/bitmap.h"
#include "wx/toolbar.h"
+#ifndef WX_PRECOMP
+ #include "wx/wx.h"
+#endif
+
#include "wx/mac/uma.h"
#include "wx/geometry.h"
SetControlHandle( (ControlRef) control->GetHandle() );
}
- ~wxToolBarTool()
+ virtual ~wxToolBarTool()
{
ClearControl();
- if ( m_controlHandle )
- DisposeControl( m_controlHandle );
#if wxMAC_USE_NATIVE_TOOLBAR
if ( m_toolbarItemRef )
void ClearControl()
{
m_control = NULL;
+ if ( m_controlHandle )
+ {
+ if ( !IsControl() )
+ DisposeControl( m_controlHandle );
+ else
+ {
+ // the embedded control is not under the responsibility of the tool
+ }
+ m_controlHandle = NULL ;
+ }
#if wxMAC_USE_NATIVE_TOOLBAR
m_toolbarItemRef = NULL;
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;
}
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
{
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 )
{
wxMemoryDC dc;
dc.SelectObject( bmp );
- dc.SetPen( wxNullPen );
- dc.SetBackground( *wxWHITE );
+ dc.SetPen( wxPen(*wxBLACK) );
+ dc.SetBrush( wxBrush( *wxLIGHT_GREY ));
dc.DrawRectangle( 0, 0, w, h );
dc.DrawBitmap( m_bmpNormal, 0, 0, true );
dc.SelectObject( wxNullBitmap );
ControlButtonContentInfo info;
wxMacCreateBitmapButton( &info, bmp );
SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if (m_toolbarItemRef != NULL)
+ {
+ HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef );
+ }
+#endif
wxMacReleaseBitmapButton( &info );
}
else
ControlButtonContentInfo info;
wxMacCreateBitmapButton( &info, m_bmpNormal );
SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if (m_toolbarItemRef != NULL)
+ {
+ HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef );
+ }
+#endif
wxMacReleaseBitmapButton( &info );
}
#endif
}
+#define kControlToolbarItemClassID CFSTR( "org.wxwidgets.controltoolbaritem" )
+
+const EventTypeSpec kEvents[] =
+{
+ { kEventClassHIObject, kEventHIObjectConstruct },
+ { kEventClassHIObject, kEventHIObjectInitialize },
+ { kEventClassHIObject, kEventHIObjectDestruct },
+
+ { kEventClassToolbarItem, kEventToolbarItemCreateCustomView }
+};
+
+const EventTypeSpec kViewEvents[] =
+{
+ { kEventClassControl, kEventControlGetSizeConstraints }
+};
+
+struct ControlToolbarItem
+{
+ HIToolbarItemRef toolbarItem;
+ HIViewRef viewRef;
+ wxSize lastValidSize ;
+};
+
+static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
+{
+ OSStatus result = eventNotHandledErr;
+ ControlToolbarItem* object = (ControlToolbarItem*)inUserData;
+
+ switch ( GetEventClass( inEvent ) )
+ {
+ case kEventClassHIObject:
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventHIObjectConstruct:
+ {
+ HIObjectRef toolbarItem;
+ ControlToolbarItem* item;
+
+ GetEventParameter( inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL,
+ sizeof( HIObjectRef ), NULL, &toolbarItem );
+
+ item = (ControlToolbarItem*) malloc(sizeof(ControlToolbarItem)) ;
+ item->toolbarItem = toolbarItem ;
+ item->viewRef = NULL ;
+
+ SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof( void * ), &item );
+
+ result = noErr ;
+ }
+ break;
+
+ case kEventHIObjectInitialize:
+ result = CallNextEventHandler( inCallRef, inEvent );
+ if ( result == noErr )
+ {
+ CFDataRef data;
+ GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
+ sizeof( CFTypeRef ), NULL, &data );
+
+ HIViewRef viewRef ;
+
+ wxASSERT_MSG( CFDataGetLength( data ) == sizeof( viewRef ) , wxT("Illegal Data passed") ) ;
+ memcpy( &viewRef , CFDataGetBytePtr( data ) , sizeof( viewRef ) ) ;
+
+ object->viewRef = (HIViewRef) viewRef ;
+
+ result = noErr ;
+ }
+ break;
+
+ case kEventHIObjectDestruct:
+ free( object ) ;
+ result = noErr;
+ break;
+ }
+ break;
+
+ case kEventClassToolbarItem:
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventToolbarItemCreateCustomView:
+ {
+ HIViewRef viewRef = object->viewRef ;
+
+ HIViewRemoveFromSuperview( viewRef ) ;
+ HIViewSetVisible(viewRef, true) ;
+ InstallEventHandler( GetControlEventTarget( viewRef ), ControlToolbarItemHandler,
+ GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL );
+
+ result = SetEventParameter( inEvent, kEventParamControlRef, typeControlRef, sizeof( HIViewRef ), &viewRef );
+ }
+ break;
+ }
+ break;
+
+ case kEventClassControl:
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventControlGetSizeConstraints:
+ {
+ wxWindow* wxwindow = wxFindControlFromMacControl(object->viewRef ) ;
+ if ( wxwindow )
+ {
+ wxSize sz = wxwindow->GetSize() ;
+ sz.x -= wxwindow->MacGetLeftBorderSize() + wxwindow->MacGetRightBorderSize();
+ sz.y -= wxwindow->MacGetTopBorderSize() + wxwindow->MacGetBottomBorderSize();
+ // during toolbar layout the native window sometimes gets negative sizes
+ // so we always keep the last valid size here, to make sure we survive the
+ // shuffle ...
+ if ( sz.x > 0 && sz.y > 0 )
+ object->lastValidSize = sz ;
+ else
+ sz = object->lastValidSize ;
+
+ HISize min, max;
+ min.width = max.width = sz.x ;
+ min.height = max.height = sz.y ;
+
+ result = SetEventParameter( inEvent, kEventParamMinimumSize, typeHISize,
+ sizeof( HISize ), &min );
+
+ result = SetEventParameter( inEvent, kEventParamMaximumSize, typeHISize,
+ sizeof( HISize ), &max );
+ result = noErr ;
+ }
+ }
+ break;
+ }
+ break;
+ }
+
+ return result;
+}
+
+void RegisterControlToolbarItemClass()
+{
+ static bool sRegistered;
+
+ if ( !sRegistered )
+ {
+ HIObjectRegisterSubclass( kControlToolbarItemClassID, kHIToolbarItemClassID, 0,
+ ControlToolbarItemHandler, GetEventTypeCount( kEvents ), kEvents, 0, NULL );
+
+ sRegistered = true;
+ }
+}
+
+HIToolbarItemRef CreateControlToolbarItem(CFStringRef inIdentifier, CFTypeRef inConfigData)
+{
+ RegisterControlToolbarItemClass();
+
+ OSStatus err;
+ EventRef event;
+ UInt32 options = kHIToolbarItemAllowDuplicates;
+ HIToolbarItemRef result = NULL;
+
+ err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event );
+ require_noerr( err, CantCreateEvent );
+
+ SetEventParameter( event, kEventParamAttributes, typeUInt32, sizeof( UInt32 ), &options );
+ SetEventParameter( event, kEventParamToolbarItemIdentifier, typeCFStringRef, sizeof( CFStringRef ), &inIdentifier );
+
+ if ( inConfigData )
+ SetEventParameter( event, kEventParamToolbarItemConfigData, typeCFTypeRef, sizeof( CFTypeRef ), &inConfigData );
+
+ err = HIObjectCreate( kControlToolbarItemClassID, event, (HIObjectRef*)&result );
+ check_noerr( err );
+
+ ReleaseEvent( event );
+CantCreateEvent :
+ return result ;
+}
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+static const EventTypeSpec kToolbarEvents[] =
+{
+ { kEventClassToolbar, kEventToolbarGetDefaultIdentifiers },
+ { kEventClassToolbar, kEventToolbarGetAllowedIdentifiers },
+ { kEventClassToolbar, kEventToolbarCreateItemWithIdentifier },
+};
+
+static OSStatus ToolbarDelegateHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
+{
+ OSStatus result = eventNotHandledErr;
+ // Not yet needed
+ // wxToolBar* toolbar = (wxToolBar*) inUserData ;
+ CFMutableArrayRef array;
+
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventToolbarGetDefaultIdentifiers:
+ {
+ GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
+ sizeof( CFMutableArrayRef ), NULL, &array );
+ // not implemented yet
+ // GetToolbarDefaultItems( array );
+ result = noErr;
+ }
+ break;
+
+ case kEventToolbarGetAllowedIdentifiers:
+ {
+ GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
+ sizeof( CFMutableArrayRef ), NULL, &array );
+ // not implemented yet
+ // GetToolbarAllowedItems( array );
+ result = noErr;
+ }
+ break;
+ case kEventToolbarCreateItemWithIdentifier:
+ {
+ HIToolbarItemRef item = NULL;
+ CFTypeRef data = NULL;
+ CFStringRef identifier = NULL ;
+
+ GetEventParameter( inEvent, kEventParamToolbarItemIdentifier, typeCFStringRef, NULL,
+ sizeof( CFStringRef ), NULL, &identifier );
+
+ GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
+ sizeof( CFTypeRef ), NULL, &data );
+
+ if ( CFStringCompare( kControlToolbarItemClassID, identifier, kCFCompareBackwards ) == kCFCompareEqualTo )
+ {
+ item = CreateControlToolbarItem( kControlToolbarItemClassID, data );
+ if ( item )
+ {
+ SetEventParameter( inEvent, kEventParamToolbarItem, typeHIToolbarItemRef,
+ sizeof( HIToolbarItemRef ), &item );
+ result = noErr;
+ }
+ }
+
+ }
+ break;
+ }
+ return result ;
+}
+#endif // wxMAC_USE_NATIVE_TOOLBAR
+
// also for the toolbar we have the dual implementation:
// only when MacInstallNativeToolbar is called is the native toolbar set as the window toolbar
-//
+
bool wxToolBar::Create(
wxWindow *parent,
wxWindowID id,
if ( !wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name ) )
return false;
+ FixupStyle();
+
OSStatus err = noErr;
#if wxMAC_USE_NATIVE_TOOLBAR
if (m_macHIToolbarRef != NULL)
{
+ InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler,
+ GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL );
+
HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault;
HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall;
bool lastIsRadio = false;
bool curIsRadio = false;
- bool setChoiceInGroup = false;
#if wxMAC_USE_NATIVE_TOOLBAR
CFIndex currentPosition = 0;
if (err != noErr)
{
wxString errMsg = wxString::Format( wxT("HIToolbarRemoveItemAtIndex failed [%ld]"), (long)err );
- wxASSERT_MSG( 0, errMsg.c_str() );
+ wxFAIL_MSG( errMsg.c_str() );
}
}
if (err != noErr)
{
wxString errMsg = wxString::Format( wxT("HIToolbarInsertItemAtIndex failed [%ld]"), (long)err );
- wxASSERT_MSG( 0, errMsg.c_str() );
+ wxFAIL_MSG( errMsg.c_str() );
}
tool->SetIndex( currentPosition );
{
if ( tool->IsToggled() )
DoToggleTool( tool, true );
-
- setChoiceInGroup = false;
}
else
{
if ( tool->Toggle( true ) )
{
DoToggleTool( tool, true );
- setChoiceInGroup = true;
}
}
else if ( tool->IsToggled() )
InvalidateBestSize();
#endif
- SetBestFittingSize();
+ SetInitialSize();
return true;
}
break;
case wxTOOL_STYLE_CONTROL:
- wxASSERT( tool->GetControl() != NULL );
-#if 0 // wxMAC_USE_NATIVE_TOOLBAR
- // FIXME: doesn't work yet...
+#if wxMAC_USE_NATIVE_TOOLBAR
{
+ wxASSERT( tool->GetControl() != NULL );
HIToolbarItemRef item;
- wxString labelStr = wxString::Format( wxT("%xd"), (int)tool );
- result = HIToolbarItemCreate(
- wxMacCFStringHolder( labelStr, wxFont::GetDefaultEncoding() ),
- kHIToolbarItemCantBeRemoved | kHIToolbarItemAnchoredLeft | kHIToolbarItemAllowDuplicates,
- &item );
- if ( result == noErr )
+ HIViewRef viewRef = (HIViewRef) tool->GetControl()->GetHandle() ;
+ // as this control now is part of both the wxToolBar children and the native toolbar, we have to increase the
+ // reference count to make sure we are not dealing with zombie controls after the native toolbar has released its views
+ CFRetain( viewRef ) ;
+ CFDataRef data = CFDataCreate( kCFAllocatorDefault , (UInt8*) &viewRef , sizeof(viewRef) ) ;
+ err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID,
+ data , &item ) ;
+
+ if (err == noErr)
{
- HIToolbarItemSetLabel( item, wxMacCFStringHolder( tool->GetLabel(), m_font.GetEncoding() ) );
- HIToolbarItemSetCommandID( item, tool->GetId() );
tool->SetToolbarItemRef( item );
-
- controlHandle = ( ControlRef ) tool->GetControlHandle();
- wxASSERT_MSG( controlHandle != NULL, wxT("NULL tool control") );
-
- // FIXME: is this necessary ??
- ::GetControlBounds( controlHandle, &toolrect );
- UMAMoveControl( controlHandle, -toolrect.left, -toolrect.top );
-
- // FIXME: is this necessary ??
- InstallControlEventHandler(
- controlHandle, GetwxMacToolBarToolEventHandlerUPP(),
- GetEventTypeCount(eventList), eventList, tool, NULL );
}
- }
+ CFRelease( data ) ;
+ }
#else
- // FIXME: right now there's nothing to do here
+ // right now there's nothing to do here
#endif
break;
else
{
wxString errMsg = wxString::Format( wxT("wxToolBar::DoInsertTool - failure [%ld]"), (long)err );
- wxASSERT_MSG( false, errMsg.c_str() );
+ wxFAIL_MSG( errMsg.c_str() );
}
return (err == noErr);
case wxTOOL_STYLE_SEPARATOR:
if ( tool->GetControlHandle() )
{
- DisposeControl( (ControlRef) tool->GetControlHandle() );
-
#if wxMAC_USE_NATIVE_TOOLBAR
if ( removeIndex != -1 && m_macHIToolbarRef )
{
drawInfo.kind = kThemeBackgroundMetal;
HIThemeApplyBackground( &hiToolbarrect, &drawInfo, cgContext, kHIThemeOrientationNormal );
+#ifndef __LP64__
QDEndCGContext( (CGrafPtr) dc.m_macPort, &cgContext );
+#endif
#endif
}
}
projects / wxWidgets.git / blobdiff