cxWindow.h

Go to the documentation of this file.

// Copyright (c) 2026 E. Oulashin
#ifndef __CXWINDOW_H__
#define __CXWINDOW_H__
 
// Copyright (c) 2005-2007 Michael H. Kinney
 
// The cxWindow class is used to draw windows/boxes on the screen.
// Note: Quite a few objects are derived from this class.
// Note: If cxWindow is updated so that it might not wait for a keypress in
//  its input loop, modalGetsKeypress() will need to be updated to reflect
//  this.
//
// Maybe in the future we can add a window ID member variable (and
//  parameters to the constructors, making sure it's consistent with
//  wxWidgets classes).  This way, as in the wxWidgets framework, we
//  can identify what command came from which window, etc.).
 
#include "cxObject.h"
#include "cxPositions.h"
#include "cxReturnCodes.h"
#include "cxBorderStyles.h"
#include "cxMiscDefines.h"
#include "cxFunction.h"
#include "cxWidgetItems.h"
#include <unistd.h>
#include <sstream>
#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <utility>
#include <memory>
 
namespace cx {
 
class cxWindow;
typedef std::vector<cxWindow*> cxWindowPtrContainer;
 
// If the version of ncurses on the current machine doesn't support the mouse,
//  then define some of ncurses' mouse event macros so that code using them
//  will still compile.
#ifndef NCURSES_MOUSE_VERSION
   #define BUTTON1_PRESSED 2
   #define BUTTON1_RELEASED 1
   #define BUTTON1_CLICKED 4
   #define BUTTON1_DOUBLE_CLICKED 8
   #define BUTTON1_TRIPLE_CLICKED 16
   #define BUTTON2_PRESSED 128
   #define BUTTON2_RELEASED 64
   #define BUTTON2_CLICKED 256
   #define BUTTON2_DOUBLE_CLICKED 512
   #define BUTTON2_TRIPLE_CLICKED 1024
   #define BUTTON3_PRESSED 8192
   #define BUTTON3_RELEASED 4096
   #define BUTTON3_CLICKED 16384
   #define BUTTON3_DOUBLE_CLICKED 32768
   #define BUTTON3_TRIPLE_CLICKED 65536
   #define BUTTON4_PRESSED 524288
   #define BUTTON4_RELEASED 262144
   #define BUTTON4_CLICKED 1048576
   #define BUTTON4_DOUBLE_CLICKED 2097152
   #define BUTTON4_TRIPLE_CLICKED 4194304
#endif
 
#define DEFAULT_HEIGHT 24
#define DEFAULT_WIDTH  80
 
typedef std::deque<std::string> messageLineContainer;
 
class cxWindow : public cxObject
{
   public:
      explicit cxWindow(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_SINGLE_LINE,
                        cxWindow *pExtTitleWindow = nullptr,
                        cxWindow *pExtStatusWindow = nullptr,
                        bool pHotkeyHighlighting = false);
 
      cxWindow(cxWindow *pParentWindow,
               int pRow, int pCol, const std::string& pTitle,
               const std::string& pMessage, const std::string& pStatus,
               cxWindow *pExtTitleWindow = nullptr,
               cxWindow *pExtStatusWindow = nullptr,
               bool pHotkeyHighlighting = false);
      cxWindow(cxWindow *pParentWindow,
               const std::string& pTitle, const std::string& pMessage,
               const std::string& pStatus,
               cxWindow *pExtTitleWindow = nullptr,
               cxWindow *pExtStatusWindow = nullptr,
               bool pHotkeyHighlighting = false);
 
      cxWindow(cxWindow *pParentWindow,
               const std::string& pTitle, const std::string& pMessage,
               const std::string& pStatus,
               int pHeight, int pWidth,
               cxWindow *pExtTitleWindow = nullptr,
               cxWindow *pExtStatusWindow = nullptr,
               bool pHotkeyHighlighting = false);
 
