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