cxForm.h

Go to the documentation of this file.

// Copyright (c) 2026 E. Oulashin
#ifndef __CXFORM_H__
#define __CXFORM_H__
 
/*
 * cxForm.h - This is a form that contains text inputs.
 *
 * Copyright (C) 2005-2007 Michael H. Kinney
 *
 *
 * Date     User    Description
 */
 
#include "cxWindow.h"
#include "cxMultiLineInput.h"
#include "cxComboBox.h"
#include "cxMenu.h"
#include <string>
#include <vector>
#include <set>
#include <map>
#include <memory>
 
namespace cx {
 
#define DEFAULT_CXFORM_JUMPMENU_KEY KEY_F(4)  // Default hotkey for input jumping
 
// This is used in append() for specifying the type of input to append, either
//  a cxMultiLineInput or a cxComboBox.
enum eInputType
{
   eIT_CXMULTILINEINPUT,
   eIT_CXCOMBOBOX
};
 
class cxMultiForm; // Pre-declaration to avoid a circular reference
 
// These typedefs are for appendPair() and appendComboBoxPair().
typedef std::pair<std::shared_ptr<cxMultiLineInput>, std::shared_ptr<cxMultiLineInput> > cxMLInputPtrPair;
typedef std::pair<std::shared_ptr<cxComboBox>, std::shared_ptr<cxComboBox> > cxComboBoxPtrPair;
 
class cxForm : public cxWindow
{
   public:
      explicit cxForm(cxWindow *pParentWindow = nullptr, int pRow = 0,
                      int pCol = 0, int pHeight = DEFAULT_HEIGHT,
                      int pWidth = DEFAULT_WIDTH, const std::string& pTitle = "",
                      eBorderStyle pBorderStyle = eBS_SINGLE_LINE,
                      cxWindow *pExtTitleWindow = nullptr,
                      cxWindow *pExtStatusWindow = nullptr,
                      bool pAutoExit = false, bool pStacked = false);
 
      cxForm(const cxForm& pThatForm);
 
      virtual ~cxForm();
 
      virtual std::shared_ptr<cxMultiLineInput> append(int pRow, int pCol, int pHeight,
                                                       int pWidth, const std::string& pLabel,
                                                       const std::string& pValidator = "",
                                                       const std::string& pHelpString = "",
                                                       eInputOptions pInputOption = eINPUT_EDITABLE,
                                                       const std::string& pName = "",
                                                       std::string *pExtValue = nullptr,
                                                       int pRightLabelOffset = 0,
                                                       int pRightLabelHeight = 1,
                                                       int pRightLabelWidth = 7,
                                                       bool pShowRightLabel = false,
                                                       eInputType pInputType = eIT_CXMULTILINEINPUT);
 
      virtual std::shared_ptr<cxComboBox> appendComboBox(int pRow, int pCol, int pHeight,
                                                         int pWidth, const std::string& pLabel,
                                                         const std::string& pValidator = "",
                                                         const std::string& pHelpString = "",
                                                         eInputOptions pInputOption = eINPUT_EDITABLE,
                                                         const std::string& pName = "",
                                                         std::string *pExtValue = nullptr,
                                                         int pRightLabelOffset = 0,
                                                         int pRightLabelHeight = 1,
                                                         int pRightLabelWidth = 7,
                                                         bool pShowRightLabel = false);
 
      virtual cxMLInputPtrPair appendPair(int pRow, int pCol, int pHeight, int pWidth,
                              const std::string& pLabel,
                              const std::string& pValidator = "",
                              const std::string& pHelpString = "",
                              eInputOptions pInputOption = eINPUT_EDITABLE,
                              const std::string& pName = "",
                              std::string *pExtValue1 = nullptr,
                              std::string *pExtValue2 = nullptr,
                              int pRightLabel1Offset = 0,
                              int pRightLabel1Height = 1,
                              int pRightLabel1Width = 7,
                              bool pShowRightLabel1 = false,
                              int pRightLabel2Offset = 0,
                              int pRightLabel2Height = 1,
                              int pRightLabel2Width = 7,
                              bool pShowRightLabel2 = false,
                              eInputType pInput1Type = eIT_CXMULTILINEINPUT,
                              eInputType pInput2Type = eIT_CXMULTILINEINPUT);
 
      virtual cxComboBoxPtrPair appendComboBoxPair(int pRow, int pCol, int pHeight,
                                     int pWidth,
                                     const std::string& pLabel,
                                     const std::string& pValidator = "",
                                     const std::string& pHelpString = "",
                                     eInputOptions pInputOption = eINPUT_EDITABLE,
                                     const std::string& pName = "",
                                     std::string *pExtValue1 = nullptr,
                                     std::string *pExtValue2 = nullptr,
                                     int pRightLabel1Offset = 0,
                                     int pRightLabel1Height = 1,
                                     int pRightLabel1Width = 7,
                                     bool pShowRightLabel1 = false,
                                     int pRightLabel2Offset = 0,
                                     int pRightLabel2Height = 1,
                                     int pRightLabel2Width = 7,
                                     bool pShowRightLabel2 = false);
 