      cxWindow(cxWindow *pParentWindow,
               const std::string& pMessage, const std::string& pStatus,
               cxWindow *pExtTitleWindow = nullptr,
               cxWindow *pExtStatusWindow = nullptr,
               bool pHotkeyHighlighting = false);
 
      cxWindow(cxWindow *pParentWindow,
               const std::string& pMessage, const std::string& pStatus,
               int pHeight, int pWidth,
               cxWindow *pExtTitleWindow = nullptr,
               cxWindow *pExtStatusWindow = nullptr,
               bool pHotkeyHighlighting = false);
 
      cxWindow(cxWindow *pParentWindow, const std::string& pMessage,
               cxWindow *pExtTitleWindow = nullptr,
               cxWindow *pExtStatusWindow = nullptr,
               bool pHotkeyHighlighting = false);
      cxWindow(cxWindow *pParentWindow, eHPosition pHPosition,
               const std::string& pTitle, const std::string& pMessage,
               const std::string& pStatus,
               cxWindow *pExtTitleWindow = nullptr,
               cxWindow *pExtStatusWindow = nullptr,
               bool pHotkeyHighlighting = false);
 
      cxWindow(const cxWindow& pThatWindow);
 
      virtual ~cxWindow();
 
      virtual void centerHoriz(bool pRefresh = true);
 
      virtual void alignHoriz(eHPosition pPosition, bool pRefresh = true);
 
      virtual void centerVert(bool pRefresh = true);
 
      virtual void alignVert(eVPosition pPosition, bool pRefresh = true);
 
      virtual void center(bool pRefresh = true);
 
      virtual std::string getTitle() const;
 
      virtual void setTitle(const std::string& pTitle, bool pRefreshTitle = true);
 
      std::string getStatus() const;
 
      virtual void setStatus(const std::string& pStatus, bool pRefreshStatus = true);
 
      std::string getMessage() const;
 
      virtual void setMessage(const std::string &pMessage);
 
      virtual void addMessageLineBelow(const std::string &pLine);
 
      virtual void addMessageLinesBelow(const std::vector<std::string>& pLines);
 
      virtual void addMessageLinesBelow(const std::list<std::string>& pLines);
 
      virtual void addMessageLinesBelow(const std::deque<std::string>& pLines);
 
      virtual void addMessageLineAbove(const std::string& pLine);
 
      virtual void addMessageLinesAbove(const std::vector<std::string>& pLines);
 
      virtual void addMessageLinesAbove(const std::list<std::string>& pLines);
 
      virtual void addMessageLinesAbove(const std::deque<std::string>& pLines);
 
      virtual void setMessageLines(const std::vector<std::string>& pLines);
 
      virtual void setMessageLines(const std::list<std::string>& pLines);
 
      virtual void setMessageLines(const std::deque<std::string>& pLines);
 
      virtual void removeMessageLine(unsigned pIndex);
 
      virtual void setMessageLine(unsigned pIndex, const std::string& pLine);
 
      void setHorizTitleAlignment(eHPosition pHAlignment);
 
      eHPosition getHorizTitleAlignment() const;
 
      void setHorizMessageAlignment(eHPosition pHAlignment);
 
      eHPosition getHorizMessageAlignment() const;
 
      void setHorizStatusAlignment(eHPosition pHAlignment);
 
      eHPosition getHorizStatusAlignment() const;
 
      void setVerticalMessageAlignment(eVPosition pVAlignment);
 
      eVPosition getVerticalMessageAlignment() const;
 
      void setExtTitleWindow(cxWindow *pWindow, bool pRefreshTitle = true);
 
      cxWindow* getExtTitleWindow() const;
 
      void setExtStatusWindow(cxWindow *pWindow, bool pRefreshStatus = true);
 
      cxWindow* getExtStatusWindow() const;
 
      bool isHidden() const;
 
      virtual long show(bool pBringToTop = false, bool pShowSubwindows = true);
 
      virtual long showModal(bool pShowSelf = true, bool pBringToTop = true,
                             bool pShowSubwindows = true);
 
