src/common/tbarbase.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/tbarbase.cpp
   3 // Purpose:     wxToolBarBase implementation
   4 // Author:      Julian Smart
   5 // Modified by: VZ at 11.12.99 (wxScrollableToolBar split off)
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_TOOLBAR
  28
  29 #include "wx/toolbar.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/control.h"
  33     #include "wx/frame.h"
  34     #include "wx/settings.h"
  35     #if WXWIN_COMPATIBILITY_2_8
  36         #include "wx/image.h"
  37     #endif // WXWIN_COMPATIBILITY_2_8
  38     #include "wx/menu.h"
  39 #endif
  40
  41 extern WXDLLEXPORT_DATA(const char) wxToolBarNameStr[] = "toolbar";
  42
  43 // ----------------------------------------------------------------------------
  44 // wxWidgets macros
  45 // ----------------------------------------------------------------------------
  46
  47 BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
  48 END_EVENT_TABLE()
  49
  50 #include "wx/listimpl.cpp"
  51
  52 WX_DEFINE_LIST(wxToolBarToolsList)
  53
  54 // ============================================================================
  55 // implementation
  56 // ============================================================================
  57
  58 // ----------------------------------------------------------------------------
  59 // wxToolBarToolBase
  60 // ----------------------------------------------------------------------------
  61
  62 IMPLEMENT_DYNAMIC_CLASS(wxToolBarToolBase, wxObject)
  63
  64 wxToolBarToolBase::~wxToolBarToolBase()
  65 {
  66 #if wxUSE_MENUS
  67     delete m_dropdownMenu;
  68 #endif
  69
  70     if ( IsControl() )
  71         GetControl()->Destroy();
  72 }
  73
  74
  75 bool wxToolBarToolBase::Enable(bool enable)
  76 {
  77     if ( m_enabled == enable )
  78         return false;
  79
  80     m_enabled = enable;
  81
  82     return true;
  83 }
  84
  85 bool wxToolBarToolBase::Toggle(bool toggle)
  86 {
  87     wxASSERT_MSG( CanBeToggled(), wxT("can't toggle this tool") );
  88
  89     if ( m_toggled == toggle )
  90         return false;
  91
  92     m_toggled = toggle;
  93
  94     return true;
  95 }
  96
  97 bool wxToolBarToolBase::SetToggle(bool toggle)
  98 {
  99     wxItemKind kind = toggle ? wxITEM_CHECK : wxITEM_NORMAL;
 100     if ( m_kind == kind )
 101         return false;
 102
 103     m_kind = kind;
 104
 105     return true;
 106 }
 107
 108 bool wxToolBarToolBase::SetShortHelp(const wxString& help)
 109 {
 110     if ( m_shortHelpString == help )
 111         return false;
 112
 113     m_shortHelpString = help;
 114
 115     return true;
 116 }
 117
 118 bool wxToolBarToolBase::SetLongHelp(const wxString& help)
 119 {
 120     if ( m_longHelpString == help )
 121         return false;
 122
 123     m_longHelpString = help;
 124
 125     return true;
 126 }
 127
 128
 129 #if wxUSE_MENUS
 130 void wxToolBarToolBase::SetDropdownMenu(wxMenu* menu)
 131 {
 132     delete m_dropdownMenu;
 133     m_dropdownMenu = menu;
 134 }
 135 #endif
 136
 137
 138 // ----------------------------------------------------------------------------
 139 // wxToolBarBase adding/deleting items
 140 // ----------------------------------------------------------------------------
 141
 142 wxToolBarBase::wxToolBarBase()
 143 {
 144     // the list owns the pointers
 145     m_xMargin = m_yMargin = 0;
 146     m_maxRows = m_maxCols = 0;
 147     m_toolPacking = m_toolSeparation = 0;
 148     m_defaultWidth = 16;
 149     m_defaultHeight = 15;
 150 }
 151
 152 void wxToolBarBase::FixupStyle()
 153 {
 154     if ( !HasFlag(wxTB_TOP | wxTB_LEFT | wxTB_RIGHT | wxTB_BOTTOM) )
 155     {
 156         // this is the default
 157         m_windowStyle |= wxTB_TOP;
 158     }
 159 }
 160
 161 wxToolBarToolBase *wxToolBarBase::DoAddTool(int id,
 162                                             const wxString& label,
 163                                             const wxBitmap& bitmap,
 164                                             const wxBitmap& bmpDisabled,
 165                                             wxItemKind kind,
 166                                             const wxString& shortHelp,
 167                                             const wxString& longHelp,
 168                                             wxObject *clientData,
 169                                             wxCoord WXUNUSED(xPos),
 170                                             wxCoord WXUNUSED(yPos))
 171 {
 172     InvalidateBestSize();
 173     return InsertTool(GetToolsCount(), id, label, bitmap, bmpDisabled,
 174                       kind, shortHelp, longHelp, clientData);
 175 }
 176
 177 wxToolBarToolBase *wxToolBarBase::InsertTool(size_t pos,
 178                                              int id,
 179                                              const wxString& label,
 180                                              const wxBitmap& bitmap,
 181                                              const wxBitmap& bmpDisabled,
 182                                              wxItemKind kind,
 183                                              const wxString& shortHelp,
 184                                              const wxString& longHelp,
 185                                              wxObject *clientData)
 186 {
 187     wxCHECK_MSG( pos <= GetToolsCount(), NULL,
 188                  wxT("invalid position in wxToolBar::InsertTool()") );
 189
 190     return DoInsertNewTool(pos, CreateTool(id, label, bitmap, bmpDisabled, kind,
 191                                            clientData, shortHelp, longHelp));
 192 }
 193
 194 wxToolBarToolBase *wxToolBarBase::AddTool(wxToolBarToolBase *tool)
 195 {
 196     return InsertTool(GetToolsCount(), tool);
 197 }
 198
 199 wxToolBarToolBase *
 200 wxToolBarBase::InsertTool(size_t pos, wxToolBarToolBase *tool)
 201 {
 202     wxCHECK_MSG( pos <= GetToolsCount(), NULL,
 203                  wxT("invalid position in wxToolBar::InsertTool()") );
 204
 205     if ( !tool || !DoInsertTool(pos, tool) )
 206     {
 207         return NULL;
 208     }
 209
 210     m_tools.Insert(pos, tool);
 211     tool->Attach(this);
 212
 213     return tool;
 214 }
 215
 216 wxToolBarToolBase *
 217 wxToolBarBase::AddControl(wxControl *control, const wxString& label)
 218 {
 219     return InsertControl(GetToolsCount(), control, label);
 220 }
 221
 222 wxToolBarToolBase *
 223 wxToolBarBase::InsertControl(size_t pos,
 224                              wxControl *control,
 225                              const wxString& label)
 226 {
 227     wxCHECK_MSG( control, NULL,
 228                  wxT("toolbar: can't insert NULL control") );
 229
 230     wxCHECK_MSG( control->GetParent() == this, NULL,
 231                  wxT("control must have toolbar as parent") );
 232
 233     return DoInsertNewTool(pos, CreateTool(control, label));
 234 }
 235
 236 wxControl *wxToolBarBase::FindControl( int id )
 237 {
 238     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 239           node;
 240           node = node->GetNext() )
 241     {
 242         const wxToolBarToolBase * const tool = node->GetData();
 243         if ( tool->IsControl() )
 244         {
 245             wxControl * const control = tool->GetControl();
 246
 247             if ( !control )
 248             {
 249                 wxFAIL_MSG( wxT("NULL control in toolbar?") );
 250             }
 251             else if ( control->GetId() == id )
 252             {
 253                 // found
 254                 return control;
 255             }
 256         }
 257     }
 258
 259    return NULL;
 260 }
 261
 262 wxToolBarToolBase *wxToolBarBase::AddSeparator()
 263 {
 264     return InsertSeparator(GetToolsCount());
 265 }
 266
 267 wxToolBarToolBase *wxToolBarBase::InsertSeparator(size_t pos)
 268 {
 269     return DoInsertNewTool(pos, CreateSeparator());
 270 }
 271
 272 wxToolBarToolBase *wxToolBarBase::AddStretchableSpace()
 273 {
 274     return InsertStretchableSpace(GetToolsCount());
 275 }
 276
 277 wxToolBarToolBase *wxToolBarBase::InsertStretchableSpace(size_t pos)
 278 {
 279     wxToolBarToolBase * const tool = CreateSeparator();
 280     if ( tool )
 281     {
 282         // this is a hack but we know that all the current implementations
 283         // don't really use the tool when it's created, they will do it
 284         // InsertTool() at earliest and maybe even in Realize() much later
 285         //
 286         // so we can create the tool as a plain separator and mark it as being
 287         // a stretchable space later
 288         tool->MakeStretchable();
 289     }
 290
 291     return DoInsertNewTool(pos, tool);
 292 }
 293
 294 wxToolBarToolBase *wxToolBarBase::RemoveTool(int id)
 295 {
 296     size_t pos = 0;
 297     wxToolBarToolsList::compatibility_iterator node;
 298     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 299     {
 300         if ( node->GetData()->GetId() == id )
 301             break;
 302
 303         pos++;
 304     }
 305
 306     if ( !node )
 307     {
 308         // don't give any error messages - sometimes we might call RemoveTool()
 309         // without knowing whether the tool is or not in the toolbar
 310         return NULL;
 311     }
 312
 313     wxToolBarToolBase *tool = node->GetData();
 314     wxCHECK_MSG( tool, NULL, "NULL tool in the tools list?" );
 315
 316     if ( !DoDeleteTool(pos, tool) )
 317         return NULL;
 318
 319     m_tools.Erase(node);
 320
 321     tool->Detach();
 322
 323     return tool;
 324 }
 325
 326 bool wxToolBarBase::DeleteToolByPos(size_t pos)
 327 {
 328     wxCHECK_MSG( pos < GetToolsCount(), false,
 329                  wxT("invalid position in wxToolBar::DeleteToolByPos()") );
 330
 331     wxToolBarToolsList::compatibility_iterator node = m_tools.Item(pos);
 332
 333     if ( !DoDeleteTool(pos, node->GetData()) )
 334     {
 335         return false;
 336     }
 337
 338     delete node->GetData();
 339     m_tools.Erase(node);
 340
 341     return true;
 342 }
 343
 344 bool wxToolBarBase::DeleteTool(int id)
 345 {
 346     size_t pos = 0;
 347     wxToolBarToolsList::compatibility_iterator node;
 348     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 349     {
 350         if ( node->GetData()->GetId() == id )
 351             break;
 352
 353         pos++;
 354     }
 355
 356     if ( !node || !DoDeleteTool(pos, node->GetData()) )
 357     {
 358         return false;
 359     }
 360
 361     delete node->GetData();
 362     m_tools.Erase(node);
 363
 364     return true;
 365 }
 366
 367 wxToolBarToolBase *wxToolBarBase::FindById(int id) const
 368 {
 369     wxToolBarToolBase *tool = NULL;
 370
 371     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 372           node;
 373           node = node->GetNext() )
 374     {
 375         tool = node->GetData();
 376         if ( tool->GetId() == id )
 377         {
 378             // found
 379             break;
 380         }
 381
 382         tool = NULL;
 383     }
 384
 385     return tool;
 386 }
 387
 388 void wxToolBarBase::UnToggleRadioGroup(wxToolBarToolBase *tool)
 389 {
 390     wxCHECK_RET( tool, wxT("NULL tool in wxToolBarTool::UnToggleRadioGroup") );
 391
 392     if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
 393         return;
 394
 395     wxToolBarToolsList::compatibility_iterator node = m_tools.Find(tool);
 396     wxCHECK_RET( node, wxT("invalid tool in wxToolBarTool::UnToggleRadioGroup") );
 397
 398     wxToolBarToolsList::compatibility_iterator nodeNext = node->GetNext();
 399     while ( nodeNext )
 400     {
 401         wxToolBarToolBase *toolNext = nodeNext->GetData();
 402
 403         if ( !toolNext->IsButton() || toolNext->GetKind() != wxITEM_RADIO )
 404             break;
 405
 406         if ( toolNext->Toggle(false) )
 407         {
 408             DoToggleTool(toolNext, false);
 409         }
 410
 411         nodeNext = nodeNext->GetNext();
 412     }
 413
 414     wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
 415     while ( nodePrev )
 416     {
 417         wxToolBarToolBase *toolNext = nodePrev->GetData();
 418
 419         if ( !toolNext->IsButton() || toolNext->GetKind() != wxITEM_RADIO )
 420             break;
 421
 422         if ( toolNext->Toggle(false) )
 423         {
 424             DoToggleTool(toolNext, false);
 425         }
 426
 427         nodePrev = nodePrev->GetPrevious();
 428     }
 429 }
 430
 431 void wxToolBarBase::ClearTools()
 432 {
 433     while ( GetToolsCount() )
 434     {
 435         DeleteToolByPos(0);
 436     }
 437 }
 438
 439 void wxToolBarBase::AdjustToolBitmapSize()
 440 {
 441     const wxSize sizeOrig(m_defaultWidth, m_defaultHeight);
 442
 443     wxSize sizeActual(sizeOrig);
 444
 445     for ( wxToolBarToolsList::const_iterator i = m_tools.begin();
 446           i != m_tools.end();
 447           ++i )
 448     {
 449         const wxBitmap& bmp = (*i)->GetNormalBitmap();
 450         if ( bmp.IsOk() )
 451             sizeActual.IncTo(bmp.GetSize());
 452     }
 453
 454     if ( sizeActual != sizeOrig )
 455         SetToolBitmapSize(sizeActual);
 456 }
 457
 458 bool wxToolBarBase::Realize()
 459 {
 460     // check if we have anything to do
 461     if ( m_tools.empty() )
 462         return false;
 463
 464     // make sure tool size is large enough for all bitmaps to fit in
 465     AdjustToolBitmapSize();
 466
 467     return true;
 468 }
 469
 470 wxToolBarBase::~wxToolBarBase()
 471 {
 472     WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
 473
 474     // notify the frame that it doesn't have a tool bar any longer to avoid
 475     // dangling pointers
 476     wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
 477     if ( frame && frame->GetToolBar() == this )
 478     {
 479         frame->SetToolBar(NULL);
 480     }
 481 }
 482
 483 // ----------------------------------------------------------------------------
 484 // wxToolBarBase tools state
 485 // ----------------------------------------------------------------------------
 486
 487 void wxToolBarBase::EnableTool(int id, bool enable)
 488 {
 489     wxToolBarToolBase *tool = FindById(id);
 490     if ( tool )
 491     {
 492         if ( tool->Enable(enable) )
 493         {
 494             DoEnableTool(tool, enable);
 495         }
 496     }
 497 }
 498
 499 void wxToolBarBase::ToggleTool(int id, bool toggle)
 500 {
 501     wxToolBarToolBase *tool = FindById(id);
 502     if ( tool && tool->CanBeToggled() )
 503     {
 504         if ( tool->Toggle(toggle) )
 505         {
 506             UnToggleRadioGroup(tool);
 507             DoToggleTool(tool, toggle);
 508         }
 509     }
 510 }
 511
 512 void wxToolBarBase::SetToggle(int id, bool toggle)
 513 {
 514     wxToolBarToolBase *tool = FindById(id);
 515     if ( tool )
 516     {
 517         if ( tool->SetToggle(toggle) )
 518         {
 519             DoSetToggle(tool, toggle);
 520         }
 521     }
 522 }
 523
 524 void wxToolBarBase::SetToolShortHelp(int id, const wxString& help)
 525 {
 526     wxToolBarToolBase *tool = FindById(id);
 527     if ( tool )
 528     {
 529         (void)tool->SetShortHelp(help);
 530     }
 531 }
 532
 533 void wxToolBarBase::SetToolLongHelp(int id, const wxString& help)
 534 {
 535     wxToolBarToolBase *tool = FindById(id);
 536     if ( tool )
 537     {
 538         (void)tool->SetLongHelp(help);
 539     }
 540 }
 541
 542 wxObject *wxToolBarBase::GetToolClientData(int id) const
 543 {
 544     wxToolBarToolBase *tool = FindById(id);
 545
 546     return tool ? tool->GetClientData() : NULL;
 547 }
 548
 549 void wxToolBarBase::SetToolClientData(int id, wxObject *clientData)
 550 {
 551     wxToolBarToolBase *tool = FindById(id);
 552
 553     wxCHECK_RET( tool, wxT("no such tool in wxToolBar::SetToolClientData") );
 554
 555     tool->SetClientData(clientData);
 556 }
 557
 558 int wxToolBarBase::GetToolPos(int id) const
 559 {
 560     size_t pos = 0;
 561     wxToolBarToolsList::compatibility_iterator node;
 562
 563     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 564     {
 565         if ( node->GetData()->GetId() == id )
 566             return pos;
 567
 568         pos++;
 569     }
 570
 571     return wxNOT_FOUND;
 572 }
 573
 574 bool wxToolBarBase::GetToolState(int id) const
 575 {
 576     wxToolBarToolBase *tool = FindById(id);
 577     wxCHECK_MSG( tool, false, wxT("no such tool") );
 578
 579     return tool->IsToggled();
 580 }
 581
 582 bool wxToolBarBase::GetToolEnabled(int id) const
 583 {
 584     wxToolBarToolBase *tool = FindById(id);
 585     wxCHECK_MSG( tool, false, wxT("no such tool") );
 586
 587     return tool->IsEnabled();
 588 }
 589
 590 wxString wxToolBarBase::GetToolShortHelp(int id) const
 591 {
 592     wxToolBarToolBase *tool = FindById(id);
 593     wxCHECK_MSG( tool, wxEmptyString, wxT("no such tool") );
 594
 595     return tool->GetShortHelp();
 596 }
 597
 598 wxString wxToolBarBase::GetToolLongHelp(int id) const
 599 {
 600     wxToolBarToolBase *tool = FindById(id);
 601     wxCHECK_MSG( tool, wxEmptyString, wxT("no such tool") );
 602
 603     return tool->GetLongHelp();
 604 }
 605
 606 // ----------------------------------------------------------------------------
 607 // wxToolBarBase geometry
 608 // ----------------------------------------------------------------------------
 609
 610 void wxToolBarBase::SetMargins(int x, int y)
 611 {
 612     m_xMargin = x;
 613     m_yMargin = y;
 614 }
 615
 616 void wxToolBarBase::SetRows(int WXUNUSED(nRows))
 617 {
 618     // nothing
 619 }
 620
 621 bool wxToolBarBase::IsVertical() const
 622 {
 623     return HasFlag(wxTB_LEFT | wxTB_RIGHT);
 624 }
 625
 626
 627 // ----------------------------------------------------------------------------
 628 // event processing
 629 // ----------------------------------------------------------------------------
 630
 631 // Only allow toggle if returns true
 632 bool wxToolBarBase::OnLeftClick(int id, bool toggleDown)
 633 {
 634     wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, id);
 635     event.SetEventObject(this);
 636
 637     // we use SetInt() to make wxCommandEvent::IsChecked() return toggleDown
 638     event.SetInt((int)toggleDown);
 639
 640     // and SetExtraLong() for backwards compatibility
 641     event.SetExtraLong((long)toggleDown);
 642
 643     // Send events to this toolbar instead (and thence up the window hierarchy)
 644     HandleWindowEvent(event);
 645
 646     return true;
 647 }
 648
 649 // Call when right button down.
 650 void wxToolBarBase::OnRightClick(int id,
 651                                  long WXUNUSED(x),
 652                                  long WXUNUSED(y))
 653 {
 654     wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id);
 655     event.SetEventObject(this);
 656     event.SetInt(id);
 657
 658     GetEventHandler()->ProcessEvent(event);
 659 }
 660
 661 // Called when the mouse cursor enters a tool bitmap (no button pressed).
 662 // Argument is wxID_ANY if mouse is exiting the toolbar.
 663 // Note that for this event, the id of the window is used,
 664 // and the integer parameter of wxCommandEvent is used to retrieve
 665 // the tool id.
 666 void wxToolBarBase::OnMouseEnter(int id)
 667 {
 668     wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
 669     event.SetEventObject(this);
 670     event.SetInt(id);
 671
 672     wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
 673     if ( frame )
 674     {
 675         wxString help;
 676         if ( id != wxID_ANY )
 677         {
 678            const wxToolBarToolBase * const tool = FindById(id);
 679            if ( tool )
 680                help = tool->GetLongHelp();
 681         }
 682
 683         // call DoGiveHelp() even if help string is empty to avoid showing the
 684         // help for the previously selected tool when another one is selected
 685         frame->DoGiveHelp(help, id != wxID_ANY);
 686     }
 687
 688     (void)GetEventHandler()->ProcessEvent(event);
 689 }
 690
 691 // ----------------------------------------------------------------------------
 692 // UI updates
 693 // ----------------------------------------------------------------------------
 694
 695 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
 696 void wxToolBarBase::UpdateWindowUI(long flags)
 697 {
 698     wxWindowBase::UpdateWindowUI(flags);
 699
 700     // don't waste time updating state of tools in a hidden toolbar
 701     if ( !IsShown() )
 702         return;
 703
 704     // There is no sense in updating the toolbar UI
 705     // if the parent window is about to get destroyed
 706     wxWindow *tlw = wxGetTopLevelParent( this );
 707     if (tlw && wxPendingDelete.Member( tlw ))
 708         return;
 709
 710     wxEvtHandler* evtHandler = GetEventHandler() ;
 711
 712     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 713           node;
 714           node = node->GetNext() )
 715     {
 716         wxToolBarToolBase * const tool = node->GetData();
 717         if ( tool->IsSeparator() )
 718             continue;
 719
 720         int id = tool->GetId();
 721
 722         wxUpdateUIEvent event(id);
 723         event.SetEventObject(this);
 724
 725         if ( evtHandler->ProcessEvent(event) )
 726         {
 727             if ( event.GetSetEnabled() )
 728                 EnableTool(id, event.GetEnabled());
 729             if ( event.GetSetChecked() )
 730                 ToggleTool(id, event.GetChecked());
 731 #if 0
 732             if ( event.GetSetText() )
 733                 // Set tooltip?
 734 #endif // 0
 735         }
 736     }
 737 }
 738
 739 #if wxUSE_MENUS
 740 bool wxToolBarBase::SetDropdownMenu(int toolid, wxMenu* menu)
 741 {
 742     wxToolBarToolBase * const tool = FindById(toolid);
 743     wxCHECK_MSG( tool, false, wxT("invalid tool id") );
 744
 745     wxCHECK_MSG( tool->GetKind() == wxITEM_DROPDOWN, false,
 746                     wxT("menu can be only associated with drop down tools") );
 747
 748     tool->SetDropdownMenu(menu);
 749
 750     return true;
 751 }
 752 #endif
 753
 754 #if WXWIN_COMPATIBILITY_2_8
 755
 756 bool wxCreateGreyedImage(const wxImage& in, wxImage& out)
 757 {
 758 #if wxUSE_IMAGE
 759     out = in.ConvertToGreyscale();
 760     if ( out.Ok() )
 761         return true;
 762 #endif // wxUSE_IMAGE
 763     return false;
 764 }
 765
 766 #endif // WXWIN_COMPATIBILITY_2_8
 767
 768 #endif // wxUSE_TOOLBAR