      virtual void appendPair(std::shared_ptr<cxMultiLineInput>& pInput1,
                              std::shared_ptr<cxMultiLineInput>& pInput2,
                              int pRow, int pCol, const std::string& pName = "");
 
      virtual std::shared_ptr<cxMultiLineInput> append(int pHeight, int pWidth, const std::string& pLabel,
                                                       const std::string& pValidator = "",
                                                       const std::string& pHelpString = "",
                                                       eInputOptions pInputOption = eINPUT_EDITABLE,
                                                       const std::string& pName = "",
                                                       std::string *pExtValue = nullptr,
                                                       int pRightLabelOffset = 0,
                                                       int pRightLabelHeight = 1,
                                                       int pRightLabelWidth = 7,
                                                       bool pShowRightLabel = false,
                                                       eInputType pInputType = eIT_CXMULTILINEINPUT);
 
      virtual std::shared_ptr<cxComboBox> appendComboBox(int pHeight, int pWidth, const std::string& pLabel,
                                                         const std::string& pValidator = "",
                                                         const std::string& pHelpString = "",
                                                         eInputOptions pInputOption = eINPUT_EDITABLE,
                                                         const std::string& pName = "",
                                                         std::string *pExtValue = nullptr,
                                                         int pRightLabelOffset = 0,
                                                         int pRightLabelHeight = 1,
                                                         int pRightLabelWidth = 7,
                                                         bool pShowRightLabel = false);
 
      virtual std::shared_ptr<cxMultiLineInput> append(const cxMultiLineInput& pInput);
 
      virtual void append(std::shared_ptr<cxMultiLineInput>& pInput, int pRow, int pCol, bool* pMoved = nullptr);
 
      virtual void remove(unsigned int pIndex);
 
      virtual void remove(const std::string& pLabel, bool pIsLabel = true);
 
      virtual void remove(const std::shared_ptr<cxMultiLineInput>& pInput);
      virtual void remove(cxMultiLineInput *pInput);
 
      virtual void removeAll();
 
      virtual void setFieldKeyFunction(const std::string& pLabel, int pFunctionKey,
                            const std::shared_ptr<cxFunction>& pFieldFunction,
                            bool pIsLabel = true);
 
      virtual void setFieldKeyFunction(const std::string& pLabel, int pFunctionKey,
                            funcPtr4 pFieldFunction, void *p1, void *p2,
                            void *p3, void *p4, bool pUseVal,
                            bool pExitAfterRun = false,
                            bool pIsLabel = true);
 
      virtual void setFieldKeyFunction(unsigned pIndex, int pFunctionKey,
                            funcPtr4 pFieldFunction, void *p1, void *p2,
                            void *p3, void *p4, bool pUseVal,
                            bool pExitAfterRun = false);
 
      virtual void setFieldKeyFunction(const std::string& pLabel, int pFunctionKey,
                            funcPtr2 pFieldFunction, void *p1, void *p2,
                            bool pUseVal, bool pExitAfterRun = false,
                            bool pIsLabel = true);
 
 
      virtual void setFieldKeyFunction(unsigned int pIndex, int pFunctionKey,
                               const std::shared_ptr<cxFunction>& pFieldFunction);
 
 
      virtual void setFieldKeyFunction(unsigned int pIndex, int pFunctionKey,
                               funcPtr2 pFieldFunction, void *p1, void *p2,
                               bool pUseVal, bool pExitAfterRun = false);
 
      virtual void setOnFocusFunction(const std::shared_ptr<cxFunction>& pFunction) override;
 
      virtual void setOnFocusFunction(const std::string& pLabel,
                           const std::shared_ptr<cxFunction>& pFunction,
                           bool pIsLabel = true);
 
      virtual void setOnFocusFunction(unsigned pIndex, const std::shared_ptr<cxFunction>& pFunction);
 
      virtual void setOnFocusFunction(const std::string& pLabel, funcPtr4 pFunction,
                           void *p1, void *p2, void *p3, void *p4, bool pUseVal,
                           bool pIsLabel = true);
 
      virtual void setOnFocusFunction(unsigned pIndex, funcPtr4 pFunction,
                         void *p1, void *p2, void *p3, void *p4, bool pUseVal);
 
      virtual void setOnLeaveFunction(const std::shared_ptr<cxFunction>& pFunction) override;
 
