cxNotebook.h

Go to the documentation of this file.

// Copyright (c) 2026 E. Oulashin
#ifndef __CXNOTEBOOK_H__
#define __CXNOTEBOOK_H__
 
// Copyright (c) 2007 Michael H. Kinney
 
#include "cxPanel.h"
#include <string>
#include <vector>
#include <map>
#include <memory>
 
namespace cx {
 
class cxNotebook: public cxPanel
{
 
   public:
 
      explicit cxNotebook(cxWindow *pParentWindow = nullptr,
                          int pRow = 0, int pCol = 0,
                          int pHeight = DEFAULT_HEIGHT,
                          int pWidth = DEFAULT_WIDTH,
                          bool pLabelsOnTop = true,
                          bool pLeftLabelSpace = true,
                          bool pRightLabelSpace = true,
                          int pTabSpacing = 0,
                          cxWindow *pExtTitleWindow = nullptr,
                          cxWindow *pExtStatusWindow = nullptr,
                          bool pTabNavWrap = true);
 
      virtual ~cxNotebook();
 
      void setLabelsOnTop(bool pLabelsOnTop, bool pRefresh = false);
 
      bool getLabelsOnTop() const;
 
      void setLeftLabelSpace(bool pLeftLabelSpace);
 
      bool getLeftLabelSpace() const;
 
      void setRightLabelSpace(bool pRightLabelSpace);
 
      bool getRightLabelSpace() const;
 
      bool setTabSpacing(int pTabSpacing, bool pRefresh = false);
 
      int getTabSpacing() const;
 
      void setTabNavWrap(bool pTabNavWrap);
 
      bool getTabNavWrap() const;
 
      virtual long show(bool pBringToTop = false, bool pShowSubwindows = true) override;
 
      virtual long showModal(bool pShowSelf = true, bool pBringToTop = true,
                             bool pShowSubwindows = true) override;
 
      virtual void hide(bool pHideSubwindows = true) override;
 
      virtual void unhide(bool pUnhideSubwindows = true) override;
 
      virtual std::string cxTypeStr() const override;
 
      virtual bool windowIsInNotebook(cxWindow *pWindow) const;
 
      virtual std::shared_ptr<cxPanel> append(const std::string& pLabel, const std::string& pPanelName = "");
 
      virtual cxPanel* getPanel(unsigned int pIndex) const;
 
      virtual cxPanel* getPanel(const std::string& pID, bool pIsLabel = true) const;
 
      virtual cxPanel* getCurrentPanelPtr() const;
 
      virtual bool move(int pNewRow, int pNewCol, bool pRefresh = true) override;
 
      virtual void setShowPanelWindow(unsigned int pIndex, bool pShowPanelWindow);
 
      virtual void setShowPanelWindow(const std::string& pID, bool pShowPanelWindow,
                                      bool pIsLabel = true);
 
      virtual bool getShowPanelWindow() const override;
 
      virtual bool getShowPanelWindow(unsigned int pIndex) const;
 
      virtual bool getShowPanelWindow(const std::string& pID, bool pIsLabel = true) const;
 
      virtual void showSubwindows(bool pBringToTop = true, bool pShowSubwindows = true) override;
 
      virtual std::string getLabel(unsigned int pIndex) const;
 
      virtual std::string getLabel(const std::string& pName) const;
 
      virtual bool setLabel(unsigned int pIndex, const std::string& pLabel, bool pRefresh = false);
 
      virtual bool setLabel(const std::string& pID, const std::string& pLabel,
                            bool pIsLabel = true, bool pRefresh = false);
 
      virtual void setEnabled(bool pEnabled) override;
 
      virtual void setEnabled(unsigned int pIndex, bool pEnabled) override;
 
      virtual void setEnabled(const std::string& pID, bool pEnabled, bool pIsTitle = true) override;
 
      void setNextTabKey(int pKey);
 
      int getNextTabKey() const;
 
      void setPrevTabKey(int pKey);
 
      int getPrevTabKey() const;
 
      void setTabNavKey(int pKey);
 
      int getTabNavKey() const;
 
      void setAllDisabledMsg(const std::string& pAllDisabledMsg);
 
      const std::string& getAllDisabledMsg() const;
 
      void setNoWindowsMsg(const std::string& pNoWindowsMsg);
 
      const std::string& getWindowDisabledMsg() const;
 
      void setWindowDisabledMsg(const std::string& pMsg);
 
      const std::string& getNoWindowsMsg() const;
 
      virtual bool mouseEvtWasInTitle() const override;
 
      virtual std::shared_ptr<cxWindow> removeWindow(unsigned int pIndex) override;
 
      virtual void removeWindow(cxWindow *pWindow) override;
 
      virtual void removeWindow(const std::shared_ptr<cxWindow>& pWindow) override;
 
      virtual void delWindow(unsigned int pIndex) override;
 
      virtual void delWindow(cxWindow *pWindow);
 
