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


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