      virtual void setOnLeaveFunction(const std::string& pLabel, const std::shared_ptr<cxFunction>& pFunction,
                              bool pIsLabel = true);
 
      virtual void setOnLeaveFunction(unsigned pIndex, const std::shared_ptr<cxFunction>& pFunction);
 
      virtual void setOnLeaveFunction(const std::string& pLabel, funcPtr4 pFunction,
                              void *p1, void *p2, void *p3, void *p4,
                              bool pIsLabel = true);
 
      virtual void setOnLeaveFunction(unsigned pIndex, funcPtr4 pFunction,
                 void *p1, void *p2, void *p3, void *p4);
 
      virtual void setFieldLabel(unsigned pIndex, const std::string& pLabel);
 
      virtual void setFieldLabel(const std::string& pName, const std::string& pLabel);
 
      virtual void setFieldName(unsigned pIndex, const std::string& pName);
 
      virtual void setFieldName(const std::string& pLabel, const std::string& pName);
 
      virtual void enableInputLoop(const std::string& pLabel, bool pDoInputLoop, bool pIsLabel = true);
 
      virtual void enableInputLoop(unsigned pIndex, bool pDoInputLoop);
 
      virtual void setAutoExit(bool pAutoExit);
 
      bool getAutoExit() const;
 
      virtual void setStartAtFirstInput(bool pStartAtFirstInput);
 
      bool getStartAtFirstInput() const;
 
      void setApplyAttrDefaults(bool pApplyAttrDefaults);
 
      bool getApplyAttrDefaults() const;
 
      virtual long show(bool pBringToTop = false, bool pShowSubwindows = true) override;
 
      virtual long showModal(bool pShowSelf = true, bool pBringToTop = false,
                             bool pShowSubwindows = true) override;
 
      virtual bool modalGetsKeypress() const override;
 
      virtual void hide(bool pHideSubwindows = true) override;
 
      virtual void unhide(bool pUnhideSubwindows = true) override;
 
      virtual bool move(int pNewRow, int pNewCol, bool pRefresh = true) override;
 
      size_t numInputs() const;
 
      virtual std::string getValue(int pIndex) const;
 
      virtual std::string getValue(const std::string& pStr, bool pIsLabel = true) const;
 
      virtual std::string getLabel(int pIndex) const;
 
      virtual std::string getName(int pIndex) const;
 
      virtual std::string getName(const std::string& pLabel) const;
 
      virtual std::string getStatus(int pIndex) const;
 
      virtual std::string getStatus(const std::string& pLabel, bool pIsLabel = true) const;
 
      virtual bool setValue(int pIndex, const std::string& pValue, bool pRefresh = false);
 
      virtual bool setValue(const std::string& pLabel, const std::string& pValue,
                            bool pIsLabel = true, bool pRefresh = false);
 
      virtual int refreshInput(unsigned pIndex);
 
      virtual int refreshInput(const std::string& pStr, bool pIsLabel = true);
 
      bool setMaskChar(int pIndex, char pMaskChar);
 
      bool setMaskChar(const std::string& pLabel, char pMaskChar, bool pIsLabel = true);
 
      bool getMasked(int pIndex);
 
      bool getMasked(const std::string& pLabel, bool pIsLabel = true);
 
      virtual bool toggleMasking(int pIndex, bool pMasking);
 
      virtual bool toggleMasking(const std::string& pLabel, bool pMasking, bool pIsLabel = true);
 
      virtual bool setCurrentInput(int pIndex);
 
      virtual bool setCurrentInput(const std::string& pLabel, bool pIsLabel = true);
 
      virtual bool setCurrentInputByPtr(const std::shared_ptr<cxMultiLineInput>& pInput);
      virtual bool setCurrentInputByPtr(const cxMultiLineInput* const pInput);
 
      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 bool setKeyFunction(int pIndex, int pKey, const std::shared_ptr<cxFunction>& pFunction);
 
      virtual bool setKeyFunction(const std::string& pLabel, int pKey, const std::shared_ptr<cxFunction>& pFunction, bool pIsLabel = true);
 
      virtual bool setKeyFunction(int pIndex, int pKey,
                                  funcPtr4 pFunction, void *p1, void *p2,
                                  void *p3, void *p4, bool pUseVal,
                                  bool pExitAfterRun, bool pRunOnLeaveFunction,
                                  bool pRunValidator);
 
      virtual bool setKeyFunction(const std::string& pLabel, int pKey,
                                  funcPtr4 pFunction, void *p1, void *p2,
                                  void *p3, void *p4, bool pUseVal,
                                  bool pExitAfterRun, bool pRunOnLeaveFunction,
                                  bool pRunValidator, bool pIsLabel = true);
 
