juce/source/src/gui/components/menus/juce_PopupMenu.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_PopupMenu.h"
  31 #include "../windows/juce_ComponentPeer.h"
  32 #include "../lookandfeel/juce_LookAndFeel.h"
  33 #include "../juce_Desktop.h"
  34 #include "../../graphics/imaging/juce_Image.h"
  35 #include "../keyboard/juce_KeyPressMappingSet.h"
  36 #include "../../../events/juce_Timer.h"
  37 #include "../../../threads/juce_Process.h"
  38 #include "../../../core/juce_Time.h"
  39
  40
  41 //==============================================================================
  42 class PopupMenu::Item
  43 {
  44 public:
  45     //==============================================================================
  46     Item()
  47       : itemId (0), active (true), isSeparator (true), isTicked (false),
  48         usesColour (false), commandManager (nullptr)
  49     {
  50     }
  51
  52     Item (const int itemId_,
  53           const String& text_,
  54           const bool active_,
  55           const bool isTicked_,
  56           const Image& im,
  57           const Colour& textColour_,
  58           const bool usesColour_,
  59           CustomComponent* const customComp_,
  60           const PopupMenu* const subMenu_,
  61           ApplicationCommandManager* const commandManager_)
  62       : itemId (itemId_), text (text_), textColour (textColour_),
  63         active (active_), isSeparator (false), isTicked (isTicked_),
  64         usesColour (usesColour_), image (im), customComp (customComp_),
  65         commandManager (commandManager_)
  66     {
  67         if (subMenu_ != nullptr)
  68             subMenu = new PopupMenu (*subMenu_);
  69
  70         if (commandManager_ != nullptr && itemId_ != 0)
  71         {
  72             String shortcutKey;
  73
  74             Array <KeyPress> keyPresses (commandManager_->getKeyMappings()
  75                                             ->getKeyPressesAssignedToCommand (itemId_));
  76
  77             for (int i = 0; i < keyPresses.size(); ++i)
  78             {
  79                 const String key (keyPresses.getReference(i).getTextDescriptionWithIcons());
  80
  81                 if (shortcutKey.isNotEmpty())
  82                     shortcutKey << ", ";
  83
  84                 if (key.length() == 1 && key[0] < 128)
  85                     shortcutKey << "shortcut: '" << key << '\'';
  86                 else
  87                     shortcutKey << key;
  88             }
  89
  90             shortcutKey = shortcutKey.trim();
  91
  92             if (shortcutKey.isNotEmpty())
  93                 text << "<end>" << shortcutKey;
  94         }
  95     }
  96
  97     Item (const Item& other)
  98         : itemId (other.itemId),
  99           text (other.text),
 100           textColour (other.textColour),
 101           active (other.active),
 102           isSeparator (other.isSeparator),
 103           isTicked (other.isTicked),
 104           usesColour (other.usesColour),
 105           image (other.image),
 106           customComp (other.customComp),
 107           commandManager (other.commandManager)
 108     {
 109         if (other.subMenu != nullptr)
 110             subMenu = new PopupMenu (*(other.subMenu));
 111     }
 112
 113     bool canBeTriggered() const noexcept    { return active && ! (isSeparator || (subMenu != nullptr)); }
 114     bool hasActiveSubMenu() const noexcept  { return active && (subMenu != nullptr); }
 115
 116     //==============================================================================
 117     const int itemId;
 118     String text;
 119     const Colour textColour;
 120     const bool active, isSeparator, isTicked, usesColour;
 121     Image image;
 122     ReferenceCountedObjectPtr <CustomComponent> customComp;
 123     ScopedPointer <PopupMenu> subMenu;
 124     ApplicationCommandManager* const commandManager;
 125
 126 private:
 127     Item& operator= (const Item&);
 128
 129     JUCE_LEAK_DETECTOR (Item);
 130 };
 131
 132
 133 //==============================================================================
 134 class PopupMenu::ItemComponent  : public Component
 135 {
 136 public:
 137     //==============================================================================
 138     ItemComponent (const PopupMenu::Item& itemInfo_, int standardItemHeight, Component* const parent)
 139       : itemInfo (itemInfo_),
 140         isHighlighted (false)
 141     {
 142         if (itemInfo.customComp != nullptr)
 143             addAndMakeVisible (itemInfo.customComp);
 144
 145         parent->addAndMakeVisible (this);
 146
 147         int itemW = 80;
 148         int itemH = 16;
 149         getIdealSize (itemW, itemH, standardItemHeight);
 150         setSize (itemW, jlimit (2, 600, itemH));
 151
 152         addMouseListener (parent, false);
 153     }
 154
 155     ~ItemComponent()
 156     {
 157         if (itemInfo.customComp != nullptr)
 158             removeChildComponent (itemInfo.customComp);
 159     }
 160
 161     void getIdealSize (int& idealWidth, int& idealHeight, const int standardItemHeight)
 162     {
 163         if (itemInfo.customComp != nullptr)
 164             itemInfo.customComp->getIdealSize (idealWidth, idealHeight);
 165         else
 166             getLookAndFeel().getIdealPopupMenuItemSize (itemInfo.text,
 167                                                         itemInfo.isSeparator,
 168                                                         standardItemHeight,
 169                                                         idealWidth, idealHeight);
 170     }
 171
 172     void paint (Graphics& g)
 173     {
 174         if (itemInfo.customComp == nullptr)
 175         {
 176             String mainText (itemInfo.text);
 177             String endText;
 178             const int endIndex = mainText.indexOf ("<end>");
 179
 180             if (endIndex >= 0)
 181             {
 182                 endText = mainText.substring (endIndex + 5).trim();
 183                 mainText = mainText.substring (0, endIndex);
 184             }
 185
 186             getLookAndFeel()
 187                 .drawPopupMenuItem (g, getWidth(), getHeight(),
 188                                     itemInfo.isSeparator,
 189                                     itemInfo.active,
 190                                     isHighlighted,
 191                                     itemInfo.isTicked,
 192                                     itemInfo.subMenu != 0,
 193                                     mainText, endText,
 194                                     itemInfo.image.isValid() ? &itemInfo.image : 0,
 195                                     itemInfo.usesColour ? &(itemInfo.textColour) : 0);
 196         }
 197     }
 198
 199     void resized()
 200     {
 201         if (getNumChildComponents() > 0)
 202             getChildComponent(0)->setBounds (2, 0, getWidth() - 4, getHeight());
 203     }
 204
 205     void setHighlighted (bool shouldBeHighlighted)
 206     {
 207         shouldBeHighlighted = shouldBeHighlighted && itemInfo.active;
 208
 209         if (isHighlighted != shouldBeHighlighted)
 210         {
 211             isHighlighted = shouldBeHighlighted;
 212
 213             if (itemInfo.customComp != nullptr)
 214                 itemInfo.customComp->setHighlighted (shouldBeHighlighted);
 215
 216             repaint();
 217         }
 218     }
 219
 220     PopupMenu::Item itemInfo;
 221
 222 private:
 223     bool isHighlighted;
 224
 225     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ItemComponent);
 226 };
 227
 228
 229 //==============================================================================
 230 namespace PopupMenuSettings
 231 {
 232     const int scrollZone = 24;
 233     const int borderSize = 2;
 234     const int timerInterval = 50;
 235     const int dismissCommandId = 0x6287345f;
 236
 237     static bool menuWasHiddenBecauseOfAppChange = false;
 238 }
 239
 240 //==============================================================================
 241 class PopupMenu::Window  : public Component,
 242                            private Timer
 243 {
 244 public:
 245     //==============================================================================
 246     Window (const PopupMenu& menu, Window* const owner_, const Rectangle<int>& target,
 247             const bool alignToRectangle, const int itemIdThatMustBeVisible,
 248             const int minimumWidth_, const int maximumNumColumns_,
 249             const int standardItemHeight_, const bool dismissOnMouseUp_,
 250             ApplicationCommandManager** const managerOfChosenCommand_,
 251             Component* const componentAttachedTo_)
 252        : Component ("menu"),
 253          owner (owner_),
 254          activeSubMenu (nullptr),
 255          managerOfChosenCommand (managerOfChosenCommand_),
 256          componentAttachedTo (componentAttachedTo_),
 257          componentAttachedToOriginal (componentAttachedTo_),
 258          minimumWidth (minimumWidth_),
 259          maximumNumColumns (maximumNumColumns_),
 260          standardItemHeight (standardItemHeight_),
 261          isOver (false),
 262          hasBeenOver (false),
 263          isDown (false),
 264          needsToScroll (false),
 265          dismissOnMouseUp (dismissOnMouseUp_),
 266          hideOnExit (false),
 267          disableMouseMoves (false),
 268          hasAnyJuceCompHadFocus (false),
 269          numColumns (0),
 270          contentHeight (0),
 271          childYOffset (0),
 272          menuCreationTime (Time::getMillisecondCounter()),
 273          lastMouseMoveTime (0),
 274          timeEnteredCurrentChildComp (0),
 275          scrollAcceleration (1.0)
 276     {
 277         lastFocused = lastScroll = menuCreationTime;
 278         setWantsKeyboardFocus (false);
 279         setMouseClickGrabsKeyboardFocus (false);
 280         setAlwaysOnTop (true);
 281
 282         setLookAndFeel (menu.lookAndFeel);
 283         setOpaque (getLookAndFeel().findColour (PopupMenu::backgroundColourId).isOpaque() || ! Desktop::canUseSemiTransparentWindows());
 284
 285         for (int i = 0; i < menu.items.size(); ++i)
 286             items.add (new PopupMenu::ItemComponent (*menu.items.getUnchecked(i), standardItemHeight, this));
 287
 288         calculateWindowPos (target, alignToRectangle);
 289         setTopLeftPosition (windowPos.getX(), windowPos.getY());
 290         updateYPositions();
 291
 292         if (itemIdThatMustBeVisible != 0)
 293         {
 294             const int y = target.getY() - windowPos.getY();
 295             ensureItemIsVisible (itemIdThatMustBeVisible,
 296                                  isPositiveAndBelow (y, windowPos.getHeight()) ? y : -1);
 297         }
 298
 299         resizeToBestWindowPos();
 300         addToDesktop (ComponentPeer::windowIsTemporary
 301                        | ComponentPeer::windowIgnoresKeyPresses
 302                        | getLookAndFeel().getMenuWindowFlags());
 303
 304         getActiveWindows().add (this);
 305         Desktop::getInstance().addGlobalMouseListener (this);
 306     }
 307
 308     ~Window()
 309     {
 310         getActiveWindows().removeValue (this);
 311         Desktop::getInstance().removeGlobalMouseListener (this);
 312         activeSubMenu = nullptr;
 313         items.clear();
 314     }
 315
 316     //==============================================================================
 317     static Window* create (const PopupMenu& menu,
 318                            bool dismissOnMouseUp,
 319                            Window* const owner_,
 320                            const Rectangle<int>& target,
 321                            int minimumWidth,
 322                            int maximumNumColumns,
 323                            int standardItemHeight,
 324                            bool alignToRectangle,
 325                            int itemIdThatMustBeVisible,
 326                            ApplicationCommandManager** managerOfChosenCommand,
 327                            Component* componentAttachedTo)
 328     {
 329         if (menu.items.size() > 0)
 330             return new Window (menu, owner_, target, alignToRectangle, itemIdThatMustBeVisible,
 331                                minimumWidth, maximumNumColumns, standardItemHeight, dismissOnMouseUp,
 332                                managerOfChosenCommand, componentAttachedTo);
 333
 334         return nullptr;
 335     }
 336
 337     //==============================================================================
 338     void paint (Graphics& g)
 339     {
 340         if (isOpaque())
 341             g.fillAll (Colours::white);
 342
 343         getLookAndFeel().drawPopupMenuBackground (g, getWidth(), getHeight());
 344     }
 345
 346     void paintOverChildren (Graphics& g)
 347     {
 348         if (isScrolling())
 349         {
 350             LookAndFeel& lf = getLookAndFeel();
 351
 352             if (isScrollZoneActive (false))
 353                 lf.drawPopupMenuUpDownArrow (g, getWidth(), PopupMenuSettings::scrollZone, true);
 354
 355             if (isScrollZoneActive (true))
 356             {
 357                 g.setOrigin (0, getHeight() - PopupMenuSettings::scrollZone);
 358                 lf.drawPopupMenuUpDownArrow (g, getWidth(), PopupMenuSettings::scrollZone, false);
 359             }
 360         }
 361     }
 362
 363     bool isScrollZoneActive (bool bottomOne) const
 364     {
 365         return isScrolling()
 366                 && (bottomOne ? childYOffset < contentHeight - windowPos.getHeight()
 367                               : childYOffset > 0);
 368     }
 369
 370     //==============================================================================
 371     // hide this and all sub-comps
 372     void hide (const PopupMenu::Item* const item, const bool makeInvisible)
 373     {
 374         if (isVisible())
 375         {
 376             WeakReference<Component> deletionChecker (this);
 377
 378             activeSubMenu = nullptr;
 379             currentChild = nullptr;
 380
 381             if (item != nullptr
 382                  && item->commandManager != nullptr
 383                  && item->itemId != 0)
 384             {
 385                 *managerOfChosenCommand = item->commandManager;
 386             }
 387
 388             exitModalState (item != nullptr ? item->itemId : 0);
 389
 390             if (makeInvisible && (deletionChecker != nullptr))
 391                 setVisible (false);
 392         }
 393     }
 394
 395     void dismissMenu (const PopupMenu::Item* const item)
 396     {
 397         if (owner != nullptr)
 398         {
 399             owner->dismissMenu (item);
 400         }
 401         else
 402         {
 403             if (item != nullptr)
 404             {
 405                 // need a copy of this on the stack as the one passed in will get deleted during this call
 406                 const PopupMenu::Item mi (*item);
 407                 hide (&mi, false);
 408             }
 409             else
 410             {
 411                 hide (0, false);
 412             }
 413         }
 414     }
 415
 416     //==============================================================================
 417     void mouseMove (const MouseEvent&)    { timerCallback(); }
 418     void mouseDown (const MouseEvent&)    { timerCallback(); }
 419     void mouseDrag (const MouseEvent&)    { timerCallback(); }
 420     void mouseUp   (const MouseEvent&)    { timerCallback(); }
 421
 422     void mouseWheelMove (const MouseEvent&, float /*amountX*/, float amountY)
 423     {
 424         alterChildYPos (roundToInt (-10.0f * amountY * PopupMenuSettings::scrollZone));
 425         lastMouse = Point<int> (-1, -1);
 426     }
 427
 428     bool keyPressed (const KeyPress& key)
 429     {
 430         if (key.isKeyCode (KeyPress::downKey))
 431         {
 432             selectNextItem (1);
 433         }
 434         else if (key.isKeyCode (KeyPress::upKey))
 435         {
 436             selectNextItem (-1);
 437         }
 438         else if (key.isKeyCode (KeyPress::leftKey))
 439         {
 440             if (owner != nullptr)
 441             {
 442                 Component::SafePointer<Window> parentWindow (owner);
 443                 PopupMenu::ItemComponent* currentChildOfParent = parentWindow->currentChild;
 444
 445                 hide (0, true);
 446
 447                 if (parentWindow != nullptr)
 448                     parentWindow->setCurrentlyHighlightedChild (currentChildOfParent);
 449
 450                 disableTimerUntilMouseMoves();
 451             }
 452             else if (componentAttachedTo != nullptr)
 453             {
 454                 componentAttachedTo->keyPressed (key);
 455             }
 456         }
 457         else if (key.isKeyCode (KeyPress::rightKey))
 458         {
 459             disableTimerUntilMouseMoves();
 460
 461             if (showSubMenuFor (currentChild))
 462             {
 463                 if (activeSubMenu != nullptr && activeSubMenu->isVisible())
 464                     activeSubMenu->selectNextItem (1);
 465             }
 466             else if (componentAttachedTo != nullptr)
 467             {
 468                 componentAttachedTo->keyPressed (key);
 469             }
 470         }
 471         else if (key.isKeyCode (KeyPress::returnKey))
 472         {
 473             triggerCurrentlyHighlightedItem();
 474         }
 475         else if (key.isKeyCode (KeyPress::escapeKey))
 476         {
 477             dismissMenu (0);
 478         }
 479         else
 480         {
 481             return false;
 482         }
 483
 484         return true;
 485     }
 486
 487     void inputAttemptWhenModal()
 488     {
 489         WeakReference<Component> deletionChecker (this);
 490
 491         timerCallback();
 492
 493         if (deletionChecker != nullptr && ! isOverAnyMenu())
 494         {
 495             if (componentAttachedTo != nullptr)
 496             {
 497                 // we want to dismiss the menu, but if we do it synchronously, then
 498                 // the mouse-click will be allowed to pass through. That's good, except
 499                 // when the user clicks on the button that orginally popped the menu up,
 500                 // as they'll expect the menu to go away, and in fact it'll just
 501                 // come back. So only dismiss synchronously if they're not on the original
 502                 // comp that we're attached to.
 503                 const Point<int> mousePos (componentAttachedTo->getMouseXYRelative());
 504
 505                 if (componentAttachedTo->reallyContains (mousePos, true))
 506                 {
 507                     postCommandMessage (PopupMenuSettings::dismissCommandId); // dismiss asynchrounously
 508                     return;
 509                 }
 510             }
 511
 512             dismissMenu (0);
 513         }
 514     }
 515
 516     void handleCommandMessage (int commandId)
 517     {
 518         Component::handleCommandMessage (commandId);
 519
 520         if (commandId == PopupMenuSettings::dismissCommandId)
 521             dismissMenu (0);
 522     }
 523
 524     //==============================================================================
 525     void timerCallback()
 526     {
 527         if (! isVisible())
 528             return;
 529
 530         if (componentAttachedTo != componentAttachedToOriginal)
 531         {
 532             dismissMenu (0);
 533             return;
 534         }
 535
 536         Window* currentlyModalWindow = dynamic_cast <Window*> (Component::getCurrentlyModalComponent());
 537
 538         if (currentlyModalWindow != nullptr && ! treeContains (currentlyModalWindow))
 539             return;
 540
 541         startTimer (PopupMenuSettings::timerInterval);  // do this in case it was called from a mouse
 542                                                         // move rather than a real timer callback
 543
 544         const Point<int> globalMousePos (Desktop::getMousePosition());
 545         const Point<int> localMousePos (getLocalPoint (nullptr, globalMousePos));
 546
 547         const uint32 now = Time::getMillisecondCounter();
 548
 549         if (now > timeEnteredCurrentChildComp + 100
 550              && reallyContains (localMousePos, true)
 551              && currentChild != nullptr
 552              && (! disableMouseMoves)
 553              && ! (activeSubMenu != nullptr && activeSubMenu->isVisible()))
 554         {
 555             showSubMenuFor (currentChild);
 556         }
 557
 558         if (globalMousePos != lastMouse || now > lastMouseMoveTime + 350)
 559         {
 560             highlightItemUnderMouse (globalMousePos, localMousePos);
 561         }
 562
 563         bool overScrollArea = false;
 564
 565         if (isScrolling()
 566              && (isOver || (isDown && isPositiveAndBelow (localMousePos.getX(), getWidth())))
 567              && ((isScrollZoneActive (false) && localMousePos.getY() < PopupMenuSettings::scrollZone)
 568                   || (isScrollZoneActive (true) && localMousePos.getY() > getHeight() - PopupMenuSettings::scrollZone)))
 569         {
 570             if (now > lastScroll + 20)
 571             {
 572                 scrollAcceleration = jmin (4.0, scrollAcceleration * 1.04);
 573                 int amount = 0;
 574
 575                 for (int i = 0; i < items.size() && amount == 0; ++i)
 576                     amount = ((int) scrollAcceleration) * items.getUnchecked(i)->getHeight();
 577
 578                 alterChildYPos (localMousePos.getY() < PopupMenuSettings::scrollZone ? -amount : amount);
 579
 580                 lastScroll = now;
 581             }
 582
 583             overScrollArea = true;
 584             lastMouse = Point<int> (-1, -1); // trigger a mouse-move
 585         }
 586         else
 587         {
 588             scrollAcceleration = 1.0;
 589         }
 590
 591         const bool wasDown = isDown;
 592         bool isOverAny = isOverAnyMenu();
 593
 594         if (hideOnExit && hasBeenOver && (! isOverAny) && activeSubMenu != nullptr)
 595         {
 596             activeSubMenu->updateMouseOverStatus (globalMousePos);
 597             isOverAny = isOverAnyMenu();
 598         }
 599
 600         if (hideOnExit && hasBeenOver && ! isOverAny)
 601         {
 602             hide (0, true);
 603         }
 604         else
 605         {
 606             isDown = hasBeenOver
 607                         && (ModifierKeys::getCurrentModifiers().isAnyMouseButtonDown()
 608                             || ModifierKeys::getCurrentModifiersRealtime().isAnyMouseButtonDown());
 609
 610             bool anyFocused = Process::isForegroundProcess();
 611
 612             if (anyFocused && Component::getCurrentlyFocusedComponent() == nullptr)
 613             {
 614                 // because no component at all may have focus, our test here will
 615                 // only be triggered when something has focus and then loses it.
 616                 anyFocused = ! hasAnyJuceCompHadFocus;
 617
 618                 for (int i = ComponentPeer::getNumPeers(); --i >= 0;)
 619                 {
 620                     if (ComponentPeer::getPeer (i)->isFocused())
 621                     {
 622                         anyFocused = true;
 623                         hasAnyJuceCompHadFocus = true;
 624                         break;
 625                     }
 626                 }
 627             }
 628
 629             if (! anyFocused)
 630             {
 631                 if (now > lastFocused + 10)
 632                 {
 633                     PopupMenuSettings::menuWasHiddenBecauseOfAppChange = true;
 634                     dismissMenu (0);
 635
 636                     return;  // may have been deleted by the previous call..
 637                 }
 638             }
 639             else if (wasDown && now > menuCreationTime + 250
 640                        && ! (isDown || overScrollArea))
 641             {
 642                 isOver = reallyContains (localMousePos, true);
 643
 644                 if (isOver)
 645                 {
 646                     triggerCurrentlyHighlightedItem();
 647                 }
 648                 else if ((hasBeenOver || ! dismissOnMouseUp) && ! isOverAny)
 649                 {
 650                     dismissMenu (0);
 651                 }
 652
 653                 return;  // may have been deleted by the previous calls..
 654             }
 655             else
 656             {
 657                 lastFocused = now;
 658             }
 659         }
 660     }
 661
 662     static Array<Window*>& getActiveWindows()
 663     {
 664         static Array<Window*> activeMenuWindows;
 665         return activeMenuWindows;
 666     }
 667
 668     //==============================================================================
 669 private:
 670     Window* owner;
 671     OwnedArray <PopupMenu::ItemComponent> items;
 672     Component::SafePointer<PopupMenu::ItemComponent> currentChild;
 673     ScopedPointer <Window> activeSubMenu;
 674     ApplicationCommandManager** managerOfChosenCommand;
 675     WeakReference<Component> componentAttachedTo;
 676     Component* componentAttachedToOriginal;
 677     Rectangle<int> windowPos;
 678     Point<int> lastMouse;
 679     int minimumWidth, maximumNumColumns, standardItemHeight;
 680     bool isOver, hasBeenOver, isDown, needsToScroll;
 681     bool dismissOnMouseUp, hideOnExit, disableMouseMoves, hasAnyJuceCompHadFocus;
 682     int numColumns, contentHeight, childYOffset;
 683     Array <int> columnWidths;
 684     uint32 menuCreationTime, lastFocused, lastScroll, lastMouseMoveTime, timeEnteredCurrentChildComp;
 685     double scrollAcceleration;
 686
 687     //==============================================================================
 688     bool overlaps (const Rectangle<int>& r) const
 689     {
 690         return r.intersects (getBounds())
 691                 || (owner != nullptr && owner->overlaps (r));
 692     }
 693
 694     bool isOverAnyMenu() const
 695     {
 696         return owner != nullptr ? owner->isOverAnyMenu()
 697                                 : isOverChildren();
 698     }
 699
 700     bool isOverChildren() const
 701     {
 702         return isVisible()
 703                 && (isOver || (activeSubMenu != nullptr && activeSubMenu->isOverChildren()));
 704     }
 705
 706     void updateMouseOverStatus (const Point<int>& globalMousePos)
 707     {
 708         const Point<int> relPos (getLocalPoint (nullptr, globalMousePos));
 709         isOver = reallyContains (relPos, true);
 710
 711         if (activeSubMenu != nullptr)
 712             activeSubMenu->updateMouseOverStatus (globalMousePos);
 713     }
 714
 715     bool treeContains (const Window* const window) const noexcept
 716     {
 717         const Window* mw = this;
 718
 719         while (mw->owner != nullptr)
 720             mw = mw->owner;
 721
 722         while (mw != nullptr)
 723         {
 724             if (mw == window)
 725                 return true;
 726
 727             mw = mw->activeSubMenu;
 728         }
 729
 730         return false;
 731     }
 732
 733     //==============================================================================
 734     void calculateWindowPos (const Rectangle<int>& target, const bool alignToRectangle)
 735     {
 736         const Rectangle<int> mon (Desktop::getInstance()
 737                                      .getMonitorAreaContaining (target.getCentre(),
 738                                                                #if JUCE_MAC
 739                                                                 true));
 740                                                                #else
 741                                                                 false)); // on windows, don't stop the menu overlapping the taskbar
 742                                                                #endif
 743
 744         const int maxMenuHeight = mon.getHeight() - 24;
 745
 746         int x, y, widthToUse, heightToUse;
 747         layoutMenuItems (mon.getWidth() - 24, maxMenuHeight, widthToUse, heightToUse);
 748
 749         if (alignToRectangle)
 750         {
 751             x = target.getX();
 752
 753             const int spaceUnder = mon.getHeight() - (target.getBottom() - mon.getY());
 754             const int spaceOver = target.getY() - mon.getY();
 755
 756             if (heightToUse < spaceUnder - 30 || spaceUnder >= spaceOver)
 757                 y = target.getBottom();
 758             else
 759                 y = target.getY() - heightToUse;
 760         }
 761         else
 762         {
 763             bool tendTowardsRight = target.getCentreX() < mon.getCentreX();
 764
 765             if (owner != nullptr)
 766             {
 767                 if (owner->owner != nullptr)
 768                 {
 769                     const bool ownerGoingRight = (owner->getX() + owner->getWidth() / 2
 770                                                     > owner->owner->getX() + owner->owner->getWidth() / 2);
 771
 772                     if (ownerGoingRight && target.getRight() + widthToUse < mon.getRight() - 4)
 773                         tendTowardsRight = true;
 774                     else if ((! ownerGoingRight) && target.getX() > widthToUse + 4)
 775                         tendTowardsRight = false;
 776                 }
 777                 else if (target.getRight() + widthToUse < mon.getRight() - 32)
 778                 {
 779                     tendTowardsRight = true;
 780                 }
 781             }
 782
 783             const int biggestSpace = jmax (mon.getRight() - target.getRight(),
 784                                            target.getX() - mon.getX()) - 32;
 785
 786             if (biggestSpace < widthToUse)
 787             {
 788                 layoutMenuItems (biggestSpace + target.getWidth() / 3, maxMenuHeight, widthToUse, heightToUse);
 789
 790                 if (numColumns > 1)
 791                     layoutMenuItems (biggestSpace - 4, maxMenuHeight, widthToUse, heightToUse);
 792
 793                 tendTowardsRight = (mon.getRight() - target.getRight()) >= (target.getX() - mon.getX());
 794             }
 795
 796             if (tendTowardsRight)
 797                 x = jmin (mon.getRight() - widthToUse - 4, target.getRight());
 798             else
 799                 x = jmax (mon.getX() + 4, target.getX() - widthToUse);
 800
 801             y = target.getY();
 802             if (target.getCentreY() > mon.getCentreY())
 803                 y = jmax (mon.getY(), target.getBottom() - heightToUse);
 804         }
 805
 806         x = jmax (mon.getX() + 1, jmin (mon.getRight() - (widthToUse + 6), x));
 807         y = jmax (mon.getY() + 1, jmin (mon.getBottom() - (heightToUse + 6), y));
 808
 809         windowPos.setBounds (x, y, widthToUse, heightToUse);
 810
 811         // sets this flag if it's big enough to obscure any of its parent menus
 812         hideOnExit = owner != nullptr
 813                       && owner->windowPos.intersects (windowPos.expanded (-4, -4));
 814     }
 815
 816     void layoutMenuItems (const int maxMenuW, const int maxMenuH, int& width, int& height)
 817     {
 818         numColumns = 0;
 819         contentHeight = 0;
 820         int totalW;
 821
 822         do
 823         {
 824             ++numColumns;
 825             totalW = workOutBestSize (maxMenuW);
 826
 827             if (totalW > maxMenuW)
 828             {
 829                 numColumns = jmax (1, numColumns - 1);
 830                 totalW = workOutBestSize (maxMenuW); // to update col widths
 831                 break;
 832             }
 833             else if (totalW > maxMenuW / 2 || contentHeight < maxMenuH)
 834             {
 835                 break;
 836             }
 837
 838         } while (numColumns < maximumNumColumns);
 839
 840         const int actualH = jmin (contentHeight, maxMenuH);
 841
 842         needsToScroll = contentHeight > actualH;
 843
 844         width = updateYPositions();
 845         height = actualH + PopupMenuSettings::borderSize * 2;
 846     }
 847
 848     int workOutBestSize (const int maxMenuW)
 849     {
 850         int totalW = 0;
 851         contentHeight = 0;
 852         int childNum = 0;
 853
 854         for (int col = 0; col < numColumns; ++col)
 855         {
 856             int i, colW = standardItemHeight, colH = 0;
 857
 858             const int numChildren = jmin (items.size() - childNum,
 859                                           (items.size() + numColumns - 1) / numColumns);
 860
 861             for (i = numChildren; --i >= 0;)
 862             {
 863                 colW = jmax (colW, items.getUnchecked (childNum + i)->getWidth());
 864                 colH += items.getUnchecked (childNum + i)->getHeight();
 865             }
 866
 867             colW = jmin (maxMenuW / jmax (1, numColumns - 2), colW + PopupMenuSettings::borderSize * 2);
 868
 869             columnWidths.set (col, colW);
 870             totalW += colW;
 871             contentHeight = jmax (contentHeight, colH);
 872
 873             childNum += numChildren;
 874         }
 875
 876         if (totalW < minimumWidth)
 877         {
 878             totalW = minimumWidth;
 879
 880             for (int col = 0; col < numColumns; ++col)
 881                 columnWidths.set (0, totalW / numColumns);
 882         }
 883
 884         return totalW;
 885     }
 886
 887     void ensureItemIsVisible (const int itemId, int wantedY)
 888     {
 889         jassert (itemId != 0)
 890
 891         for (int i = items.size(); --i >= 0;)
 892         {
 893             PopupMenu::ItemComponent* const m = items.getUnchecked(i);
 894
 895             if (m != nullptr
 896                 && m->itemInfo.itemId == itemId
 897                 && windowPos.getHeight() > PopupMenuSettings::scrollZone * 4)
 898             {
 899                 const int currentY = m->getY();
 900
 901                 if (wantedY > 0 || currentY < 0 || m->getBottom() > windowPos.getHeight())
 902                 {
 903                     if (wantedY < 0)
 904                         wantedY = jlimit (PopupMenuSettings::scrollZone,
 905                                           jmax (PopupMenuSettings::scrollZone,
 906                                                 windowPos.getHeight() - (PopupMenuSettings::scrollZone + m->getHeight())),
 907                                           currentY);
 908
 909                     const Rectangle<int> mon (Desktop::getInstance().getMonitorAreaContaining (windowPos.getPosition(), true));
 910
 911                     int deltaY = wantedY - currentY;
 912
 913                     windowPos.setSize (jmin (windowPos.getWidth(), mon.getWidth()),
 914                                        jmin (windowPos.getHeight(), mon.getHeight()));
 915
 916                     const int newY = jlimit (mon.getY(),
 917                                              mon.getBottom() - windowPos.getHeight(),
 918                                              windowPos.getY() + deltaY);
 919
 920                     deltaY -= newY - windowPos.getY();
 921
 922                     childYOffset -= deltaY;
 923                     windowPos.setPosition (windowPos.getX(), newY);
 924
 925                     updateYPositions();
 926                 }
 927
 928                 break;
 929             }
 930         }
 931     }
 932
 933     void resizeToBestWindowPos()
 934     {
 935         Rectangle<int> r (windowPos);
 936
 937         if (childYOffset < 0)
 938         {
 939             r.setBounds (r.getX(), r.getY() - childYOffset,
 940                          r.getWidth(), r.getHeight() + childYOffset);
 941         }
 942         else if (childYOffset > 0)
 943         {
 944             const int spaceAtBottom = r.getHeight() - (contentHeight - childYOffset);
 945
 946             if (spaceAtBottom > 0)
 947                 r.setSize (r.getWidth(), r.getHeight() - spaceAtBottom);
 948         }
 949
 950         setBounds (r);
 951         updateYPositions();
 952     }
 953
 954     void alterChildYPos (const int delta)
 955     {
 956         if (isScrolling())
 957         {
 958             childYOffset += delta;
 959
 960             if (delta < 0)
 961             {
 962                 childYOffset = jmax (childYOffset, 0);
 963             }
 964             else if (delta > 0)
 965             {
 966                 childYOffset = jmin (childYOffset,
 967                                      contentHeight - windowPos.getHeight() + PopupMenuSettings::borderSize);
 968             }
 969
 970             updateYPositions();
 971         }
 972         else
 973         {
 974             childYOffset = 0;
 975         }
 976
 977         resizeToBestWindowPos();
 978         repaint();
 979     }
 980
 981     int updateYPositions()
 982     {
 983         int x = 0;
 984         int childNum = 0;
 985
 986         for (int col = 0; col < numColumns; ++col)
 987         {
 988             const int numChildren = jmin (items.size() - childNum,
 989                                           (items.size() + numColumns - 1) / numColumns);
 990
 991             const int colW = columnWidths [col];
 992
 993             int y = PopupMenuSettings::borderSize - (childYOffset + (getY() - windowPos.getY()));
 994
 995             for (int i = 0; i < numChildren; ++i)
 996             {
 997                 Component* const c = items.getUnchecked (childNum + i);
 998                 c->setBounds (x, y, colW, c->getHeight());
 999                 y += c->getHeight();
1000             }
1001
1002             x += colW;
1003             childNum += numChildren;
1004         }
1005
1006         return x;
1007     }
1008
1009     bool isScrolling() const noexcept
1010     {
1011         return childYOffset != 0 || needsToScroll;
1012     }
1013
1014     void setCurrentlyHighlightedChild (PopupMenu::ItemComponent* const child)
1015     {
1016         if (currentChild != nullptr)
1017             currentChild->setHighlighted (false);
1018
1019         currentChild = child;
1020
1021         if (currentChild != nullptr)
1022         {
1023             currentChild->setHighlighted (true);
1024             timeEnteredCurrentChildComp = Time::getApproximateMillisecondCounter();
1025         }
1026     }
1027
1028     bool showSubMenuFor (PopupMenu::ItemComponent* const childComp)
1029     {
1030         activeSubMenu = nullptr;
1031
1032         if (childComp != nullptr && childComp->itemInfo.hasActiveSubMenu())
1033         {
1034             activeSubMenu = Window::create (*(childComp->itemInfo.subMenu),
1035                                             dismissOnMouseUp,
1036                                             this,
1037                                             childComp->getScreenBounds(),
1038                                             0, maximumNumColumns,
1039                                             standardItemHeight,
1040                                             false, 0, managerOfChosenCommand,
1041                                             componentAttachedTo);
1042
1043             if (activeSubMenu != nullptr)
1044             {
1045                 activeSubMenu->setVisible (true);
1046                 activeSubMenu->enterModalState (false);
1047                 activeSubMenu->toFront (false);
1048                 return true;
1049             }
1050         }
1051
1052         return false;
1053     }
1054
1055     void highlightItemUnderMouse (const Point<int>& globalMousePos, const Point<int>& localMousePos)
1056     {
1057         isOver = reallyContains (localMousePos, true);
1058
1059         if (isOver)
1060             hasBeenOver = true;
1061
1062         if (lastMouse.getDistanceFrom (globalMousePos) > 2)
1063         {
1064             lastMouseMoveTime = Time::getApproximateMillisecondCounter();
1065
1066             if (disableMouseMoves && isOver)
1067                 disableMouseMoves = false;
1068         }
1069
1070         if (disableMouseMoves || (activeSubMenu != nullptr && activeSubMenu->isOverChildren()))
1071             return;
1072
1073         bool isMovingTowardsMenu = false;
1074
1075         if (isOver && (activeSubMenu != nullptr) && globalMousePos != lastMouse)
1076         {
1077             // try to intelligently guess whether the user is moving the mouse towards a currently-open
1078             // submenu. To do this, look at whether the mouse stays inside a triangular region that
1079             // extends from the last mouse pos to the submenu's rectangle..
1080
1081             float subX = (float) activeSubMenu->getScreenX();
1082
1083             if (activeSubMenu->getX() > getX())
1084             {
1085                 lastMouse -= Point<int> (2, 0);  // to enlarge the triangle a bit, in case the mouse only moves a couple of pixels
1086             }
1087             else
1088             {
1089                 lastMouse += Point<int> (2, 0);
1090                 subX += activeSubMenu->getWidth();
1091             }
1092
1093             Path areaTowardsSubMenu;
1094             areaTowardsSubMenu.addTriangle ((float) lastMouse.getX(), (float) lastMouse.getY(),
1095                                             subX, (float) activeSubMenu->getScreenY(),
1096                                             subX, (float) (activeSubMenu->getScreenY() + activeSubMenu->getHeight()));
1097
1098             isMovingTowardsMenu = areaTowardsSubMenu.contains ((float) globalMousePos.getX(), (float) globalMousePos.getY());
1099         }
1100
1101         lastMouse = globalMousePos;
1102
1103         if (! isMovingTowardsMenu)
1104         {
1105             Component* c = getComponentAt (localMousePos.getX(), localMousePos.getY());
1106             if (c == this)
1107                 c = nullptr;
1108
1109             PopupMenu::ItemComponent* mic = dynamic_cast <PopupMenu::ItemComponent*> (c);
1110
1111             if (mic == nullptr && c != nullptr)
1112                 mic = c->findParentComponentOfClass ((PopupMenu::ItemComponent*) nullptr);
1113
1114             if (mic != currentChild
1115                  && (isOver || (activeSubMenu == nullptr) || ! activeSubMenu->isVisible()))
1116             {
1117                 if (isOver && (c != nullptr) && (activeSubMenu != nullptr))
1118                     activeSubMenu->hide (0, true);
1119
1120                 if (! isOver)
1121                     mic = nullptr;
1122
1123                 setCurrentlyHighlightedChild (mic);
1124             }
1125         }
1126     }
1127
1128     void triggerCurrentlyHighlightedItem()
1129     {
1130         if (currentChild != nullptr
1131              && currentChild->itemInfo.canBeTriggered()
1132              && (currentChild->itemInfo.customComp == nullptr
1133                   || currentChild->itemInfo.customComp->isTriggeredAutomatically()))
1134         {
1135             dismissMenu (&currentChild->itemInfo);
1136         }
1137     }
1138
1139     void selectNextItem (const int delta)
1140     {
1141         disableTimerUntilMouseMoves();
1142         PopupMenu::ItemComponent* mic = nullptr;
1143         bool wasLastOne = (currentChild == nullptr);
1144         const int numItems = items.size();
1145
1146         for (int i = 0; i < numItems + 1; ++i)
1147         {
1148             int index = (delta > 0) ? i : (numItems - 1 - i);
1149             index = (index + numItems) % numItems;
1150
1151             mic = items.getUnchecked (index);
1152
1153             if (mic != nullptr && (mic->itemInfo.canBeTriggered() || mic->itemInfo.hasActiveSubMenu())
1154                  && wasLastOne)
1155                 break;
1156
1157             if (mic == currentChild)
1158                 wasLastOne = true;
1159         }
1160
1161         setCurrentlyHighlightedChild (mic);
1162     }
1163
1164     void disableTimerUntilMouseMoves()
1165     {
1166         disableMouseMoves = true;
1167
1168         if (owner != nullptr)
1169             owner->disableTimerUntilMouseMoves();
1170     }
1171
1172     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Window);
1173 };
1174
1175
1176 //==============================================================================
1177 PopupMenu::PopupMenu()
1178     : lookAndFeel (nullptr),
1179       separatorPending (false)
1180 {
1181 }
1182
1183 PopupMenu::PopupMenu (const PopupMenu& other)
1184     : lookAndFeel (other.lookAndFeel),
1185       separatorPending (false)
1186 {
1187     items.addCopiesOf (other.items);
1188 }
1189
1190 PopupMenu& PopupMenu::operator= (const PopupMenu& other)
1191 {
1192     if (this != &other)
1193     {
1194         lookAndFeel = other.lookAndFeel;
1195
1196         clear();
1197         items.addCopiesOf (other.items);
1198     }
1199
1200     return *this;
1201 }
1202
1203 PopupMenu::~PopupMenu()
1204 {
1205     clear();
1206 }
1207
1208 void PopupMenu::clear()
1209 {
1210     items.clear();
1211     separatorPending = false;
1212 }
1213
1214 void PopupMenu::addSeparatorIfPending()
1215 {
1216     if (separatorPending)
1217     {
1218         separatorPending = false;
1219
1220         if (items.size() > 0)
1221             items.add (new Item());
1222     }
1223 }
1224
1225 void PopupMenu::addItem (const int itemResultId, const String& itemText,
1226                          const bool isActive, const bool isTicked, const Image& iconToUse)
1227 {
1228     jassert (itemResultId != 0);    // 0 is used as a return value to indicate that the user
1229                                     // didn't pick anything, so you shouldn't use it as the id
1230                                     // for an item..
1231
1232     addSeparatorIfPending();
1233
1234     items.add (new Item (itemResultId, itemText, isActive, isTicked, iconToUse,
1235                          Colours::black, false, 0, 0, 0));
1236 }
1237
1238 void PopupMenu::addCommandItem (ApplicationCommandManager* commandManager,
1239                                 const int commandID,
1240                                 const String& displayName)
1241 {
1242     jassert (commandManager != nullptr && commandID != 0);
1243
1244     const ApplicationCommandInfo* const registeredInfo = commandManager->getCommandForID (commandID);
1245
1246     if (registeredInfo != nullptr)
1247     {
1248         ApplicationCommandInfo info (*registeredInfo);
1249         ApplicationCommandTarget* const target = commandManager->getTargetForCommand (commandID, info);
1250
1251         addSeparatorIfPending();
1252
1253         items.add (new Item (commandID,
1254                              displayName.isNotEmpty() ? displayName
1255                                                       : info.shortName,
1256                              target != nullptr && (info.flags & ApplicationCommandInfo::isDisabled) == 0,
1257                              (info.flags & ApplicationCommandInfo::isTicked) != 0,
1258                              Image::null,
1259                              Colours::black,
1260                              false,
1261                              0, 0,
1262                              commandManager));
1263     }
1264 }
1265
1266 void PopupMenu::addColouredItem (const int itemResultId,
1267                                  const String& itemText,
1268                                  const Colour& itemTextColour,
1269                                  const bool isActive,
1270                                  const bool isTicked,
1271                                  const Image& iconToUse)
1272 {
1273     jassert (itemResultId != 0);    // 0 is used as a return value to indicate that the user
1274                                     // didn't pick anything, so you shouldn't use it as the id
1275                                     // for an item..
1276
1277     addSeparatorIfPending();
1278
1279     items.add (new Item (itemResultId, itemText, isActive, isTicked, iconToUse,
1280                          itemTextColour, true, 0, 0, 0));
1281 }
1282
1283 //==============================================================================
1284 void PopupMenu::addCustomItem (const int itemResultId, CustomComponent* const customComponent)
1285 {
1286     jassert (itemResultId != 0);    // 0 is used as a return value to indicate that the user
1287                                     // didn't pick anything, so you shouldn't use it as the id
1288                                     // for an item..
1289
1290     addSeparatorIfPending();
1291
1292     items.add (new Item (itemResultId, String::empty, true, false, Image::null,
1293                          Colours::black, false, customComponent, 0, 0));
1294 }
1295
1296 class NormalComponentWrapper : public PopupMenu::CustomComponent
1297 {
1298 public:
1299     NormalComponentWrapper (Component* const comp, const int w, const int h,
1300                             const bool triggerMenuItemAutomaticallyWhenClicked)
1301         : PopupMenu::CustomComponent (triggerMenuItemAutomaticallyWhenClicked),
1302           width (w), height (h)
1303     {
1304         addAndMakeVisible (comp);
1305     }
1306
1307     void getIdealSize (int& idealWidth, int& idealHeight)
1308     {
1309         idealWidth = width;
1310         idealHeight = height;
1311     }
1312
1313     void resized()
1314     {
1315         if (getChildComponent(0) != nullptr)
1316             getChildComponent(0)->setBounds (getLocalBounds());
1317     }
1318
1319 private:
1320     const int width, height;
1321
1322     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (NormalComponentWrapper);
1323 };
1324
1325 void PopupMenu::addCustomItem (const int itemResultId,
1326                                Component* customComponent,
1327                                int idealWidth, int idealHeight,
1328                                const bool triggerMenuItemAutomaticallyWhenClicked)
1329 {
1330     addCustomItem (itemResultId,
1331                    new NormalComponentWrapper (customComponent, idealWidth, idealHeight,
1332                                                triggerMenuItemAutomaticallyWhenClicked));
1333 }
1334
1335 //==============================================================================
1336 void PopupMenu::addSubMenu (const String& subMenuName,
1337                             const PopupMenu& subMenu,
1338                             const bool isActive,
1339                             const Image& iconToUse,
1340                             const bool isTicked)
1341 {
1342     addSeparatorIfPending();
1343
1344     items.add (new Item (0, subMenuName, isActive && (subMenu.getNumItems() > 0), isTicked,
1345                          iconToUse, Colours::black, false, 0, &subMenu, 0));
1346 }
1347
1348 void PopupMenu::addSeparator()
1349 {
1350     separatorPending = true;
1351 }
1352
1353
1354 //==============================================================================
1355 class HeaderItemComponent  : public PopupMenu::CustomComponent
1356 {
1357 public:
1358     HeaderItemComponent (const String& name)
1359         : PopupMenu::CustomComponent (false)
1360     {
1361         setName (name);
1362     }
1363
1364     void paint (Graphics& g)
1365     {
1366         Font f (getLookAndFeel().getPopupMenuFont());
1367         f.setBold (true);
1368         g.setFont (f);
1369         g.setColour (findColour (PopupMenu::headerTextColourId));
1370
1371         g.drawFittedText (getName(),
1372                           12, 0, getWidth() - 16, proportionOfHeight (0.8f),
1373                           Justification::bottomLeft, 1);
1374     }
1375
1376     void getIdealSize (int& idealWidth, int& idealHeight)
1377     {
1378         getLookAndFeel().getIdealPopupMenuItemSize (getName(), false, -1, idealWidth, idealHeight);
1379         idealHeight += idealHeight / 2;
1380         idealWidth += idealWidth / 4;
1381     }
1382
1383 private:
1384     JUCE_LEAK_DETECTOR (HeaderItemComponent);
1385 };
1386
1387 void PopupMenu::addSectionHeader (const String& title)
1388 {
1389     addCustomItem (0X4734a34f, new HeaderItemComponent (title));
1390 }
1391
1392 //==============================================================================
1393 PopupMenu::Options::Options()
1394     : targetComponent (nullptr),
1395       visibleItemID (0),
1396       minWidth (0),
1397       maxColumns (0),
1398       standardHeight (0)
1399 {
1400     targetArea.setPosition (Desktop::getMousePosition());
1401 }
1402
1403 const PopupMenu::Options PopupMenu::Options::withTargetComponent (Component* comp) const
1404 {
1405     Options o (*this);
1406     o.targetComponent = comp;
1407
1408     if (comp != nullptr)
1409         o.targetArea = comp->getScreenBounds();
1410
1411     return o;
1412 }
1413
1414 const PopupMenu::Options PopupMenu::Options::withTargetScreenArea (const Rectangle<int>& area) const
1415 {
1416     Options o (*this);
1417     o.targetArea = area;
1418     return o;
1419 }
1420
1421 const PopupMenu::Options PopupMenu::Options::withMinimumWidth (int w) const
1422 {
1423     Options o (*this);
1424     o.minWidth = w;
1425     return o;
1426 }
1427
1428 const PopupMenu::Options PopupMenu::Options::withMaximumNumColumns (int cols) const
1429 {
1430     Options o (*this);
1431     o.maxColumns = cols;
1432     return o;
1433 }
1434
1435 const PopupMenu::Options PopupMenu::Options::withStandardItemHeight (int height) const
1436 {
1437     Options o (*this);
1438     o.standardHeight = height;
1439     return o;
1440 }
1441
1442 const PopupMenu::Options PopupMenu::Options::withItemThatMustBeVisible (int idOfItemToBeVisible) const
1443 {
1444     Options o (*this);
1445     o.visibleItemID = idOfItemToBeVisible;
1446     return o;
1447 }
1448
1449 Component* PopupMenu::createWindow (const Options& options,
1450                                     ApplicationCommandManager** managerOfChosenCommand) const
1451 {
1452     return Window::create (*this, ModifierKeys::getCurrentModifiers().isAnyMouseButtonDown(),
1453                            0, options.targetArea, options.minWidth, options.maxColumns > 0 ? options.maxColumns : 7,
1454                            options.standardHeight, ! options.targetArea.isEmpty(), options.visibleItemID,
1455                            managerOfChosenCommand, options.targetComponent);
1456 }
1457
1458 //==============================================================================
1459 // This invokes any command manager commands and deletes the menu window when it is dismissed
1460 class PopupMenuCompletionCallback  : public ModalComponentManager::Callback
1461 {
1462 public:
1463     PopupMenuCompletionCallback()
1464         : managerOfChosenCommand (nullptr),
1465           prevFocused (Component::getCurrentlyFocusedComponent()),
1466           prevTopLevel (prevFocused != nullptr ? prevFocused->getTopLevelComponent() : 0)
1467     {
1468         PopupMenuSettings::menuWasHiddenBecauseOfAppChange = false;
1469     }
1470
1471     void modalStateFinished (int result)
1472     {
1473         if (managerOfChosenCommand != nullptr && result != 0)
1474         {
1475             ApplicationCommandTarget::InvocationInfo info (result);
1476             info.invocationMethod = ApplicationCommandTarget::InvocationInfo::fromMenu;
1477
1478             managerOfChosenCommand->invoke (info, true);
1479         }
1480
1481         // (this would be the place to fade out the component, if that's what's required)
1482         component = nullptr;
1483
1484         if (! PopupMenuSettings::menuWasHiddenBecauseOfAppChange)
1485         {
1486             if (prevTopLevel != nullptr)
1487                 prevTopLevel->toFront (true);
1488
1489             if (prevFocused != nullptr)
1490                 prevFocused->grabKeyboardFocus();
1491         }
1492     }
1493
1494     ApplicationCommandManager* managerOfChosenCommand;
1495     ScopedPointer<Component> component;
1496     WeakReference<Component> prevFocused, prevTopLevel;
1497
1498 private:
1499     JUCE_DECLARE_NON_COPYABLE (PopupMenuCompletionCallback);
1500 };
1501
1502 int PopupMenu::showWithOptionalCallback (const Options& options, ModalComponentManager::Callback* const userCallback,
1503                                          const bool canBeModal)
1504 {
1505     ScopedPointer<ModalComponentManager::Callback> userCallbackDeleter (userCallback);
1506     ScopedPointer<PopupMenuCompletionCallback> callback (new PopupMenuCompletionCallback());
1507
1508     Component* window = createWindow (options, &(callback->managerOfChosenCommand));
1509     if (window == nullptr)
1510         return 0;
1511
1512     callback->component = window;
1513
1514     window->enterModalState (false, userCallbackDeleter.release());
1515     ModalComponentManager::getInstance()->attachCallback (window, callback.release());
1516
1517     window->toFront (false);  // need to do this after making it modal, or it could
1518                               // be stuck behind other comps that are already modal..
1519
1520    #if JUCE_MODAL_LOOPS_PERMITTED
1521     return (userCallback == nullptr && canBeModal) ? window->runModalLoop() : 0;
1522    #else
1523     jassert (userCallback != nullptr && canBeModal);
1524     return 0;
1525    #endif
1526 }
1527
1528 //==============================================================================
1529 #if JUCE_MODAL_LOOPS_PERMITTED
1530 int PopupMenu::showMenu (const Options& options)
1531 {
1532     return showWithOptionalCallback (options, 0, true);
1533 }
1534 #endif
1535
1536 void PopupMenu::showMenuAsync (const Options& options, ModalComponentManager::Callback* userCallback)
1537 {
1538    #if ! JUCE_MODAL_LOOPS_PERMITTED
1539     jassert (userCallback != nullptr);
1540    #endif
1541
1542     showWithOptionalCallback (options, userCallback, false);
1543 }
1544
1545 //==============================================================================
1546 #if JUCE_MODAL_LOOPS_PERMITTED
1547 int PopupMenu::show (const int itemIdThatMustBeVisible,
1548                      const int minimumWidth, const int maximumNumColumns,
1549                      const int standardItemHeight,
1550                      ModalComponentManager::Callback* callback)
1551 {
1552     return showWithOptionalCallback (Options().withItemThatMustBeVisible (itemIdThatMustBeVisible)
1553                                               .withMinimumWidth (minimumWidth)
1554                                               .withMaximumNumColumns (maximumNumColumns)
1555                                               .withStandardItemHeight (standardItemHeight),
1556                                      callback, true);
1557 }
1558
1559 int PopupMenu::showAt (const Rectangle<int>& screenAreaToAttachTo,
1560                        const int itemIdThatMustBeVisible,
1561                        const int minimumWidth, const int maximumNumColumns,
1562                        const int standardItemHeight,
1563                        ModalComponentManager::Callback* callback)
1564 {
1565     return showWithOptionalCallback (Options().withTargetScreenArea (screenAreaToAttachTo)
1566                                               .withItemThatMustBeVisible (itemIdThatMustBeVisible)
1567                                               .withMinimumWidth (minimumWidth)
1568                                               .withMaximumNumColumns (maximumNumColumns)
1569                                               .withStandardItemHeight (standardItemHeight),
1570                                      callback, true);
1571 }
1572
1573 int PopupMenu::showAt (Component* componentToAttachTo,
1574                        const int itemIdThatMustBeVisible,
1575                        const int minimumWidth, const int maximumNumColumns,
1576                        const int standardItemHeight,
1577                        ModalComponentManager::Callback* callback)
1578 {
1579     Options options (Options().withItemThatMustBeVisible (itemIdThatMustBeVisible)
1580                               .withMinimumWidth (minimumWidth)
1581                               .withMaximumNumColumns (maximumNumColumns)
1582                               .withStandardItemHeight (standardItemHeight));
1583
1584     if (componentToAttachTo != nullptr)
1585         options = options.withTargetComponent (componentToAttachTo);
1586
1587     return showWithOptionalCallback (options, callback, true);
1588 }
1589 #endif
1590
1591 bool JUCE_CALLTYPE PopupMenu::dismissAllActiveMenus()
1592 {
1593     const int numWindows = Window::getActiveWindows().size();
1594     for (int i = numWindows; --i >= 0;)
1595     {
1596         Window* const pmw = Window::getActiveWindows()[i];
1597
1598         if (pmw != nullptr)
1599             pmw->dismissMenu (0);
1600     }
1601
1602     return numWindows > 0;
1603 }
1604
1605 //==============================================================================
1606 int PopupMenu::getNumItems() const noexcept
1607 {
1608     int num = 0;
1609
1610     for (int i = items.size(); --i >= 0;)
1611         if (! items.getUnchecked(i)->isSeparator)
1612             ++num;
1613
1614     return num;
1615 }
1616
1617 bool PopupMenu::containsCommandItem (const int commandID) const
1618 {
1619     for (int i = items.size(); --i >= 0;)
1620     {
1621         const Item* mi = items.getUnchecked (i);
1622
1623         if ((mi->itemId == commandID && mi->commandManager != nullptr)
1624             || (mi->subMenu != nullptr && mi->subMenu->containsCommandItem (commandID)))
1625         {
1626             return true;
1627         }
1628     }
1629
1630     return false;
1631 }
1632
1633 bool PopupMenu::containsAnyActiveItems() const noexcept
1634 {
1635     for (int i = items.size(); --i >= 0;)
1636     {
1637         const Item* const mi = items.getUnchecked (i);
1638
1639         if (mi->subMenu != nullptr)
1640         {
1641             if (mi->subMenu->containsAnyActiveItems())
1642                 return true;
1643         }
1644         else if (mi->active)
1645         {
1646             return true;
1647         }
1648     }
1649
1650     return false;
1651 }
1652
1653 void PopupMenu::setLookAndFeel (LookAndFeel* const newLookAndFeel)
1654 {
1655     lookAndFeel = newLookAndFeel;
1656 }
1657
1658 //==============================================================================
1659 PopupMenu::CustomComponent::CustomComponent (const bool isTriggeredAutomatically_)
1660     : isHighlighted (false),
1661       triggeredAutomatically (isTriggeredAutomatically_)
1662 {
1663 }
1664
1665 PopupMenu::CustomComponent::~CustomComponent()
1666 {
1667 }
1668
1669 void PopupMenu::CustomComponent::setHighlighted (bool shouldBeHighlighted)
1670 {
1671     isHighlighted = shouldBeHighlighted;
1672     repaint();
1673 }
1674
1675 void PopupMenu::CustomComponent::triggerMenuItem()
1676 {
1677     PopupMenu::ItemComponent* const mic = dynamic_cast <PopupMenu::ItemComponent*> (getParentComponent());
1678
1679     if (mic != nullptr)
1680     {
1681         PopupMenu::Window* const pmw = dynamic_cast <PopupMenu::Window*> (mic->getParentComponent());
1682
1683         if (pmw != nullptr)
1684         {
1685             pmw->dismissMenu (&mic->itemInfo);
1686         }
1687         else
1688         {
1689             // something must have gone wrong with the component hierarchy if this happens..
1690             jassertfalse;
1691         }
1692     }
1693     else
1694     {
1695         // why isn't this component inside a menu? Not much point triggering the item if
1696         // there's no menu.
1697         jassertfalse;
1698     }
1699 }
1700
1701 //==============================================================================
1702 PopupMenu::MenuItemIterator::MenuItemIterator (const PopupMenu& menu_)
1703     : subMenu (nullptr),
1704       itemId (0),
1705       isSeparator (false),
1706       isTicked (false),
1707       isEnabled (false),
1708       isCustomComponent (false),
1709       isSectionHeader (false),
1710       customColour (0),
1711       menu (menu_),
1712       index (0)
1713 {
1714 }
1715
1716 PopupMenu::MenuItemIterator::~MenuItemIterator()
1717 {
1718 }
1719
1720 bool PopupMenu::MenuItemIterator::next()
1721 {
1722     if (index >= menu.items.size())
1723         return false;
1724
1725     const Item* const item = menu.items.getUnchecked (index);
1726     ++index;
1727
1728     itemName = item->customComp != nullptr ? item->customComp->getName() : item->text;
1729     subMenu = item->subMenu;
1730     itemId = item->itemId;
1731
1732     isSeparator = item->isSeparator;
1733     isTicked = item->isTicked;
1734     isEnabled = item->active;
1735     isSectionHeader = dynamic_cast <HeaderItemComponent*> (static_cast <CustomComponent*> (item->customComp)) != nullptr;
1736     isCustomComponent = (! isSectionHeader) && item->customComp != nullptr;
1737     customColour = item->usesColour ? &(item->textColour) : 0;
1738     customImage = item->image;
1739     commandManager = item->commandManager;
1740
1741     return true;
1742 }
1743
1744
1745 END_JUCE_NAMESPACE