IPopupMenuControl.h

Go to the documentation of this file.

/*
 ==============================================================================
 
 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers.
 
 See LICENSE.txt for  more info.
 
 ==============================================================================
*/
 
#pragma once
 
#include "IControl.h"
 
BEGIN_IPLUG_NAMESPACE
BEGIN_IGRAPHICS_NAMESPACE
 
class IPopupMenuControl : public IControl
{
  class MenuPanel;
    
public:
  enum EPopupState
  {
    kCollapsed = 0,
    kExpanding,
    kExpanded,
    kCollapsing,
    kFlickering, // on click
    kSubMenuAppearing, // when a submenu appears, only that menu is faded in
    kIdling,
  };
 
  enum EArrowDir
  {
    kNorth,
    kEast,
    kSouth,
    kWest
  };
 
  IPopupMenuControl(int paramIdx = kNoParameter, IText text = IText(16), IRECT collapsedBounds = IRECT(), IRECT expandedBounds = IRECT());
  virtual ~IPopupMenuControl();
 
  //IControl
  void Draw(IGraphics& g) override;
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnMouseDrag(float x, float y, float dX, float dY, const IMouseMod& mod) override;
  void OnMouseOver(float x, float y, const IMouseMod& mod) override;
  void OnMouseOut() override;
  void OnMouseWheel(float x, float y, const IMouseMod& mod, float d) override;
  void OnEndAnimation() override;
 
  //IPopupMenuControl
 
  void CalculateMenuPanels(float x, float y);
 
  virtual void DrawCalloutArrow(IGraphics& g, const IRECT& bounds, IBlend* pBlend);
  virtual void DrawSubMenuCalloutArrow(IGraphics& g, const IRECT& bounds, IBlend* pBlend);
  virtual void DrawPanelBackground(IGraphics& g, MenuPanel* panel);
  virtual void DrawPanelShadow(IGraphics& g, MenuPanel* panel);
  virtual void DrawCellBackground(IGraphics& g, const IRECT& bounds, const IPopupMenu::Item* pItem, bool sel, IBlend* pBlend);
  virtual void DrawCellText(IGraphics& g, const IRECT& bounds, const IPopupMenu::Item* pItem, bool sel, IBlend* pBlend);
  virtual void DrawTick(IGraphics& g, const IRECT& bounds, const IPopupMenu::Item* pItem, bool sel, IBlend* pBlend);
  virtual void DrawSubMenuArrow(IGraphics& g, const IRECT& bounds, const IPopupMenu::Item* pItem, bool sel, IBlend* pBlend);
  virtual void DrawUpArrow(IGraphics& g, const IRECT& bounds, bool sel, IBlend* pBlend);
  virtual void DrawDownArrow(IGraphics& g, const IRECT& bounds, bool sel, IBlend* pBlend);
  virtual void DrawSeparator(IGraphics& g, const IRECT& bounds, IBlend* pBlend);
  
  void SetPanelColor(IColor color) { mPanelBackgroundColor = color; }
  void SetCellBackgroundColor(IColor color) { mCellBackGroundColor = color; }
  void SetItemMouseoverColor(IColor color) { mItemMouseoverColor = color; }
  void SetItemColor(IColor color) { mItemColor = color; }
  void SetDisabledItemColor(IColor color) { mDisabledItemColor = color; }
  void SetSeparatorColor(IColor color) { mSeparatorColor = color; }
  void SetShiftForSubmenus(float distance) { mMenuShift = distance; }
  void SetMenuForcedSouth(bool isForcedSouth) { mForcedSouth = isForcedSouth;}
 
  void CreatePopupMenu(IPopupMenu& menu, const IRECT& anchorArea);
 
  bool GetExpanded() const { return mState == kExpanded; }
 
  EPopupState GetState() const { return mState; }
 
  void SetExpandedBounds(const IRECT& bounds) { mSpecifiedExpandedBounds = bounds; }
 
  void SetCallout(bool callout) { mCallOut = callout; }
 
  void SetMaxBounds(const IRECT& bounds) { mMaxBounds = bounds; }
 
private:
  IRECT GetLargestCellRectForMenu(IPopupMenu& menu, float x, float y) const;
  
  void GetPanelDimensions(IPopupMenu&menu, float& width, float& height) const;
 
  void Expand(const IRECT& bounds);
 
  virtual void CollapseEverything();
 
private:
 
  class MenuPanel
  {
  public:
    MenuPanel(IPopupMenuControl& owner, IPopupMenu& menu, float x, float y, int parentIdx);
    ~MenuPanel();
      
    MenuPanel(const MenuPanel&) = delete;
    MenuPanel& operator=(const MenuPanel&) = delete;
      
    float CellWidth() const { return mSingleCellBounds.W(); }
 
    float CellHeight() const { return mSingleCellBounds.H(); }
 
    void ScrollUp() { mScrollItemOffset--; mScrollItemOffset = Clip(mScrollItemOffset, 0, mCellBounds.GetSize()-1); }
 