      virtual bool setKeyFunction(int pIndex, int pKey, funcPtr2 pFunction,
                                  void *p1, void *p2, bool pUseVal,
                                  bool pExitAfterRun, bool pRunOnLeaveFunction,
                                  bool pRunValidator);
 
      virtual bool setKeyFunction(const std::string& pLabel, int pKey,
                                  funcPtr2 pFunction, void *p1, void *p2,
                                  bool pUseVal, bool pExitAfterRun,
                                  bool pRunOnLeaveFunction, bool pRunValidator,
                                  bool pIsLabel = true);
 
      virtual bool setKeyFunction(int pIndex, int pKey, funcPtr0 pFunction,
                                  bool pUseVal, bool pExitAfterRun,
                                  bool pRunOnLeaveFunction, bool pRunValidator);
 
      virtual bool setKeyFunction(const std::string& pLabel, int pKey,
                                  funcPtr0 pFunction, bool pUseVal,
                                  bool pExitAfterRun, bool pRunOnLeaveFunction,
                                  bool pRunValidator, bool pIsLabel = true);
 
      bool allFieldsBlank() const;
 
      void setLabelColor(const int& pIndex, e_cxColors pColor);
 
      void setLabelColor(const std::string& pLabel, e_cxColors pColor, bool pIsLabel = true);
 
      void setAllLabelColor(e_cxColors pColor);
 
      int getLabelColor(const int& pIndex) const;
 
      int getLabelColor(const std::string& pLabel, bool pIsLabel = true) const;
 
      void setValueColor(const int& pIndex, e_cxColors pColor);
 
      void setValueColor(const std::string& pLabel, e_cxColors pColor, bool pIsLabel = true);
 
      void setAllValueColor(e_cxColors pColor);
 
      int getValueColor(const int& pIndex) const;
 
      int getValueColor(const std::string& pLabel, bool pIsLabel = true) const;
 
      void setAllColors(e_cxColors pLabelColor, e_cxColors pValueColor);
 
      virtual void setColor(e_WidgetItems pItem, e_cxColors pColor) override;
 
      int inputTopRow(int pIndex) const;
 
      int inputTopRow(const std::string& pLabel, bool pIslabel = true) const;
 
      int inputLeftCol(int pIndex) const;
 
      int inputLeftCol(const std::string& pLabel, bool pIsLabel = true) const;
 
      int inputHeight(int pIndex) const;
 
      int inputHeight(const std::string& pLabel, bool pIsLabel = true) const;
 
      int inputWidth(int pIndex) const;
 
      int inputWidth(const std::string& pLabel, bool pIsLabel = true) const;
 
      int maxInputLen(int pIndex) const;
 
      int maxInputLen(const std::string& pLabel, bool pIsLabel = true) const;
 
      std::string inputLabel(int pIndex) const;
 
      std::string inputLabel(const std::string& pName) const;
 
      std::string inputName(int pIndex) const;
 
      std::string inputName(const std::string& pLabel) const;
 
      virtual void scrollInputs(int pVScrollAmt, int pHScrollAmt, bool pRefresh = false, bool pBringToTop = false);
 
      virtual void toggleCursor(int pIndex, bool pShowCursor);
 
      virtual void toggleCursor(const std::string& pLabel, bool pShowCursor, bool pIsLabel = true);
 
      virtual void toggleCursor(bool pShowCursor);
 
      std::shared_ptr<cxMultiLineInput> getInput(int pIndex) const;
 
      std::shared_ptr<cxMultiLineInput> getInput(const std::string& pLabel, bool pIsLabel = true) const;
 
      std::shared_ptr<cxMultiLineInput> getCurrentInput() const;
 
      virtual int getInputOption(int pIndex) const;
 
      virtual int getInputOption(const std::string& pLabel, bool pIsLabel = true) const;
 
      virtual void setInputOption(int pIndex, eInputOptions pInputOption, bool pRefresh = true);
 
      virtual void setInputOption(const std::string& pLabel, eInputOptions pInputOption,
                           bool pIsLabel = true, bool pRefresh = true);
 
      virtual void setAllInputOption(eInputOptions pInputOption, bool pRefresh = true);
 
      virtual void setStatus(const std::string& pStatus, bool pRefreshStatus = true) override;
 
      virtual void disableCustomStatus(bool pRefreshStatus = true);
 
      virtual void setValidatorFunction(int pIndex, const std::shared_ptr<cxFunction>& pFunction);
 
      virtual void setValidatorFunction(int pIndex, funcPtr4 pFunction, void *p1, void *p2,
                                        void *p3, void *p4);
 
      virtual void setValidatorFunction(const std::string& pLabel, const std::shared_ptr<cxFunction>& pFunction,
                                        bool pIsLabel = true);
 
