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