      virtual bool modalGetsKeypress() const;
 
      virtual long setFocus(bool pShowSelf = true, bool pBringToTop = true,
                            bool pShowSubwindows = true);
 
      virtual void setFocusColors();
 
      virtual void setFocusColors(attr_t pAttr);
 
      virtual void unSetFocusColors();
 
      virtual void unSetFocusColors(attr_t pAttr);
 
      virtual void erase(bool pEraseSubwindows = true);
 
      virtual void bringToTop(bool pRefresh = true);
 
      virtual void bringToBottom(bool pRefresh = false);
 
      virtual bool isOnTop() const;
 
      virtual bool isOnBottom() const;
 
      virtual bool isAbove(const cxWindow& pThatWindow) const;
 
      virtual bool isBelow(const cxWindow& pThatWindow) const;
 
      virtual void hide(bool pHideSubwindows = true);
 
      virtual void unhide(bool pUnhideSubwindows = true);
 
      void touchWindow() { if (mWindow) touchwin(mWindow); }
 
      virtual void drawBorder(int pRow, int pCol, int pHeight, int pWidth,
                              bool pTop=true, bool pBottom=true,
                              bool pLeft=true, bool pRight=true);
 
      virtual void drawBorder(int pHeight, int pWidth);
 
      virtual void drawBorder();
 
      virtual int top() const;
 
      virtual int centerRow() const;
 
      virtual int bottom() const;
 
      virtual int left() const;
 
      virtual int centerCol() const;
 
      virtual int right() const;
 
      virtual int width(int pWidth);
 
      virtual int width() const;
 
      virtual int height(int pHeight);
 
      virtual int height() const;
 
      virtual void getRect(int& pTop, int& pLeft, int& pBottom, int& pRight);
 
      virtual bool pointIsInWindow(int pY, int pX) const;
 
      virtual bool pointIsInTitle(int pY, int pX) const;
 
      virtual void getSize(int& pHeight, int& pWidth);
 
      virtual void addAttr(e_WidgetItems pItem, attr_t pAttr);
 
      virtual void setAttr(e_WidgetItems pItem, attr_t pAttr);
 
      virtual void removeAttr(e_WidgetItems pItem, attr_t pAttr);
 
      virtual void removeAttrs(e_WidgetItems pItem);
 
      virtual void getAttrs(e_WidgetItems pItem, std::set<attr_t>& pAttrs) const;
 
      virtual void resize(int pNewHeight, int pNewWidth, bool pRefresh = true);
 
      virtual bool move(int pNewRow, int pNewCol, bool pRefresh = true);
 
      virtual bool moveRelative(int pVerticalOffset, int pHorizOffset, bool pRefresh = true);
 
      unsigned numSubWindows();
 
      void setSubWinMessage(unsigned pIndex, const std::string& pMessage);
 
      void setSubWinMessage(const std::string& pTitle, const std::string& pMessage);
 
      virtual bool hasFocus() const;
 
      virtual void setBorderStyle(eBorderStyle pBorderStyle);
 
      eBorderStyle getBorderStyle() const;
 
      bool hasBorder() const;
 
      virtual cxWindow* getParent() const;
 
      void setParent(cxWindow *pNewParent);
 
      virtual void dump(std::string& pResult);
 
      virtual void showSubwindows(bool pBringToTop = true, bool pShowSubwindows = true);
 
      cxWindow& operator =(const cxWindow& pThatWindow);
 
      virtual void writeText(int pRow, int pCol, const std::string& pText, bool pRefresh = true);
 
      virtual void setHotkeyHighlighting(bool pHotkeyHighlighting);
 
      bool getHotkeyHighlighting() const;
 
      virtual bool isEnabled() const;
 
      virtual void setEnabled(bool pEnabled);
 
      virtual void setDisableCursorOnShow(bool pDisableCursorOnShow);
 
      virtual bool getDisableCursorOnShow() const;
 
