]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/toolbar.cpp
projects / wxWidgets.git / blob
? search:


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