    void ScrollDown() { mScrollItemOffset++; mScrollItemOffset = Clip(mScrollItemOffset, 0, mMenu.NItems()-mCellBounds.GetSize()); }
 
    IRECT* HitTestCells(float x, float y) const;
 
   public:
    IPopupMenu& mMenu; // The IPopupMenu that this MenuPanel is displaying
    WDL_PtrList<IRECT> mCellBounds; // The size of this array will always correspond to the number of items in the top level of the menu
 
    IRECT mRECT; // The drawing bounds for this panel
    IRECT mTargetRECT; // The mouse target bounds for this panel
    int mScrollMaxRows = 0; // 0 when no scroll
    bool mShouldDraw = true; // boolean determining whether this panel should be drawn
    IBlend mBlend = { EBlend::Default, 0.f }; // blend for sub panels appearing
 
    IRECT mSingleCellBounds; // The dimensions of the largest cell for the menu
    IRECT* mHighlightedCell = nullptr; // A pointer to one of the IRECTs in mCellBounds, if one should be highlighted
    IRECT* mClickedCell = nullptr; // A pointer to one of the IRECTs in mCellBounds, if one has been clicked
    int mParentIdx = 0; // An index into the IPopupMenuControl::mMenuPanels lists, representing the parent menu panel
    bool mScroller = false;
    int mScrollItemOffset = 0;
      
#ifndef IGRAPHICS_NANOVG
    ILayerPtr mShadowLayer;
#endif
  };
 
  WDL_PtrList<MenuPanel> mMenuPanels; // An array of ptrs to MenuPanel objects for every panel, expands as sub menus are revealed, contents deleted when the menu is dismissed
  MenuPanel* mActiveMenuPanel = nullptr; // A pointer to the active MenuPanel within the mMenuPanels array
  MenuPanel* mAppearingMenuPanel = nullptr; // A pointer to a MenuPanel that's in the process of fading in
  EPopupState mState = kCollapsed; // The state of the pop-up, mainly used for animation
  IRECT* mMouseCellBounds = nullptr;
  IPopupMenu* mMenu = nullptr; // Pointer to the main IPopupMenu, that this control is visualising. This control does not own the menu.
    
  int mMaxColumnItems = 0; // How long the list can get before adding a new column - 0 equals no limit
  bool mScrollIfTooBig = true; // If the menu is higher than the graphics context, should it scroll or should it start a new column
  bool mCallOut = false; // set true if popup should be outside of bounds (i.e. on a tablet touchscreen interface)
  bool mMenuHasSubmenu = false; // Gets automatically set to true in CreatePopupMenu() if *mMenu contains any submenus... false if not.
  bool mForcedSouth = true; // if set true, a menu in the lower half of the GUI will appear below it's control if there is enough room for it.
  bool mSubmenuOnRight = true; // If set true, the submenu will be drawn on the right of the parent menu.... on the left if false.
  bool mSubMenuOpened = false; // Is set true when a submenu panel is open and false when menu is collapsed.
 
  float mCellGap = 2.f; // The gap between cells in pixels
  float mSeparatorSize = 2.; // The size in pixels of a separator. This could be width or height
  float mRoundness = 5.f; // The roundness of the corners of the menu panel backgrounds
  float mDropShadowSize = 10.f; // The size in pixels of the drop shadow
  float mOpacity = 0.95f; // The opacity of the menu panel backgrounds when fully faded in
  float mMenuShift = 0.f; // The distance in pixels the main menu is shifted to make room for submenus (only if one exist). Set by SetShiftForSubmenus()
 
  const float TEXT_HPAD = 5.; // The amount of horizontal padding on either side of cell text in pixels
  const float TICK_SIZE = 10.; // The size of the area on the left of the cell where a tick mark appears on checked items - actual
  const float ARROW_SIZE = 8; // The width of the area on the right of the cell where an arrow appears for new submenus
  const float PAD = 5.; // How much white space between the background and the cells
  const float CALLOUT_SPACE = 8; // The space between start bounds and callout
  IRECT mAnchorArea; // The area where the menu was triggered; menu will be adjacent, but won't occupy it.
  EArrowDir mCalloutArrowDir = kEast;
  IRECT mCalloutArrowBounds; // The rectangle in which the CallOut arrow is drawn.
  IRECT mSubMenuCalloutArrowBounds; // The rectangle in which the CallOut arrow for a submenus is drawn.
 
  IRECT mMaxBounds; // if view is only showing a part of the graphics context, we need to know because menus can't go there
  
  IColor mPanelBackgroundColor = COLOR_WHITE;
  IColor mCellBackGroundColor = COLOR_BLUE;
  IColor mItemMouseoverColor = COLOR_WHITE;
  IColor mItemColor = COLOR_BLACK;
  IColor mDisabledItemColor = COLOR_GRAY;
  IColor mSeparatorColor = COLOR_MID_GRAY;
 
protected:
  IRECT mSpecifiedCollapsedBounds;
  IRECT mSpecifiedExpandedBounds;
};
 
END_IGRAPHICS_NAMESPACE
END_IPLUG_NAMESPACE