src/common/tbarbase.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        common/tbarbase.cpp
   3 // Purpose:     wxToolBarBase implementation
   4 // Author:      Julian Smart
   5 // Modified by: VZ at 11.12.99 (wxScrollableToolBar splitted 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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "tbarbase.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_TOOLBAR
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/control.h"
  35 #endif
  36
  37 #include "wx/frame.h"
  38 #include "wx/image.h"
  39 #include "wx/settings.h"
  40
  41 #include "wx/toolbar.h"
  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 bool wxToolBarToolBase::Enable(bool enable)
  65 {
  66     if ( m_enabled == enable )
  67         return false;
  68
  69     m_enabled = enable;
  70
  71     return true;
  72 }
  73
  74 bool wxToolBarToolBase::Toggle(bool toggle)
  75 {
  76     wxASSERT_MSG( CanBeToggled(), _T("can't toggle this tool") );
  77
  78     if ( m_toggled == toggle )
  79         return false;
  80
  81     m_toggled = toggle;
  82
  83     return true;
  84 }
  85
  86 bool wxToolBarToolBase::SetToggle(bool toggle)
  87 {
  88     wxItemKind kind = toggle ? wxITEM_CHECK : wxITEM_NORMAL;
  89     if ( m_kind == kind )
  90         return false;
  91
  92     m_kind = kind;
  93
  94     return true;
  95 }
  96
  97 bool wxToolBarToolBase::SetShortHelp(const wxString& help)
  98 {
  99     if ( m_shortHelpString == help )
 100         return false;
 101
 102     m_shortHelpString = help;
 103
 104     return true;
 105 }
 106
 107 bool wxToolBarToolBase::SetLongHelp(const wxString& help)
 108 {
 109     if ( m_longHelpString == help )
 110         return false;
 111
 112     m_longHelpString = help;
 113
 114     return true;
 115 }
 116
 117 wxToolBarToolBase::~wxToolBarToolBase()
 118 {
 119 }
 120
 121 // ----------------------------------------------------------------------------
 122 // wxToolBarBase adding/deleting items
 123 // ----------------------------------------------------------------------------
 124
 125 wxToolBarBase::wxToolBarBase()
 126 {
 127     // the list owns the pointers
 128     m_xMargin = m_yMargin = 0;
 129
 130     m_maxRows = m_maxCols = 0;
 131 }
 132
 133 wxToolBarToolBase *wxToolBarBase::DoAddTool(int id,
 134                                             const wxString& label,
 135                                             const wxBitmap& bitmap,
 136                                             const wxBitmap& bmpDisabled,
 137                                             wxItemKind kind,
 138                                             const wxString& shortHelp,
 139                                             const wxString& longHelp,
 140                                             wxObject *clientData,
 141                                             wxCoord WXUNUSED(xPos),
 142                                             wxCoord WXUNUSED(yPos))
 143 {
 144     InvalidateBestSize();
 145     return InsertTool(GetToolsCount(), id, label, bitmap, bmpDisabled,
 146                       kind, shortHelp, longHelp, clientData);
 147 }
 148
 149 wxToolBarToolBase *wxToolBarBase::InsertTool(size_t pos,
 150                                              int id,
 151                                              const wxString& label,
 152                                              const wxBitmap& bitmap,
 153                                              const wxBitmap& bmpDisabled,
 154                                              wxItemKind kind,
 155                                              const wxString& shortHelp,
 156                                              const wxString& longHelp,
 157                                              wxObject *clientData)
 158 {
 159     wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
 160                  _T("invalid position in wxToolBar::InsertTool()") );
 161
 162     wxToolBarToolBase *tool = CreateTool(id, label, bitmap, bmpDisabled, kind,
 163                                          clientData, shortHelp, longHelp);
 164
 165     if ( !InsertTool(pos, tool) )
 166     {
 167         delete tool;
 168
 169         return NULL;
 170     }
 171
 172     return tool;
 173 }
 174
 175 wxToolBarToolBase *wxToolBarBase::AddTool(wxToolBarToolBase *tool)
 176 {
 177     return InsertTool(GetToolsCount(), tool);
 178 }
 179
 180 wxToolBarToolBase *
 181 wxToolBarBase::InsertTool(size_t pos, wxToolBarToolBase *tool)
 182 {
 183     wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
 184                  _T("invalid position in wxToolBar::InsertTool()") );
 185
 186     if ( !tool || !DoInsertTool(pos, tool) )
 187     {
 188         return NULL;
 189     }
 190
 191     m_tools.Insert(pos, tool);
 192
 193     return tool;
 194 }
 195
 196 wxToolBarToolBase *wxToolBarBase::AddControl(wxControl *control)
 197 {
 198     return InsertControl(GetToolsCount(), control);
 199 }
 200
 201 wxToolBarToolBase *wxToolBarBase::InsertControl(size_t pos, wxControl *control)
 202 {
 203     wxCHECK_MSG( control, (wxToolBarToolBase *)NULL,
 204                  _T("toolbar: can't insert NULL control") );
 205
 206     wxCHECK_MSG( control->GetParent() == this, (wxToolBarToolBase *)NULL,
 207                  _T("control must have toolbar as parent") );
 208
 209     wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
 210                  _T("invalid position in wxToolBar::InsertControl()") );
 211
 212     wxToolBarToolBase *tool = CreateTool(control);
 213
 214     if ( !InsertTool(pos, tool) )
 215     {
 216         delete tool;
 217
 218         return NULL;
 219     }
 220
 221     return tool;
 222 }
 223
 224 wxControl *wxToolBarBase::FindControl( int id )
 225 {
 226     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 227           node;
 228           node = node->GetNext() )
 229     {
 230         const wxToolBarToolBase * const tool = node->GetData();
 231         if ( tool->IsControl() )
 232         {
 233             wxControl * const control = tool->GetControl();
 234
 235             if ( !control )
 236             {
 237                 wxFAIL_MSG( _T("NULL control in toolbar?") );
 238             }
 239             else if ( control->GetId() == id )
 240             {
 241                 // found
 242                 return control;
 243             }
 244         }
 245     }
 246
 247    return NULL;
 248 }
 249
 250 wxToolBarToolBase *wxToolBarBase::AddSeparator()
 251 {
 252     return InsertSeparator(GetToolsCount());
 253 }
 254
 255 wxToolBarToolBase *wxToolBarBase::InsertSeparator(size_t pos)
 256 {
 257     wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
 258                  _T("invalid position in wxToolBar::InsertSeparator()") );
 259
 260     wxToolBarToolBase *tool = CreateTool(wxID_SEPARATOR,
 261                                          wxEmptyString,
 262                                          wxNullBitmap, wxNullBitmap,
 263                                          wxITEM_SEPARATOR, (wxObject *)NULL,
 264                                          wxEmptyString, wxEmptyString);
 265
 266     if ( !tool || !DoInsertTool(pos, tool) )
 267     {
 268         delete tool;
 269
 270         return NULL;
 271     }
 272
 273     m_tools.Insert(pos, tool);
 274
 275     return tool;
 276 }
 277
 278 wxToolBarToolBase *wxToolBarBase::RemoveTool(int id)
 279 {
 280     size_t pos = 0;
 281     wxToolBarToolsList::compatibility_iterator node;
 282     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 283     {
 284         if ( node->GetData()->GetId() == id )
 285             break;
 286
 287         pos++;
 288     }
 289
 290     if ( !node )
 291     {
 292         // don't give any error messages - sometimes we might call RemoveTool()
 293         // without knowing whether the tool is or not in the toolbar
 294         return (wxToolBarToolBase *)NULL;
 295     }
 296
 297     wxToolBarToolBase *tool = node->GetData();
 298     if ( !DoDeleteTool(pos, tool) )
 299     {
 300         return (wxToolBarToolBase *)NULL;
 301     }
 302
 303     m_tools.Erase(node);
 304
 305     return tool;
 306 }
 307
 308 bool wxToolBarBase::DeleteToolByPos(size_t pos)
 309 {
 310     wxCHECK_MSG( pos < GetToolsCount(), false,
 311                  _T("invalid position in wxToolBar::DeleteToolByPos()") );
 312
 313     wxToolBarToolsList::compatibility_iterator node = m_tools.Item(pos);
 314
 315     if ( !DoDeleteTool(pos, node->GetData()) )
 316     {
 317         return false;
 318     }
 319
 320     delete node->GetData();
 321     m_tools.Erase(node);
 322
 323     return true;
 324 }
 325
 326 bool wxToolBarBase::DeleteTool(int id)
 327 {
 328     size_t pos = 0;
 329     wxToolBarToolsList::compatibility_iterator node;
 330     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 331     {
 332         if ( node->GetData()->GetId() == id )
 333             break;
 334
 335         pos++;
 336     }
 337
 338     if ( !node || !DoDeleteTool(pos, node->GetData()) )
 339     {
 340         return false;
 341     }
 342
 343     delete node->GetData();
 344     m_tools.Erase(node);
 345
 346     return true;
 347 }
 348
 349 wxToolBarToolBase *wxToolBarBase::FindById(int id) const
 350 {
 351     wxToolBarToolBase *tool = (wxToolBarToolBase *)NULL;
 352
 353     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 354           node;
 355           node = node->GetNext() )
 356     {
 357         tool = node->GetData();
 358         if ( tool->GetId() == id )
 359         {
 360             // found
 361             break;
 362         }
 363
 364         tool = NULL;
 365     }
 366
 367     return tool;
 368 }
 369
 370 void wxToolBarBase::UnToggleRadioGroup(wxToolBarToolBase *tool)
 371 {
 372     wxCHECK_RET( tool, _T("NULL tool in wxToolBarTool::UnToggleRadioGroup") );
 373
 374     if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
 375         return;
 376
 377     wxToolBarToolsList::compatibility_iterator node = m_tools.Find(tool);
 378     wxCHECK_RET( node, _T("invalid tool in wxToolBarTool::UnToggleRadioGroup") );
 379
 380     wxToolBarToolsList::compatibility_iterator nodeNext = node->GetNext();
 381     while ( nodeNext )
 382     {
 383         wxToolBarToolBase *tool = nodeNext->GetData();
 384
 385         if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
 386             break;
 387
 388         if ( tool->Toggle(false) )
 389         {
 390             DoToggleTool(tool, false);
 391         }
 392
 393         nodeNext = nodeNext->GetNext();
 394     }
 395
 396     wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
 397     while ( nodePrev )
 398     {
 399         wxToolBarToolBase *tool = nodePrev->GetData();
 400
 401         if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
 402             break;
 403
 404         if ( tool->Toggle(false) )
 405         {
 406             DoToggleTool(tool, false);
 407         }
 408
 409         nodePrev = nodePrev->GetPrevious();
 410     }
 411 }
 412
 413 void wxToolBarBase::ClearTools()
 414 {
 415     WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
 416 }
 417
 418 bool wxToolBarBase::Realize()
 419 {
 420     return true;
 421 }
 422
 423 wxToolBarBase::~wxToolBarBase()
 424 {
 425     WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
 426
 427     // notify the frame that it doesn't have a tool bar any longer to avoid
 428     // dangling pointers
 429     wxFrameBase *frame = wxDynamicCast(GetParent(), wxFrameBase);
 430     if ( frame && frame->GetToolBar() == this )
 431     {
 432         frame->SetToolBar(NULL);
 433     }
 434 }
 435
 436 // ----------------------------------------------------------------------------
 437 // wxToolBarBase tools state
 438 // ----------------------------------------------------------------------------
 439
 440 void wxToolBarBase::EnableTool(int id, bool enable)
 441 {
 442     wxToolBarToolBase *tool = FindById(id);
 443     if ( tool )
 444     {
 445         if ( tool->Enable(enable) )
 446         {
 447             DoEnableTool(tool, enable);
 448         }
 449     }
 450 }
 451
 452 void wxToolBarBase::ToggleTool(int id, bool toggle)
 453 {
 454     wxToolBarToolBase *tool = FindById(id);
 455     if ( tool && tool->CanBeToggled() )
 456     {
 457         if ( tool->Toggle(toggle) )
 458         {
 459             UnToggleRadioGroup(tool);
 460             DoToggleTool(tool, toggle);
 461         }
 462     }
 463 }
 464
 465 void wxToolBarBase::SetToggle(int id, bool toggle)
 466 {
 467     wxToolBarToolBase *tool = FindById(id);
 468     if ( tool )
 469     {
 470         if ( tool->SetToggle(toggle) )
 471         {
 472             DoSetToggle(tool, toggle);
 473         }
 474     }
 475 }
 476
 477 void wxToolBarBase::SetToolShortHelp(int id, const wxString& help)
 478 {
 479     wxToolBarToolBase *tool = FindById(id);
 480     if ( tool )
 481     {
 482         (void)tool->SetShortHelp(help);
 483     }
 484 }
 485
 486 void wxToolBarBase::SetToolLongHelp(int id, const wxString& help)
 487 {
 488     wxToolBarToolBase *tool = FindById(id);
 489     if ( tool )
 490     {
 491         (void)tool->SetLongHelp(help);
 492     }
 493 }
 494
 495 wxObject *wxToolBarBase::GetToolClientData(int id) const
 496 {
 497     wxToolBarToolBase *tool = FindById(id);
 498
 499     return tool ? tool->GetClientData() : (wxObject *)NULL;
 500 }
 501
 502 void wxToolBarBase::SetToolClientData(int id, wxObject *clientData)
 503 {
 504     wxToolBarToolBase *tool = FindById(id);
 505
 506     wxCHECK_RET( tool, _T("no such tool in wxToolBar::SetToolClientData") );
 507
 508     tool->SetClientData(clientData);
 509 }
 510
 511 int wxToolBarBase::GetToolPos(int id) const
 512 {
 513     size_t pos = 0;
 514     wxToolBarToolsList::compatibility_iterator node;
 515
 516     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 517     {
 518         if ( node->GetData()->GetId() == id )
 519             return pos;
 520
 521         pos++;
 522     }
 523
 524     return wxNOT_FOUND;
 525 }
 526
 527 bool wxToolBarBase::GetToolState(int id) const
 528 {
 529     wxToolBarToolBase *tool = FindById(id);
 530     wxCHECK_MSG( tool, false, _T("no such tool") );
 531
 532     return tool->IsToggled();
 533 }
 534
 535 bool wxToolBarBase::GetToolEnabled(int id) const
 536 {
 537     wxToolBarToolBase *tool = FindById(id);
 538     wxCHECK_MSG( tool, false, _T("no such tool") );
 539
 540     return tool->IsEnabled();
 541 }
 542
 543 wxString wxToolBarBase::GetToolShortHelp(int id) const
 544 {
 545     wxToolBarToolBase *tool = FindById(id);
 546     wxCHECK_MSG( tool, _T(""), _T("no such tool") );
 547
 548     return tool->GetShortHelp();
 549 }
 550
 551 wxString wxToolBarBase::GetToolLongHelp(int id) const
 552 {
 553     wxToolBarToolBase *tool = FindById(id);
 554     wxCHECK_MSG( tool, _T(""), _T("no such tool") );
 555
 556     return tool->GetLongHelp();
 557 }
 558
 559 // ----------------------------------------------------------------------------
 560 // wxToolBarBase geometry
 561 // ----------------------------------------------------------------------------
 562
 563 void wxToolBarBase::SetMargins(int x, int y)
 564 {
 565     m_xMargin = x;
 566     m_yMargin = y;
 567 }
 568
 569 void wxToolBarBase::SetRows(int WXUNUSED(nRows))
 570 {
 571     // nothing
 572 }
 573
 574 // ----------------------------------------------------------------------------
 575 // event processing
 576 // ----------------------------------------------------------------------------
 577
 578 // Only allow toggle if returns true
 579 bool wxToolBarBase::OnLeftClick(int id, bool toggleDown)
 580 {
 581     wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, id);
 582     event.SetEventObject(this);
 583
 584     // we use SetInt() to make wxCommandEvent::IsChecked() return toggleDown
 585     event.SetInt((int)toggleDown);
 586
 587     // and SetExtraLong() for backwards compatibility
 588     event.SetExtraLong((long)toggleDown);
 589
 590     // Send events to this toolbar instead (and thence up the window hierarchy)
 591     GetEventHandler()->ProcessEvent(event);
 592
 593     return true;
 594 }
 595
 596 // Call when right button down.
 597 void wxToolBarBase::OnRightClick(int id,
 598                                  long WXUNUSED(x),
 599                                  long WXUNUSED(y))
 600 {
 601     wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id);
 602     event.SetEventObject(this);
 603     event.SetInt(id);
 604
 605     GetEventHandler()->ProcessEvent(event);
 606 }
 607
 608 // Called when the mouse cursor enters a tool bitmap (no button pressed).
 609 // Argument is wxID_ANY if mouse is exiting the toolbar.
 610 // Note that for this event, the id of the window is used,
 611 // and the integer parameter of wxCommandEvent is used to retrieve
 612 // the tool id.
 613 void wxToolBarBase::OnMouseEnter(int id)
 614 {
 615     wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
 616     event.SetEventObject(this);
 617     event.SetInt(id);
 618
 619     wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
 620     if( frame )
 621     {
 622         wxString help;
 623         wxToolBarToolBase* tool = id == wxID_ANY ? (wxToolBarToolBase*)NULL : FindById(id);
 624         if(tool)
 625             help = tool->GetLongHelp();
 626         frame->DoGiveHelp( help, id != wxID_ANY );
 627     }
 628
 629     (void)GetEventHandler()->ProcessEvent(event);
 630 }
 631
 632 // ----------------------------------------------------------------------------
 633 // UI updates
 634 // ----------------------------------------------------------------------------
 635
 636 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
 637 void wxToolBarBase::UpdateWindowUI(long flags)
 638 {
 639     wxWindowBase::UpdateWindowUI(flags);
 640
 641     // There is no sense in updating the toolbar UI
 642     // if the parent window is about to get destroyed
 643     wxWindow *tlw = wxGetTopLevelParent( this );
 644     if (tlw && wxPendingDelete.Member( tlw ))
 645         return;
 646
 647     wxEvtHandler* evtHandler = GetEventHandler() ;
 648
 649     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 650           node;
 651           node = node->GetNext() )
 652     {
 653         int id = node->GetData()->GetId();
 654
 655         wxUpdateUIEvent event(id);
 656         event.SetEventObject(this);
 657
 658         if ( evtHandler->ProcessEvent(event) )
 659         {
 660             if ( event.GetSetEnabled() )
 661                 EnableTool(id, event.GetEnabled());
 662             if ( event.GetSetChecked() )
 663                 ToggleTool(id, event.GetChecked());
 664 #if 0
 665             if ( event.GetSetText() )
 666                 // Set tooltip?
 667 #endif // 0
 668         }
 669     }
 670 }
 671
 672 // Helper function, used by wxCreateGreyedImage
 673
 674 static void wxGreyOutImage( const wxImage& src,
 675                             wxImage& dest,
 676                             const wxColour& darkCol,
 677                             const wxColour& lightCol,
 678                             const wxColour& bgCol )
 679 {
 680     // Second attempt, just making things monochrome
 681     int width = src.GetWidth();
 682     int height = src.GetHeight();
 683
 684     int redCur, greenCur, blueCur;
 685     for ( int x = 0; x < width; x++ )
 686     {
 687         for ( int y = 1; y < height; y++ )
 688         {
 689             redCur = src.GetRed(x, y);
 690             greenCur = src.GetGreen(x, y);
 691             blueCur = src.GetBlue(x, y);
 692
 693             // Change light things to the background colour
 694             if ( redCur >= (lightCol.Red() - 50) && greenCur >= (lightCol.Green() - 50) && blueCur >= (lightCol.Blue() - 50) )
 695             {
 696                 dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
 697             }
 698             else if ( redCur == bgCol.Red() && greenCur == bgCol.Green() && blueCur == bgCol.Blue() )
 699             {
 700                 // Leave the background colour as-is
 701                 // dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
 702             }
 703             else // if ( redCur <= darkCol.Red() && greenCur <= darkCol.Green() && blueCur <= darkCol.Blue() )
 704             {
 705                 // Change dark things to really dark
 706                 dest.SetRGB(x,y, darkCol.Red(), darkCol.Green(), darkCol.Blue());
 707             }
 708         }
 709     }
 710 }
 711
 712 /*
 713  * Make a greyed-out image suitable for disabled buttons.
 714  * This code is adapted from wxNewBitmapButton in FL.
 715  */
 716
 717 bool wxCreateGreyedImage(const wxImage& in, wxImage& out)
 718 {
 719     out = in.Copy();
 720
 721     // assuming the pixels along the edges are of the background color
 722     wxColour bgCol(in.GetRed(0, 0), in.GetGreen(0, 0), in.GetBlue(0, 0));
 723
 724     wxColour darkCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW) ;
 725     wxColour lightCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT) ;
 726
 727     wxGreyOutImage(in, out, darkCol, lightCol, bgCol);
 728
 729     return true;
 730 }
 731
 732 #endif // wxUSE_TOOLBAR