cxPanel.h

Go to the documentation of this file.

// Copyright (c) 2026 E. Oulashin
#ifndef __CXPANEL_H__
#define __CXPANEL_H__
 
// Copyright (c) 2006-2007 Michael H. Kinney
 
#include "cxWindow.h"
#include <string>
#include <vector>
#include <memory>
 
namespace cx {
 
class cxPanel : public cxWindow
{
   public:
      explicit cxPanel(cxWindow *pParentWindow = nullptr,
                       int pRow = 0, int pCol = 0,
                       int pHeight = DEFAULT_HEIGHT,
                       int pWidth = DEFAULT_WIDTH,
                       const std::string& pTitle = "",
                       const std::string& pMessage = "",
                       const std::string& pStatus = "",
                       eBorderStyle pBorderStyle = eBS_NOBORDER,
                       cxWindow *pExtTitleWindow = nullptr,
                       cxWindow *pExtStatusWindow = nullptr,
                       bool pMessageUnderlines = false);
 
      virtual ~cxPanel();
 
      virtual long showModal(bool pShowSelf = true, bool pBringToTop = true,
                             bool pShowSubwindows = true) override;
 
      virtual bool getExitOnLeaveLast() const;
 
      virtual void setExitOnLeaveLast(bool pExitOnLeaveLast);
 
      virtual bool getExitOnLeaveFirst() const;
 
      virtual void setExitOnLeaveFirst(bool pExitOnLeaveFirst);
 
      virtual unsigned int numWindows() const;
 
      virtual std::shared_ptr<cxWindow> getWindow(unsigned pIndex) const;
 
      virtual bool append(const std::shared_ptr<cxWindow>& pWindow);
 
      virtual bool append(const std::shared_ptr<cxWindow>& pWindow, int pRow, int pCol, bool pRefresh = false);
 
      virtual void delWindow(unsigned pIndex);
 
      virtual void delWindow(const std::shared_ptr<cxWindow>& pWindow);
 
      virtual void delAllWindows();
 
      virtual std::shared_ptr<cxWindow> removeWindow(unsigned int pIndex);
 
      virtual void removeWindow(const std::shared_ptr<cxWindow>& pWindow);
      virtual void removeWindow(cxWindow *pWindow);
 
      virtual bool windowIsInPanel(const std::shared_ptr<cxWindow>& pWindow) const;
      virtual bool windowIsInPanel(cxWindow *pWindow) const;
 
      virtual bool move(int pNewRow, int pNewCol, bool pRefresh = true) override;
 
      virtual bool setCurrentWindow(unsigned pIndex);
 
      virtual bool setCurrentWindow(const std::string& pID, bool pIsTitle = true);
 
      virtual bool setCurrentWindowByPtr(const std::shared_ptr<cxWindow>& pWindow);
      virtual bool setCurrentWindowByPtr(cxWindow *pWindow);
 
      virtual bool setKeyFunction(int pKey, const std::shared_ptr<cxFunction>& pFunction) override;
 
      virtual void clearKeyFunction(int pKey) override;
 
      virtual bool setKeyFunction(int pKey, funcPtr4 pFunction,
                                  void *p1, void *p2, void *p3, void *p4,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true) override;
 
      virtual bool setKeyFunction(int pKey, funcPtr2 pFunction,
                                  void *p1, void *p2,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true) override;
 
      virtual bool setKeyFunction(int pKey, funcPtr0 pFunction,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true) override;
 
      virtual int getCurrentWindowIndex() const;
 
      virtual int getWindowIndex(const std::shared_ptr<cxWindow>& pWindow) const;
      virtual int getWindowIndex(cxWindow *pWindow) const;
 
      virtual const std::shared_ptr<cxWindow>& getCurrentWindowPtr() const;
 
      virtual long show(bool pBringToTop = false, bool pShowSubwindows = true) override;
 
      virtual void hide(bool pHideSubwindows = true) override;
 
      virtual void unhide(bool pUnhideSubwindows = true) override;
 
      virtual bool getShowPanelWindow() const;
 
      virtual void setShowPanelWindow(bool pShowPanelWindow);
 
      virtual bool getAllowExit() const;
 
      virtual void setAllowExit(bool pAllowExit);
 
      virtual bool getAllowQuit() const;
 
      virtual void setAllowQuit(bool pAllowQuit);
 
      virtual bool windowIsEnabled(unsigned pIndex) const;
 
      virtual void enableWindow(unsigned pIndex, bool pEnabled = true);
 
      virtual void clear(bool pRefresh = false) override;
 
      virtual bool addQuitKey(int pKey, bool pRunOnLeaveFunction = true,
                              bool pOverride = false) override;
 
      virtual void removeQuitKey(int pKey) override;
 
      virtual bool addExitKey(int pKey, bool pRunOnLeaveFunction = true,
                              bool pOverride = false) override;
 
      virtual void removeExitKey(int pKey) override;
 
      virtual void setEnabled(bool pEnabled) override;
 