      virtual bool getExitOnMouseOutside() const;
 
      virtual void setExitOnMouseOutside(bool pExitOnMouseOutside);
 
      virtual int getLastKey() const;
 
      virtual void setLastKey(int pLastKey);
 
      virtual bool lastKeyWasMouseEvt() const;
 
      virtual void getLastMouseEvtCoords(int& pY, int& pX);
 
      virtual bool getChangeColorsOnFocus() const;
 
      virtual void setChangeColorsOnFocus(bool pChangeColorsOnFocus);
 
      virtual void setOnFocusFunction(const std::shared_ptr<cxFunction>& pFunction);
 
      virtual void setOnFocusFunction(funcPtr4 pFunction, void *p1, void *p2,
                              void *p3, void *p4, bool pUseVal = false,
                              bool pExitAfterRun = false);
 
      virtual void setOnFocusFunction(funcPtr2 pFunction, void *p1, void *p2,
                              bool pUseVal = false, bool pExitAfterRun = false);
 
      virtual void setOnFocusFunction(funcPtr0 pFunction, bool pUseVal = false,
                                      bool pExitAfterRun = false);
 
      virtual void setOnLeaveFunction(const std::shared_ptr<cxFunction>& pFunction);
 
      virtual void setOnLeaveFunction(funcPtr4 pFunction, void *p1, void *p2, void *p3,
                                      void *p4);
 
      virtual void setOnLeaveFunction(funcPtr2 pFunction, void *p1, void *p2);
 
      virtual void setOnLeaveFunction(funcPtr0 pFunction);
 
      virtual bool runOnFocusFunction(std::string *pFunctionRetval = nullptr);
 
      virtual bool runOnLeaveFunction(std::string *pFunctionRetval = nullptr);
 
      virtual void toggleOnFocusFunction(bool pRunOnFocus);
 
      virtual void toggleOnLeaveFunction(bool pRunOnLeave);
 
      virtual bool onFocusFunctionEnabled() const;
 
      virtual bool onLeaveFunctionEnabled() const;
 
      virtual const std::shared_ptr<cxFunction>& getOnFocusFunction() const;
 
      virtual const std::shared_ptr<cxFunction>& getOnLeaveFunction() const;
 
      virtual bool isModal() const;
 
      virtual bool setKeyFunction(int pKey, const std::shared_ptr<cxFunction>& pFunction);
 
      virtual bool setKeyFunction(int pKey, funcPtr4 pFunction,
                                  void *p1, void *p2, void *p3, void *p4,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true);
 
      virtual bool setKeyFunction(int pKey, funcPtr2 pFunction,
                                  void *p1, void *p2,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true);
 
      virtual bool setKeyFunction(int pKey, funcPtr0 pFunction,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true);
 
      virtual void clearKeyFunction(int pKey);
 
      virtual void clearKeyFunctionByPtr(funcPtr4 pFunction);
 
      virtual void clearKeyFunctionByPtr(funcPtr2 pFunction);
 
      virtual void clearKeyFunctionByPtr(funcPtr0 pFunction);
 
      virtual void clearKeyFunctions();
 
      virtual bool hasKeyFunction(int pKey) const;
 
      virtual bool setMouseFunction(int pMouseState, const std::shared_ptr<cxFunction>& pFunction);
 
      virtual bool setMouseFunction(int pMouseState, funcPtr4 pFunction,
                                  void *p1, void *p2, void *p3, void *p4,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true);
 
      virtual bool setMouseFunction(int pMouseState, funcPtr2 pFunction,
                                  void *p1, void *p2,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true);
 
      virtual bool setMouseFunction(int pMouseState, funcPtr0 pFunction,
                                  bool pUseReturnVal = false,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true);
 
      virtual void clearMouseFunction(int pMouseState);
 
      virtual void clearMouseFunctions();
 
      virtual bool hasMouseFunction(int pMouseState) const;
 
