src/osx/cocoa/toolbar.mm

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/carbon/toolbar.cpp
   3 // Purpose:     wxToolBar
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id: toolbar.cpp 54954 2008-08-03 11:27:03Z VZ $
   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/osx/private.h"
  24 #include "wx/geometry.h"
  25 #include "wx/sysopt.h"
  26
  27 const short kwxMacToolBarToolDefaultWidth = 16;
  28 const short kwxMacToolBarToolDefaultHeight = 16;
  29 const short kwxMacToolBarTopMargin = 4;
  30 const short kwxMacToolBarLeftMargin =  4;
  31 const short kwxMacToolBorder = 0;
  32 const short kwxMacToolSpacing = 6;
  33
  34 BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
  35     EVT_PAINT( wxToolBar::OnPaint )
  36 END_EVENT_TABLE()
  37
  38
  39 #pragma mark -
  40 #pragma mark Tool Implementation
  41
  42 // ----------------------------------------------------------------------------
  43 // private classes
  44 // ----------------------------------------------------------------------------
  45
  46 // We have a dual implementation for each tool, WXWidget and NSToolbarItem*
  47
  48 // when embedding native controls in the native toolbar we must make sure the
  49 // control does not get deleted behind our backs, so the retain count gets increased
  50 // (after creation it is 1), first be the creation of the custom NSToolbarItem wrapper
  51 // object, and second by the code 'creating' the custom HIView (which is the same as the
  52 // already existing native control, therefore we just increase the ref count)
  53 // when this view is removed from the native toolbar its count gets decremented again
  54 // and when the HITooolbarItem wrapper object gets destroyed it is decremented as well
  55 // so in the end the control lives with a refcount of one and can be disposed of by the
  56 // wxControl code. For embedded controls on a non-native toolbar this ref count is less
  57 // so we can only test against a range, not a specific value of the refcount.
  58
  59 class wxToolBarTool : public wxToolBarToolBase
  60 {
  61 public:
  62     wxToolBarTool(
  63         wxToolBar *tbar,
  64         int id,
  65         const wxString& label,
  66         const wxBitmap& bmpNormal,
  67         const wxBitmap& bmpDisabled,
  68         wxItemKind kind,
  69         wxObject *clientData,
  70         const wxString& shortHelp,
  71         const wxString& longHelp );
  72
  73     wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
  74         : wxToolBarToolBase(tbar, control, label)
  75     {
  76         Init();
  77         if (control != NULL)
  78             SetControlHandle( (WXWidget) control->GetHandle() );
  79     }
  80
  81     virtual ~wxToolBarTool()
  82     {
  83         ClearControl();
  84     }
  85
  86     WXWidget GetControlHandle()
  87     {
  88         return (WXWidget) m_controlHandle;
  89     }
  90
  91     void SetControlHandle( WXWidget handle )
  92     {
  93         m_controlHandle = handle;
  94     }
  95
  96     void SetPosition( const wxPoint& position );
  97
  98     void ClearControl()
  99     {
 100         if ( m_controlHandle )
 101         {
 102             if ( !IsControl() )
 103             {
 104                 [m_controlHandle retain];
 105             }
 106             else
 107             {
 108                 // the embedded control is not under the responsibility of the tool, it gets disposed of in the
 109                 // proper wxControl destructor
 110             }
 111             m_controlHandle = NULL ;
 112         }
 113
 114 #if wxOSX_USE_NATIVE_TOOLBAR
 115         if ( m_toolbarItem )
 116         {
 117             [m_toolbarItem release];
 118             m_toolbarItem = NULL;
 119         }
 120 #endif // wxOSX_USE_NATIVE_TOOLBAR
 121     }
 122
 123     wxSize GetSize() const
 124     {
 125         wxSize curSize;
 126
 127         if ( IsControl() )
 128         {
 129             curSize = GetControl()->GetSize();
 130         }
 131         else if ( IsButton() )
 132         {
 133             curSize = GetToolBar()->GetToolSize();
 134         }
 135         else
 136         {
 137             // separator size
 138             curSize = GetToolBar()->GetToolSize();
 139             if ( GetToolBar()->GetWindowStyleFlag() & (wxTB_LEFT|wxTB_RIGHT) )
 140                 curSize.y /= 4;
 141             else
 142                 curSize.x /= 4;
 143         }
 144
 145         return curSize;
 146     }
 147
 148     wxPoint GetPosition() const
 149     {
 150         return wxPoint( m_x, m_y );
 151     }
 152
 153     bool DoEnable( bool enable );
 154
 155     void UpdateImages();
 156
 157     void UpdateToggleImage( bool toggle );
 158
 159     void UpdateLabel()
 160     {
 161 #if wxOSX_USE_NATIVE_TOOLBAR
 162        if ( m_toolbarItem )
 163         {
 164             // strip mnemonics from the label for compatibility with the usual
 165             // labels in wxStaticText sense
 166             wxString labelStr = wxStripMenuCodes(m_label);
 167             wxCFStringRef l(labelStr, GetToolBarFontEncoding());
 168
 169             [m_toolbarItem setLabel:l.AsNSString()];
 170
 171             wxCFStringRef sh( GetShortHelp(), GetToolBarFontEncoding() );
 172             [m_toolbarItem setToolTip:sh.AsNSString()];
 173         }
 174 #endif
 175     }
 176
 177     void Action()
 178     {
 179         wxToolBar *tbar = (wxToolBar*) GetToolBar();
 180         if (CanBeToggled())
 181         {
 182             bool    shouldToggle;
 183
 184             shouldToggle = !IsToggled();
 185             tbar->ToggleTool( GetId(), shouldToggle );
 186         }
 187
 188         tbar->OnLeftClick( GetId(), IsToggled() );
 189     }
 190
 191 #if wxOSX_USE_NATIVE_TOOLBAR
 192     void SetToolbarItemRef( NSToolbarItem* ref )
 193     {
 194         if ( m_controlHandle )
 195             [m_controlHandle setHidden:YES];
 196         if ( m_toolbarItem )
 197             [m_toolbarItem release];
 198
 199         m_toolbarItem = ref;
 200     }
 201
 202     NSToolbarItem* GetToolbarItemRef() const
 203     {
 204         return m_toolbarItem;
 205     }
 206
 207     void SetIndex( CFIndex idx )
 208     {
 209         m_index = idx;
 210     }
 211
 212     CFIndex GetIndex() const
 213     {
 214         return m_index;
 215     }
 216
 217     virtual void SetLabel(const wxString& label)
 218     {
 219         wxToolBarToolBase::SetLabel(label);
 220         UpdateLabel();
 221      }
 222 #endif // wxOSX_USE_NATIVE_TOOLBAR
 223
 224 private:
 225 #if wxOSX_USE_NATIVE_TOOLBAR
 226     wxFontEncoding GetToolBarFontEncoding() const
 227     {
 228         wxFont f;
 229         if ( GetToolBar() )
 230             f = GetToolBar()->GetFont();
 231         return f.IsOk() ? f.GetEncoding() : wxFont::GetDefaultEncoding();
 232     }
 233 #endif // wxOSX_USE_NATIVE_TOOLBAR
 234
 235     void Init()
 236     {
 237         m_controlHandle = NULL;
 238
 239 #if wxOSX_USE_NATIVE_TOOLBAR
 240         m_toolbarItem = NULL;
 241         m_index = -1;
 242 #endif
 243     }
 244
 245     WXWidget m_controlHandle;
 246     wxCoord     m_x;
 247     wxCoord     m_y;
 248     wxBitmap    m_alternateBitmap;
 249
 250 #if wxOSX_USE_NATIVE_TOOLBAR
 251     NSToolbarItem* m_toolbarItem;
 252     // position in its toolbar, -1 means not inserted
 253     CFIndex m_index;
 254 #endif
 255 };
 256
 257 #if wxOSX_USE_NATIVE_TOOLBAR
 258
 259 @interface wxNSToolbarItem : NSToolbarItem
 260 {
 261     wxToolBarTool* impl;
 262 }
 263
 264 - (id) initWithItemIdentifier: (NSString*) identifier;
 265 - (void)setImplementation: (wxToolBarTool *) theImplementation;
 266 - (wxToolBarTool*) implementation;
 267 - (void) clickedAction: (id) sender;
 268
 269 @end
 270
 271
 272 @interface wxNSToolbarDelegate : NSObject wxOSX_10_6_AND_LATER(<NSToolbarDelegate>)
 273 {
 274 }
 275
 276 - (NSToolbarItem *)toolbar:(NSToolbar *)toolbar itemForItemIdentifier:(NSString *)itemIdentifier willBeInsertedIntoToolbar:(BOOL)flag;
 277
 278 - (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar*)toolbar;
 279
 280 - (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar*)toolbar;
 281
 282 - (NSArray *)toolbarSelectableItemIdentifiers:(NSToolbar *)toolbar;
 283
 284
 285 @end
 286
 287 #endif
 288
 289
 290 @interface wxNSToolBarButton : NSButton
 291 {
 292     wxToolBarTool* impl;
 293 }
 294
 295 - (id)initWithFrame:(NSRect)frame;
 296 - (void) clickedAction: (id) sender;
 297 - (void)setImplementation: (wxToolBarTool *) theImplementation;
 298 - (wxToolBarTool*) implementation;
 299 - (BOOL) isFlipped;
 300
 301 @end
 302
 303 #if wxOSX_USE_NATIVE_TOOLBAR
 304
 305 @implementation wxNSToolbarItem
 306
 307 - (id)initWithItemIdentifier: (NSString*) identifier
 308 {
 309     [super initWithItemIdentifier:identifier];
 310     impl = NULL;
 311     [self setTarget: self];
 312     [self setAction: @selector(clickedAction:)];
 313     return self;
 314 }
 315
 316 - (void) clickedAction: (id) sender
 317 {
 318     wxUnusedVar(sender);
 319     if ( impl )
 320     {
 321         impl->Action();
 322     }
 323 }
 324
 325 - (void)setImplementation: (wxToolBarTool *) theImplementation
 326 {
 327     impl = theImplementation;
 328 }
 329
 330 - (wxToolBarTool*) implementation
 331 {
 332     return impl;
 333 }
 334
 335 @end
 336
 337 @implementation wxNSToolbarDelegate
 338
 339 - (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar*)toolbar
 340 {
 341     wxUnusedVar(toolbar);
 342     return nil;
 343 }
 344
 345 - (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar*)toolbar
 346 {
 347     wxUnusedVar(toolbar);
 348     return nil;
 349 }
 350
 351 - (NSArray *)toolbarSelectableItemIdentifiers:(NSToolbar *)toolbar
 352 {
 353     wxUnusedVar(toolbar);
 354     return nil;
 355 }
 356
 357 - (NSToolbarItem*) toolbar:(NSToolbar*) toolbar itemForItemIdentifier:(NSString*) itemIdentifier willBeInsertedIntoToolbar:(BOOL) flag
 358 {
 359     wxUnusedVar(toolbar);
 360 #ifdef __LP64__
 361     wxToolBarTool* tool = (wxToolBarTool*) [itemIdentifier longLongValue];
 362 #else
 363     wxToolBarTool* tool = (wxToolBarTool*) [itemIdentifier intValue];
 364 #endif
 365     if ( tool )
 366     {
 367         wxNSToolbarItem* item = (wxNSToolbarItem*) tool->GetToolbarItemRef();
 368         if ( flag && tool->IsControl() )
 369         {
 370             NSView* view = tool->GetControl()->GetHandle();
 371             [view removeFromSuperview];
 372             [item setView:view];
 373             wxSize sz = tool->GetControl()->GetSize();
 374             NSSize size = NSMakeSize((float)sz.x, (float)sz.y);
 375             [item setMaxSize:size];
 376             [item setMinSize:size];
 377             [view setHidden:NO];
 378         }
 379         return item;
 380     }
 381     return nil;
 382 }
 383
 384 @end
 385
 386 #endif
 387
 388 @implementation wxNSToolBarButton
 389
 390 - (id)initWithFrame:(NSRect)frame
 391 {
 392     [super initWithFrame:frame];
 393     impl = NULL;
 394     [self setTarget: self];
 395     [self setAction: @selector(clickedAction:)];
 396     return self;
 397 }
 398
 399 - (void) clickedAction: (id) sender
 400 {
 401     wxUnusedVar(sender);
 402     if ( impl )
 403     {
 404         impl->Action();
 405     }
 406 }
 407
 408 - (void)setImplementation: (wxToolBarTool *) theImplementation
 409 {
 410     impl = theImplementation;
 411 }
 412
 413 - (wxToolBarTool*) implementation
 414 {
 415     return impl;
 416 }
 417
 418 - (BOOL) isFlipped
 419 {
 420     return YES;
 421 }
 422
 423 @end
 424
 425 bool wxToolBarTool::DoEnable( bool enable )
 426 {
 427     if ( IsControl() )
 428     {
 429         GetControl()->Enable( enable );
 430     }
 431     else if ( IsButton() )
 432     {
 433 #if wxOSX_USE_NATIVE_TOOLBAR
 434         if ( m_toolbarItem != NULL )
 435             [m_toolbarItem setEnabled:enable];
 436 #endif
 437
 438         if ( m_controlHandle != NULL )
 439             [(NSControl*)m_controlHandle setEnabled:enable];
 440     }
 441
 442     return true;
 443 }
 444
 445 void wxToolBarTool::SetPosition( const wxPoint& position )
 446 {
 447     m_x = position.x;
 448     m_y = position.y;
 449
 450     int mac_x = position.x;
 451     int mac_y = position.y;
 452
 453     if ( IsButton() )
 454     {
 455         NSRect frame = [m_controlHandle frame];
 456         if ( frame.origin.x != mac_x || frame.origin.y != mac_y )
 457         {
 458             frame.origin.x = mac_x;
 459             frame.origin.y = mac_y;
 460             [m_controlHandle setFrame:frame];
 461         }
 462     }
 463     else if ( IsControl() )
 464     {
 465         // embedded native controls are moved by the OS
 466 #if wxOSX_USE_NATIVE_TOOLBAR
 467         if ( ((wxToolBar*)GetToolBar())->MacWantsNativeToolbar() == false )
 468 #endif
 469         {
 470             GetControl()->Move( position );
 471         }
 472     }
 473     else
 474     {
 475         NSRect frame = [m_controlHandle frame];
 476         if ( frame.origin.x != mac_x || frame.origin.y != mac_y )
 477         {
 478             frame.origin.x = mac_x;
 479             frame.origin.y = mac_y;
 480             [m_controlHandle setFrame:frame];
 481         }
 482     }
 483 }
 484
 485 void wxToolBarTool::UpdateImages()
 486 {
 487     [(NSButton*) m_controlHandle setImage:m_bmpNormal.GetNSImage()];
 488
 489     if ( CanBeToggled() )
 490     {
 491         int w = m_bmpNormal.GetWidth();
 492         int h = m_bmpNormal.GetHeight();
 493         m_alternateBitmap = wxBitmap( w, h );
 494         wxMemoryDC dc;
 495
 496         dc.SelectObject( m_alternateBitmap );
 497         dc.SetPen( wxPen(*wxBLACK) );
 498         dc.SetBrush( wxBrush( *wxLIGHT_GREY ));
 499         dc.DrawRectangle( 0, 0, w, h );
 500         dc.DrawBitmap( m_bmpNormal, 0, 0, true );
 501         dc.SelectObject( wxNullBitmap );
 502
 503         [(NSButton*) m_controlHandle setAlternateImage:m_alternateBitmap.GetNSImage()];
 504     }
 505     UpdateToggleImage( CanBeToggled() && IsToggled() );
 506 }
 507
 508 void wxToolBarTool::UpdateToggleImage( bool toggle )
 509 {
 510 #if wxOSX_USE_NATIVE_TOOLBAR
 511     if (m_toolbarItem != NULL )
 512     {
 513         // the native toolbar item only has a 'selected' state (one for one toolbar)
 514         // so we emulate the toggle here
 515         if ( CanBeToggled() && toggle )
 516             [m_toolbarItem setImage:m_alternateBitmap.GetNSImage()];
 517         else
 518             [m_toolbarItem setImage:m_bmpNormal.GetNSImage()];
 519     }
 520 #endif
 521 }
 522
 523 wxToolBarTool::wxToolBarTool(
 524     wxToolBar *tbar,
 525     int id,
 526     const wxString& label,
 527     const wxBitmap& bmpNormal,
 528     const wxBitmap& bmpDisabled,
 529     wxItemKind kind,
 530     wxObject *clientData,
 531     const wxString& shortHelp,
 532     const wxString& longHelp )
 533     :
 534     wxToolBarToolBase(
 535         tbar, id, label, bmpNormal, bmpDisabled, kind,
 536         clientData, shortHelp, longHelp )
 537 {
 538     Init();
 539 }
 540
 541 #pragma mark -
 542 #pragma mark Toolbar Implementation
 543
 544 wxToolBarToolBase *wxToolBar::CreateTool(
 545     int id,
 546     const wxString& label,
 547     const wxBitmap& bmpNormal,
 548     const wxBitmap& bmpDisabled,
 549     wxItemKind kind,
 550     wxObject *clientData,
 551     const wxString& shortHelp,
 552     const wxString& longHelp )
 553 {
 554     return new wxToolBarTool(
 555         this, id, label, bmpNormal, bmpDisabled, kind,
 556         clientData, shortHelp, longHelp );
 557 }
 558
 559 wxToolBarToolBase *
 560 wxToolBar::CreateTool(wxControl *control, const wxString& label)
 561 {
 562     return new wxToolBarTool(this, control, label);
 563 }
 564
 565 void wxToolBar::Init()
 566 {
 567     m_maxWidth = -1;
 568     m_maxHeight = -1;
 569     m_defaultWidth = kwxMacToolBarToolDefaultWidth;
 570     m_defaultHeight = kwxMacToolBarToolDefaultHeight;
 571
 572 #if wxOSX_USE_NATIVE_TOOLBAR
 573     m_macToolbar = NULL;
 574     m_macUsesNativeToolbar = false;
 575 #endif
 576 }
 577
 578 // also for the toolbar we have the dual implementation:
 579 // only when MacInstallNativeToolbar is called is the native toolbar set as the window toolbar
 580
 581 bool wxToolBar::Create(
 582     wxWindow *parent,
 583     wxWindowID id,
 584     const wxPoint& pos,
 585     const wxSize& size,
 586     long style,
 587     const wxString& name )
 588 {
 589     if ( !wxToolBarBase::Create( parent, id, pos, size, style, wxDefaultValidator, name ) )
 590         return false;
 591
 592     FixupStyle();
 593
 594     OSStatus err = noErr;
 595
 596 #if wxOSX_USE_NATIVE_TOOLBAR
 597
 598     if (parent->IsKindOf(CLASSINFO(wxFrame)) && wxSystemOptions::GetOptionInt(wxT("mac.toolbar.no-native")) != 1)
 599     {
 600         static wxNSToolbarDelegate* controller = nil;
 601
 602         if ( controller == nil )
 603             controller = [[wxNSToolbarDelegate alloc] init];
 604         wxString identifier = wxString::Format( wxT("%p"), this );
 605         wxCFStringRef cfidentifier(identifier);
 606         NSToolbar* tb =  [[NSToolbar alloc] initWithIdentifier:cfidentifier.AsNSString()];
 607
 608         m_macToolbar = tb ;
 609
 610         if (m_macToolbar != NULL)
 611         {
 612             [tb setDelegate:controller];
 613
 614             NSToolbarDisplayMode mode = NSToolbarDisplayModeDefault;
 615             NSToolbarSizeMode displaySize = NSToolbarSizeModeSmall;
 616
 617             if ( style & wxTB_NOICONS )
 618                 mode = NSToolbarDisplayModeLabelOnly;
 619             else if ( style & wxTB_TEXT )
 620                 mode = NSToolbarDisplayModeIconAndLabel;
 621             else
 622                 mode = NSToolbarDisplayModeIconOnly;
 623
 624             [tb setDisplayMode:mode];
 625             [tb setSizeMode:displaySize];
 626        }
 627     }
 628 #endif // wxOSX_USE_NATIVE_TOOLBAR
 629
 630     return (err == noErr);
 631 }
 632
 633 wxToolBar::~wxToolBar()
 634 {
 635     [(NSToolbar*)m_macToolbar setDelegate:nil];
 636     [(NSToolbar*)m_macToolbar release];
 637     m_macToolbar = NULL;
 638 }
 639
 640 bool wxToolBar::Show( bool show )
 641 {
 642     WXWindow tlw = MacGetTopLevelWindowRef();
 643     bool bResult = (tlw != NULL);
 644
 645     if (bResult)
 646     {
 647 #if wxOSX_USE_NATIVE_TOOLBAR
 648         bool ownToolbarInstalled = false;
 649         MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
 650         if (ownToolbarInstalled)
 651         {
 652             bResult = ([(NSToolbar*)m_macToolbar isVisible] != show);
 653             if ( bResult )
 654                 [(NSToolbar*)m_macToolbar setVisible:show];
 655         }
 656         else
 657             bResult = wxToolBarBase::Show( show );
 658 #else
 659
 660         bResult = wxToolBarBase::Show( show );
 661 #endif
 662     }
 663
 664     return bResult;
 665 }
 666
 667 bool wxToolBar::IsShown() const
 668 {
 669     bool bResult;
 670
 671 #if wxOSX_USE_NATIVE_TOOLBAR
 672     bool ownToolbarInstalled;
 673
 674     MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
 675     if (ownToolbarInstalled)
 676     {
 677         bResult = [(NSToolbar*)m_macToolbar isVisible];
 678     }
 679     else
 680         bResult = wxToolBarBase::IsShown();
 681 #else
 682
 683     bResult = wxToolBarBase::IsShown();
 684 #endif
 685
 686     return bResult;
 687 }
 688
 689 void wxToolBar::DoGetSize( int *width, int *height ) const
 690 {
 691 #if wxOSX_USE_NATIVE_TOOLBAR
 692     bool    ownToolbarInstalled;
 693
 694     MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
 695     if ( ownToolbarInstalled )
 696     {
 697         WXWindow tlw = MacGetTopLevelWindowRef();
 698         float toolbarHeight = 0.0;
 699         NSRect windowFrame = NSMakeRect(0, 0, 0, 0);
 700
 701         if(m_macToolbar && [(NSToolbar*)m_macToolbar isVisible])
 702         {
 703             windowFrame = [NSWindow contentRectForFrameRect:[tlw frame]
 704                                 styleMask:[tlw styleMask]];
 705             toolbarHeight = NSHeight(windowFrame)
 706                         - NSHeight([[tlw contentView] frame]);
 707         }
 708
 709         if ( width != NULL )
 710             *width = (int)windowFrame.size.width;
 711         if ( height != NULL )
 712             *height = (int)toolbarHeight;
 713     }
 714     else
 715         wxToolBarBase::DoGetSize( width, height );
 716
 717 #else
 718     wxToolBarBase::DoGetSize( width, height );
 719 #endif
 720 }
 721
 722 wxSize wxToolBar::DoGetBestSize() const
 723 {
 724     int width, height;
 725
 726     DoGetSize( &width, &height );
 727
 728     return wxSize( width, height );
 729 }
 730
 731 void wxToolBar::SetWindowStyleFlag( long style )
 732 {
 733     wxToolBarBase::SetWindowStyleFlag( style );
 734
 735 #if wxOSX_USE_NATIVE_TOOLBAR
 736     if (m_macToolbar != NULL)
 737     {
 738         NSToolbarDisplayMode mode = NSToolbarDisplayModeDefault;
 739
 740         if ( style & wxTB_NOICONS )
 741             mode = NSToolbarDisplayModeLabelOnly;
 742         else if ( style & wxTB_TEXT )
 743             mode = NSToolbarDisplayModeIconAndLabel;
 744         else
 745             mode = NSToolbarDisplayModeIconOnly;
 746
 747         [(NSToolbar*) m_macToolbar setDisplayMode:mode];
 748     }
 749 #endif
 750 }
 751
 752 #if wxOSX_USE_NATIVE_TOOLBAR
 753 bool wxToolBar::MacWantsNativeToolbar()
 754 {
 755     return m_macUsesNativeToolbar;
 756 }
 757
 758 bool wxToolBar::MacTopLevelHasNativeToolbar(bool *ownToolbarInstalled) const
 759 {
 760     bool bResultV = false;
 761
 762     if (ownToolbarInstalled != NULL)
 763         *ownToolbarInstalled = false;
 764
 765     WXWindow tlw = MacGetTopLevelWindowRef();
 766     if (tlw != NULL)
 767     {
 768         NSToolbar* curToolbarRef = [tlw toolbar];
 769         bResultV = (curToolbarRef != NULL);
 770         if (bResultV && (ownToolbarInstalled != NULL))
 771             *ownToolbarInstalled = (curToolbarRef == m_macToolbar);
 772     }
 773
 774     return bResultV;
 775 }
 776
 777 bool wxToolBar::MacInstallNativeToolbar(bool usesNative)
 778 {
 779     bool bResult = false;
 780
 781     if (usesNative && (m_macToolbar == NULL))
 782         return bResult;
 783
 784     if (usesNative && ((GetWindowStyleFlag() & (wxTB_LEFT|wxTB_RIGHT|wxTB_BOTTOM)) != 0))
 785         return bResult;
 786
 787     WXWindow tlw = MacGetTopLevelWindowRef();
 788     if (tlw == NULL)
 789         return bResult;
 790
 791     // check the existing toolbar
 792     NSToolbar* curToolbarRef = [tlw toolbar];
 793
 794     m_macUsesNativeToolbar = usesNative;
 795
 796     if (m_macUsesNativeToolbar)
 797     {
 798         // only install toolbar if there isn't one installed already
 799         if (curToolbarRef == NULL)
 800         {
 801             bResult = true;
 802             [tlw setToolbar:(NSToolbar*) m_macToolbar];
 803             [(NSToolbar*) m_macToolbar setVisible:YES];
 804
 805             m_peer->Move(0,0,0,0 );
 806             SetSize( wxSIZE_AUTO_WIDTH, 0 );
 807             m_peer->SetVisibility( false );
 808             wxToolBarBase::Show( false );
 809         }
 810     }
 811     else
 812     {
 813         // only deinstall toolbar if this is the installed one
 814         if (m_macToolbar == curToolbarRef)
 815         {
 816             bResult = true;
 817             [(NSToolbar*) m_macToolbar setVisible:NO];
 818             MacUninstallNativeToolbar();
 819             m_peer->SetVisibility( true );
 820         }
 821     }
 822
 823     if (bResult)
 824         InvalidateBestSize();
 825
 826 // wxLogDebug( wxT("    --> [%lx] - result [%s]"), (long)this, bResult ? wxT("T") : wxT("F") );
 827     return bResult;
 828 }
 829
 830 void wxToolBar::MacUninstallNativeToolbar()
 831 {
 832     if (!m_macToolbar)
 833         return;
 834
 835     WXWindow tlw = MacGetTopLevelWindowRef();
 836     if (tlw)
 837         [tlw setToolbar:nil];
 838 }
 839 #endif
 840
 841 bool wxToolBar::Realize()
 842 {
 843     if ( !wxToolBarBase::Realize() )
 844         return false;
 845
 846     int maxWidth = 0;
 847     int maxHeight = 0;
 848
 849     int maxToolWidth = 0;
 850     int maxToolHeight = 0;
 851
 852     int x = m_xMargin + kwxMacToolBarLeftMargin;
 853     int y = m_yMargin + kwxMacToolBarTopMargin;
 854
 855     int tw, th;
 856     GetSize( &tw, &th );
 857
 858     // find the maximum tool width and height
 859     wxToolBarTool *tool;
 860     wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 861     while ( node )
 862     {
 863         tool = (wxToolBarTool *) node->GetData();
 864         if ( tool != NULL )
 865         {
 866             wxSize  sz = tool->GetSize();
 867
 868             if ( sz.x > maxToolWidth )
 869                 maxToolWidth = sz.x;
 870             if ( sz.y > maxToolHeight )
 871                 maxToolHeight = sz.y;
 872         }
 873
 874         node = node->GetNext();
 875     }
 876
 877     bool lastIsRadio = false;
 878     bool curIsRadio = false;
 879
 880 #if wxOSX_USE_NATIVE_TOOLBAR
 881     CFIndex currentPosition = 0;
 882     bool insertAll = false;
 883
 884     NSToolbar* refTB = (NSToolbar*)m_macToolbar;
 885     wxFont f;
 886     wxFontEncoding enc;
 887     f = GetFont();
 888     if ( f.IsOk() )
 889         enc = f.GetEncoding();
 890     else
 891         enc = wxFont::GetDefaultEncoding();
 892 #endif
 893
 894     node = m_tools.GetFirst();
 895     while ( node )
 896     {
 897         tool = (wxToolBarTool*) node->GetData();
 898         if ( tool == NULL )
 899         {
 900             node = node->GetNext();
 901             continue;
 902         }
 903
 904         // set tool position:
 905         // for the moment just perform a single row/column alignment
 906         wxSize  cursize = tool->GetSize();
 907         if ( x + cursize.x > maxWidth )
 908             maxWidth = x + cursize.x;
 909         if ( y + cursize.y > maxHeight )
 910             maxHeight = y + cursize.y;
 911
 912         if ( GetWindowStyleFlag() & (wxTB_LEFT|wxTB_RIGHT) )
 913         {
 914             int x1 = x + ( maxToolWidth - cursize.x ) / 2;
 915             tool->SetPosition( wxPoint(x1, y) );
 916         }
 917         else
 918         {
 919             int y1 = y + ( maxToolHeight - cursize.y ) / 2;
 920             tool->SetPosition( wxPoint(x, y1) );
 921         }
 922
 923         // update the item positioning state
 924         if ( GetWindowStyleFlag() & (wxTB_LEFT|wxTB_RIGHT) )
 925             y += cursize.y + kwxMacToolSpacing;
 926         else
 927             x += cursize.x + kwxMacToolSpacing;
 928
 929 #if wxOSX_USE_NATIVE_TOOLBAR
 930         // install in native NSToolbar
 931         if ( refTB )
 932         {
 933             NSToolbarItem* hiItemRef = tool->GetToolbarItemRef();
 934             if ( hiItemRef != NULL )
 935             {
 936                 // since setting the help texts is non-virtual we have to update
 937                 // the strings now
 938                 wxCFStringRef sh( tool->GetShortHelp(), enc);
 939                 [hiItemRef setToolTip:sh.AsNSString()];
 940
 941                 if ( insertAll || (tool->GetIndex() != currentPosition) )
 942                 {
 943                     if ( !insertAll )
 944                     {
 945                         insertAll = true;
 946
 947                         // if this is the first tool that gets newly inserted or repositioned
 948                         // first remove all 'old' tools from here to the right, because of this
 949                         // all following tools will have to be reinserted (insertAll).
 950                         for ( wxToolBarToolsList::compatibility_iterator node2 = m_tools.GetLast();
 951                               node2 != node;
 952                               node2 = node2->GetPrevious() )
 953                         {
 954                             wxToolBarTool *tool2 = (wxToolBarTool*) node2->GetData();
 955
 956                             const long idx = tool2->GetIndex();
 957                             if ( idx != -1 )
 958                             {
 959                                 [refTB removeItemAtIndex:idx];
 960                                 tool2->SetIndex(-1);
 961                             }
 962                         }
 963                     }
 964
 965                     wxCFStringRef cfidentifier;
 966                     const NSString *nsItemId;
 967                     if (tool->GetStyle() == wxTOOL_STYLE_SEPARATOR)
 968                     {
 969                         nsItemId = tool->IsStretchable() ? NSToolbarFlexibleSpaceItemIdentifier
 970                                                          : NSToolbarSeparatorItemIdentifier;
 971                     }
 972                     else
 973                     {
 974                         cfidentifier = wxCFStringRef(wxString::Format("%ld", (long)tool));
 975                         nsItemId = cfidentifier.AsNSString();
 976                     }
 977
 978                     [refTB insertItemWithItemIdentifier:nsItemId atIndex:currentPosition];
 979                     tool->SetIndex( currentPosition );
 980                 }
 981
 982                 currentPosition++;
 983             }
 984         }
 985 #endif
 986
 987         // update radio button (and group) state
 988         lastIsRadio = curIsRadio;
 989         curIsRadio = ( tool->IsButton() && (tool->GetKind() == wxITEM_RADIO) );
 990
 991         if ( !curIsRadio )
 992         {
 993             if ( tool->IsToggled() )
 994                 DoToggleTool( tool, true );
 995         }
 996         else
 997         {
 998             if ( !lastIsRadio )
 999             {
1000                 if ( tool->Toggle( true ) )
1001                 {
1002                     DoToggleTool( tool, true );
1003                 }
1004             }
1005             else if ( tool->IsToggled() )
1006             {
1007                 if ( tool->IsToggled() )
1008                     DoToggleTool( tool, true );
1009
1010                 wxToolBarToolsList::compatibility_iterator  nodePrev = node->GetPrevious();
1011                 while ( nodePrev )
1012                 {
1013                     wxToolBarToolBase   *toggleTool = nodePrev->GetData();
1014                     if ( (toggleTool == NULL) || !toggleTool->IsButton() || (toggleTool->GetKind() != wxITEM_RADIO) )
1015                         break;
1016
1017                     if ( toggleTool->Toggle( false ) )
1018                         DoToggleTool( toggleTool, false );
1019
1020                     nodePrev = nodePrev->GetPrevious();
1021                 }
1022             }
1023         }
1024
1025         node = node->GetNext();
1026     }
1027
1028     if ( GetWindowStyleFlag() & (wxTB_TOP|wxTB_BOTTOM) )
1029     {
1030         // if not set yet, only one row
1031         if ( m_maxRows <= 0 )
1032             SetRows( 1 );
1033
1034         m_minWidth = maxWidth;
1035         // maxHeight = th;
1036         maxHeight += m_yMargin + kwxMacToolBarTopMargin;
1037         m_minHeight = m_maxHeight = maxHeight;
1038     }
1039     else
1040     {
1041         // if not set yet, have one column
1042         if ( (GetToolsCount() > 0) && (m_maxRows <= 0) )
1043             SetRows( GetToolsCount() );
1044
1045         m_minHeight = maxHeight;
1046         // maxWidth = tw;
1047         maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
1048         m_minWidth = m_maxWidth = maxWidth;
1049     }
1050
1051 #if 0
1052     // FIXME: should this be OSX-only?
1053     {
1054         bool wantNativeToolbar, ownToolbarInstalled;
1055
1056         // attempt to install the native toolbar
1057         wantNativeToolbar = ((GetWindowStyleFlag() & (wxTB_LEFT|wxTB_BOTTOM|wxTB_RIGHT)) == 0);
1058         MacInstallNativeToolbar( wantNativeToolbar );
1059         (void)MacTopLevelHasNativeToolbar( &ownToolbarInstalled );
1060         if (!ownToolbarInstalled)
1061         {
1062            SetSize( maxWidth, maxHeight );
1063            InvalidateBestSize();
1064         }
1065     }
1066 #else
1067     SetSize( maxWidth, maxHeight );
1068     InvalidateBestSize();
1069 #endif
1070
1071     SetInitialSize();
1072
1073     return true;
1074 }
1075
1076 void wxToolBar::SetToolBitmapSize(const wxSize& size)
1077 {
1078     m_defaultWidth = size.x + kwxMacToolBorder;
1079     m_defaultHeight = size.y + kwxMacToolBorder;
1080
1081 #if wxOSX_USE_NATIVE_TOOLBAR
1082     if (m_macToolbar != NULL)
1083     {
1084         int maxs = wxMax( size.x, size.y );
1085         NSToolbarSizeMode sizeSpec;
1086         if ( maxs > 32 )
1087             sizeSpec = NSToolbarSizeModeRegular;
1088         else if ( maxs > 24 )
1089             sizeSpec = NSToolbarSizeModeDefault;
1090         else
1091             sizeSpec = NSToolbarSizeModeSmall;
1092
1093         [(NSToolbar*) m_macToolbar setSizeMode:sizeSpec ];
1094     }
1095 #endif
1096 }
1097
1098 // The button size is bigger than the bitmap size
1099 wxSize wxToolBar::GetToolSize() const
1100 {
1101     return wxSize(m_defaultWidth + kwxMacToolBorder, m_defaultHeight + kwxMacToolBorder);
1102 }
1103
1104 void wxToolBar::SetRows(int nRows)
1105 {
1106     // avoid resizing the frame uselessly
1107     if ( nRows != m_maxRows )
1108         m_maxRows = nRows;
1109 }
1110
1111 void wxToolBar::MacSuperChangedPosition()
1112 {
1113     wxWindow::MacSuperChangedPosition();
1114
1115 #if wxOSX_USE_NATIVE_TOOLBAR
1116     if (! m_macUsesNativeToolbar )
1117         Realize();
1118 #else
1119
1120     Realize();
1121 #endif
1122 }
1123
1124 void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap )
1125 {
1126     wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
1127     if ( tool )
1128     {
1129         wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1130
1131         tool->SetNormalBitmap(bitmap);
1132
1133         // a side-effect of the UpdateToggleImage function is that it always changes the bitmap used on the button.
1134         tool->UpdateImages();
1135     }
1136 }
1137
1138 void wxToolBar::SetToolDisabledBitmap( int id, const wxBitmap& bitmap )
1139 {
1140     wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
1141     if ( tool )
1142     {
1143         wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1144
1145         tool->SetDisabledBitmap(bitmap);
1146
1147         // TODO:  what to do for this one?
1148     }
1149 }
1150
1151 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
1152 {
1153     wxToolBarTool *tool;
1154     wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
1155     while ( node )
1156     {
1157         tool = (wxToolBarTool *)node->GetData();
1158         if (tool != NULL)
1159         {
1160             wxRect2DInt r( tool->GetPosition(), tool->GetSize() );
1161             if ( r.Contains( wxPoint( x, y ) ) )
1162                 return tool;
1163         }
1164
1165         node = node->GetNext();
1166     }
1167
1168     return NULL;
1169 }
1170
1171 wxString wxToolBar::MacGetToolTipString( wxPoint &pt )
1172 {
1173     wxToolBarToolBase *tool = FindToolForPosition( pt.x, pt.y );
1174     if ( tool != NULL )
1175         return tool->GetShortHelp();
1176
1177     return wxEmptyString;
1178 }
1179
1180 void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
1181 {
1182     if ( t != NULL )
1183         ((wxToolBarTool*)t)->DoEnable( enable );
1184 }
1185
1186 void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
1187 {
1188     wxToolBarTool *tool = (wxToolBarTool *)t;
1189     if ( ( tool != NULL ) && tool->IsButton() )
1190         tool->UpdateToggleImage( toggle );
1191 }
1192
1193 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolBase)
1194 {
1195     wxToolBarTool *tool = static_cast< wxToolBarTool*>(toolBase );
1196     if (tool == NULL)
1197         return false;
1198
1199     wxSize toolSize = GetToolSize();
1200     WXWidget controlHandle = NULL;
1201     NSRect toolrect = NSMakeRect(0, 0, toolSize.x, toolSize.y );
1202
1203 #if wxOSX_USE_NATIVE_TOOLBAR
1204     wxString label = tool->GetLabel();
1205     if (m_macToolbar && !label.empty() )
1206     {
1207         // strip mnemonics from the label for compatibility
1208         // with the usual labels in wxStaticText sense
1209         label = wxStripMenuCodes(label);
1210     }
1211 #endif // wxOSX_USE_NATIVE_TOOLBAR
1212
1213     switch (tool->GetStyle())
1214     {
1215         case wxTOOL_STYLE_SEPARATOR:
1216             {
1217                 wxASSERT( tool->GetControlHandle() == NULL );
1218                 toolSize.x /= 4;
1219                 toolSize.y /= 4;
1220                 if ( GetWindowStyleFlag() & (wxTB_LEFT|wxTB_RIGHT) )
1221                     toolrect.size.height = toolSize.y;
1222                 else
1223                     toolrect.size.width = toolSize.x;
1224
1225                 // in flat style we need a visual separator
1226 #if wxOSX_USE_NATIVE_TOOLBAR
1227                 if (m_macToolbar != NULL)
1228                 {
1229                     const NSString * const
1230                         nsItemId = tool->IsStretchable() ? NSToolbarFlexibleSpaceItemIdentifier
1231                                                          : NSToolbarSeparatorItemIdentifier;
1232                     NSToolbarItem* item = [[NSToolbarItem alloc] initWithItemIdentifier:nsItemId];
1233                     tool->SetToolbarItemRef( item );
1234                 }
1235 #endif // wxOSX_USE_NATIVE_TOOLBAR
1236
1237                 NSBox* box = [[NSBox alloc] initWithFrame:toolrect];
1238                 [box setBoxType:NSBoxSeparator];
1239                 controlHandle = box;
1240                 tool->SetControlHandle( controlHandle );
1241             }
1242             break;
1243
1244         case wxTOOL_STYLE_BUTTON:
1245             {
1246                 wxASSERT( tool->GetControlHandle() == NULL );
1247
1248                 wxNSToolBarButton* v = [[wxNSToolBarButton alloc] initWithFrame:toolrect];
1249
1250                 [v setBezelStyle:NSRegularSquareBezelStyle];
1251                 [v setBordered:NO];
1252                 [v setButtonType: ( tool->CanBeToggled() ? NSOnOffButton : NSMomentaryPushInButton )];
1253                 [v setImplementation:tool];
1254
1255                 controlHandle = v;
1256
1257 #if wxOSX_USE_NATIVE_TOOLBAR
1258                 if (m_macToolbar != NULL)
1259                 {
1260                     wxString identifier = wxString::Format(wxT("%ld"), (long) tool);
1261                     wxCFStringRef cfidentifier( identifier, wxFont::GetDefaultEncoding() );
1262                     wxNSToolbarItem* item = [[wxNSToolbarItem alloc] initWithItemIdentifier:cfidentifier.AsNSString() ];
1263                     [item setImplementation:tool];
1264                     tool->SetToolbarItemRef( item );
1265                 }
1266
1267 #endif // wxOSX_USE_NATIVE_TOOLBAR
1268                 tool->SetControlHandle( controlHandle );
1269                 tool->UpdateImages();
1270                 tool->UpdateLabel();
1271 #if 0
1272                 SetBevelButtonTextPlacement( m_controlHandle, kControlBevelButtonPlaceBelowGraphic );
1273                 SetControlTitleWithCFString( m_controlHandle , wxCFStringRef( label, wxFont::GetDefaultEncoding() );
1274 #endif
1275 #if 0
1276                 InstallControlEventHandler(
1277                     (WXWidget) controlHandle, GetwxMacToolBarToolEventHandlerUPP(),
1278                     GetEventTypeCount(eventList), eventList, tool, NULL );
1279 #endif
1280             }
1281             break;
1282
1283         case wxTOOL_STYLE_CONTROL:
1284
1285 #if wxOSX_USE_NATIVE_TOOLBAR
1286             if (m_macToolbar != NULL)
1287             {
1288                 WXWidget view = (WXWidget) tool->GetControl()->GetHandle() ;
1289                 wxCHECK_MSG( view, false, wxT("control must be non-NULL") );
1290
1291                 wxString identifier = wxString::Format(wxT("%ld"), (long) tool);
1292                 wxCFStringRef cfidentifier( identifier, wxFont::GetDefaultEncoding() );
1293                 wxNSToolbarItem* item = [[wxNSToolbarItem alloc] initWithItemIdentifier:cfidentifier.AsNSString() ];
1294                 [item setImplementation:tool];
1295                 tool->SetToolbarItemRef( item );
1296            }
1297 #else
1298             // right now there's nothing to do here
1299 #endif
1300             tool->UpdateLabel();
1301             break;
1302
1303         default:
1304             break;
1305     }
1306
1307     if ( controlHandle )
1308     {
1309         WXWidget container = (WXWidget) GetHandle();
1310         wxASSERT_MSG( container != NULL, wxT("No valid Mac container control") );
1311
1312 //        SetControlVisibility( controlHandle, true, true );
1313         [container addSubview:controlHandle];
1314     }
1315
1316     // nothing special to do here - we relayout in Realize() later
1317     InvalidateBestSize();
1318
1319     return true;
1320
1321 }
1322
1323 void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
1324 {
1325     wxFAIL_MSG( wxT("not implemented") );
1326 }
1327
1328 bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *toolbase)
1329 {
1330     wxToolBarTool* tool = static_cast< wxToolBarTool*>(toolbase );
1331     wxToolBarToolsList::compatibility_iterator node;
1332     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1333     {
1334         wxToolBarToolBase *tool2 = node->GetData();
1335         if ( tool2 == tool )
1336         {
1337             // let node point to the next node in the list
1338             node = node->GetNext();
1339
1340             break;
1341         }
1342     }
1343
1344     wxSize sz = ((wxToolBarTool*)tool)->GetSize();
1345
1346 #if wxOSX_USE_NATIVE_TOOLBAR
1347     CFIndex removeIndex = tool->GetIndex();
1348 #endif
1349
1350 #if wxOSX_USE_NATIVE_TOOLBAR
1351     if (m_macToolbar != NULL)
1352     {
1353         if ( removeIndex != -1 && m_macToolbar )
1354         {
1355             [(NSToolbar*) m_macToolbar removeItemAtIndex:removeIndex];
1356             tool->SetIndex( -1 );
1357         }
1358     }
1359 #endif
1360
1361     tool->ClearControl();
1362
1363     // and finally reposition all the controls after this one
1364
1365     for ( /* node -> first after deleted */; node; node = node->GetNext() )
1366     {
1367         wxToolBarTool *tool2 = (wxToolBarTool*) node->GetData();
1368         wxPoint pt = tool2->GetPosition();
1369
1370         if ( GetWindowStyleFlag() & (wxTB_LEFT|wxTB_RIGHT) )
1371             pt.y -= sz.y;
1372         else
1373             pt.x -= sz.x;
1374
1375         tool2->SetPosition( pt );
1376
1377 #if wxOSX_USE_NATIVE_TOOLBAR
1378         if (m_macToolbar != NULL)
1379         {
1380             if ( removeIndex != -1 && tool2->GetIndex() > removeIndex )
1381                 tool2->SetIndex( tool2->GetIndex() - 1 );
1382         }
1383 #endif
1384     }
1385
1386     InvalidateBestSize();
1387
1388     return true;
1389 }
1390
1391 #include <Carbon/Carbon.h>
1392
1393 void wxToolBar::OnPaint(wxPaintEvent& event)
1394 {
1395 #if wxOSX_USE_NATIVE_TOOLBAR
1396     if ( m_macUsesNativeToolbar )
1397     {
1398         event.Skip(true);
1399         return;
1400     }
1401 #endif
1402
1403     wxPaintDC dc(this);
1404
1405     int w, h;
1406     GetSize( &w, &h );
1407
1408     bool drawMetalTheme = MacGetTopLevelWindow()->GetExtraStyle() & wxFRAME_EX_METAL;
1409
1410     if ( !drawMetalTheme  )
1411     {
1412         HIThemePlacardDrawInfo info;
1413         memset( &info, 0, sizeof(info) );
1414         info.version = 0;
1415         info.state = IsEnabled() ? kThemeStateActive : kThemeStateInactive;
1416
1417         CGContextRef cgContext = (CGContextRef) MacGetCGContextRef();
1418         HIRect rect = CGRectMake( 0, 0, w, h );
1419         HIThemeDrawPlacard( &rect, &info, cgContext, kHIThemeOrientationNormal );
1420     }
1421     else
1422     {
1423         // leave the background as it is (striped or metal)
1424     }
1425
1426     event.Skip();
1427 }
1428
1429 #endif // wxUSE_TOOLBAR