src/mac/carbon/toolbar.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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:     The wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 #pragma implementation "toolbar.h"
  14 #endif
  15
  16 #include "wx/wxprec.h"
  17
  18 #if wxUSE_TOOLBAR
  19
  20 #include "wx/wx.h"
  21 #include "wx/toolbar.h"
  22 #include "wx/notebook.h"
  23 #include "wx/tabctrl.h"
  24 #include "wx/bitmap.h"
  25
  26 #if !USE_SHARED_LIBRARY
  27 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
  28
  29 BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
  30     EVT_PAINT( wxToolBar::OnPaint )
  31 END_EVENT_TABLE()
  32 #endif
  33
  34 #include "wx/mac/uma.h"
  35 #include "wx/geometry.h"
  36
  37 #ifdef __WXMAC_OSX__
  38 const short kwxMacToolBarToolDefaultWidth = 24 ;
  39 const short kwxMacToolBarToolDefaultHeight = 24 ;
  40 const short kwxMacToolBarTopMargin = 4 ;
  41 const short kwxMacToolBarLeftMargin = 4 ;
  42 const short kwxMacToolBorder = 0 ;
  43 const short kwxMacToolSpacing = 6 ;
  44 #else
  45 const short kwxMacToolBarToolDefaultWidth = 24 ;
  46 const short kwxMacToolBarToolDefaultHeight = 22 ;
  47 const short kwxMacToolBarTopMargin = 2 ;
  48 const short kwxMacToolBarLeftMargin = 2 ;
  49 const short kwxMacToolBorder = 4 ;
  50 const short kwxMacToolSpacing = 0 ;
  51 #endif
  52
  53 // ----------------------------------------------------------------------------
  54 // private classes
  55 // ----------------------------------------------------------------------------
  56
  57 class wxToolBarTool : public wxToolBarToolBase
  58 {
  59 public:
  60     wxToolBarTool(wxToolBar *tbar,
  61                   int id,
  62                   const wxString& label,
  63                   const wxBitmap& bmpNormal,
  64                   const wxBitmap& bmpDisabled,
  65                   wxItemKind kind,
  66                   wxObject *clientData,
  67                   const wxString& shortHelp,
  68                   const wxString& longHelp) ;
  69
  70     wxToolBarTool(wxToolBar *tbar, wxControl *control)
  71         : wxToolBarToolBase(tbar, control)
  72     {
  73         Init() ;
  74     }
  75
  76     ~wxToolBarTool()
  77     {
  78         if ( m_controlHandle )
  79             DisposeControl( m_controlHandle ) ;
  80     }
  81
  82     WXWidget GetControlHandle() { return (WXWidget) m_controlHandle ; }
  83     void SetControlHandle( ControlRef handle ) { m_controlHandle = handle ; }
  84
  85     void SetSize(const wxSize& size) ;
  86     void SetPosition( const wxPoint& position ) ;
  87
  88     wxSize GetSize() const
  89     {
  90         if ( IsControl() )
  91         {
  92             return GetControl()->GetSize() ;
  93         }
  94         else if ( IsButton() )
  95         {
  96             return GetToolBar()->GetToolSize() ;
  97         }
  98         else
  99         {
 100             // separator size
 101             wxSize sz = GetToolBar()->GetToolSize() ;
 102             if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL )
 103                 sz.y /= 4 ;
 104             else
 105                 sz.x /= 4 ;
 106             return sz ;
 107         }
 108     }
 109     wxPoint GetPosition() const
 110     {
 111         return wxPoint(m_x, m_y);
 112     }
 113     bool DoEnable( bool enable ) ;
 114
 115     void UpdateToggleImage( bool toggle ) ;
 116 private :
 117     void Init()
 118     {
 119         m_controlHandle = NULL ;
 120     }
 121     ControlRef m_controlHandle ;
 122
 123     wxCoord     m_x;
 124     wxCoord     m_y;
 125 };
 126
 127 static const EventTypeSpec eventList[] =
 128 {
 129         { kEventClassControl , kEventControlHit } ,
 130 #ifdef __WXMAC_OSX__
 131         { kEventClassControl , kEventControlHitTest } ,
 132 #endif
 133 } ;
 134
 135 static pascal OSStatus wxMacToolBarToolControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 136 {
 137     OSStatus result = eventNotHandledErr ;
 138
 139     wxMacCarbonEvent cEvent( event ) ;
 140
 141     ControlRef controlRef ;
 142
 143     cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
 144
 145     switch( GetEventKind( event ) )
 146     {
 147         case kEventControlHit :
 148             {
 149                 wxToolBarTool* tbartool = (wxToolBarTool*)data ;
 150                 if ( tbartool->CanBeToggled() )
 151                 {
 152 #ifdef __WXMAC_OSX__
 153                     ((wxToolBar*)tbartool->GetToolBar())->ToggleTool(tbartool->GetId(), !tbartool->IsToggled() );
 154 #else
 155                     ((wxToolBar*)tbartool->GetToolBar())->ToggleTool(tbartool->GetId(), GetControl32BitValue((ControlRef)tbartool->GetControlHandle()));
 156 #endif
 157                 }
 158                 ((wxToolBar*)tbartool->GetToolBar())->OnLeftClick( tbartool->GetId() , tbartool -> IsToggled() ) ;
 159                 result = noErr;
 160             }
 161             break ;
 162 #ifdef __WXMAC_OSX__
 163         case kEventControlHitTest :
 164             {
 165                 HIPoint pt = cEvent.GetParameter<HIPoint>(kEventParamMouseLocation) ;
 166                 HIRect rect ;
 167                 HIViewGetBounds( controlRef , &rect ) ;
 168
 169                 ControlPartCode pc = kControlNoPart ;
 170                 if ( CGRectContainsPoint( rect , pt ) )
 171                     pc = kControlButtonPart ;
 172                 cEvent.SetParameter( kEventParamControlPart , typeControlPartCode, pc ) ;
 173                 result = noErr ;
 174             }
 175             break ;
 176 #endif
 177         default :
 178             break ;
 179     }
 180     return result ;
 181 }
 182
 183 pascal OSStatus wxMacToolBarToolEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 184 {
 185     OSStatus result = eventNotHandledErr ;
 186
 187     switch ( GetEventClass( event ) )
 188     {
 189         case kEventClassControl :
 190             result = wxMacToolBarToolControlEventHandler( handler, event, data ) ;
 191             break ;
 192         default :
 193             break ;
 194     }
 195     return result ;
 196 }
 197
 198 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacToolBarToolEventHandler )
 199
 200 // ============================================================================
 201 // implementation
 202 // ============================================================================
 203
 204 // ----------------------------------------------------------------------------
 205 // wxToolBarTool
 206 // ----------------------------------------------------------------------------
 207
 208 bool wxToolBarTool::DoEnable(bool enable)
 209 {
 210     if ( IsControl() )
 211     {
 212         GetControl()->Enable( enable ) ;
 213     }
 214     else if ( IsButton() )
 215     {
 216 #if TARGET_API_MAC_OSX
 217         if ( enable )
 218             EnableControl( m_controlHandle ) ;
 219         else
 220             DisableControl( m_controlHandle ) ;
 221 #else
 222         if ( enable )
 223             ActivateControl( m_controlHandle ) ;
 224         else
 225             DeactivateControl( m_controlHandle ) ;
 226 #endif
 227     }
 228     return true ;
 229 }
 230 void wxToolBarTool::SetSize(const wxSize& size)
 231 {
 232     if ( IsControl() )
 233     {
 234         GetControl()->SetSize( size ) ;
 235     }
 236 }
 237
 238 void wxToolBarTool::SetPosition(const wxPoint& position)
 239 {
 240     m_x = position.x;
 241     m_y = position.y;
 242
 243     if ( IsButton() )
 244     {
 245         int x , y ;
 246         x = y = 0 ;
 247         int mac_x = position.x ;
 248         int mac_y = position.y ;
 249 #ifdef __WXMAC_OSX__
 250         // already correctly set up
 251 #else
 252         WindowRef rootwindow = (WindowRef) GetToolBar()->MacGetTopLevelWindowRef() ;
 253         GetToolBar()->MacWindowToRootWindow( &x , &y ) ;
 254         mac_x += x;
 255         mac_y += y;
 256 #endif
 257         Rect contrlRect ;
 258         GetControlBounds( m_controlHandle , &contrlRect ) ;
 259         int former_mac_x = contrlRect.left ;
 260         int former_mac_y = contrlRect.top ;
 261         GetToolBar()->GetToolSize() ;
 262
 263         if ( mac_x != former_mac_x || mac_y != former_mac_y )
 264         {
 265             UMAMoveControl( m_controlHandle , mac_x , mac_y ) ;
 266         }
 267     }
 268     else if ( IsControl() )
 269     {
 270         GetControl()->Move( position ) ;
 271     }
 272     else
 273     {
 274         // separator
 275 #ifdef __WXMAC_OSX__
 276         int x , y ;
 277         x = y = 0 ;
 278         int mac_x = position.x ;
 279         int mac_y = position.y ;
 280
 281         Rect contrlRect ;
 282         GetControlBounds( m_controlHandle , &contrlRect ) ;
 283         int former_mac_x = contrlRect.left ;
 284         int former_mac_y = contrlRect.top ;
 285
 286         if ( mac_x != former_mac_x || mac_y != former_mac_y )
 287         {
 288             UMAMoveControl( m_controlHandle , mac_x , mac_y ) ;
 289         }
 290 #endif
 291     }
 292 }
 293
 294 void wxToolBarTool::UpdateToggleImage( bool toggle )
 295 {
 296 #ifdef __WXMAC_OSX__
 297     if ( toggle )
 298     {
 299         int w = m_bmpNormal.GetWidth() ;
 300         int h = m_bmpNormal.GetHeight() ;
 301         wxBitmap bmp( w , h ) ;
 302         wxMemoryDC dc ;
 303         dc.SelectObject( bmp ) ;
 304         dc.SetPen( wxNullPen ) ;
 305         dc.SetBackground( *wxWHITE ) ;
 306         dc.DrawRectangle( 0 , 0 , w , h ) ;
 307         dc.DrawBitmap( m_bmpNormal , 0 , 0 , true) ;
 308         dc.SelectObject( wxNullBitmap ) ;
 309         ControlButtonContentInfo info ;
 310         wxMacCreateBitmapButton( &info , bmp ) ;
 311         SetControlData( m_controlHandle , 0, kControlIconContentTag, sizeof( info ),
 312                         (Ptr)&info );
 313         wxMacReleaseBitmapButton( &info ) ;
 314     }
 315     else
 316     {
 317         ControlButtonContentInfo info ;
 318         wxMacCreateBitmapButton( &info , m_bmpNormal ) ;
 319         SetControlData( m_controlHandle , 0, kControlIconContentTag, sizeof( info ),
 320                         (Ptr)&info );
 321         wxMacReleaseBitmapButton( &info ) ;
 322     }
 323
 324     IconTransformType transform = toggle ? kTransformSelected : kTransformNone ;
 325         SetControlData( m_controlHandle, 0, kControlIconTransformTag, sizeof( transform ),
 326                         (Ptr)&transform );
 327     HIViewSetNeedsDisplay( m_controlHandle , true ) ;
 328
 329 #else
 330     ::SetControl32BitValue( m_controlHandle , toggle ) ;
 331 #endif
 332 }
 333
 334 wxToolBarTool::wxToolBarTool(wxToolBar *tbar,
 335   int id,
 336   const wxString& label,
 337   const wxBitmap& bmpNormal,
 338   const wxBitmap& bmpDisabled,
 339   wxItemKind kind,
 340   wxObject *clientData,
 341   const wxString& shortHelp,
 342   const wxString& longHelp)
 343         : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
 344                             clientData, shortHelp, longHelp)
 345 {
 346     Init();
 347
 348     WindowRef window = (WindowRef) tbar->MacGetTopLevelWindowRef() ;
 349     wxSize toolSize = tbar->GetToolSize() ;
 350     Rect toolrect = { 0, 0 , toolSize.y , toolSize.x } ;
 351
 352     if ( id == wxID_SEPARATOR )
 353     {
 354         toolSize.x /= 4 ;
 355         toolSize.y /= 4 ;
 356         if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL )
 357         {
 358             toolrect.bottom = toolSize.y ;
 359         }
 360         else
 361         {
 362             toolrect.right = toolSize.x ;
 363         }
 364 #ifdef __WXMAC_OSX__
 365         // in flat style we need a visual separator
 366         CreateSeparatorControl( window , &toolrect , &m_controlHandle ) ;
 367 #endif
 368     }
 369     else
 370     {
 371         ControlButtonContentInfo info ;
 372         wxMacCreateBitmapButton( &info , GetNormalBitmap()  , kControlContentIconRef ) ;
 373
 374 #ifdef __WXMAC_OSX__
 375         CreateIconControl( window , &toolrect , &info , false , &m_controlHandle ) ;
 376 #else
 377         SInt16 behaviour = kControlBehaviorOffsetContents ;
 378         if ( CanBeToggled() )
 379             behaviour += kControlBehaviorToggles ;
 380         CreateBevelButtonControl( window , &toolrect , CFSTR("") , kControlBevelButtonNormalBevel , behaviour , &info ,
 381             0 , 0 , 0 , &m_controlHandle ) ;
 382 #endif
 383
 384         wxMacReleaseBitmapButton( &info ) ;
 385         /*
 386         SetBevelButtonTextPlacement( m_controlHandle , kControlBevelButtonPlaceBelowGraphic ) ;
 387         UMASetControlTitle(  m_controlHandle , label , wxFont::GetDefaultEncoding() ) ;
 388         */
 389
 390         InstallControlEventHandler( (ControlRef) m_controlHandle, GetwxMacToolBarToolEventHandlerUPP(),
 391             GetEventTypeCount(eventList), eventList, this,NULL);
 392
 393     }
 394     ControlRef container = (ControlRef) tbar->GetHandle() ;
 395     wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
 396     if ( m_controlHandle )
 397     {
 398         UMAShowControl( m_controlHandle ) ;
 399         ::EmbedControl( m_controlHandle , container ) ;
 400     }
 401     if ( CanBeToggled() && IsToggled() )
 402     {
 403         UpdateToggleImage( true ) ;
 404     }
 405 }
 406
 407
 408 wxToolBarToolBase *wxToolBar::CreateTool(int id,
 409                                          const wxString& label,
 410                                          const wxBitmap& bmpNormal,
 411                                          const wxBitmap& bmpDisabled,
 412                                          wxItemKind kind,
 413                                          wxObject *clientData,
 414                                          const wxString& shortHelp,
 415                                          const wxString& longHelp)
 416 {
 417     return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
 418                              clientData, shortHelp, longHelp);
 419 }
 420
 421 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
 422 {
 423     return new wxToolBarTool(this, control);
 424 }
 425
 426 void wxToolBar::Init()
 427 {
 428     m_maxWidth = -1;
 429     m_maxHeight = -1;
 430     m_defaultWidth = kwxMacToolBarToolDefaultWidth;
 431     m_defaultHeight = kwxMacToolBarToolDefaultHeight;
 432 }
 433
 434 bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
 435             long style, const wxString& name)
 436 {
 437
 438     if ( !wxToolBarBase::Create( parent , id , pos , size , style ) )
 439         return FALSE ;
 440
 441     return TRUE;
 442 }
 443
 444 wxToolBar::~wxToolBar()
 445 {
 446     // we must refresh the frame size when the toolbar is deleted but the frame
 447     // is not - otherwise toolbar leaves a hole in the place it used to occupy
 448 }
 449
 450 bool wxToolBar::Realize()
 451 {
 452     if (m_tools.GetCount() == 0)
 453         return FALSE;
 454
 455     int x = m_xMargin + kwxMacToolBarLeftMargin ;
 456     int y = m_yMargin + kwxMacToolBarTopMargin ;
 457
 458     int tw, th;
 459     GetSize(& tw, & th);
 460
 461     int maxWidth = 0 ;
 462     int maxHeight = 0 ;
 463
 464     int maxToolWidth = 0;
 465     int maxToolHeight = 0;
 466
 467     // Find the maximum tool width and height
 468     wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 469     while ( node )
 470     {
 471         wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
 472         wxSize sz = tool->GetSize() ;
 473
 474         if ( sz.x > maxToolWidth )
 475             maxToolWidth = sz.x ;
 476         if (sz.y> maxToolHeight)
 477             maxToolHeight = sz.y;
 478
 479         node = node->GetNext();
 480     }
 481
 482     bool lastWasRadio = FALSE;
 483     node = m_tools.GetFirst();
 484     while (node)
 485     {
 486         wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
 487         wxSize cursize = tool->GetSize() ;
 488
 489         bool isRadio = FALSE;
 490
 491         if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO )
 492         {
 493             if ( !lastWasRadio )
 494             {
 495                 if (tool->Toggle(true))
 496                 {
 497                     DoToggleTool(tool, true);
 498                 }
 499             }
 500             isRadio = TRUE;
 501         }
 502         else
 503         {
 504             isRadio = FALSE;
 505         }
 506         lastWasRadio = isRadio;
 507
 508         // for the moment we just do a single row/column alignement
 509         if ( x + cursize.x > maxWidth )
 510             maxWidth = x + cursize.x ;
 511         if ( y + cursize.y > maxHeight )
 512             maxHeight = y + cursize.y ;
 513
 514         if ( GetWindowStyleFlag() & wxTB_VERTICAL )
 515         {
 516             int x1 = x + (maxToolWidth - cursize.x)/2 ;
 517             tool->SetPosition( wxPoint( x1 , y ) ) ;
 518         }
 519         else
 520         {
 521             int y1 = y + (maxToolHeight - cursize.y)/2 ;
 522             tool->SetPosition( wxPoint( x , y1 ) ) ;
 523         }
 524         if ( GetWindowStyleFlag() & wxTB_VERTICAL )
 525         {
 526             y += cursize.y ;
 527             y += kwxMacToolSpacing ;
 528         }
 529         else
 530         {
 531             x += cursize.x ;
 532             x += kwxMacToolSpacing ;
 533         }
 534
 535         node = node->GetNext();
 536     }
 537
 538     if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 539     {
 540         if ( m_maxRows == 0 )
 541         {
 542             // if not set yet, only one row
 543             SetRows(1);
 544         }
 545         m_minWidth = maxWidth;
 546         maxWidth = tw ;
 547         maxHeight += m_yMargin + kwxMacToolBarTopMargin;
 548         m_minHeight = m_maxHeight = maxHeight ;
 549     }
 550     else
 551     {
 552         if ( GetToolsCount() > 0 && m_maxRows == 0 )
 553         {
 554             // if not set yet, have one column
 555             SetRows(GetToolsCount());
 556         }
 557         m_minHeight = maxHeight;
 558         maxHeight = th ;
 559         maxWidth += m_xMargin + kwxMacToolBarLeftMargin;
 560         m_minWidth = m_maxWidth = maxWidth ;
 561     }
 562
 563     SetSize( maxWidth, maxHeight );
 564     InvalidateBestSize();
 565
 566     return TRUE;
 567 }
 568
 569 void wxToolBar::SetToolBitmapSize(const wxSize& size)
 570 {
 571     m_defaultWidth = size.x+kwxMacToolBorder; m_defaultHeight = size.y+kwxMacToolBorder;
 572 }
 573
 574 // The button size is bigger than the bitmap size
 575 wxSize wxToolBar::GetToolSize() const
 576 {
 577     return wxSize(m_defaultWidth + kwxMacToolBorder, m_defaultHeight + kwxMacToolBorder);
 578 }
 579
 580 void wxToolBar::SetRows(int nRows)
 581 {
 582     if ( nRows == m_maxRows )
 583     {
 584         // avoid resizing the frame uselessly
 585         return;
 586     }
 587
 588     m_maxRows = nRows;
 589 }
 590
 591 void wxToolBar::MacSuperChangedPosition()
 592 {
 593     wxWindow::MacSuperChangedPosition() ;
 594     Realize() ;
 595 }
 596
 597 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
 598 {
 599     wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 600     while (node)
 601     {
 602         wxToolBarTool *tool = (wxToolBarTool *)node->GetData() ;
 603         wxRect2DInt r( tool->GetPosition() , tool->GetSize() ) ;
 604         if ( r.Contains( wxPoint( x , y ) ) )
 605         {
 606             return tool;
 607         }
 608
 609         node = node->GetNext();
 610     }
 611
 612     return (wxToolBarToolBase *)NULL;
 613 }
 614
 615 wxString wxToolBar::MacGetToolTipString( wxPoint &pt )
 616 {
 617     wxToolBarToolBase* tool = FindToolForPosition( pt.x , pt.y ) ;
 618     if ( tool )
 619     {
 620         return tool->GetShortHelp() ;
 621     }
 622     return wxEmptyString ;
 623 }
 624
 625 void wxToolBar::DoEnableTool(wxToolBarToolBase *t, bool enable)
 626 {
 627     ((wxToolBarTool*)t)->DoEnable( enable ) ;
 628 }
 629
 630 void wxToolBar::DoToggleTool(wxToolBarToolBase *t, bool toggle)
 631 {
 632     wxToolBarTool *tool = (wxToolBarTool *)t;
 633     if ( tool->IsButton() )
 634     {
 635         tool->UpdateToggleImage( toggle ) ;
 636     }
 637 }
 638
 639 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
 640                              wxToolBarToolBase *tool)
 641 {
 642     // nothing special to do here - we relayout in Realize() later
 643     tool->Attach(this);
 644     InvalidateBestSize();
 645
 646     return TRUE;
 647 }
 648
 649 void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
 650 {
 651     wxFAIL_MSG( _T("not implemented") );
 652 }
 653
 654 bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
 655 {
 656     wxToolBarToolsList::compatibility_iterator node;
 657     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 658     {
 659         wxToolBarToolBase *tool2 = node->GetData();
 660         if ( tool2 == tool )
 661         {
 662             // let node point to the next node in the list
 663             node = node->GetNext();
 664
 665             break;
 666         }
 667     }
 668
 669     wxSize sz = ((wxToolBarTool*)tool)->GetSize() ;
 670
 671     tool->Detach();
 672
 673     // and finally reposition all the controls after this one
 674
 675     for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
 676     {
 677         wxToolBarTool *tool2 = (wxToolBarTool*) node->GetData();
 678         wxPoint pt = tool2->GetPosition() ;
 679
 680         if ( GetWindowStyleFlag() & wxTB_VERTICAL )
 681         {
 682             pt.y -= sz.y ;
 683         }
 684         else
 685         {
 686             pt.x -= sz.x ;
 687         }
 688         tool2->SetPosition( pt ) ;
 689     }
 690
 691     InvalidateBestSize();
 692     return TRUE ;
 693 }
 694
 695 void wxToolBar::OnPaint(wxPaintEvent& event)
 696 {
 697     wxPaintDC dc(this) ;
 698 #if wxMAC_USE_CORE_GRAPHICS
 699     // leave the background as it is (striped or metal)
 700 #else
 701     wxMacPortSetter helper(&dc) ;
 702     int w, h ;
 703     GetSize( &w , &h ) ;
 704
 705     Rect toolbarrect = { dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) ,
 706         dc.YLOG2DEVMAC(h) , dc.XLOG2DEVMAC(w) } ;
 707 /*
 708     if( toolbarrect.left < 0 )
 709         toolbarrect.left = 0 ;
 710     if ( toolbarrect.top < 0 )
 711         toolbarrect.top = 0 ;
 712 */
 713     if ( !MacGetTopLevelWindow()->MacGetMetalAppearance() )
 714     {
 715         UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
 716     }
 717     else
 718     {
 719 #if TARGET_API_MAC_OSX
 720 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
 721         if ( UMAGetSystemVersion() >= 0x1030 )
 722         {
 723             HIRect hiToolbarrect = CGRectMake( dc.YLOG2DEVMAC(0) , dc.XLOG2DEVMAC(0) ,
 724             dc.YLOG2DEVREL(h) , dc.XLOG2DEVREL(w) );
 725             CGContextRef cgContext ;
 726             Rect bounds ;
 727             GetPortBounds( (CGrafPtr) dc.m_macPort , &bounds ) ;
 728             QDBeginCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
 729             CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ;
 730             CGContextScaleCTM( cgContext , 1 , -1 ) ;
 731
 732             {
 733                 HIThemeBackgroundDrawInfo drawInfo ;
 734                 drawInfo.version = 0 ;
 735                 drawInfo.state = kThemeStateActive ;
 736                 drawInfo.kind = kThemeBackgroundMetal ;
 737                 HIThemeApplyBackground( &hiToolbarrect, &drawInfo , cgContext,kHIThemeOrientationNormal) ;
 738             }
 739             QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
 740         }
 741         else
 742 #endif
 743         {
 744             UMADrawThemePlacard( &toolbarrect , IsEnabled() ? kThemeStateActive : kThemeStateInactive) ;
 745         }
 746 #endif
 747     }
 748 #endif
 749
 750     event.Skip() ;
 751 }
 752
 753 #endif // wxUSE_TOOLBAR
 754