      std::map<int, std::shared_ptr<cxFunction> >::iterator keyFunctions_begin();
 
      std::map<int, std::shared_ptr<cxFunction> >::iterator keyFunctions_end();
 
      virtual void getFunctionKeyStrings(std::vector<std::string>& pKeys) const;
 
      virtual void getFunctionKeys(std::vector<int>& pKeys) const;
 
      virtual void setShowSubwinsForward(bool pShowSubwinsForward);
 
      virtual bool getShowSubwinsForward() const;
 
      virtual void setShowSelfBeforeSubwins(bool pShowSelfBeforeSubwins);
 
      virtual bool getShowSelfBeforeSubwins() const;
 
      virtual long getReturnCode() const;
 
      virtual bool addTitleString(int pHPos, const std::string& pStr,
                                  bool pRefreshTitle = false);
 
      virtual std::string getTitleString(int pHPos) const;
 
      virtual std::map<int, std::string> getTitleStrings() const;
 
      virtual void getTitleStrings(std::map<int, std::string>& pTitleStrings) const;
 
      virtual void setTitleStrings(const std::map<int, std::string>& pTitleStrings);
 
      virtual void removeTitleString(int pHPos);
 
      virtual void removeTitleStrings();
 
      virtual bool addStatusString(int pHPos, const std::string& pStr,
                                   bool pRefreshStatus = false);
 
      virtual std::string getStatusString(int pHPos) const;
 
      virtual std::map<int, std::string> getStatusStrings() const;
 
      virtual void getStatusStrings(std::map<int, std::string>& pStatusStrings) const;
 
      virtual void setStatusStrings(const std::map<int, std::string>& pStatusStrings);
 
      virtual void removeStatusString(int pHPos);
 
      virtual void removeStatusStrings();
 
      virtual bool addQuitKey(int pKey, bool pRunOnLeaveFunction = true,
                              bool pOverride = false);
 
      virtual void removeQuitKey(int pKey);
 
      virtual void removeQuitKeys();
 
      virtual bool addExitKey(int pKey, bool pRunOnLeaveFunction = true,
                              bool pOverride = false);
 
      virtual void removeExitKey(int pKey);
 
      virtual void removeExitKeys();
 
      virtual bool hasExitKey(int pKey) const;
 
      virtual bool hasQuitKey(int pKey) const;
 
      virtual void clear(bool pRefresh = false);
 
      virtual void quitNow();
 
      virtual void exitNow();
 
      virtual void getQuitKeyStrings(std::vector<std::string>& pKeys) const;
 
      virtual std::string getQuitKeyListString() const;
 
      virtual void getExitKeyStrings(std::vector<std::string>& pKeys) const;
 
      virtual std::string getExitKeyListString() const;
 
      virtual std::map<int, bool> getQuitKeys() const;
 
      virtual std::map<int, bool> getExitKeys() const;
 
      void toggleMessage(bool pDrawMessage);
 
      void toggleTitle(bool pDrawTitle);
 
      void toggleStatus(bool pDrawStatus);
 
      bool messageWillDraw() const;
 
      bool titleWillDraw() const;
 
      bool statusWillDraw() const;
 
      void toggleSpecialChars(bool pDrawSpecialChars);
 
      bool specialCharsWillDraw() const;
 
      virtual void drawTitle();
 
      virtual void drawStatus();
 
      virtual void drawMessage();
 
      virtual void drawSpecialChars();
 
      virtual void setReturnCode(const long& pReturnCode);
 
      virtual void setMessageColor(e_cxColors pColor);
 
      virtual void setTitleColor(e_cxColors pColor);
 
      virtual void setStatusColor(e_cxColors pColor);
 
      virtual void setBorderColor(e_cxColors pColor);
 
      virtual void setColor(e_WidgetItems pItem, e_cxColors pColor);
 
      virtual bool hasAttr(e_WidgetItems pItem, attr_t pAttr);
 
      virtual std::string cxTypeStr() const override;
 