      virtual void setValidatorFunction(const std::string& pLabel, funcPtr4 pFunction,
                                        void *p1, void *p2, void *p3, void *p4,
                                        bool pIsLabel = true);
 
      virtual void showInputsOnBorder(bool pShowInputsOnBorder);
 
      virtual void setOnKeyFunction(int pIndex, const std::shared_ptr<cxFunction>& pFunction);
 
      virtual void setOnKeyFunction(int pIndex, funcPtr4 pFunction, void *p1,
                                   void *p2, void *p3, void *p4);
 
      virtual void setOnKeyFunction(const std::string& pLabel, const std::shared_ptr<cxFunction>& pFunction,
                                    bool pIsLabel = true);
 
      virtual void setOnKeyFunction(const std::string& pLabel, funcPtr4 pFunction, void *p1,
                                    void *p2, void *p3, void *p4, bool pIsLabel = true);
 
      virtual void setOnKeyFunction(int pIndex, funcPtr2 pFunction, void *p1, void *p2);
 
      virtual void setOnKeyFunction(const std::string& pLabel, funcPtr2 pFunction, void *p1,
                                    void *p2, bool pIsLabel = true);
 
      virtual void setOnKeyFunction(int pIndex, funcPtr0 pFunction);
 
      virtual void setOnKeyFunction(const std::string& pLabel, funcPtr0 pFunction, bool pIsLabel = true);
 
      virtual void setAllOnKeyFunction(const std::shared_ptr<cxFunction>& pFunction);
 
      virtual void setAllOnKeyFunction(funcPtr4 pFunction, void *p1, void *p2, void *p3, void *p4);
 
      virtual void setAllOnKeyFunction(funcPtr2 pFunction, void *p1, void *p2);
 
      virtual void setAllOnKeyFunction(funcPtr0 pFunction);
 
      virtual void toggleOnKeyFunction(int pIndex, bool pRunOnKeyFunction);
 
      virtual void toggleOnKeyFunction(const std::string& pLabel, bool pRunOnKeyFunction, bool pIsLabel = true);
 
      virtual void toggleAllOnKeyFunction(bool pRunOnKeyFunction);
 
      virtual bool onKeyFunctionEnabled(int pIndex) const;
 
      virtual bool onKeyFunctionEnabled(const std::string& pLabel, bool pIsLabel = true) const;
 
      cxForm& operator =(const cxForm& pThatForm);
 
      virtual bool addInputJumpKey(int pKey, int pIndex);
 
      virtual bool addInputJumpKey(int pKey, const std::string& pLabel, bool pIsLabel = true);
 
      virtual int getCurrentInputIndex() const;
 
      virtual std::string getCurrentInputLabel() const;
 
      virtual std::string getCurrentInputName() const;
 
      virtual int getInputIndex(const std::string& pLabel, bool pIsLabel = true) const;
 
      virtual int getInputIndex(const std::shared_ptr<cxMultiLineInput>& pInput) const;
      virtual int getInputIndex(const cxMultiLineInput *pInput) const;
 
      virtual void setInputJumpKey(int pInputJumpKey);
 
      virtual int getInputJumpKey() const;
 
      virtual void setCanBeEditable(int pIndex, bool pCanBeEditable);
 
      virtual void setCanBeEditable(const std::string& pLabel, bool pCanBeEditable, bool pIsLabel = true);
 
      virtual void setAllCanBeEditable(bool pCanBeEditable);
 
      virtual bool canBeEditable(int pIndex) const;
 
      virtual bool canBeEditable(const std::string& pLabel, bool pIsLabel = true) const;
 
      virtual bool anyInputsCanBeEditable() const;
 
      virtual void setAllowQuit(bool pAllowQuit);
 
      virtual bool getAllowQuit() const;
 
      virtual void setAllowExit(bool pAllowExit);
 
      virtual bool getAllowExit() const;
 
      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 setOnFocusFunction(funcPtr4 pFuncPtr, void *p1, void *p2,
                           void *p3, void *p4, bool pUseVal = false,
                           bool pExitAfterRun = false) override;
 
      virtual void setOnFocusFunction(funcPtr2 pFuncPtr, void *p1, void *p2,
                           bool pUseVal = false, bool pExitAfterRun = false) override;
 
      virtual void setOnFocusFunction(funcPtr0 pFuncPtr, bool pUseVal = false,
                                      bool pExitAfterRun = false) override;
 
      virtual void setLoopStartFunction(const std::shared_ptr<cxFunction>& pFuncPtr);
 
      virtual void setLoopEndFunction(const std::shared_ptr<cxFunction>& pFuncPtr);
 
