]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/carbon/toolbar.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
compilation fix: don't try to convert wxString to bool (apparently unnecessarily)
[wxWidgets.git] / src / mac / carbon / toolbar.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/mac/carbon/toolbar.cpp
3// Purpose: wxToolBar
4// Author: Stefan Csomor
5// Modified by:
6// Created: 04/01/98
7// RCS-ID: $Id$
8// Copyright: (c) Stefan Csomor
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#include "wx/wxprec.h"
13
14#if wxUSE_TOOLBAR
15
16#include "wx/toolbar.h"
17
18#ifndef WX_PRECOMP
19 #include "wx/wx.h"
20#endif
21
22#include "wx/app.h"
23#include "wx/mac/uma.h"
24#include "wx/geometry.h"
25
26
27#ifdef __WXMAC_OSX__
28const short kwxMacToolBarToolDefaultWidth = 16;
29const short kwxMacToolBarToolDefaultHeight = 16;
30const short kwxMacToolBarTopMargin = 4;
31const short kwxMacToolBarLeftMargin = 4;
32const short kwxMacToolBorder = 0;
33const short kwxMacToolSpacing = 6;
34#else
35const short kwxMacToolBarToolDefaultWidth = 24;
36const short kwxMacToolBarToolDefaultHeight = 22;
37const short kwxMacToolBarTopMargin = 2;
38const short kwxMacToolBarLeftMargin = 2;
39const short kwxMacToolBorder = 4;
40const short kwxMacToolSpacing = 0;
41#endif
42
43
44IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
45
46BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
47 EVT_PAINT( wxToolBar::OnPaint )
48END_EVENT_TABLE()
49
50
51#pragma mark -
52#pragma mark Tool Implementation
53
54
55// ----------------------------------------------------------------------------
56// private classes
57// ----------------------------------------------------------------------------
58
59// We have a dual implementation for each tool, ControlRef and HIToolbarItemRef
60
61class wxToolBarTool : public wxToolBarToolBase
62{
63public:
64 wxToolBarTool(
65 wxToolBar *tbar,
66 int id,
67 const wxString& label,
68 const wxBitmap& bmpNormal,
69 const wxBitmap& bmpDisabled,
70 wxItemKind kind,
71 wxObject *clientData,
72 const wxString& shortHelp,
73 const wxString& longHelp );
74
75 wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
76 : wxToolBarToolBase(tbar, control, label)
77 {
78 Init();
79 if (control != NULL)
80 SetControlHandle( (ControlRef) control->GetHandle() );
81 }
82
83 virtual ~wxToolBarTool()
84 {
85 ClearControl();
86 }
87
88 WXWidget GetControlHandle()
89 {
90 return (WXWidget) m_controlHandle;
91 }
92
93 void SetControlHandle( ControlRef handle )
94 {
95 m_controlHandle = handle;
96 }
97
98 void SetPosition( const wxPoint& position );
99
100 void ClearControl()
101 {
102 m_control = NULL;
103 if ( m_controlHandle )
104 {
105 if ( !IsControl() )
106 DisposeControl( m_controlHandle );
107 else
108 {
109 // the embedded control is not under the responsibility of the tool
110 }
111 m_controlHandle = NULL ;
112 }
113
114#if wxMAC_USE_NATIVE_TOOLBAR
115 if ( m_toolbarItemRef )
116 {
117 CFIndex count = CFGetRetainCount( m_toolbarItemRef ) ;
118 wxASSERT_MSG( count == 1 , wxT("Reference Count of native tool was not 1 in wxToolBarTool destructor") );
119 wxTheApp->MacAddToAutorelease(m_toolbarItemRef);
120 CFRelease(m_toolbarItemRef);
121 m_toolbarItemRef = NULL;
122 }
123#endif
124 }
125
126 wxSize GetSize() const
127 {
128 wxSize curSize;
129
130 if ( IsControl() )
131 {
132 curSize = GetControl()->GetSize();
133 }
134 else if ( IsButton() )
135 {
136 curSize = GetToolBar()->GetToolSize();
137 }
138 else
139 {
140 // separator size
141 curSize = GetToolBar()->GetToolSize();
142 if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL )
143 curSize.y /= 4;
144 else
145 curSize.x /= 4;
146 }
147
148 return curSize;
149 }
150
151 wxPoint GetPosition() const
152 {
153 return wxPoint( m_x, m_y );
154 }
155
156 bool DoEnable( bool enable );
157
158 void UpdateToggleImage( bool toggle );
159
160#if wxMAC_USE_NATIVE_TOOLBAR
161 void SetToolbarItemRef( HIToolbarItemRef ref )
162 {
163 if ( m_controlHandle )
164 HideControl( m_controlHandle );
165 if ( m_toolbarItemRef )
166 CFRelease( m_toolbarItemRef );
167
168 m_toolbarItemRef = ref;
169 if ( m_toolbarItemRef )
170 {
171 wxFont f;
172 wxFontEncoding enc;
173 if ( GetToolBar() )
174 f = GetToolBar()->GetFont();
175 if ( f.IsOk() )
176 enc = f.GetEncoding();
177 else
178 enc = wxFont::GetDefaultEncoding();
179
180 HIToolbarItemSetHelpText(
181 m_toolbarItemRef,
182 wxMacCFStringHolder( GetShortHelp(), enc ),
183 wxMacCFStringHolder( GetLongHelp(), enc ) );
184 }
185 }
186
187 HIToolbarItemRef GetToolbarItemRef() const
188 {
189 return m_toolbarItemRef;
190 }
191
192 void SetIndex( CFIndex idx )
193 {
194 m_index = idx;
195 }
196
197 CFIndex GetIndex() const
198 {
199 return m_index;
200 }
201#endif
202
203private:
204 void Init()
205 {
206 m_controlHandle = NULL;
207
208#if wxMAC_USE_NATIVE_TOOLBAR
209 m_toolbarItemRef = NULL;
210 m_index = -1;
211#endif
212 }
213
214 ControlRef m_controlHandle;
215 wxCoord m_x;
216 wxCoord m_y;
217
218#if wxMAC_USE_NATIVE_TOOLBAR
219 HIToolbarItemRef m_toolbarItemRef;
220 // position in its toolbar, -1 means not inserted
221 CFIndex m_index;
222#endif
223};
224
225static const EventTypeSpec eventList[] =
226{
227 { kEventClassControl, kEventControlHit },
228#ifdef __WXMAC_OSX__
229 { kEventClassControl, kEventControlHitTest },
230#endif
231};
232
233static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
234{
235 OSStatus result = eventNotHandledErr;
236 ControlRef controlRef;
237 wxMacCarbonEvent cEvent( event );
238
239 cEvent.GetParameter( kEventParamDirectObject, &controlRef );
240
241 switch ( GetEventKind( event ) )
242 {
243 case kEventControlHit:
244 {
245 wxToolBarTool *tbartool = (wxToolBarTool*)data;
246 wxToolBar *tbar = tbartool != NULL ? (wxToolBar*) (tbartool->GetToolBar()) : NULL;
247 if ((tbartool != NULL) && tbartool->CanBeToggled())
248 {
249 bool shouldToggle;
250
251#ifdef __WXMAC_OSX__
252 shouldToggle = !tbartool->IsToggled();
253#else
254 shouldToggle = (GetControl32BitValue( (ControlRef)(tbartool->GetControlHandle()) ) != 0);
255#endif
256
257 tbar->ToggleTool( tbartool->GetId(), shouldToggle );
258 }
259
260 if (tbartool != NULL)
261 tbar->OnLeftClick( tbartool->GetId(), tbartool->IsToggled() );
262 result = noErr;
263 }
264 break;
265
266#ifdef __WXMAC_OSX__
267 case kEventControlHitTest:
268 {
269 HIPoint pt = cEvent.GetParameter<HIPoint>(kEventParamMouseLocation);
270 HIRect rect;
271 HIViewGetBounds( controlRef, &rect );
272
273 ControlPartCode pc = kControlNoPart;
274 if ( CGRectContainsPoint( rect, pt ) )
275 pc = kControlIconPart;
276 cEvent.SetParameter( kEventParamControlPart, typeControlPartCode, pc );
277 result = noErr;
278 }
279 break;
280#endif
281
282 default:
283 break;
284 }
285
286 return result;
287}
288
289static pascal OSStatus wxMacToolBarToolEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
290{
291 OSStatus result = eventNotHandledErr;
292
293 switch ( GetEventClass( event ) )
294 {
295 case kEventClassControl:
296 result = wxMacToolBarToolControlEventHandler( handler, event, data );
297 break;
298
299 default:
300 break;
301 }
302
303 return result;
304}
305
306DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarToolEventHandler )
307
308#if wxMAC_USE_NATIVE_TOOLBAR
309
310static const EventTypeSpec toolBarEventList[] =
311{
312 { kEventClassToolbarItem, kEventToolbarItemPerformAction },
313};
314
315static pascal OSStatus wxMacToolBarCommandEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
316{
317 OSStatus result = eventNotHandledErr;
318
319 switch ( GetEventKind( event ) )
320 {
321 case kEventToolbarItemPerformAction:
322 {
323 wxToolBarTool* tbartool = (wxToolBarTool*) data;
324 if ( tbartool != NULL )
325 {
326 wxToolBar *tbar = (wxToolBar*)(tbartool->GetToolBar());
327 int toolID = tbartool->GetId();
328
329 if ( tbartool->CanBeToggled() )
330 {
331 if ( tbar != NULL )
332 tbar->ToggleTool(toolID, !tbartool->IsToggled() );
333 }
334
335 if ( tbar != NULL )
336 tbar->OnLeftClick( toolID, tbartool->IsToggled() );
337 result = noErr;
338 }
339 }
340 break;
341
342 default:
343 break;
344 }
345
346 return result;
347}
348
349static pascal OSStatus wxMacToolBarEventHandler( EventHandlerCallRef handler, EventRef event, void *data )
350{
351 OSStatus result = eventNotHandledErr;
352
353 switch ( GetEventClass( event ) )
354 {
355 case kEventClassToolbarItem:
356 result = wxMacToolBarCommandEventHandler( handler, event, data );
357 break;
358
359 default:
360 break;
361 }
362
363 return result;
364}
365
366DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarEventHandler )
367
368#endif
369
370bool wxToolBarTool::DoEnable( bool enable )
371{
372 if ( IsControl() )
373 {
374 GetControl()->Enable( enable );
375 }
376 else if ( IsButton() )
377 {
378#if wxMAC_USE_NATIVE_TOOLBAR
379 if ( m_toolbarItemRef != NULL )
380 HIToolbarItemSetEnabled( m_toolbarItemRef, enable );
381#endif
382
383 if ( m_controlHandle != NULL )
384 {
385#if TARGET_API_MAC_OSX
386 if ( enable )
387 EnableControl( m_controlHandle );
388 else
389 DisableControl( m_controlHandle );
390#else
391 if ( enable )
392 ActivateControl( m_controlHandle );
393 else
394 DeactivateControl( m_controlHandle );
395#endif
396 }
397 }
398
399 return true;
400}
401
402void wxToolBarTool::SetPosition( const wxPoint& position )
403{
404 m_x = position.x;
405 m_y = position.y;
406
407 int mac_x = position.x;
408 int mac_y = position.y;
409
410 if ( IsButton() )
411 {
412 Rect contrlRect;
413 GetControlBounds( m_controlHandle, &contrlRect );
414 int former_mac_x = contrlRect.left;
415 int former_mac_y = contrlRect.top;
416 GetToolBar()->GetToolSize();
417
418 if ( mac_x != former_mac_x || mac_y != former_mac_y )
419 {
420 UMAMoveControl( m_controlHandle, mac_x, mac_y );
421 }
422 }
423 else if ( IsControl() )
424 {
425 // embedded native controls are moved by the OS
426#if wxMAC_USE_NATIVE_TOOLBAR
427 if ( ((wxToolBar*)GetToolBar())->MacWantsNativeToolbar() == false )
428#endif
429 {
430 GetControl()->Move( position );
431 }
432 }
433 else
434 {
435 // separator
436#ifdef __WXMAC_OSX__
437 Rect contrlRect;
438 GetControlBounds( m_controlHandle, &contrlRect );
439 int former_mac_x = contrlRect.left;
440 int former_mac_y = contrlRect.top;
441
442 if ( mac_x != former_mac_x || mac_y != former_mac_y )
443 UMAMoveControl( m_controlHandle, mac_x, mac_y );
444#endif
445 }
446}
447
448void wxToolBarTool::UpdateToggleImage( bool toggle )
449{
450#ifdef __WXMAC_OSX__
451 if ( toggle )
452 {
453 int w = m_bmpNormal.GetWidth();
454 int h = m_bmpNormal.GetHeight();
455 wxBitmap bmp( w, h );
456 wxMemoryDC dc;
457
458 dc.SelectObject( bmp );
459 dc.SetPen( wxPen(*wxBLACK) );
460 dc.SetBrush( wxBrush( *wxLIGHT_GREY ));
461 dc.DrawRectangle( 0, 0, w, h );
462 dc.DrawBitmap( m_bmpNormal, 0, 0, true );
463 dc.SelectObject( wxNullBitmap );
464 ControlButtonContentInfo info;
465 wxMacCreateBitmapButton( &info, bmp, kControlContentIconRef );
466 SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
467#if wxMAC_USE_NATIVE_TOOLBAR
468 if (m_toolbarItemRef != NULL)
469 {
470 HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef );
471 }
472#endif
473 wxMacReleaseBitmapButton( &info );
474 }
475 else
476 {
477 ControlButtonContentInfo info;
478 wxMacCreateBitmapButton( &info, m_bmpNormal, kControlContentIconRef );
479 SetControlData( m_controlHandle, 0, kControlIconContentTag, sizeof(info), (Ptr)&info );
480#if wxMAC_USE_NATIVE_TOOLBAR
481 if (m_toolbarItemRef != NULL)
482 {
483 HIToolbarItemSetIconRef( m_toolbarItemRef, info.u.iconRef );
484 }
485#endif
486 wxMacReleaseBitmapButton( &info );
487 }
488
489 IconTransformType transform = toggle ? kTransformSelected : kTransformNone;
490 SetControlData(
491 m_controlHandle, 0, kControlIconTransformTag,
492 sizeof(transform), (Ptr)&transform );
493 HIViewSetNeedsDisplay( m_controlHandle, true );
494
495#else
496 ::SetControl32BitValue( m_controlHandle, toggle );
497#endif
498}
499
500wxToolBarTool::wxToolBarTool(
501 wxToolBar *tbar,
502 int id,
503 const wxString& label,
504 const wxBitmap& bmpNormal,
505 const wxBitmap& bmpDisabled,
506 wxItemKind kind,
507 wxObject *clientData,
508 const wxString& shortHelp,
509 const wxString& longHelp )
510 :
511 wxToolBarToolBase(
512 tbar, id, label, bmpNormal, bmpDisabled, kind,
513 clientData, shortHelp, longHelp )
514{
515 Init();
516}
517
518#pragma mark -
519#pragma mark Toolbar Implementation
520
521wxToolBarToolBase *wxToolBar::CreateTool(
522 int id,
523 const wxString& label,
524 const wxBitmap& bmpNormal,
525 const wxBitmap& bmpDisabled,
526 wxItemKind kind,
527 wxObject *clientData,
528 const wxString& shortHelp,
529 const wxString& longHelp )
530{
531 return new wxToolBarTool(
532 this, id, label, bmpNormal, bmpDisabled, kind,
533 clientData, shortHelp, longHelp );
534}
535
536wxToolBarToolBase *
537wxToolBar::CreateTool(wxControl *control, const wxString& label)
538{
539 return new wxToolBarTool(this, control, label);
540}
541
542void wxToolBar::Init()
543{
544 m_maxWidth = -1;
545 m_maxHeight = -1;
546 m_defaultWidth = kwxMacToolBarToolDefaultWidth;
547 m_defaultHeight = kwxMacToolBarToolDefaultHeight;
548
549#if wxMAC_USE_NATIVE_TOOLBAR
550 m_macHIToolbarRef = NULL;
551 m_macUsesNativeToolbar = false;
552#endif
553}
554
555#define kControlToolbarItemClassID CFSTR( "org.wxwidgets.controltoolbaritem" )
556
557const EventTypeSpec kEvents[] =
558{
559 { kEventClassHIObject, kEventHIObjectConstruct },
560 { kEventClassHIObject, kEventHIObjectInitialize },
561 { kEventClassHIObject, kEventHIObjectDestruct },
562
563 { kEventClassToolbarItem, kEventToolbarItemCreateCustomView }
564};
565
566const EventTypeSpec kViewEvents[] =
567{
568 { kEventClassControl, kEventControlGetSizeConstraints }
569};
570
571struct ControlToolbarItem
572{
573 HIToolbarItemRef toolbarItem;
574 HIViewRef viewRef;
575 wxSize lastValidSize ;
576};
577
578static pascal OSStatus ControlToolbarItemHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
579{
580 OSStatus result = eventNotHandledErr;
581 ControlToolbarItem* object = (ControlToolbarItem*)inUserData;
582
583 switch ( GetEventClass( inEvent ) )
584 {
585 case kEventClassHIObject:
586 switch ( GetEventKind( inEvent ) )
587 {
588 case kEventHIObjectConstruct:
589 {
590 HIObjectRef toolbarItem;
591 ControlToolbarItem* item;
592
593 GetEventParameter( inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL,
594 sizeof( HIObjectRef ), NULL, &toolbarItem );
595
596 item = (ControlToolbarItem*) malloc(sizeof(ControlToolbarItem)) ;
597 item->toolbarItem = toolbarItem ;
598 item->viewRef = NULL ;
599
600 SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof( void * ), &item );
601
602 result = noErr ;
603 }
604 break;
605
606 case kEventHIObjectInitialize:
607 result = CallNextEventHandler( inCallRef, inEvent );
608 if ( result == noErr )
609 {
610 CFDataRef data;
611 GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
612 sizeof( CFTypeRef ), NULL, &data );
613
614 HIViewRef viewRef ;
615
616 wxASSERT_MSG( CFDataGetLength( data ) == sizeof( viewRef ) , wxT("Illegal Data passed") ) ;
617 memcpy( &viewRef , CFDataGetBytePtr( data ) , sizeof( viewRef ) ) ;
618
619 object->viewRef = (HIViewRef) viewRef ;
620
621 result = noErr ;
622 }
623 break;
624
625 case kEventHIObjectDestruct:
626 {
627 // we've increased the ref count when creating this, so we decrease manually again in case
628 // it was never really installed and deinstalled
629 HIViewRef viewRef = object->viewRef ;
630 if( viewRef && IsValidControlHandle( viewRef) )
631 {
632 CFIndex count = CFGetRetainCount( viewRef ) ;
633 if ( count >= 1 )
634 CFRelease( viewRef ) ;
635 }
636 free( object ) ;
637 result = noErr;
638 }
639 break;
640 }
641 break;
642
643 case kEventClassToolbarItem:
644 switch ( GetEventKind( inEvent ) )
645 {
646 case kEventToolbarItemCreateCustomView:
647 {
648 HIViewRef viewRef = object->viewRef ;
649
650 HIViewRemoveFromSuperview( viewRef ) ;
651 HIViewSetVisible(viewRef, true) ;
652 InstallEventHandler( GetControlEventTarget( viewRef ), ControlToolbarItemHandler,
653 GetEventTypeCount( kViewEvents ), kViewEvents, object, NULL );
654
655 result = SetEventParameter( inEvent, kEventParamControlRef, typeControlRef, sizeof( HIViewRef ), &viewRef );
656 }
657 break;
658 }
659 break;
660
661 case kEventClassControl:
662 switch ( GetEventKind( inEvent ) )
663 {
664 case kEventControlGetSizeConstraints:
665 {
666 wxWindow* wxwindow = wxFindControlFromMacControl(object->viewRef ) ;
667 if ( wxwindow )
668 {
669 wxSize sz = wxwindow->GetSize() ;
670 sz.x -= wxwindow->MacGetLeftBorderSize() + wxwindow->MacGetRightBorderSize();
671 sz.y -= wxwindow->MacGetTopBorderSize() + wxwindow->MacGetBottomBorderSize();
672 // during toolbar layout the native window sometimes gets negative sizes
673 // so we always keep the last valid size here, to make sure we survive the
674 // shuffle ...
675 if ( sz.x > 0 && sz.y > 0 )
676 object->lastValidSize = sz ;
677 else
678 sz = object->lastValidSize ;
679
680 HISize min, max;
681 min.width = max.width = sz.x ;
682 min.height = max.height = sz.y ;
683
684 result = SetEventParameter( inEvent, kEventParamMinimumSize, typeHISize,
685 sizeof( HISize ), &min );
686
687 result = SetEventParameter( inEvent, kEventParamMaximumSize, typeHISize,
688 sizeof( HISize ), &max );
689 result = noErr ;
690 }
691 }
692 break;
693 }
694 break;
695 }
696
697 return result;
698}
699
700void RegisterControlToolbarItemClass()
701{
702 static bool sRegistered;
703
704 if ( !sRegistered )
705 {
706 HIObjectRegisterSubclass( kControlToolbarItemClassID, kHIToolbarItemClassID, 0,
707 ControlToolbarItemHandler, GetEventTypeCount( kEvents ), kEvents, 0, NULL );
708
709 sRegistered = true;
710 }
711}
712
713HIToolbarItemRef CreateControlToolbarItem(CFStringRef inIdentifier, CFTypeRef inConfigData)
714{
715 RegisterControlToolbarItemClass();
716
717 OSStatus err;
718 EventRef event;
719 UInt32 options = kHIToolbarItemAllowDuplicates;
720 HIToolbarItemRef result = NULL;
721
722 err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event );
723 require_noerr( err, CantCreateEvent );
724
725 SetEventParameter( event, kEventParamAttributes, typeUInt32, sizeof( UInt32 ), &options );
726 SetEventParameter( event, kEventParamToolbarItemIdentifier, typeCFStringRef, sizeof( CFStringRef ), &inIdentifier );
727
728 if ( inConfigData )
729 SetEventParameter( event, kEventParamToolbarItemConfigData, typeCFTypeRef, sizeof( CFTypeRef ), &inConfigData );
730
731 err = HIObjectCreate( kControlToolbarItemClassID, event, (HIObjectRef*)&result );
732 check_noerr( err );
733
734 ReleaseEvent( event );
735CantCreateEvent :
736 return result ;
737}
738
739#if wxMAC_USE_NATIVE_TOOLBAR
740static const EventTypeSpec kToolbarEvents[] =
741{
742 { kEventClassToolbar, kEventToolbarGetDefaultIdentifiers },
743 { kEventClassToolbar, kEventToolbarGetAllowedIdentifiers },
744 { kEventClassToolbar, kEventToolbarCreateItemWithIdentifier },
745};
746
747static OSStatus ToolbarDelegateHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
748{
749 OSStatus result = eventNotHandledErr;
750 // Not yet needed
751 // wxToolBar* toolbar = (wxToolBar*) inUserData ;
752 CFMutableArrayRef array;
753
754 switch ( GetEventKind( inEvent ) )
755 {
756 case kEventToolbarGetDefaultIdentifiers:
757 {
758 GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
759 sizeof( CFMutableArrayRef ), NULL, &array );
760 // not implemented yet
761 // GetToolbarDefaultItems( array );
762 result = noErr;
763 }
764 break;
765
766 case kEventToolbarGetAllowedIdentifiers:
767 {
768 GetEventParameter( inEvent, kEventParamMutableArray, typeCFMutableArrayRef, NULL,
769 sizeof( CFMutableArrayRef ), NULL, &array );
770 // not implemented yet
771 // GetToolbarAllowedItems( array );
772 result = noErr;
773 }
774 break;
775 case kEventToolbarCreateItemWithIdentifier:
776 {
777 HIToolbarItemRef item = NULL;
778 CFTypeRef data = NULL;
779 CFStringRef identifier = NULL ;
780
781 GetEventParameter( inEvent, kEventParamToolbarItemIdentifier, typeCFStringRef, NULL,
782 sizeof( CFStringRef ), NULL, &identifier );
783
784 GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
785 sizeof( CFTypeRef ), NULL, &data );
786
787 if ( CFStringCompare( kControlToolbarItemClassID, identifier, kCFCompareBackwards ) == kCFCompareEqualTo )
788 {
789 item = CreateControlToolbarItem( kControlToolbarItemClassID, data );
790 if ( item )
791 {
792 SetEventParameter( inEvent, kEventParamToolbarItem, typeHIToolbarItemRef,
793 sizeof( HIToolbarItemRef ), &item );
794 result = noErr;
795 }
796 }
797
798 }
799 break;
800 }
801 return result ;
802}
803#endif // wxMAC_USE_NATIVE_TOOLBAR
804
805// also for the toolbar we have the dual implementation:
806// only when MacInstallNativeToolbar is called is the native toolbar set as the window toolbar
807
808bool wxToolBar::Create(
809 wxWindow *parent,
810 wxWindowID id,
811 const wxPoint& pos,
812 const wxSize& size,
813 long style,
814 const wxString& name )
815{
816 if ( !wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name ) )
817 return false;
818
819 FixupStyle();
820
821 OSStatus err = noErr;
822
823#if wxMAC_USE_NATIVE_TOOLBAR
824 wxString labelStr = wxString::Format( wxT("%xd"), (int)this );
825 err = HIToolbarCreate(
826 wxMacCFStringHolder( labelStr, wxFont::GetDefaultEncoding() ), 0,
827 (HIToolbarRef*) &m_macHIToolbarRef );
828
829 if (m_macHIToolbarRef != NULL)
830 {
831 InstallEventHandler( HIObjectGetEventTarget((HIToolbarRef)m_macHIToolbarRef ), ToolbarDelegateHandler,
832 GetEventTypeCount( kToolbarEvents ), kToolbarEvents, this, NULL );
833
834 HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault;
835 HIToolbarDisplaySize displaySize = kHIToolbarDisplaySizeSmall;
836
837 if ( style & wxTB_NOICONS )
838 mode = kHIToolbarDisplayModeLabelOnly;
839 else if ( style & wxTB_TEXT )
840 mode = kHIToolbarDisplayModeIconAndLabel;
841 else
842 mode = kHIToolbarDisplayModeIconOnly;
843
844 HIToolbarSetDisplayMode( (HIToolbarRef) m_macHIToolbarRef, mode );
845 HIToolbarSetDisplaySize( (HIToolbarRef) m_macHIToolbarRef, displaySize );
846 }
847#endif // wxMAC_USE_NATIVE_TOOLBAR
848
849 return (err == noErr);
850}
851
852wxToolBar::~wxToolBar()
853{
854#if wxMAC_USE_NATIVE_TOOLBAR
855 if (m_macHIToolbarRef != NULL)
856 {
857 // if this is the installed toolbar, then deinstall it
858 if (m_macUsesNativeToolbar)
859 MacInstallNativeToolbar( false );
860
861 CFIndex count = CFGetRetainCount( m_macHIToolbarRef ) ;
862 wxASSERT_MSG( count == 1 , wxT("Reference Count of native control was not 1 in wxToolBar destructor") );
863
864 CFRelease( (HIToolbarRef)m_macHIToolbarRef );
865 m_macHIToolbarRef = NULL;
866 }
867#endif
868}
869
870bool wxToolBar::Show( bool show )
871{
872 WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef());
873 bool bResult = (tlw != NULL);
874
875 if (bResult)
876 {
877#if wxMAC_USE_NATIVE_TOOLBAR
878 bool ownToolbarInstalled = false;
879 MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
880 if (ownToolbarInstalled)
881 {
882 bResult = (IsWindowToolbarVisible( tlw ) != show);
883 if ( bResult )
884 ShowHideWindowToolbar( tlw, show, false );
885 }
886 else
887 bResult = wxToolBarBase::Show( show );
888#else
889
890 bResult = wxToolBarBase::Show( show );
891#endif
892 }
893
894 return bResult;
895}
896
897bool wxToolBar::IsShown() const
898{
899 bool bResult;
900
901#if wxMAC_USE_NATIVE_TOOLBAR
902 bool ownToolbarInstalled;
903
904 MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
905 if (ownToolbarInstalled)
906 {
907 WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef());
908 bResult = IsWindowToolbarVisible( tlw );
909 }
910 else
911 bResult = wxToolBarBase::IsShown();
912#else
913
914 bResult = wxToolBarBase::IsShown();
915#endif
916
917 return bResult;
918}
919
920void wxToolBar::DoGetSize( int *width, int *height ) const
921{
922#if wxMAC_USE_NATIVE_TOOLBAR
923 Rect boundsR;
924 bool ownToolbarInstalled;
925
926 MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
927 if ( ownToolbarInstalled )
928 {
929 // TODO: is this really a control ?
930 GetControlBounds( (ControlRef) m_macHIToolbarRef, &boundsR );
931 if ( width != NULL )
932 *width = boundsR.right - boundsR.left;
933 if ( height != NULL )
934 *height = boundsR.bottom - boundsR.top;
935 }
936 else
937 wxToolBarBase::DoGetSize( width, height );
938
939#else
940 wxToolBarBase::DoGetSize( width, height );
941#endif
942}
943
944wxSize wxToolBar::DoGetBestSize() const
945{
946 int width, height;
947
948 DoGetSize( &width, &height );
949
950 return wxSize( width, height );
951}
952
953void wxToolBar::SetWindowStyleFlag( long style )
954{
955 wxToolBarBase::SetWindowStyleFlag( style );
956
957#if wxMAC_USE_NATIVE_TOOLBAR
958 if (m_macHIToolbarRef != NULL)
959 {
960 HIToolbarDisplayMode mode = kHIToolbarDisplayModeDefault;
961
962 if ( style & wxTB_NOICONS )
963 mode = kHIToolbarDisplayModeLabelOnly;
964 else if ( style & wxTB_TEXT )
965 mode = kHIToolbarDisplayModeIconAndLabel;
966 else
967 mode = kHIToolbarDisplayModeIconOnly;
968
969 HIToolbarSetDisplayMode( (HIToolbarRef) m_macHIToolbarRef, mode );
970 }
971#endif
972}
973
974#if wxMAC_USE_NATIVE_TOOLBAR
975bool wxToolBar::MacWantsNativeToolbar()
976{
977 return m_macUsesNativeToolbar;
978}
979
980bool wxToolBar::MacTopLevelHasNativeToolbar(bool *ownToolbarInstalled) const
981{
982 bool bResultV = false;
983
984 if (ownToolbarInstalled != NULL)
985 *ownToolbarInstalled = false;
986
987 WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef());
988 if (tlw != NULL)
989 {
990 HIToolbarRef curToolbarRef = NULL;
991 OSStatus err = GetWindowToolbar( tlw, &curToolbarRef );
992 bResultV = ((err == noErr) && (curToolbarRef != NULL));
993 if (bResultV && (ownToolbarInstalled != NULL))
994 *ownToolbarInstalled = (curToolbarRef == m_macHIToolbarRef);
995 }
996
997 return bResultV;
998}
999
1000bool wxToolBar::MacInstallNativeToolbar(bool usesNative)
1001{
1002 bool bResult = false;
1003
1004 if (usesNative && (m_macHIToolbarRef == NULL))
1005 return bResult;
1006
1007 if (usesNative && ((GetWindowStyleFlag() & wxTB_VERTICAL) != 0))
1008 return bResult;
1009
1010 WindowRef tlw = MAC_WXHWND(MacGetTopLevelWindowRef());
1011 if (tlw == NULL)
1012 return bResult;
1013
1014 // check the existing toolbar
1015 HIToolbarRef curToolbarRef = NULL;
1016 OSStatus err = GetWindowToolbar( tlw, &curToolbarRef );
1017 if (err != noErr)
1018 curToolbarRef = NULL;
1019
1020 m_macUsesNativeToolbar = usesNative;
1021
1022 if (m_macUsesNativeToolbar)
1023 {
1024 // only install toolbar if there isn't one installed already
1025 if (curToolbarRef == NULL)
1026 {
1027 bResult = true;
1028
1029 SetWindowToolbar( tlw, (HIToolbarRef) m_macHIToolbarRef );
1030 ShowHideWindowToolbar( tlw, true, false );
1031 ChangeWindowAttributes( tlw, kWindowToolbarButtonAttribute, 0 );
1032 SetAutomaticControlDragTrackingEnabledForWindow( tlw, true );
1033
1034 Rect r = { 0, 0, 0, 0 };
1035 m_peer->SetRect( &r );
1036 SetSize( wxSIZE_AUTO_WIDTH, 0 );
1037 m_peer->SetVisibility( false, true );
1038 wxToolBarBase::Show( false );
1039 }
1040 }
1041 else
1042 {
1043 // only deinstall toolbar if this is the installed one
1044 if (m_macHIToolbarRef == curToolbarRef)
1045 {
1046 bResult = true;
1047
1048 ShowHideWindowToolbar( tlw, false, false );
1049 ChangeWindowAttributes( tlw, 0, kWindowToolbarButtonAttribute );
1050 SetWindowToolbar( tlw, NULL );
1051
1052 m_peer->SetVisibility( true, true );
1053 }
1054 }
1055
1056 if (bResult)
1057 InvalidateBestSize();
1058
1059// wxLogDebug( wxT(" --> [%lx] - result [%s]"), (long)this, bResult ? wxT("T") : wxT("F") );
1060 return bResult;
1061}
1062#endif
1063
1064bool wxToolBar::Realize()
1065{
1066 if (m_tools.GetCount() == 0)
1067 return false;
1068
1069 int maxWidth = 0;
1070 int maxHeight = 0;
1071
1072 int maxToolWidth = 0;
1073 int maxToolHeight = 0;
1074
1075 int x = m_xMargin + kwxMacToolBarLeftMargin;
1076 int y = m_yMargin + kwxMacToolBarTopMargin;
1077
1078 int tw, th;
1079 GetSize( &tw, &th );
1080
1081 // find the maximum tool width and height
1082 wxToolBarTool *tool;
1083 wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
1084 while ( node != NULL )
1085 {
1086 tool = (wxToolBarTool *) node->GetData();
1087 if ( tool != NULL )
1088 {
1089 wxSize sz = tool->GetSize();
1090
1091 if ( sz.x > maxToolWidth )
1092 maxToolWidth = sz.x;
1093 if ( sz.y > maxToolHeight )
1094 maxToolHeight = sz.y;
1095 }
1096
1097 node = node->GetNext();
1098 }
1099
1100 bool lastIsRadio = false;
1101 bool curIsRadio = false;
1102
1103#if wxMAC_USE_NATIVE_TOOLBAR
1104 CFIndex currentPosition = 0;
1105 bool insertAll = false;
1106#endif
1107
1108 node = m_tools.GetFirst();
1109 while ( node != NULL )
1110 {
1111 tool = (wxToolBarTool*) node->GetData();
1112 if ( tool == NULL )
1113 {
1114 node = node->GetNext();
1115 continue;
1116 }
1117
1118 // set tool position:
1119 // for the moment just perform a single row/column alignment
1120 wxSize cursize = tool->GetSize();
1121 if ( x + cursize.x > maxWidth )
1122 maxWidth = x + cursize.x;
1123 if ( y + cursize.y > maxHeight )
1124 maxHeight = y + cursize.y;
1125
1126 if ( GetWindowStyleFlag() & wxTB_VERTICAL )
1127 {
1128 int x1 = x + ( maxToolWidth - cursize.x ) / 2;
1129 tool->SetPosition( wxPoint(x1, y) );
1130 }
1131 else
1132 {
1133 int y1 = y + ( maxToolHeight - cursize.y ) / 2;
1134 tool->SetPosition( wxPoint(x, y1) );
1135 }
1136
1137 // update the item positioning state
1138 if ( GetWindowStyleFlag() & wxTB_VERTICAL )
1139 y += cursize.y + kwxMacToolSpacing;
1140 else
1141 x += cursize.x + kwxMacToolSpacing;
1142
1143#if wxMAC_USE_NATIVE_TOOLBAR
1144 // install in native HIToolbar
1145 if ( m_macHIToolbarRef != NULL )
1146 {
1147 HIToolbarItemRef hiItemRef = tool->GetToolbarItemRef();
1148 if ( hiItemRef != NULL )
1149 {
1150 if ( insertAll || (tool->GetIndex() != currentPosition) )
1151 {
1152 OSStatus err = noErr;
1153 if ( !insertAll )
1154 {
1155 insertAll = true;
1156
1157 // if this is the first tool that gets newly inserted or repositioned
1158 // first remove all 'old' tools from here to the right, because of this
1159 // all following tools will have to be reinserted (insertAll). i = 100 because there's
1160 // no way to determine how many there are in a toolbar, so just a high number :-(
1161 for ( CFIndex i = 100; i >= currentPosition; --i )
1162 {
1163 err = HIToolbarRemoveItemAtIndex( (HIToolbarRef) m_macHIToolbarRef, i );
1164 }
1165
1166 if (err != noErr)
1167 {
1168 wxString errMsg = wxString::Format( wxT("HIToolbarRemoveItemAtIndex failed [%ld]"), (long)err );
1169 wxFAIL_MSG( errMsg.c_str() );
1170 }
1171 }
1172
1173 err = HIToolbarInsertItemAtIndex( (HIToolbarRef) m_macHIToolbarRef, hiItemRef, currentPosition );
1174 if (err != noErr)
1175 {
1176 wxString errMsg = wxString::Format( wxT("HIToolbarInsertItemAtIndex failed [%ld]"), (long)err );
1177 wxFAIL_MSG( errMsg.c_str() );
1178 }
1179
1180 tool->SetIndex( currentPosition );
1181 }
1182
1183 currentPosition++;
1184 }
1185 }
1186#endif
1187
1188 // update radio button (and group) state
1189 lastIsRadio = curIsRadio;
1190 curIsRadio = ( tool->IsButton() && (tool->GetKind() == wxITEM_RADIO) );
1191
1192 if ( !curIsRadio )
1193 {
1194 if ( tool->IsToggled() )
1195 DoToggleTool( tool, true );
1196 }
1197 else
1198 {
1199 if ( !lastIsRadio )
1200 {
1201 if ( tool->Toggle( true ) )
1202 {
1203 DoToggleTool( tool, true );
1204 }
1205 }
1206 else if ( tool->IsToggled() )
1207 {
1208 if ( tool->IsToggled() )
1209 DoToggleTool( tool, true );
1210
1211 wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
1212 while ( nodePrev != NULL )
1213 {
1214 wxToolBarToolBase *toggleTool = nodePrev->GetData();
1215 if ( (toggleTool == NULL) || !toggleTool->IsButton() || (toggleTool->GetKind() != wxITEM_RADIO) )
1216 break;
1217
1218 if ( toggleTool->Toggle( false ) )
1219 DoToggleTool( toggleTool, false );
1220
1221 nodePrev = nodePrev->GetPrevious();
1222 }
1223 }
1224 }
1225
1226 node = node->GetNext();
1227 }
1228
1229 if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
1230 {
1231 // if not set yet, only one row
1232 if ( m_maxRows <= 0 )
1233 SetRows( 1 );
1234
1235 m_minWidth = maxWidth;
1236 maxWidth = tw;
1237 maxHeight += m_yMargin + kwxMacToolBarTopMargin;
1238 m_minHeight = m_maxHeight = maxHeight;
1239 }
1240 else
1241 {
1242 // if not set yet, have one column
1243 if ( (GetToolsCount() > 0) && (m_maxRows <= 0) )
1244 SetRows( GetToolsCount() );
1245
1246 m_minHeight = maxHeight;
1247 maxHeight = th;
1248 maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
1249 m_minWidth = m_maxWidth = maxWidth;
1250 }
1251
1252#if 0
1253 // FIXME: should this be OSX-only?
1254 {
1255 bool wantNativeToolbar, ownToolbarInstalled;
1256
1257 // attempt to install the native toolbar
1258 wantNativeToolbar = ((GetWindowStyleFlag() & wxTB_VERTICAL) == 0);
1259 MacInstallNativeToolbar( wantNativeToolbar );
1260 (void)MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
1261 if (!ownToolbarInstalled)
1262 {
1263 SetSize( maxWidth, maxHeight );
1264 InvalidateBestSize();
1265 }
1266 }
1267#else
1268 SetSize( maxWidth, maxHeight );
1269 InvalidateBestSize();
1270#endif
1271
1272 SetInitialSize();
1273
1274 return true;
1275}
1276
1277void wxToolBar::SetToolBitmapSize(const wxSize& size)
1278{
1279 m_defaultWidth = size.x + kwxMacToolBorder;
1280 m_defaultHeight = size.y + kwxMacToolBorder;
1281
1282#if wxMAC_USE_NATIVE_TOOLBAR
1283 if (m_macHIToolbarRef != NULL)
1284 {
1285 int maxs = wxMax( size.x, size.y );
1286 HIToolbarDisplaySize sizeSpec;
1287 if ( maxs > 32 )
1288 sizeSpec = kHIToolbarDisplaySizeNormal;
1289 else if ( maxs > 24 )
1290 sizeSpec = kHIToolbarDisplaySizeDefault;
1291 else
1292 sizeSpec = kHIToolbarDisplaySizeSmall;
1293
1294 HIToolbarSetDisplaySize( (HIToolbarRef) m_macHIToolbarRef, sizeSpec );
1295 }
1296#endif
1297}
1298
1299// The button size is bigger than the bitmap size
1300wxSize wxToolBar::GetToolSize() const
1301{
1302 return wxSize(m_defaultWidth + kwxMacToolBorder, m_defaultHeight + kwxMacToolBorder);
1303}
1304
1305void wxToolBar::SetRows(int nRows)
1306{
1307 // avoid resizing the frame uselessly
1308 if ( nRows != m_maxRows )
1309 m_maxRows = nRows;
1310}
1311
1312void wxToolBar::MacSuperChangedPosition()
1313{
1314 wxWindow::MacSuperChangedPosition();
1315
1316#if wxMAC_USE_NATIVE_TOOLBAR
1317 if (! m_macUsesNativeToolbar )
1318 Realize();
1319#else
1320
1321 Realize();
1322#endif
1323}
1324
1325void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap )
1326{
1327 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id));
1328 if ( tool )
1329 {
1330 wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1331
1332 tool->SetNormalBitmap(bitmap);
1333
1334 // a side-effect of the UpdateToggleImage function is that it always changes the bitmap used on the button.
1335 tool->UpdateToggleImage( tool->CanBeToggled() && tool->IsToggled() );
1336 }
1337}
1338
1339void wxToolBar::SetToolDisabledBitmap( int id, const wxBitmap& bitmap )
1340{
1341 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id));
1342 if ( tool )
1343 {
1344 wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1345
1346 tool->SetDisabledBitmap(bitmap);
1347
1348 // TODO: what to do for this one?
1349 }
1350}
1351
1352wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
1353{
1354 wxToolBarTool *tool;
1355 wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
1356 while ( node != NULL )
1357 {
1358 tool = (wxToolBarTool *)node->GetData();
1359 if (tool != NULL)
1360 {
1361 wxRect2DInt r( tool->GetPosition(), tool->GetSize() );
1362 if ( r.Contains( wxPoint( x, y ) ) )
1363 return tool;
1364 }
1365
1366 node = node->GetNext();
1367 }
1368
1369 return (wxToolBarToolBase*)NULL;
1370}
1371
1372wxString wxToolBar::MacGetToolTipString( wxPoint &pt )
1373{
1374 wxToolBarToolBase *tool = FindToolForPosition( pt.x, pt.y );
1375 if ( tool != NULL )
1376 return tool->GetShortHelp();
1377
1378 return wxEmptyString;
1379}
1380
1381void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
1382{
1383 if ( t != NULL )
1384 ((wxToolBarTool*)t)->DoEnable( enable );
1385}
1386
1387void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
1388{
1389 wxToolBarTool *tool = (wxToolBarTool *)t;
1390 if ( ( tool != NULL ) && tool->IsButton() )
1391 tool->UpdateToggleImage( toggle );
1392}
1393
1394bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
1395{
1396 wxToolBarTool *tool = wx_static_cast( wxToolBarTool*, toolBase );
1397 if (tool == NULL)
1398 return false;
1399
1400 WindowRef window = (WindowRef) MacGetTopLevelWindowRef();
1401 wxSize toolSize = GetToolSize();
1402 Rect toolrect = { 0, 0, toolSize.y, toolSize.x };
1403 ControlRef controlHandle = NULL;
1404 OSStatus err = 0;
1405 tool->Attach( this );
1406
1407#if wxMAC_USE_NATIVE_TOOLBAR
1408 HIToolbarItemRef item;
1409#endif
1410
1411 switch (tool->GetStyle())
1412 {
1413 case wxTOOL_STYLE_SEPARATOR:
1414 {
1415 wxASSERT( tool->GetControlHandle() == NULL );
1416 toolSize.x /= 4;
1417 toolSize.y /= 4;
1418 if ( GetWindowStyleFlag() & wxTB_VERTICAL )
1419 toolrect.bottom = toolSize.y;
1420 else
1421 toolrect.right = toolSize.x;
1422
1423 // in flat style we need a visual separator
1424#if wxMAC_USE_NATIVE_TOOLBAR
1425 err = HIToolbarItemCreate(
1426 kHIToolbarSeparatorIdentifier,
1427 kHIToolbarItemCantBeRemoved | kHIToolbarItemIsSeparator | kHIToolbarItemAllowDuplicates,
1428 &item );
1429 if (err == noErr)
1430 tool->SetToolbarItemRef( item );
1431#endif // wxMAC_USE_NATIVE_TOOLBAR
1432
1433 CreateSeparatorControl( window, &toolrect, &controlHandle );
1434 tool->SetControlHandle( controlHandle );
1435 }
1436 break;
1437
1438 case wxTOOL_STYLE_BUTTON:
1439 {
1440 wxASSERT( tool->GetControlHandle() == NULL );
1441 ControlButtonContentInfo info;
1442 wxMacCreateBitmapButton( &info, tool->GetNormalBitmap(), kControlContentIconRef );
1443
1444 if ( UMAGetSystemVersion() >= 0x1000)
1445 {
1446 CreateIconControl( window, &toolrect, &info, false, &controlHandle );
1447 }
1448 else
1449 {
1450 SInt16 behaviour = kControlBehaviorOffsetContents;
1451 if ( tool->CanBeToggled() )
1452 behaviour |= kControlBehaviorToggles;
1453 err = CreateBevelButtonControl( window,
1454 &toolrect, CFSTR(""), kControlBevelButtonNormalBevel,
1455 behaviour, &info, 0, 0, 0, &controlHandle );
1456 }
1457
1458#if wxMAC_USE_NATIVE_TOOLBAR
1459 wxString labelStr = wxString::Format(wxT("%xd"), (int)tool);
1460 err = HIToolbarItemCreate(
1461 wxMacCFStringHolder(labelStr, wxFont::GetDefaultEncoding()),
1462 kHIToolbarItemCantBeRemoved | kHIToolbarItemAnchoredLeft | kHIToolbarItemAllowDuplicates, &item );
1463 if (err == noErr)
1464 {
1465 InstallEventHandler(
1466 HIObjectGetEventTarget(item), GetwxMacToolBarEventHandlerUPP(),
1467 GetEventTypeCount(toolBarEventList), toolBarEventList, tool, NULL );
1468
1469 HIToolbarItemSetIconRef( item, info.u.iconRef );
1470 HIToolbarItemSetCommandID( item, kHIToolbarCommandPressAction );
1471 tool->SetToolbarItemRef( item );
1472 }
1473#endif // wxMAC_USE_NATIVE_TOOLBAR
1474
1475 wxMacReleaseBitmapButton( &info );
1476
1477#if 0
1478 SetBevelButtonTextPlacement( m_controlHandle, kControlBevelButtonPlaceBelowGraphic );
1479 UMASetControlTitle( m_controlHandle, label, wxFont::GetDefaultEncoding() );
1480#endif
1481
1482 InstallControlEventHandler(
1483 (ControlRef) controlHandle, GetwxMacToolBarToolEventHandlerUPP(),
1484 GetEventTypeCount(eventList), eventList, tool, NULL );
1485
1486 tool->SetControlHandle( controlHandle );
1487 }
1488 break;
1489
1490 case wxTOOL_STYLE_CONTROL:
1491
1492#if wxMAC_USE_NATIVE_TOOLBAR
1493 {
1494 wxASSERT( tool->GetControl() != NULL );
1495 HIToolbarItemRef item;
1496 HIViewRef viewRef = (HIViewRef) tool->GetControl()->GetHandle() ;
1497 // as this control now is part of both the wxToolBar children and the native toolbar, we have to increase the
1498 // reference count to make sure we are not dealing with zombie controls after the native toolbar has released its views
1499 CFRetain( viewRef ) ;
1500 CFDataRef data = CFDataCreate( kCFAllocatorDefault , (UInt8*) &viewRef , sizeof(viewRef) ) ;
1501 err = HIToolbarCreateItemWithIdentifier((HIToolbarRef) m_macHIToolbarRef,kControlToolbarItemClassID,
1502 data , &item ) ;
1503
1504 if (err == noErr)
1505 {
1506 tool->SetToolbarItemRef( item );
1507 }
1508 CFRelease( data ) ;
1509 }
1510
1511#else
1512 // right now there's nothing to do here
1513#endif
1514 break;
1515
1516 default:
1517 break;
1518 }
1519
1520#if wxMAC_USE_NATIVE_TOOLBAR
1521 wxString label = tool->GetLabel();
1522 if ( !label.empty() )
1523 {
1524 // strip mnemonics from the label for compatibility
1525 // with the usual labels in wxStaticText sense
1526 label = wxStripMenuCodes(label);
1527
1528 HIToolbarItemSetLabel(item,
1529 wxMacCFStringHolder(label, m_font.GetEncoding()));
1530 }
1531#endif // wxMAC_USE_NATIVE_TOOLBAR
1532
1533 if ( err == noErr )
1534 {
1535 if ( controlHandle )
1536 {
1537 ControlRef container = (ControlRef) GetHandle();
1538 wxASSERT_MSG( container != NULL, wxT("No valid Mac container control") );
1539
1540 UMAShowControl( controlHandle );
1541 ::EmbedControl( controlHandle, container );
1542 }
1543
1544 if ( tool->CanBeToggled() && tool->IsToggled() )
1545 tool->UpdateToggleImage( true );
1546
1547 // nothing special to do here - we relayout in Realize() later
1548 InvalidateBestSize();
1549 }
1550 else
1551 {
1552 wxString errMsg = wxString::Format( wxT("wxToolBar::DoInsertTool - failure [%ld]"), (long)err );
1553 wxFAIL_MSG( errMsg.c_str() );
1554 }
1555
1556 return (err == noErr);
1557}
1558
1559void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
1560{
1561 wxFAIL_MSG( wxT("not implemented") );
1562}
1563
1564bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase)
1565{
1566 wxToolBarTool* tool = wx_static_cast( wxToolBarTool*, toolbase );
1567 wxToolBarToolsList::compatibility_iterator node;
1568 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1569 {
1570 wxToolBarToolBase *tool2 = node->GetData();
1571 if ( tool2 == tool )
1572 {
1573 // let node point to the next node in the list
1574 node = node->GetNext();
1575
1576 break;
1577 }
1578 }
1579
1580 wxSize sz = ((wxToolBarTool*)tool)->GetSize();
1581
1582 tool->Detach();
1583
1584#if wxMAC_USE_NATIVE_TOOLBAR
1585 CFIndex removeIndex = tool->GetIndex();
1586#endif
1587
1588#if wxMAC_USE_NATIVE_TOOLBAR
1589 if ( removeIndex != -1 && m_macHIToolbarRef )
1590 {
1591 HIToolbarRemoveItemAtIndex( (HIToolbarRef) m_macHIToolbarRef, removeIndex );
1592 tool->SetIndex( -1 );
1593 }
1594#endif
1595 switch ( tool->GetStyle() )
1596 {
1597 case wxTOOL_STYLE_CONTROL:
1598 if ( tool->GetControl() )
1599 tool->GetControl()->Destroy();
1600 break;
1601
1602 case wxTOOL_STYLE_BUTTON:
1603 case wxTOOL_STYLE_SEPARATOR:
1604 // nothing special
1605 break;
1606
1607 default:
1608 break;
1609 }
1610 tool->ClearControl();
1611
1612 // and finally reposition all the controls after this one
1613
1614 for ( /* node -> first after deleted */; node; node = node->GetNext() )
1615 {
1616 wxToolBarTool *tool2 = (wxToolBarTool*) node->GetData();
1617 wxPoint pt = tool2->GetPosition();
1618
1619 if ( GetWindowStyleFlag() & wxTB_VERTICAL )
1620 pt.y -= sz.y;
1621 else
1622 pt.x -= sz.x;
1623
1624 tool2->SetPosition( pt );
1625
1626#if wxMAC_USE_NATIVE_TOOLBAR
1627 if ( removeIndex != -1 && tool2->GetIndex() > removeIndex )
1628 tool2->SetIndex( tool2->GetIndex() - 1 );
1629#endif
1630 }
1631
1632 InvalidateBestSize();
1633
1634 return true;
1635}
1636
1637void wxToolBar::OnPaint(wxPaintEvent& event)
1638{
1639#if wxMAC_USE_NATIVE_TOOLBAR
1640 if ( m_macUsesNativeToolbar )
1641 {
1642 event.Skip(true);
1643 return;
1644 }
1645#endif
1646
1647 wxPaintDC dc(this);
1648
1649 int w, h;
1650 GetSize( &w, &h );
1651
1652 bool drawMetalTheme = MacGetTopLevelWindow()->MacGetMetalAppearance();
1653 bool minimumUmaAvailable = (UMAGetSystemVersion() >= 0x1030);
1654
1655#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
1656 if ( !drawMetalTheme && minimumUmaAvailable )
1657 {
1658 HIThemePlacardDrawInfo info;
1659 memset( &info, 0, sizeof(info) );
1660 info.version = 0;
1661 info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive;
1662
1663 CGContextRef cgContext = (CGContextRef) MacGetCGContextRef();
1664 HIRect rect = CGRectMake( 0, 0, w, h );
1665 HIThemeDrawPlacard( &rect, &info, cgContext, kHIThemeOrientationNormal );
1666 }
1667 else
1668 {
1669 // leave the background as it is (striped or metal)
1670 }
1671
1672#else
1673
1674 const bool drawBorder = true;
1675
1676 if (drawBorder)
1677 {
1678 wxMacPortSetter helper( &dc );
1679
1680 if ( !drawMetalTheme || !minimumUmaAvailable )
1681 {
1682 Rect toolbarrect = { dc.YLOG2DEVMAC(0), dc.XLOG2DEVMAC(0),
1683 dc.YLOG2DEVMAC(h), dc.XLOG2DEVMAC(w) };
1684
1685#if 0
1686 if ( toolbarrect.left < 0 )
1687 toolbarrect.left = 0;
1688 if ( toolbarrect.top < 0 )
1689 toolbarrect.top = 0;
1690#endif
1691
1692 UMADrawThemePlacard( &toolbarrect, IsEnabled() ? kThemeStateActive : kThemeStateInactive );
1693 }
1694 else
1695 {
1696#if TARGET_API_MAC_OSX
1697 HIRect hiToolbarrect = CGRectMake(
1698 dc.YLOG2DEVMAC(0), dc.XLOG2DEVMAC(0),
1699 dc.YLOG2DEVREL(h), dc.XLOG2DEVREL(w) );
1700 CGContextRef cgContext;
1701 Rect bounds;
1702
1703 GetPortBounds( (CGrafPtr) dc.m_macPort, &bounds );
1704 QDBeginCGContext( (CGrafPtr) dc.m_macPort, &cgContext );
1705
1706 CGContextTranslateCTM( cgContext, 0, bounds.bottom - bounds.top );
1707 CGContextScaleCTM( cgContext, 1, -1 );
1708
1709 HIThemeBackgroundDrawInfo drawInfo;
1710 drawInfo.version = 0;
1711 drawInfo.state = kThemeStateActive;
1712 drawInfo.kind = kThemeBackgroundMetal;
1713 HIThemeApplyBackground( &hiToolbarrect, &drawInfo, cgContext, kHIThemeOrientationNormal );
1714
1715#ifndef __LP64__
1716 QDEndCGContext( (CGrafPtr) dc.m_macPort, &cgContext );
1717#endif
1718#endif
1719 }
1720 }
1721#endif
1722
1723 event.Skip();
1724}
1725
1726#endif // wxUSE_TOOLBAR
wxWidgets (Impactor)