      bool getLeaveNow() const;
 
      std::string getName() const;
 
      virtual void setName(const std::string& pName);
 
      bool mouseEvtWasInWindow() const;
 
      virtual bool mouseEvtWasInTitle() const;
 
      virtual void doMouseBehavior();
 
      virtual void doMouseBehavior(int pMouseY, int pMouseX);
 
      std::shared_ptr<cxFunction> getKeyFunction(int pKey) const;
 
      std::shared_ptr<cxFunction0> getKeyFunctionAsFunction0(int pKey) const;
 
      std::shared_ptr<cxFunction2> getKeyFunctionAsFunction2(int pKey) const;
 
      std::shared_ptr<cxFunction4> getKeyFunctionAsFunction4(int pKey) const;
 
      bool mouseEvtWasButtonEvt() const;
 
      bool mouseButton1Pressed() const;
 
      bool mouseButton1Released() const;
 
      bool mouseButton1Clicked() const;
 
      bool mouseButton1DoubleClicked() const;
 
      bool mouseButton2Clicked() const;
 
      bool mouseButton2DoubleClicked() const;
 
      bool mouseButton3Clicked() const;
 
      virtual void mouseButton1Click(int pY, int pX);
 
      virtual void mouseButton2Click(int pY, int pX);
 
      virtual void mouseButton3Click(int pY, int pX);
 
#ifdef NCURSES_MOUSE_VERSION
      MEVENT getMouseEvent() const;
#endif
 
      std::string getString(int pRow, int pCol, int pNumber);
 
      void info();
 
      virtual void toggleBorderTop(bool pToggle);
 
      virtual void toggleBorderBottom(bool pToggle);
 
      virtual void toggleBorderLeft(bool pToggle);
 
      virtual void toggleBorderRight(bool pToggle);
 
      virtual void addSpecialChar(int pY, int pX, chtype pChar,
                                  attr_t pAttr = A_NORMAL);
 
      virtual void removeSpecialChar(int pY, int pX);
 
      virtual void clearSpecialChars();
 
      virtual bool functionExistsForLastMouseState() const;
 
      int getMouseState() const;
 
      std::string getMouseStateStr() const;
 
      virtual e_cxColors getItemColor(e_WidgetItems pItem) const;
 
   protected:
 
      WINDOW *mWindow = nullptr;
 
      messageLineContainer mMessageLines;
 
      std::map<std::pair<int, int>, chtype> mSpecialChars;
 
      std::set<attr_t> mMessageAttrs;
      std::set<attr_t> mTitleAttrs;
      std::set<attr_t> mStatusAttrs;
      std::set<attr_t> mBorderAttrs;
      std::set<attr_t> mHotkeyAttrs;
      std::map<std::pair<int, int>, attr_t> mSpecialCharAttrs;
 
      // Colors for the various elements
      short mMessageColorPair = eWHITE_BLUE;
      short mTitleColorPair = eGRAY_BLUE;
      short mStatusColorPair = eBROWN_BLUE;
      short mBorderColorPair = eGRAY_BLUE;
 
      eHPosition mHorizTitleAlignment = eHP_LEFT;   // Horizontal title alignment
      eHPosition mHorizMessageAlignment = eHP_LEFT; // Horizontal message alignment
      eHPosition mHorizStatusAlignment = eHP_LEFT;  // Horizontal status alignment
      eVPosition mVerticalMessageAlignment = eVP_TOP; // Vertical message alignment
 
      bool mDrawMessage = true;      // Whether or not to draw the message
      bool mDrawTitle = true;        // Whether or not to draw the title
      bool mDrawStatus = true;       // Whether or not to draw the status
      bool mDrawSpecialChars = true; // Whether or not to draw the "special" chars
 
