+// We have a dual implementation for each tool, ControlRef and HIToolbarItemRef
+
+class wxToolBarTool : public wxToolBarToolBase
+{
+public:
+ wxToolBarTool(
+ wxToolBar *tbar,
+ int id,
+ const wxString& label,
+ const wxBitmap& bmpNormal,
+ const wxBitmap& bmpDisabled,
+ wxItemKind kind,
+ wxObject *clientData,
+ const wxString& shortHelp,
+ const wxString& longHelp );
+
+ wxToolBarTool(wxToolBar *tbar, wxControl *control)
+ : wxToolBarToolBase(tbar, control)
+ {
+ Init();
+ if (control != NULL)
+ SetControlHandle( (ControlRef) control->GetHandle() );
+ }
+
+ ~wxToolBarTool()
+ {
+ ClearControl();
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if ( m_toolbarItemRef )
+ CFRelease( m_toolbarItemRef );
+#endif
+ }
+
+ WXWidget GetControlHandle()
+ {
+ return (WXWidget) m_controlHandle;
+ }
+
+ void SetControlHandle( ControlRef handle )
+ {
+ m_controlHandle = handle;
+ }
+
+ void SetPosition( const wxPoint& position );
+
+ void ClearControl()
+ {
+ m_control = NULL;
+ if ( m_controlHandle )
+ {
+ DisposeControl( m_controlHandle );
+ m_controlHandle = NULL ;
+ }
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+ m_toolbarItemRef = NULL;
+#endif
+ }
+
+ wxSize GetSize() const
+ {
+ wxSize curSize;
+
+ if ( IsControl() )
+ {
+ curSize = GetControl()->GetSize();
+ }
+ else if ( IsButton() )
+ {
+ curSize = GetToolBar()->GetToolSize();
+ }
+ else
+ {
+ // separator size
+ curSize = GetToolBar()->GetToolSize();
+ if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL )
+ curSize.y /= 4;
+ else
+ curSize.x /= 4;
+ }
+
+ return curSize;
+ }
+
+ wxPoint GetPosition() const
+ {
+ return wxPoint( m_x, m_y );
+ }
+
+ bool DoEnable( bool enable );
+
+ void UpdateToggleImage( bool toggle );
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+ void SetToolbarItemRef( HIToolbarItemRef ref )
+ {
+ if ( m_controlHandle )
+ HideControl( m_controlHandle );
+ if ( m_toolbarItemRef )
+ CFRelease( m_toolbarItemRef );
+
+ m_toolbarItemRef = ref;
+ if ( m_toolbarItemRef )
+ {
+ HIToolbarItemSetHelpText(
+ m_toolbarItemRef,
+ wxMacCFStringHolder( GetShortHelp(), GetToolBar()->GetFont().GetEncoding() ),
+ wxMacCFStringHolder( GetLongHelp(), GetToolBar()->GetFont().GetEncoding() ) );
+ }
+ }
+
+ HIToolbarItemRef GetToolbarItemRef() const
+ {
+ return m_toolbarItemRef;
+ }
+
+ void SetIndex( CFIndex idx )
+ {
+ m_index = idx;
+ }
+
+ CFIndex GetIndex() const
+ {
+ return m_index;
+ }
+#endif
+
+private:
+ void Init()
+ {
+ m_controlHandle = NULL;
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+ m_toolbarItemRef = NULL;
+ m_index = -1;
+#endif
+ }
+
+ ControlRef m_controlHandle;
+ wxCoord m_x;
+ wxCoord m_y;
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+ HIToolbarItemRef m_toolbarItemRef;
+ // position in its toolbar, -1 means not inserted
+ CFIndex m_index;
+#endif
+};
+
+static const EventTypeSpec eventList[] =
+{
+ { kEventClassControl, kEventControlHit },
+#ifdef __WXMAC_OSX__
+ { kEventClassControl, kEventControlHitTest },
+#endif
+};
+
+static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
+{
+ OSStatus result = eventNotHandledErr;
+ ControlRef controlRef;
+ wxMacCarbonEvent cEvent( event );
+
+ cEvent.GetParameter( kEventParamDirectObject, &controlRef );
+
+ switch ( GetEventKind( event ) )
+ {
+ case kEventControlHit:
+ {
+ wxToolBarTool *tbartool = (wxToolBarTool*)data;
+ wxToolBar *tbar = tbartool != NULL ? (wxToolBar*) (tbartool->GetToolBar()) : NULL;
+ if ((tbartool != NULL) && tbartool->CanBeToggled())
+ {
+ bool shouldToggle;
+
+#ifdef __WXMAC_OSX__
+ shouldToggle = !tbartool->IsToggled();
+#else
+ shouldToggle = (GetControl32BitValue( (ControlRef)(tbartool->GetControlHandle()) ) != 0);
+#endif
+
+ tbar->ToggleTool( tbartool->GetId(), shouldToggle );
+ }
+
+ if (tbartool != NULL)
+ tbar->OnLeftClick( tbartool->GetId(), tbartool->IsToggled() );
+ result = noErr;
+ }
+ break;
+
+#ifdef __WXMAC_OSX__
+ case kEventControlHitTest:
+ {
+ HIPoint pt = cEvent.GetParameter<HIPoint>(kEventParamMouseLocation);
+ HIRect rect;
+ HIViewGetBounds( controlRef, &rect );
+
+ ControlPartCode pc = kControlNoPart;
+ if ( CGRectContainsPoint( rect, pt ) )
+ pc = kControlIconPart;
+ cEvent.SetParameter( kEventParamControlPart, typeControlPartCode, pc );
+ result = noErr;
+ }
+ break;
+#endif
+
+ default:
+ break;
+ }
+
+ return result;
+}
+
+static pascal OSStatus wxMacToolBarToolEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
+{
+ OSStatus result = eventNotHandledErr;
+
+ switch ( GetEventClass( event ) )
+ {
+ case kEventClassControl:
+ result = wxMacToolBarToolControlEventHandler( handler, event, data );
+ break;
+
+ default:
+ break;
+ }
+
+ return result;
+}
+
+DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarToolEventHandler )
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+
+static const EventTypeSpec toolBarEventList[] =
+{
+ { kEventClassToolbarItem, kEventToolbarItemPerformAction },
+};
+
+static pascal OSStatus wxMacToolBarCommandEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
+{
+ OSStatus result = eventNotHandledErr;
+
+ switch ( GetEventKind( event ) )
+ {
+ case kEventToolbarItemPerformAction:
+ {
+ wxToolBarTool* tbartool = (wxToolBarTool*) data;
+ if ( tbartool != NULL )
+ {
+ wxToolBar *tbar = (wxToolBar*)(tbartool->GetToolBar());
+ int toolID = tbartool->GetId();
+
+ if ( tbartool->CanBeToggled() )
+ {
+ if ( tbar != NULL )
+ tbar->ToggleTool(toolID, !tbartool->IsToggled() );
+ }
+
+ if ( tbar != NULL )
+ tbar->OnLeftClick( toolID, tbartool->IsToggled() );
+ result = noErr;
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return result;
+}
+
+static pascal OSStatus wxMacToolBarEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
+{
+ OSStatus result = eventNotHandledErr;
+
+ switch ( GetEventClass( event ) )
+ {
+ case kEventClassToolbarItem:
+ result = wxMacToolBarCommandEventHandler( handler, event, data );
+ break;
+
+ default:
+ break;
+ }
+
+ return result;
+}
+
+DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarEventHandler )
+
+#endif
+
+bool wxToolBarTool::DoEnable( bool enable )
+{
+ if ( IsControl() )
+ {
+ GetControl()->Enable( enable );
+ }
+ else if ( IsButton() )
+ {
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if ( m_toolbarItemRef != NULL )
+ HIToolbarItemSetEnabled( m_toolbarItemRef, enable );
+#endif
+
+ 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
+ }
+ }
+
+ return true;
+}
+
+void wxToolBarTool::SetPosition( const wxPoint& position )
+{
+ 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;
+ GetControlBounds( m_controlHandle, &contrlRect );
+ int former_mac_x = contrlRect.left;
+ int former_mac_y = contrlRect.top;
+ GetToolBar()->GetToolSize();
+
+ if ( mac_x != former_mac_x || mac_y != former_mac_y )
+ {
+ UMAMoveControl( m_controlHandle, mac_x, mac_y );
+ }
+ }
+ else if ( IsControl() )
+ {
+ 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
+ }
+}
+
+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();
+ int h = m_bmpNormal.GetHeight();
+ wxBitmap bmp( w, h );
+ wxMemoryDC dc;
+
+ dc.SelectObject( bmp );
+ dc.SetPen( wxNullPen );
+ dc.SetBackground( *wxWHITE );
+ 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 );
+ wxMacReleaseBitmapButton( &info );
+ }
+ else
+ {
+ ControlButtonContentInfo info;
+ wxMacCreateBitmapButton( &info, m_bmpNormal );
+ SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
+ wxMacReleaseBitmapButton( &info );
+ }
+
+ IconTransformType transform = toggle ? kTransformSelected : kTransformNone;
+ SetControlData(
+ m_controlHandle, 0, kControlIconTransformTag,
+ sizeof(transform), (Ptr)&transform );
+ HIViewSetNeedsDisplay( m_controlHandle, true );
+
+#else
+ ::SetControl32BitValue( m_controlHandle, toggle );
+#endif
+}
+
+wxToolBarTool::wxToolBarTool(
+ wxToolBar *tbar,
+ int id,
+ const wxString& label,
+ const wxBitmap& bmpNormal,
+ const wxBitmap& bmpDisabled,
+ wxItemKind kind,
+ wxObject *clientData,
+ const wxString& shortHelp,
+ const wxString& longHelp )
+ :
+ wxToolBarToolBase(
+ tbar, id, label, bmpNormal, bmpDisabled, kind,
+ clientData, shortHelp, longHelp )
+{
+ Init();
+}
+
+#pragma mark -
+#pragma mark Toolbar Implementation
+
+wxToolBarToolBase *wxToolBar::CreateTool(
+ int id,
+ const wxString& label,
+ const wxBitmap& bmpNormal,
+ const wxBitmap& bmpDisabled,
+ wxItemKind kind,
+ wxObject *clientData,
+ const wxString& shortHelp,
+ const wxString& longHelp )
+{
+ return new wxToolBarTool(
+ this, id, label, bmpNormal, bmpDisabled, kind,
+ clientData, shortHelp, longHelp );
+}
+
+wxToolBarToolBase * wxToolBar::CreateTool( wxControl *control )
+{
+ return new wxToolBarTool( this, control );
+}
+
+void wxToolBar::Init()
+{
+ m_maxWidth = -1;
+ m_maxHeight = -1;
+ m_defaultWidth = kwxMacToolBarToolDefaultWidth;
+ m_defaultHeight = kwxMacToolBarToolDefaultHeight;
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+ m_macHIToolbarRef = NULL;
+ m_macUsesNativeToolbar = false;
+#endif
+}
+
+// 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,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name )
+{
+ if ( !wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name ) )
+ return false;
+
+ 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)
+ {
+ 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
+
+ return (err == noErr);
+}
+
+wxToolBar::~wxToolBar()
+{
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if (m_macHIToolbarRef != NULL)
+ {
+ // if this is the installed toolbar, then deinstall it
+ if (m_macUsesNativeToolbar)
+ MacInstallNativeToolbar( false );
+
+ CFRelease( (HIToolbarRef)m_macHIToolbarRef );
+ m_macHIToolbarRef = NULL;
+ }
+#endif
+}
+
+bool wxToolBar::Show( bool show )
+{
+ WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef());
+ bool bResult = (tlw != NULL);
+
+ if (bResult)
+ {
+#if wxMAC_USE_NATIVE_TOOLBAR
+ bool ownToolbarInstalled = false;
+ MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
+ if (ownToolbarInstalled)
+ {
+ bResult = (IsWindowToolbarVisible( tlw ) != show);
+ if ( bResult )
+ ShowHideWindowToolbar( tlw, show, false );
+ }
+ else
+ bResult = wxToolBarBase::Show( show );
+#else
+
+ bResult = wxToolBarBase::Show( show );
+#endif
+ }
+
+ return bResult;
+}
+
+bool wxToolBar::IsShown() const
+{
+ bool bResult;
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+ bool ownToolbarInstalled;
+
+ MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
+ if (ownToolbarInstalled)
+ {
+ WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef());
+ bResult = IsWindowToolbarVisible( tlw );
+ }
+ else
+ bResult = wxToolBarBase::IsShown();
+#else
+
+ bResult = wxToolBarBase::IsShown();
+#endif
+
+ return bResult;
+}
+
+void wxToolBar::DoGetSize( int *width, int *height ) const
+{
+#if wxMAC_USE_NATIVE_TOOLBAR
+ Rect boundsR;
+ bool ownToolbarInstalled;
+
+ MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
+ if ( ownToolbarInstalled )
+ {
+ // TODO: is this really a control ?
+ GetControlBounds( (ControlRef) m_macHIToolbarRef, &boundsR );
+ if ( width != NULL )
+ *width = boundsR.right - boundsR.left;
+ if ( height != NULL )
+ *height = boundsR.bottom - boundsR.top;
+ }
+ else
+ wxToolBarBase::DoGetSize( width, height );
+
+#else
+ wxToolBarBase::DoGetSize( width, height );
+#endif
+}
+
+wxSize wxToolBar::DoGetBestSize() const
+{
+ int width, height;
+
+ DoGetSize( &width, &height );
+
+ return wxSize( width, height );
+}
+
+void wxToolBar::SetWindowStyleFlag( long style )
+{
+ wxToolBarBase::SetWindowStyleFlag( style );
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+ if (m_macHIToolbarRef != NULL)
+ {
+ HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault;
+
+ if ( style & wxTB_NOICONS )
+ mode = kHIToolbarDisplayModeLabelOnly;
+ else if ( style & wxTB_TEXT )
+ mode = kHIToolbarDisplayModeIconAndLabel;
+ else
+ mode = kHIToolbarDisplayModeIconOnly;
+
+ HIToolbarSetDisplayMode( (HIToolbarRef) m_macHIToolbarRef, mode );
+ }
+#endif
+}
+
+#if wxMAC_USE_NATIVE_TOOLBAR
+bool wxToolBar::MacWantsNativeToolbar()
+{
+ return m_macUsesNativeToolbar;
+}
+
+bool wxToolBar::MacTopLevelHasNativeToolbar(bool *ownToolbarInstalled) const
+{
+ bool bResultV = false;
+
+ if (ownToolbarInstalled != NULL)
+ *ownToolbarInstalled = false;
+
+ WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef());
+ if (tlw != NULL)
+ {
+ HIToolbarRef curToolbarRef = NULL;
+ OSStatus err = GetWindowToolbar( tlw, &curToolbarRef );
+ bResultV = ((err == noErr) && (curToolbarRef != NULL));
+ if (bResultV && (ownToolbarInstalled != NULL))
+ *ownToolbarInstalled = (curToolbarRef == m_macHIToolbarRef);
+ }
+
+ return bResultV;
+}
+
+bool wxToolBar::MacInstallNativeToolbar(bool usesNative)
+{
+ bool bResult = false;
+
+ if (usesNative && (m_macHIToolbarRef == NULL))
+ return bResult;
+
+ if (usesNative && ((GetWindowStyleFlag() & wxTB_VERTICAL) != 0))
+ return bResult;
+
+ WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef());
+ if (tlw == NULL)
+ return bResult;
+
+ // check the existing toolbar
+ HIToolbarRef curToolbarRef = NULL;
+ OSStatus err = GetWindowToolbar( tlw, &curToolbarRef );
+ if (err != noErr)
+ curToolbarRef = NULL;
+
+ m_macUsesNativeToolbar = usesNative;
projects / wxWidgets.git / blobdiff