juce/source/src/gui/components/layout/juce_TabbedButtonBar.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_TabbedComponent.h"
  31 #include "../menus/juce_PopupMenu.h"
  32 #include "../lookandfeel/juce_LookAndFeel.h"
  33
  34
  35 //==============================================================================
  36 TabBarButton::TabBarButton (const String& name, TabbedButtonBar& owner_)
  37     : Button (name),
  38       owner (owner_),
  39       overlapPixels (0)
  40 {
  41     shadow.setShadowProperties (2.2f, 0.7f, 0, 0);
  42     setComponentEffect (&shadow);
  43     setWantsKeyboardFocus (false);
  44 }
  45
  46 TabBarButton::~TabBarButton()
  47 {
  48 }
  49
  50 int TabBarButton::getIndex() const
  51 {
  52     return owner.indexOfTabButton (this);
  53 }
  54
  55 void TabBarButton::paintButton (Graphics& g,
  56                                 bool isMouseOverButton,
  57                                 bool isButtonDown)
  58 {
  59     const Rectangle<int> area (getActiveArea());
  60     g.setOrigin (area.getX(), area.getY());
  61
  62     getLookAndFeel()
  63         .drawTabButton (g, area.getWidth(), area.getHeight(),
  64                         owner.getTabBackgroundColour (getIndex()),
  65                         getIndex(), getButtonText(), *this,
  66                         owner.getOrientation(),
  67                         isMouseOverButton, isButtonDown,
  68                         getToggleState());
  69 }
  70
  71 void TabBarButton::clicked (const ModifierKeys& mods)
  72 {
  73     if (mods.isPopupMenu())
  74         owner.popupMenuClickOnTab (getIndex(), getButtonText());
  75     else
  76         owner.setCurrentTabIndex (getIndex());
  77 }
  78
  79 bool TabBarButton::hitTest (int mx, int my)
  80 {
  81     const Rectangle<int> area (getActiveArea());
  82
  83     if (owner.getOrientation() == TabbedButtonBar::TabsAtLeft
  84          || owner.getOrientation() == TabbedButtonBar::TabsAtRight)
  85     {
  86         if (isPositiveAndBelow (mx, getWidth())
  87              && my >= area.getY() + overlapPixels
  88              && my < area.getBottom() - overlapPixels)
  89             return true;
  90     }
  91     else
  92     {
  93         if (mx >= area.getX() + overlapPixels && mx < area.getRight() - overlapPixels
  94              && isPositiveAndBelow (my, getHeight()))
  95             return true;
  96     }
  97
  98     Path p;
  99     getLookAndFeel()
 100         .createTabButtonShape (p, area.getWidth(), area.getHeight(), getIndex(), getButtonText(), *this,
 101                                owner.getOrientation(), false, false, getToggleState());
 102
 103     return p.contains ((float) (mx - area.getX()),
 104                        (float) (my - area.getY()));
 105 }
 106
 107 int TabBarButton::getBestTabLength (const int depth)
 108 {
 109     return jlimit (depth * 2,
 110                    depth * 7,
 111                    getLookAndFeel().getTabButtonBestWidth (getIndex(), getButtonText(), depth, *this));
 112 }
 113
 114 const Rectangle<int> TabBarButton::getActiveArea()
 115 {
 116     Rectangle<int> r (getLocalBounds());
 117     const int spaceAroundImage = getLookAndFeel().getTabButtonSpaceAroundImage();
 118
 119     if (owner.getOrientation() != TabbedButtonBar::TabsAtLeft)      r.removeFromRight (spaceAroundImage);
 120     if (owner.getOrientation() != TabbedButtonBar::TabsAtRight)     r.removeFromLeft (spaceAroundImage);
 121     if (owner.getOrientation() != TabbedButtonBar::TabsAtBottom)    r.removeFromTop (spaceAroundImage);
 122     if (owner.getOrientation() != TabbedButtonBar::TabsAtTop)       r.removeFromBottom (spaceAroundImage);
 123
 124     return r;
 125 }
 126
 127
 128 //==============================================================================
 129 class TabbedButtonBar::BehindFrontTabComp  : public Component,
 130                                              public ButtonListener // (can't use Button::Listener due to idiotic VC2005 bug)
 131 {
 132 public:
 133     BehindFrontTabComp (TabbedButtonBar& owner_)
 134         : owner (owner_)
 135     {
 136         setInterceptsMouseClicks (false, false);
 137     }
 138
 139     void paint (Graphics& g)
 140     {
 141         getLookAndFeel().drawTabAreaBehindFrontButton (g, getWidth(), getHeight(),
 142                                                        owner, owner.getOrientation());
 143     }
 144
 145     void enablementChanged()
 146     {
 147         repaint();
 148     }
 149
 150     void buttonClicked (Button*)
 151     {
 152         owner.showExtraItemsMenu();
 153     }
 154
 155 private:
 156     TabbedButtonBar& owner;
 157
 158     JUCE_DECLARE_NON_COPYABLE (BehindFrontTabComp);
 159 };
 160
 161
 162 //==============================================================================
 163 TabbedButtonBar::TabbedButtonBar (const Orientation orientation_)
 164     : orientation (orientation_),
 165       minimumScale (0.7),
 166       currentTabIndex (-1)
 167 {
 168     setInterceptsMouseClicks (false, true);
 169     addAndMakeVisible (behindFrontTab = new BehindFrontTabComp (*this));
 170     setFocusContainer (true);
 171 }
 172
 173 TabbedButtonBar::~TabbedButtonBar()
 174 {
 175     tabs.clear();
 176     extraTabsButton = nullptr;
 177 }
 178
 179 //==============================================================================
 180 void TabbedButtonBar::setOrientation (const Orientation newOrientation)
 181 {
 182     orientation = newOrientation;
 183
 184     for (int i = getNumChildComponents(); --i >= 0;)
 185         getChildComponent (i)->resized();
 186
 187     resized();
 188 }
 189
 190 TabBarButton* TabbedButtonBar::createTabButton (const String& name, const int /*index*/)
 191 {
 192     return new TabBarButton (name, *this);
 193 }
 194
 195 void TabbedButtonBar::setMinimumTabScaleFactor (double newMinimumScale)
 196 {
 197     minimumScale = newMinimumScale;
 198     resized();
 199 }
 200
 201 //==============================================================================
 202 void TabbedButtonBar::clearTabs()
 203 {
 204     tabs.clear();
 205     extraTabsButton = nullptr;
 206     setCurrentTabIndex (-1);
 207 }
 208
 209 void TabbedButtonBar::addTab (const String& tabName,
 210                               const Colour& tabBackgroundColour,
 211                               int insertIndex)
 212 {
 213     jassert (tabName.isNotEmpty()); // you have to give them all a name..
 214
 215     if (tabName.isNotEmpty())
 216     {
 217         if (! isPositiveAndBelow (insertIndex, tabs.size()))
 218             insertIndex = tabs.size();
 219
 220         TabInfo* newTab = new TabInfo();
 221         newTab->name = tabName;
 222         newTab->colour = tabBackgroundColour;
 223         newTab->component = createTabButton (tabName, insertIndex);
 224
 225         jassert (newTab->component != nullptr);
 226
 227         tabs.insert (insertIndex, newTab);
 228         addAndMakeVisible (newTab->component, insertIndex);
 229
 230         resized();
 231
 232         if (currentTabIndex < 0)
 233             setCurrentTabIndex (0);
 234     }
 235 }
 236
 237 void TabbedButtonBar::setTabName (const int tabIndex, const String& newName)
 238 {
 239     TabInfo* const tab = tabs [tabIndex];
 240
 241     if (tab != nullptr && tab->name != newName)
 242     {
 243         tab->name = newName;
 244         tab->component->setButtonText (newName);
 245         resized();
 246     }
 247 }
 248
 249 void TabbedButtonBar::removeTab (const int tabIndex)
 250 {
 251     if (tabs [tabIndex] != nullptr)
 252     {
 253         const int oldTabIndex = currentTabIndex;
 254         if (currentTabIndex == tabIndex)
 255             currentTabIndex = -1;
 256
 257         tabs.remove (tabIndex);
 258         resized();
 259
 260         setCurrentTabIndex (jlimit (0, jmax (0, tabs.size() - 1), oldTabIndex));
 261     }
 262 }
 263
 264 void TabbedButtonBar::moveTab (const int currentIndex, const int newIndex)
 265 {
 266     tabs.move (currentIndex, newIndex);
 267     resized();
 268 }
 269
 270 int TabbedButtonBar::getNumTabs() const
 271 {
 272     return tabs.size();
 273 }
 274
 275 String TabbedButtonBar::getCurrentTabName() const
 276 {
 277     TabInfo* tab = tabs [currentTabIndex];
 278     return tab == nullptr ? String::empty : tab->name;
 279 }
 280
 281 StringArray TabbedButtonBar::getTabNames() const
 282 {
 283     StringArray names;
 284
 285     for (int i = 0; i < tabs.size(); ++i)
 286         names.add (tabs.getUnchecked(i)->name);
 287
 288     return names;
 289 }
 290
 291 void TabbedButtonBar::setCurrentTabIndex (int newIndex, const bool sendChangeMessage_)
 292 {
 293     if (currentTabIndex != newIndex)
 294     {
 295         if (! isPositiveAndBelow (newIndex, tabs.size()))
 296             newIndex = -1;
 297
 298         currentTabIndex = newIndex;
 299
 300         for (int i = 0; i < tabs.size(); ++i)
 301         {
 302             TabBarButton* tb = tabs.getUnchecked(i)->component;
 303             tb->setToggleState (i == newIndex, false);
 304         }
 305
 306         resized();
 307
 308         if (sendChangeMessage_)
 309             sendChangeMessage();
 310
 311         currentTabChanged (newIndex, getCurrentTabName());
 312     }
 313 }
 314
 315 TabBarButton* TabbedButtonBar::getTabButton (const int index) const
 316 {
 317     TabInfo* const tab = tabs[index];
 318     return tab == nullptr ? nullptr : static_cast <TabBarButton*> (tab->component);
 319 }
 320
 321 int TabbedButtonBar::indexOfTabButton (const TabBarButton* button) const
 322 {
 323     for (int i = tabs.size(); --i >= 0;)
 324         if (tabs.getUnchecked(i)->component == button)
 325             return i;
 326
 327     return -1;
 328 }
 329
 330 void TabbedButtonBar::lookAndFeelChanged()
 331 {
 332     extraTabsButton = nullptr;
 333     resized();
 334 }
 335
 336 void TabbedButtonBar::resized()
 337 {
 338     int depth = getWidth();
 339     int length = getHeight();
 340
 341     if (orientation == TabsAtTop || orientation == TabsAtBottom)
 342         std::swap (depth, length);
 343
 344     const int overlap = getLookAndFeel().getTabButtonOverlap (depth)
 345                             + getLookAndFeel().getTabButtonSpaceAroundImage() * 2;
 346
 347     int i, totalLength = overlap;
 348     int numVisibleButtons = tabs.size();
 349
 350     for (i = 0; i < tabs.size(); ++i)
 351     {
 352         TabBarButton* const tb = tabs.getUnchecked(i)->component;
 353
 354         totalLength += tb->getBestTabLength (depth) - overlap;
 355         tb->overlapPixels = overlap / 2;
 356     }
 357
 358     double scale = 1.0;
 359
 360     if (totalLength > length)
 361         scale = jmax (minimumScale, length / (double) totalLength);
 362
 363     const bool isTooBig = totalLength * scale > length;
 364     int tabsButtonPos = 0;
 365
 366     if (isTooBig)
 367     {
 368         if (extraTabsButton == nullptr)
 369         {
 370             addAndMakeVisible (extraTabsButton = getLookAndFeel().createTabBarExtrasButton());
 371             extraTabsButton->addListener (behindFrontTab);
 372             extraTabsButton->setAlwaysOnTop (true);
 373             extraTabsButton->setTriggeredOnMouseDown (true);
 374         }
 375
 376         const int buttonSize = jmin (proportionOfWidth (0.7f), proportionOfHeight (0.7f));
 377         extraTabsButton->setSize (buttonSize, buttonSize);
 378
 379         if (orientation == TabsAtTop || orientation == TabsAtBottom)
 380         {
 381             tabsButtonPos = getWidth() - buttonSize / 2 - 1;
 382             extraTabsButton->setCentrePosition (tabsButtonPos, getHeight() / 2);
 383         }
 384         else
 385         {
 386             tabsButtonPos = getHeight() - buttonSize / 2 - 1;
 387             extraTabsButton->setCentrePosition (getWidth() / 2, tabsButtonPos);
 388         }
 389
 390         totalLength = 0;
 391
 392         for (i = 0; i < tabs.size(); ++i)
 393         {
 394             TabBarButton* const tb = tabs.getUnchecked(i)->component;
 395
 396             const int newLength = totalLength + tb->getBestTabLength (depth);
 397
 398             if (i > 0 && newLength * minimumScale > tabsButtonPos)
 399             {
 400                 totalLength += overlap;
 401                 break;
 402             }
 403
 404             numVisibleButtons = i + 1;
 405             totalLength = newLength - overlap;
 406         }
 407
 408         scale = jmax (minimumScale, tabsButtonPos / (double) totalLength);
 409     }
 410     else
 411     {
 412         extraTabsButton = nullptr;
 413     }
 414
 415     int pos = 0;
 416
 417     TabBarButton* frontTab = nullptr;
 418
 419     for (i = 0; i < tabs.size(); ++i)
 420     {
 421         TabBarButton* const tb = getTabButton (i);
 422
 423         if (tb != nullptr)
 424         {
 425             const int bestLength = roundToInt (scale * tb->getBestTabLength (depth));
 426
 427             if (i < numVisibleButtons)
 428             {
 429                 if (orientation == TabsAtTop || orientation == TabsAtBottom)
 430                     tb->setBounds (pos, 0, bestLength, getHeight());
 431                 else
 432                     tb->setBounds (0, pos, getWidth(), bestLength);
 433
 434                 tb->toBack();
 435
 436                 if (i == currentTabIndex)
 437                     frontTab = tb;
 438
 439                 tb->setVisible (true);
 440             }
 441             else
 442             {
 443                 tb->setVisible (false);
 444             }
 445
 446             pos += bestLength - overlap;
 447         }
 448     }
 449
 450     behindFrontTab->setBounds (getLocalBounds());
 451
 452     if (frontTab != nullptr)
 453     {
 454         frontTab->toFront (false);
 455         behindFrontTab->toBehind (frontTab);
 456     }
 457 }
 458
 459 //==============================================================================
 460 const Colour TabbedButtonBar::getTabBackgroundColour (const int tabIndex)
 461 {
 462     TabInfo* const tab = tabs [tabIndex];
 463     return tab == nullptr ? Colours::white : tab->colour;
 464 }
 465
 466 void TabbedButtonBar::setTabBackgroundColour (const int tabIndex, const Colour& newColour)
 467 {
 468     TabInfo* const tab = tabs [tabIndex];
 469
 470     if (tab != nullptr && tab->colour != newColour)
 471     {
 472         tab->colour = newColour;
 473         repaint();
 474     }
 475 }
 476
 477 void TabbedButtonBar::extraItemsMenuCallback (int result, TabbedButtonBar* bar)
 478 {
 479     if (bar != nullptr && result > 0)
 480         bar->setCurrentTabIndex (result - 1);
 481 }
 482
 483 void TabbedButtonBar::showExtraItemsMenu()
 484 {
 485     PopupMenu m;
 486
 487     for (int i = 0; i < tabs.size(); ++i)
 488     {
 489         const TabInfo* const tab = tabs.getUnchecked(i);
 490
 491         if (! tab->component->isVisible())
 492             m.addItem (i + 1, tab->name, true, i == currentTabIndex);
 493     }
 494
 495     m.showMenuAsync (PopupMenu::Options().withTargetComponent (extraTabsButton),
 496                      ModalCallbackFunction::forComponent (extraItemsMenuCallback, this));
 497 }
 498
 499 //==============================================================================
 500 void TabbedButtonBar::currentTabChanged (const int, const String&)
 501 {
 502 }
 503
 504 void TabbedButtonBar::popupMenuClickOnTab (const int, const String&)
 505 {
 506 }
 507
 508 END_JUCE_NAMESPACE