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