      virtual void setOnLeaveFunction(funcPtr4 pFuncPtr, void *p1, void *p2,
                           void *p3, void *p4) override;
 
      virtual void setOnLeaveFunction(funcPtr2 pFuncPtr, void *p1, void *p2) override;
 
      virtual void setOnLeaveFunction(funcPtr0 pFuncPtr) override;
 
      virtual void showAllInputs(bool pBringToTop = true, bool pSkipCurrentInput = false) const;
 
      virtual bool formKeyIsSet(int pKey) const;
 
      virtual bool isStacked() const;
 
      virtual bool getExitOnLeaveFirst() const;
 
      virtual void setExitOnLeaveFirst(bool pExitOnLeaveFirst);
 
      virtual bool hasEditableInputs() const;
 
      virtual int firstEditableInput() const;
 
      virtual int lastEditableInput() const;
 
      virtual void bringToTop(bool pRefresh = true) override;
 
      virtual bool hasChanged() const;
 
      virtual void setChanged(bool pDataChanged);
 
      virtual void trapNonAssignedFKeys(bool pTrapNonAssignedFKeys);
 
      cxMultiForm* getParentMultiForm() const;
 
      virtual void setParentMultiForm(cxMultiForm *pParentMultiForm);
 
      virtual bool runLoopStartFunction();
 
      virtual bool runLoopEndFunction();
 
      virtual int maxValueLen(int pIndex) const;
 
      virtual int maxValueLen(const std::string& pLabel, bool pIsLabel = true);
 
      virtual bool isEditable(int pIndex) const;
 
      virtual bool isEditable(const std::string& pLabel, bool pIsLabel = true) const;
 
      virtual void setDisableCursorOnShow(bool pDisableCursorOnShow) override;
 
      virtual void setWaitForInputIfEmpty(bool pWaitForInputIfEmpty);
 
      virtual bool getWaitForInputIfEmpty() const;
 
      virtual void clearInputs(bool pRefresh = false,
                               bool pOnlyEditable = false);
 
      virtual void getValues(std::map<std::string, std::string>& pValues,
                             bool pUseLabels = true,
                             bool pSkipBlankIDs = false) const;
 
      virtual void setValues(const std::map<std::string, std::string>& pValues,
                             bool pUseLabels = true, bool pRefresh = false,
                             bool pDisableValidatorFunctions = false);
 
      virtual void setEnabled(bool pEnabled) override;
 
      virtual void useInputStatus(bool pUseInputStatus);
 
      virtual bool hasInput(const std::string& pStr, bool pIsLabel = true) const;
 
      virtual cxWindow* getParent() const override;
 
      // Note: This is commented out because, for some reason, with this in
      //  the code, it seems to screw up all the forms in cprime so that they
      //  only have 1 input, even if this method is not used anywhere..
      //virtual int nextEditableInput(int pIndex) const;
 
      virtual void addAttr(e_WidgetItems pItem, attr_t pAttr) override;
 
      virtual void setAttr(e_WidgetItems pItem, attr_t pAttr) override;
 
      virtual void removeAttr(e_WidgetItems pItem, attr_t pAttr) override;
 
      virtual void removeAttrs(e_WidgetItems pItem) override;
 
      virtual void getAttrs(e_WidgetItems pItem, std::set<attr_t>& pAttrs) const override;
 
      virtual void getNavKeys(std::set<int>& pNavKeys) const;
 
      virtual void getNavKeyStrings(std::set<std::string>& pNavKeyStrings) const;
 
      virtual bool hasNavKey(int pKey) const;
 
      virtual std::string cxTypeStr() const override;
 
      virtual void setLastKey(int pLastKey) override;
 
      virtual void quitNow() override;
 
      virtual void exitNow() override;
 
      virtual void setExtendedHelpKey(int pKey);
 
      virtual void addExtendedHelpKey(int pKey);
 
      virtual std::set<int> getExtendedHelpKeys() const;
 
      std::string getExtendedHelpKeyStrings() const;
 
      virtual void clearExtendedHelpKeys();
 
      virtual void setUseExtendedHelpKeys(bool pUseExtendedHelpKeys);
 
      virtual bool getUseExtendedHelpKeys() const;
 
      virtual std::string getExtendedHelp(int pIndex) const;
 
      virtual std::string getExtendedHelp(const std::string& pIDStr, bool pIsLabel = true) const;
 
      virtual void setExtendedHelp(int pIndex, const std::string& pExtendedHelp);
 
      virtual void setExtendedHelp(const std::string& pIDStr, const std::string& pExtendedHelp,
                                     bool pIsLabel = true);
 
      virtual void validateOnJumpKey(int pIndex, bool pValidate);
 