      virtual void setEnabled(unsigned pIndex, bool pEnabled);
 
      virtual void setEnabled(const std::string& pID, bool pEnabled, bool pIsTitle = true);
 
      virtual bool swap(int pWindow1Index, int pWindow2Index);
 
      virtual bool swap(cxWindow *pWindow1, cxWindow *pWindow2);
      virtual bool swap(const std::shared_ptr<cxWindow>& pWindow1, const std::shared_ptr<cxWindow>& pWindow2);
 
      virtual void setColor(e_WidgetItems pItem, e_cxColors pColor) override;
 
      virtual std::string cxTypeStr() const override;
 
      virtual void quitNow() override;
 
      virtual void exitNow() override;
 
      const std::shared_ptr<cxWindow>& getLastWindow() const;
 
      virtual void setName(unsigned pIndex, const std::string& pName);
 
      virtual void setName(const std::string& pID, const std::string& pName, bool pIsTitle = true);
 
      virtual void setName(const std::string& pName) override;
 
      virtual int top() const override;
 
      virtual int bottom() const override;
 
   protected:
      typedef std::vector<std::shared_ptr<cxWindow> > cxWindowPtrCollection;
      cxWindowPtrCollection mWindows;        // The windows in the panel to cycle between
      bool mCycleWin = true;                 // Whether or not to cycle to the next/previous
                                             //  window in the input loop (this is set false
                                             //  in setCurrentWindow()).
      std::shared_ptr<cxWindow> mLastWindow; // The last window visited during the input loop
 
      bool anyEnabledWindows() const;
 
      bool lastEnabledWindow(int pIndex) const;
 
      bool firstEnabledWindow(int pIndex) const;
 
   private:
      friend class cxWindow;
 
      cxWindowPtrCollection::iterator mWindowIter; // To keep track of current window
      bool mExitOnLeaveLast = false;   // Exit the input loop when leaving last window?
      bool mExitOnLeaveFirst = false;  // Exit the input loop when leaving first window?
      bool mAllowExit = true;         // Whether or not the user is allowed to exit
      bool mAllowQuit = true;         // Whether or not the user is allowed to quit
      // If mShowPanelWindow is true (default), the panel window
      // will be shown (in addition to the subwindows and the windows
      // in the panel).  If it is false, only the windows in the
      // panel will be shown.
      bool mShowPanelWindow = true;
 
      // Adds a cxWindow pointer to mWindows.  Also checks to see
      // if the cxWindow already has a cxPanel parent, and if so,
      // will remove the window from the other cxPanel.
      //
      // Parameters:
      //  pWindow: A cxWindow pointer to be added to mWindows.
      //
      // Return: true if the window was added, or false if not.
      bool addWindowPtr(const std::shared_ptr<cxWindow>& pWindow);
 
      // Does the input loop.  Returns the return code
      //  according to the user's input.
      // Parameters:
      //  pSubwinShow: Whether or not to have the subwindows show
      //   themselves before doing their input loops.
      //  pRunOnLeaveFunction (OUT): This will store whether or not the onLeave
      //   function should run.
      long doInputLoop(bool pSubwinShow, bool& pRunOnLeaveFunction);
 
      // This adds an exit key to one of the windows in the panel.  If the
      //  window is a cxMenu and if the key is one of the menu's up/down
      //  navigational keys, however, the exit key will not be added to the
      //  menu.
      //
      // Parameters:
      //  pWindow: A pointer to the cxWindow to add the exit key to
      //  pKey: The key to add as the exit key
      //  pRunOnLeaveFunction: Whether or not the window should run its
      //   onLeave function before leaving focus
      //  pOverride: Whether or not the key should override a function call
      //   for the key, if there is one set up
      //
      // Note: This is inline for speed (this function will get called
      //  inside of a loop).
      inline void addExitKeyToWindow(std::shared_ptr<cxWindow>& pWindow, int pKey,
                              bool pRunOnLeaveFunction, bool pOverride);
 
      // This adds a quit key to one of the windows in the panel.  If the
      //  window is a cxMenu and if the key is one of the menu's up/down
      //  navigational keys, however, the quit key will not be added to the
      //  menu.
      //
      // Parameters:
      //  pWindow: A pointer to the cxWindow to add the quit key to
      //  pKey: The key to add as the quit key
      //  pRunOnLeaveFunction: Whether or not the window should run its
      //   onLeave function before leaving focus
      //  pOverride: Whether or not the key should override a function call
      //   for the key, if there is one set up
      //
      // Note: This is inline for speed (this function will get called
      //  inside of a loop).
      inline void addQuitKeyToWindow(std::shared_ptr<cxWindow>& pWindow, int pKey,
                              bool pRunOnLeaveFunction, bool pOverride);
 
      // Don't allow copy construction or assignment
      cxPanel(const cxPanel& pThatPanel);
      cxPanel& operator =(const cxPanel& pThatPanel);
};
 
} // namespace cx
 
#endif