      std::shared_ptr<cxFunction> mOnFocusFunction = nullptr; // Function for when focus is gained
      std::shared_ptr<cxFunction> mOnLeaveFunction = nullptr; // Function for when focus is lost
      bool mIsModal = false;   // Whether or not the window is being shown modally
      // mLeaveNow can be set true by exitNow() or quitNow() if an external
      // function wants the window object to leave its input loop.
      bool mLeaveNow = false;
      // This map contains pointers to functions to be called for various
      // keypresses.
      std::map<int, std::shared_ptr<cxFunction> > mKeyFunctions;
      // This map contains pointers to functions to be called for various
      // mouse states.
      std::map<int, std::shared_ptr<cxFunction> > mMouseFunctions;
      // mQuitKeys and mExitKeys contain additional keys to cause the window
      // to quit the input loop & return cxID_QUIT and cxID_EXIT,
      // respectively.  The key to the maps is the keypress, and the boolean
      // tells whether or not to run the onLeave function before leaving.
      std::map<int, bool> mQuitKeys;
      std::map<int, bool> mExitKeys;
      // mHotkeyHighlighting specifies whether or not to use hotkey
      // attributes in the message.
      bool mHotkeyHighlighting;
#ifdef NCURSES_MOUSE_VERSION
      MEVENT mMouse; // Stores data for mouse events
#endif
 
      virtual void reCreatePanel();
 
      void freeWindow();
 
      virtual void init(int pRow, int pCol, int pHeight, int pWidth,
                        const std::string& pTitle, const std::string& pMessage,
                        const std::string& pStatus, cxWindow *pParentWindow = nullptr,
                        bool pResizeVertically = true);
 
      virtual void removeAllSubwindows();
 
      virtual void addSubwindow(cxWindow *pSubWindow);
 
      virtual void removeSubWindow(const cxWindow *pSubWindow);
 
      virtual void setElementColor(short& pColorPair, attr_t& pElementAttr, e_cxColors pColor);
 
      virtual void enableAttrs(WINDOW *pWin, e_WidgetItems pItem);
 
      virtual void disableAttrs(WINDOW *pWin, e_WidgetItems pItem);
 
      virtual void writeWithHighlighting(WINDOW* pWindow, const std::string& pText,
                        const int& pY, const int& pStartX, const int& pEndX,
                        int pNormalTextItem = -1);
 
      virtual void copyCxWinStuff(const cxWindow* pThatWindow, bool pRecreateWin = true);
 
      virtual void getRowColBasedOn(cxWindow *pParentWindow, eHPosition pPosition,
                            const std::string& pTitle, const std::string& pStatus,
                            const std::string& pMessage, int& pRow, int& pCol);
 
      virtual bool handleFunctionForLastKey(bool *pFunctionExists = nullptr,
                                            bool *pRunOnLeaveFunction = nullptr);
 
      virtual bool handleFunctionForLastMouseState(bool *pFunctionExists = nullptr,
                                            bool *pRunOnLeaveFunction = nullptr);
 
      virtual void draw();
 
#ifdef NCURSES_MOUSE_VERSION
      static bool mouseEvtInRect(const MEVENT& pMouse, int pTop, int pLeft,
                                 int pBottom, int pRight);
#endif
 
      void setKeyFunctions(const cxWindow& pWindow);
 
      void setFocusFunctions(const cxWindow& pWindow);
 
      bool parentIsCxPanel() const;
 
      bool parentIsCxForm() const;
 
      bool parentIsCxNotebook() const;
 
      cxWindowPtrContainer::const_iterator subWindows_begin() const;
 
      cxWindowPtrContainer::const_iterator subWindows_end() const;
 
      cxWindowPtrContainer::const_reverse_iterator subWindows_rbegin() const;
 
      cxWindowPtrContainer::const_reverse_iterator subWindows_rend() const;
 
      bool onFocusFunctionIsSet() const;
 
      bool onLeaveFunctionIsSet() const;
 