      virtual void validateOnJumpKey(const std::string& pID, bool pValidate, bool pIsLabel = true);
 
      virtual void allValidateOnJumpKey(bool pValidate);
 
      virtual bool swap(int pInput1Index, int pInput2Index);
 
      virtual bool swap(std::shared_ptr<cxWindow>& pInput1, std::shared_ptr<cxWindow>& pInput2);
 
      // We still want to inherit versions of some functions from cxWindow
      using cxWindow::getName;
      using cxWindow::getStatus;
 
   protected:
      typedef std::vector<std::shared_ptr<cxMultiLineInput> > inputPtrContainer;
      // mInputs stores the pointers to the form's inputs.
      inputPtrContainer mInputs;
      int mCurrentInput = 0; // Keeps track of the current input w/ focus
 
      // mInputPositions stores the upper-left y and x
      //  coordinates of the inputs - this way, we can keep
      //  track of where the inputs are, even if they use
      //  "virtual" (negative) coordinates.  With ncurses,
      //  if you try to move a window outside the screen
      //  boundaries, it seems to only move the window to
      //  the far edges of the window (i.e., if a window
      //  were at (y, x) = (3, 2) on the screen and you
      //  move a window up 5 lines, ncurses says it's at
      //  (0, 2) rather than (-2, 2).  mInputPositions
      //  would store (-2, 2), and when the form does
      //  scrolling, it will check mInputPositions so
      //  that the inputs maintain their relative position
      //  to each other.
      std::vector<std::pair<int, int> > mInputPositions;
 
      bool mTrapNonAssignedFKeys = true;
 
      bool mStartAtFirstInput = false;
 
      void copyCxFormStuff(const cxForm* pThatForm);
 
      void lookForEditableInputs();
 
      long doInputLoop(bool& pRunOnLeaveFunction);
 
      virtual bool doCurrentInput(long& pReturnCode,
                                  bool& pRunOnLeaveFunction,
                                  bool& pFunctionExists,
                                  bool pExitOverride = false);
 
      virtual void setIsModal(bool pIsModal);
 
   private:
      // If mStacked is true, then the form will behave
      //  assuming all the inputs are on their own line (no
      //  side-by-side inputs).
      bool mStacked;
 
      // mTotalInputHeight keeps track of the total height
      //  of all inputs, if the form were in "stacked" mode.  It
      //  represents the total height of all inputs as if they
      //  were all stretched out with each above the next.
      unsigned int mTotalInputHeight = 0;
 
      bool mAutoExit; // Whether or not to auto exit the form
                      //  if the user presses enter/tab/etc. on
                      //  the last field.
      bool mApplyAttrDefaults = true; // Whether or not to apply attribute defaults
      // mCustomStatus will be true if the user explicitly called setStatus()
      //  on the form, in which case the status text from the inputs will
      //  not be used as the status text for the form.
      bool mCustomStatus = false;
      // mEditableInputsExist will be true if at least 1
      //  editable input exists on the form.
      bool mEditableInputsExist = false;
      // If the user has put an input along one of the
      //  borders, mInputsOnBorder will be true.  Then,
      //  during scrolling, etc., the form will behave
      //  accordingly.
      bool mInputsOnBorder;
      cxMenu mJumpMenu;  // Menu to choose which input to jump to
      int mInputJumpKey = DEFAULT_CXFORM_JUMPMENU_KEY; // Hotkey to use for jumping to another input
      bool mAllowQuit = true;           // Whether or not to allow the user to quit
      bool mAllowExit = true;           // Whether or not to allow the user to exit
      bool mExitOnLeaveFirst = false;   // Whether or not to exit when the user
                                        //  leaves the first input when going backwards.
      bool mWaitForInputIfEmpty = true; // Whether or not to get input in showModal()
                                        //  if there are no editable inputs
      bool mDataChanged = false;        // Whether or not any data has changed
 
      // Functions to be run at various points in the input loop
      std::shared_ptr<cxFunction> mLoopStartFunction; // At the start of each cycle
      std::shared_ptr<cxFunction> mLoopEndFunction;   // At the end of each cycle
 
      // mParentMultiForm is a pointer to a cxMultiForm, in
      // case the form appears on a cxMultiForm (it can be
      // nullptr if it isn't on a cxMultiForm).
      cxMultiForm *mParentMultiForm = nullptr;
 
      // Whether or not to cycle to the next/previous input in the input loop
      // (this is set false in setCurrentInput()).
      bool mCycleInput = true;
 
      // mUseInputStatus specifies whether or not to use the status text of
      // the inputs as the status text for the form (in the bottom border
      // This is useful for inputs with help messages.
      bool mUseInputStatus = true;
 