      virtual void delWindow(const std::shared_ptr<cxWindow>& pWindow) override;
 
      virtual bool setCurrentWindow(unsigned int pIndex) override;
 
      virtual bool setCurrentWindow(const std::string& pTitle);
 
      virtual bool setCurrentWindow(const std::string& pID, bool pIsLabel) override;
 
      virtual bool setCurrentWindowByPtr(cxWindow *pWindow) override;
 
      virtual bool setCurrentWindowByPtr(const std::shared_ptr<cxWindow>& pWindow) override;
 
      virtual bool windowIsInPanel(const std::shared_ptr<cxWindow>& pWindow) const override;
 
      virtual int lastClickTabIndex() const;
 
      virtual bool swap(int pWindow1Index, int pWindow2Index) override;
 
      virtual bool swap(const std::shared_ptr<cxWindow>& pWindow1, const std::shared_ptr<cxWindow>& pWindow2) override;
      virtual bool swap(cxWindow *pWindow1, cxWindow *pWindow2) override;
 
      bool selectNextWin();
 
      bool selectPrevWin();
 
   private:
      typedef std::vector<std::shared_ptr<cxWindow> > labelWinContainer;
      labelWinContainer mLabels;      // These act as labels for the tabs
      bool mLabelsOnTop;              // Can determine if the labels are on top or bottom
      bool mLeftLabelSpace;           // Whether to have a space to the left of label text
      bool mRightLabelSpace;          // Whether to have a space to the right of label text
      int mCurrentPanelIndex = 0;     // Index of the current panel
      int mNextTabKey = PAGE_DOWN;    // The key to use to go to the next tab
      int mPrevTabKey = PAGE_UP;      // The key to use to go to the previous tab
      int mTabNavKey;                 // The key to use to bring up a tab navigation menu
      std::string mAllDisabledMsg;    // Message to display when all windows are disabled
      std::string mNoWindowsMsg;      // Message to display when the notebook has no windows
      std::string mWindowDisabledMsg; // Message to display when a window is disabled
      int mTabSpacing;                // # of spaces between the tabs
      int mLastClickTabIndex = -1;    // Index of the window that was clicked on
      // mTabNavWrap controls whether "wrapping" occurs if user wants to
      //  navigate to the next/previous tab with the keyboard and they're
      //  on the last/first enabled tab.
      bool mTabNavWrap;
 
      // Runs the input loop
      //
      // Parameters:
      //  pRunOnLeaveFunction (OUT): This will store whether or not the onLeave
      //   function should run.
      long doInputLoop(bool& pRunOnLeaveFunction);
 
      // Shows the current panel, and hides the others
      //
      // Parameters:
      //  pApplylabelAttr: Whether or not to apply the label window attribute.
      //   Defaults to true.
      //  pBringToTop: Whether or not to bring the current panel to the top of
      //   the stack.  Defaults to true.
      void showCurrentWindow(bool pApplyLabelAttr = true, bool pBringToTop = true);
 
      // Sets up the special border characters for a label window.  This is a
      //  helper that is called when appending a panel and when the user
      //  changes one of the labels.
      //
      // Parameters:
      //  pIndex: The index of the label window.  The label windows to the left
      //   and to the right of the window will also have their border characters
      //   set.
      void setLabelWinSpecialChars(unsigned int pIndex);
 
      // Sets the special border characters for all label windows
      inline void setAllLabelWinSpecialChars();
 
      // Makes sure that all the label windows are where they should be.  Also
      //  makes sure they have the proper speical border characters.
      //
      // Parameters:
      //  pRefresh: Whether or not to refresh the screen.  Defaults to false.
      void alignLabelWindows(bool pRefresh = false);
 
      // Dis-allow some of cxPanel's methods from being called by users of
      //  this class
      bool getExitOnLeaveLast() const override;
      void setExitOnLeaveLast(bool pExitOnLeaveLast) override;
      bool getExitOnLeaveFirst() const override;
      void setExitOnLeaveFirst(bool pExitOnLeaveFirst) override;
      bool windowIsInPanel(cxWindow *pWindow) const override;
      bool append(const std::shared_ptr<cxWindow>& pWindow) override;
      bool append(const std::shared_ptr<cxWindow>& pWindow, int pRow, int pCol, bool pRefresh = false) override;
      void setShowPanelWindow(bool pShowPanelWindow) override;
 
      // Don't allow copy construction or assignment
      cxNotebook(const cxNotebook& pNotebook);
      cxNotebook& operator =(const cxNotebook& pNotebook);
 
      void setupLabelBorder(int pIndex, bool pClear = false);
 
      // This is a helper for setupLabelBorder().  It removes all strings from
      //  a title/status map that are all spaces.
      static void removeSpaceStrings(std::map<int, std::string>& pStringMap);
 
      // Shows a tab navigation menu, allowing the user to choose another tab
      //  to go to.
      void showNavMenu();
 
}; // end of class cxNotebook
 
} // namespace cx
 
#endif