   private:
      PANEL *mPanel = nullptr;            // For layered window management
      cxWindow *mExtTitleWindow;          // Optionally used for the title instead of the title line.
      cxWindow *mExtStatusWindow;         // Optionally used for status instead
                                          //  of the status line.
      cxWindow *mTitleParent = nullptr;   // Pointer to a window using me for its title
      cxWindow *mStatusParent = nullptr;  // Pointer to a window using me for its status
      std::string mExtTitleTemp;          // Keeps track of old external title window text
      std::string mExtStatusTemp;         // Keeps track of old external status window text
      cxWindow *mParentWindow;            // Pointer to the parent window (can be nullptr for none)
      cxWindowPtrContainer mSubWindows;   // Contains subwindows for this window
      bool mFocus = false;                // Whether or not the window has focus
      eBorderStyle mBorderStyle;          // Border style
      bool mEnabled = true;               // Whether or not the window is enabled
      bool mDisableCursorOnShow = true;   // Whether or not to disable the cursor in show()
      bool mExitOnMouseOutside = false;  // Exit modal input loop on mouse click outside window
      int mLastKey = NOKEY;               // The last key typed by the user during an input loop
      bool mChangeColorsOnFocus = false;  // Whether or not to apply colors upon setting focus
      bool mShowSubwinsForward = true;    // If true, the subwindows will be shown in
                                          //  forward order; if false, they will be shown
                                          //  in reverse order.
      bool mShowSelfBeforeSubwins = true; // Whether or not to show this window before
                                          //  showing the subwindows
      long mReturnCode = cxID_EXIT;       // Keeps track of the return code set by showModal()
      bool mRunOnFocus = true;            // Whether or not to run the onFocus function
      bool mRunOnLeave = true;            // Whether or not to run the onLeave function
      // mTitleStrings and mStatusStrings keep track of horizontal positions
      // and strings to write for the title and status lines, respectively.
      std::map<int, std::string> mTitleStrings;
      std::map<int, std::string> mStatusStrings;
      // mName provides an alternate way to identify a window.
      std::string mName;
      bool mDrawBorderTop = true;    // Display the top border (only applicable if borderstyle != eBS_NOBORDER)
      bool mDrawBorderBottom = true; // Display the bottom border (only applicable if borderstyle != eBS_NOBORDER)
      bool mDrawBorderLeft = true;   // Display the left border (only applicable if borderstyle != eBS_NOBORDER)
      bool mDrawBorderRight = true;  // Display the top border (only applicable if borderstyle != eBS_NOBORDER)
 
 
      // Writes text at a row & column
      void drawLabel(int pRow, int pCol, const std::string& pLabel);
 
      // Returns the largest subwindow height (or 0 if there are none).
      inline int maxSubwindowHeight() const;
 
      // Combines all the messages lines into one
      //  string.
      void combineMessageLines(std::string& message);
 
      // Returns whether or not a cxWindow exists in mSubWindows.
      // Parameters:
      //  pWindow: A cxWindow pointer to see if exists in mSubWindows
      inline bool subWindowExists(cxWindow *pWindow) const;
 
      // Helper method for the constructors - Checks the parent
      //  window pointer and adds this window to the parent (might
      //  have to call a different method if the parent window is
      //  a cxPanel)
      void addToParentWindow(cxWindow *pParentWindow);
 
      // Writes strings to a border, where the strings are mapped to
      //  horizontal positions.  This is a helper for writing multiple
      //  strings in the top/bottom border.
      // Parameters:
      //  pStrings: This maps strings to their horizontal positions
      //  pVPos: This is the vertical position in the window of where
      //         the strings will be written (this will probably be
      //         the top or bottom border position).
      //  pItem: The item type of the text, for applying the attributes.
      //  pTextColorPair: The color to apply to the text
      void writeBorderStrings(const std::map<int, std::string>& pStrings, int pVPos,
                              e_WidgetItems pItem, short pTextColorPair);
 
      // This is a helper for the destructor - It returns whether or not any
      //  of the subwindows has this window as its parent.
      inline bool anySubwinHasThisParent();
 
}; // end of class cxWindow
 
 
} // namespace cx
 
#endif