      // mHasBeenShown specifies whether or not the cxForm has been shown.
      // It is set true when show() is called.  mHasBeenShown is used in
      // the unhide() method; if the form has been shown before, then the
      // inputs on the form will be unhidden in addition to the form.  The
      // reason for this is that if the form hasn't been shown, then the
      // text in the inputs wouldn't have been drawn, so unhiding the inputs
      // may cause holes on the screen.
      bool mHasBeenShown = false;
 
      // mExtendedHelpKeys specifies keys that can be pressed to display
      // extended help for the inputs.  mUseExtendedHelpKeys specifies whether
      // or not to use them.
      std::set<int> mExtendedHelpKeys;
      bool mUseExtendedHelpKeys = true;
 
      // mAllValidateOnJumpKey specifies whether or not the validator function
      // for each input should run when the user presses the form's input jump
      // key.  If this is set to false, then when an input is appended,
      // mInputJumpKey will be added to the input's list of keys that skip the
      // validator function, allowing the user to jump to another input
      // whether or not the text in the input is valid.  Otherwise, they could
      // only jump if the input is valid.
      bool mAllValidateOnJumpKey = true;
 
      // mInputShowBools contains a boolean for each input
      // that specifies whether it should be shown.  This
      // was added to aid in scrolling the inputs in
      // stacked mode.  It's possible to have an input
      // on a top/bottom border and still have it showing,
      // but when we're scrolling the inputs, we will want
      // to make sure that showAllInputs() doesn't show
      // certain inputs.
      std::vector<bool> mInputShowBools;
 
      // mInputJumpIndexes stores indexes for inputs to
      //  which to set focus.  Indexes are appended to
      //  this container when the user calls addInputJumpKey(),
      //  and the indexes in this container are used by
      //  changeFocus().
      std::vector<int> mInputJumpIndexes;
 
      // Makes sure this window is exactly the size needed to surround the inputs.
      void fitToInputs();
 
      // Copies the current menu item's help string to the
      // status string, and optionally updates the status.
      inline void useInputStatusAsFormStatus(bool refreshStatus = false);
 
      // Selects the next editable input.  Returns true if the current input
      // was the last input, or false otherwise.
      bool selectNextInput();
 
      // Selects the previous editable input.  Returns true if the current
      // input was the first input, or false otherwise.
      bool selectPrevInput();
 
      // The following functions are helpers for selectNextInput().
 
      // Returns the greatest left side of all the inputs.
      inline int greatestLeftSide() const;
 
      // Returns the lowest left side of all the inputs.
      inline int lowestLeftSide() const;
 
      // Returns the greatest top side of all the inputs.
      inline int greatestTopSide() const;
 
      // Returns the lowest top side of all the inputs.
      inline int lowestTopSide() const;
 
      // Returns the index in mInputs that has the next lowest
      // top side of an input, or -1 if one isn't found.
      inline int inputNextLowestTop(int topSide);
 
      // Returns the index in mInputs that has the next lowest
      // left side of an input, or -1 if one isn't found.
      inline int inputNextLowestLeft(int leftSide);
 
      // Removes the last character in the current input if it
      // is a space.  (In testing, it was found that when
      // the user hits the TAB key to go to the next input, it
      // was getting an extra space for the current input.  This
      // is a kludge, but it works..)
      inline void clearInputIfSpace();
 
      // Frees the memory used by the inputs
      inline void freeInputs();
 
      // Sets the current input for focus for a form.
      static std::string changeFocus(void *theForm, void *theIndex);
 
      // Scans a string for hotkeys and uses them for keys to press
      // to jump to a particular input.
      // Parameters:
      //  pItemText: The text to scan for hotkeys
      //  pIndex: The index of the input to which to jump for the hotkeys
      void addJumpKeys(const std::string& pItemText, int pIndex);
 
      // Shows the input jump menu for the form and handles jumping
      // to another input upon the user's selection.
      void showJumpMenu();
 
      // Returns the highest editable input index (or -1 if there are no inputs).
      int highestEditableInput() const;
 
      // Applies attribute defaults to an input.  This is meant for new inputs
      // being appended to the form (used in the append() methods).
      //
      // Parameters:
      //  pInput: A pointer to an input to which to apply the attributes.
      void applyAttrDefaults(std::shared_ptr<cxMultiLineInput>& pInput);
 
      // Applies all the form's attributes to an input.  This meant for new
      // inputs being appended to the form (used in the append() methods).
      //
      // Parameters:
      //  pInput: A pointer to an input to which to apply the attributes.
      void applyWinAttributes(std::shared_ptr<cxMultiLineInput>& pInput);
 
      friend class cxMultiLineInput;
      friend class cxMultiForm;
      friend class cxPanel;
};
 
 
} // namespace cx
 
#endif