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         tool->Toggle(false);
 389
 390         nodeNext = nodeNext->GetNext();
 391     }
 392
 393     wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
 394     while ( nodePrev )
 395     {
 396         wxToolBarToolBase *tool = nodePrev->GetData();
 397
 398         if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
 399             break;
 400
 401         tool->Toggle(false);
 402
 403         nodePrev = nodePrev->GetPrevious();
 404     }
 405 }
 406
 407 void wxToolBarBase::ClearTools()
 408 {
 409     WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
 410 }
 411
 412 bool wxToolBarBase::Realize()
 413 {
 414     return true;
 415 }
 416
 417 wxToolBarBase::~wxToolBarBase()
 418 {
 419     WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
 420 }
 421
 422 // ----------------------------------------------------------------------------
 423 // wxToolBarBase tools state
 424 // ----------------------------------------------------------------------------
 425
 426 void wxToolBarBase::EnableTool(int id, bool enable)
 427 {
 428     wxToolBarToolBase *tool = FindById(id);
 429     if ( tool )
 430     {
 431         if ( tool->Enable(enable) )
 432         {
 433             DoEnableTool(tool, enable);
 434         }
 435     }
 436 }
 437
 438 void wxToolBarBase::ToggleTool(int id, bool toggle)
 439 {
 440     wxToolBarToolBase *tool = FindById(id);
 441     if ( tool && tool->CanBeToggled() )
 442     {
 443         if ( tool->Toggle(toggle) )
 444         {
 445             UnToggleRadioGroup(tool);
 446             DoToggleTool(tool, toggle);
 447         }
 448     }
 449 }
 450
 451 void wxToolBarBase::SetToggle(int id, bool toggle)
 452 {
 453     wxToolBarToolBase *tool = FindById(id);
 454     if ( tool )
 455     {
 456         if ( tool->SetToggle(toggle) )
 457         {
 458             DoSetToggle(tool, toggle);
 459         }
 460     }
 461 }
 462
 463 void wxToolBarBase::SetToolShortHelp(int id, const wxString& help)
 464 {
 465     wxToolBarToolBase *tool = FindById(id);
 466     if ( tool )
 467     {
 468         (void)tool->SetShortHelp(help);
 469     }
 470 }
 471
 472 void wxToolBarBase::SetToolLongHelp(int id, const wxString& help)
 473 {
 474     wxToolBarToolBase *tool = FindById(id);
 475     if ( tool )
 476     {
 477         (void)tool->SetLongHelp(help);
 478     }
 479 }
 480
 481 wxObject *wxToolBarBase::GetToolClientData(int id) const
 482 {
 483     wxToolBarToolBase *tool = FindById(id);
 484
 485     return tool ? tool->GetClientData() : (wxObject *)NULL;
 486 }
 487
 488 void wxToolBarBase::SetToolClientData(int id, wxObject *clientData)
 489 {
 490     wxToolBarToolBase *tool = FindById(id);
 491
 492     wxCHECK_RET( tool, _T("no such tool in wxToolBar::SetToolClientData") );
 493
 494     tool->SetClientData(clientData);
 495 }
 496
 497 int wxToolBarBase::GetToolPos(int id) const
 498 {
 499     size_t pos = 0;
 500     wxToolBarToolsList::compatibility_iterator node;
 501
 502     for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
 503     {
 504         if ( node->GetData()->GetId() == id )
 505             return pos;
 506
 507         pos++;
 508     }
 509
 510     return wxNOT_FOUND;
 511 }
 512
 513 bool wxToolBarBase::GetToolState(int id) const
 514 {
 515     wxToolBarToolBase *tool = FindById(id);
 516     wxCHECK_MSG( tool, false, _T("no such tool") );
 517
 518     return tool->IsToggled();
 519 }
 520
 521 bool wxToolBarBase::GetToolEnabled(int id) const
 522 {
 523     wxToolBarToolBase *tool = FindById(id);
 524     wxCHECK_MSG( tool, false, _T("no such tool") );
 525
 526     return tool->IsEnabled();
 527 }
 528
 529 wxString wxToolBarBase::GetToolShortHelp(int id) const
 530 {
 531     wxToolBarToolBase *tool = FindById(id);
 532     wxCHECK_MSG( tool, _T(""), _T("no such tool") );
 533
 534     return tool->GetShortHelp();
 535 }
 536
 537 wxString wxToolBarBase::GetToolLongHelp(int id) const
 538 {
 539     wxToolBarToolBase *tool = FindById(id);
 540     wxCHECK_MSG( tool, _T(""), _T("no such tool") );
 541
 542     return tool->GetLongHelp();
 543 }
 544
 545 // ----------------------------------------------------------------------------
 546 // wxToolBarBase geometry
 547 // ----------------------------------------------------------------------------
 548
 549 void wxToolBarBase::SetMargins(int x, int y)
 550 {
 551     m_xMargin = x;
 552     m_yMargin = y;
 553 }
 554
 555 void wxToolBarBase::SetRows(int WXUNUSED(nRows))
 556 {
 557     // nothing
 558 }
 559
 560 // ----------------------------------------------------------------------------
 561 // event processing
 562 // ----------------------------------------------------------------------------
 563
 564 // Only allow toggle if returns true
 565 bool wxToolBarBase::OnLeftClick(int id, bool toggleDown)
 566 {
 567     wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, id);
 568     event.SetEventObject(this);
 569
 570     // we use SetInt() to make wxCommandEvent::IsChecked() return toggleDown
 571     event.SetInt((int)toggleDown);
 572
 573     // and SetExtraLong() for backwards compatibility
 574     event.SetExtraLong((long)toggleDown);
 575
 576     // Send events to this toolbar instead (and thence up the window hierarchy)
 577     GetEventHandler()->ProcessEvent(event);
 578
 579     return true;
 580 }
 581
 582 // Call when right button down.
 583 void wxToolBarBase::OnRightClick(int id,
 584                                  long WXUNUSED(x),
 585                                  long WXUNUSED(y))
 586 {
 587     wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id);
 588     event.SetEventObject(this);
 589     event.SetInt(id);
 590
 591     GetEventHandler()->ProcessEvent(event);
 592 }
 593
 594 // Called when the mouse cursor enters a tool bitmap (no button pressed).
 595 // Argument is wxID_ANY if mouse is exiting the toolbar.
 596 // Note that for this event, the id of the window is used,
 597 // and the integer parameter of wxCommandEvent is used to retrieve
 598 // the tool id.
 599 void wxToolBarBase::OnMouseEnter(int id)
 600 {
 601     wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
 602     event.SetEventObject(this);
 603     event.SetInt(id);
 604
 605     wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
 606     if( frame )
 607     {
 608         wxToolBarToolBase* tool = id == wxID_ANY ? (wxToolBarToolBase*)0 : FindById(id);
 609         wxString help = tool ? tool->GetLongHelp() : wxString();
 610         frame->DoGiveHelp( help, id != wxID_ANY );
 611     }
 612
 613     (void)GetEventHandler()->ProcessEvent(event);
 614 }
 615
 616 // ----------------------------------------------------------------------------
 617 // UI updates
 618 // ----------------------------------------------------------------------------
 619
 620 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
 621 void wxToolBarBase::UpdateWindowUI(long flags)
 622 {
 623     wxWindowBase::UpdateWindowUI(flags);
 624
 625     // There is no sense in updating the toolbar UI
 626     // if the parent window is about to get destroyed
 627     wxWindow *tlw = wxGetTopLevelParent( this );
 628     if (tlw && wxPendingDelete.Member( tlw ))
 629         return;
 630
 631     wxEvtHandler* evtHandler = GetEventHandler() ;
 632
 633     for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
 634           node;
 635           node = node->GetNext() )
 636     {
 637         int id = node->GetData()->GetId();
 638
 639         wxUpdateUIEvent event(id);
 640         event.SetEventObject(this);
 641
 642         if ( evtHandler->ProcessEvent(event) )
 643         {
 644             if ( event.GetSetEnabled() )
 645                 EnableTool(id, event.GetEnabled());
 646             if ( event.GetSetChecked() )
 647                 ToggleTool(id, event.GetChecked());
 648 #if 0
 649             if ( event.GetSetText() )
 650                 // Set tooltip?
 651 #endif // 0
 652         }
 653     }
 654 }
 655
 656 // Helper function, used by wxCreateGreyedImage
 657
 658 static void wxGreyOutImage( const wxImage& src,
 659                             wxImage& dest,
 660                             const wxColour& darkCol,
 661                             const wxColour& lightCol,
 662                             const wxColour& bgCol )
 663 {
 664     // Second attempt, just making things monochrome
 665     int width = src.GetWidth();
 666     int height = src.GetHeight();
 667
 668     int redCur, greenCur, blueCur;
 669     for ( int x = 0; x < width; x++ )
 670     {
 671         for ( int y = 1; y < height; y++ )
 672         {
 673             redCur = src.GetRed(x, y);
 674             greenCur = src.GetGreen(x, y);
 675             blueCur = src.GetBlue(x, y);
 676
 677             // Change light things to the background colour
 678             if ( redCur >= (lightCol.Red() - 50) && greenCur >= (lightCol.Green() - 50) && blueCur >= (lightCol.Blue() - 50) )
 679             {
 680                 dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
 681             }
 682             else if ( redCur == bgCol.Red() && greenCur == bgCol.Green() && blueCur == bgCol.Blue() )
 683             {
 684                 // Leave the background colour as-is
 685                 // dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
 686             }
 687             else // if ( redCur <= darkCol.Red() && greenCur <= darkCol.Green() && blueCur <= darkCol.Blue() )
 688             {
 689                 // Change dark things to really dark
 690                 dest.SetRGB(x,y, darkCol.Red(), darkCol.Green(), darkCol.Blue());
 691             }
 692         }
 693     }
 694 }
 695
 696 /*
 697  * Make a greyed-out image suitable for disabled buttons.
 698  * This code is adapted from wxNewBitmapButton in FL.
 699  */
 700
 701 bool wxCreateGreyedImage(const wxImage& in, wxImage& out)
 702 {
 703     out = in.Copy();
 704
 705     // assuming the pixels along the edges are of the background color
 706     wxColour bgCol(in.GetRed(0, 0), in.GetGreen(0, 0), in.GetBlue(0, 0));
 707
 708     wxColour darkCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW) ;
 709     wxColour lightCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT) ;
 710
 711     wxGreyOutImage(in, out, darkCol, lightCol, bgCol);
 712
 713     return true;
 714 }
 715
 716 #endif // wxUSE_TOOLBAR