cxMultiForm.h

Go to the documentation of this file.

// Copyright (c) 2026 E. Oulashin
#ifndef __CXMULTIFORM_H__
#define __CXMULTIFORM_H__
 
// Copyright (c) 2005-2007 Michael H. Kinney
//
// This class represents a form that can contain
//  subforms (forms within the form).
//
// TODO: When the user presses ESC on one of
//  the subforms, if the subforms have any
//  onLeave functions, it will still run them..
//  ESC should quit directly out of the whole
//  multiForm.
//
// TODO: Add a way of telling the multiForm to
//  do subforms first on the first pass through
//  the input loop.  (Would have to add a private
//  boolean variable, mDoFormsFirst, and then
//  another boolean in doInputLoop(), firstPass,
//  and for each pass in the input loop, have it
//  do the inputs if firstPass is false or
//  mDoFormsFirst is false.)
 
#include "cxForm.h"
#include "cxFunction.h"
#include <string>
#include <vector>
#include <memory>
 
namespace cx {
 
class cxMultiForm : public cxForm
{
   public:
      explicit cxMultiForm(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);
 
      cxMultiForm(const cxMultiForm& pThatMultiForm);
 
      virtual ~cxMultiForm();
 
      cxMultiForm& operator =(const cxMultiForm& pThatMultiForm);
 
      virtual std::shared_ptr<cxForm> appendForm(int pRow, int pCol, int pHeight,
                          int pWidth, const std::string& pTitle = "",
                          eBorderStyle pBorderStyle = eBS_NOBORDER,
                          bool pStacked = false);
 
      virtual bool appendForm(std::shared_ptr<cxForm>& pForm, int pRow, int pCol, bool* pMoved = nullptr);
 
      virtual bool appendForm(std::shared_ptr<cxForm>& pForm);
 
      virtual std::shared_ptr<cxForm> getForm(unsigned pIndex) const;
 
      virtual std::shared_ptr<cxForm> getForm(const std::string& pTitle) 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 void showAllSubforms(bool pBringToTop = true, bool pSkipCurrentForm = false) const;
 
      virtual bool removeSubform(unsigned pIndex);
 
      virtual bool removeSubform(const std::string& pTitle);
 
      virtual std::string getValue(unsigned pFormIndex, int pInputIndex) const;
 
      virtual std::string getValue(int pIndex) const override;
 
      virtual std::string getValue(const std::string& pStr, bool pIsLabel = true) const override;
 
      virtual std::string getValue(unsigned pFormIndex, const std::string& pLabel,
                              bool pIsLabel = true) const;
 
      virtual std::string getValue(const std::string& pTitle, int pInputIndex) const;
 
      virtual std::string getValue(const std::string& pTitle, const std::string& pLabel,
                              bool pIsLabel = true) const;
 
      virtual bool setValue(unsigned pFormIndex, int pInputIndex, const std::string& pValue,
                            bool pRefresh = false);
 
 
      virtual bool setValue(unsigned pFormIndex, const std::string& pLabel,
                            const std::string& pValue, bool pIsLabel = true,
                            bool pRefresh = false);
 
      virtual bool setValue(const std::string& pTitle, int pInputIndex,
                            const std::string& pValue, bool pRefresh = false);
 
      virtual bool setValue(const std::string& pTitle, const std::string& pLabel,
                            const std::string& pValue, bool pIsLabel = true,
                            bool pRefresh = false);
 
      virtual bool setValue(int pIndex, const std::string& pValue, bool pRefresh = false) override;
 
      virtual bool setValue(const std::string& pLabel, const std::string& pValue, bool pIsLabel = true, bool pRefresh = false) override;
 
      size_t numSubforms() const;
 
      virtual int getLastKey() const override;
 
      bool hasEditableSubforms() const;
 
      virtual bool move(int pNewRow, int pNewCol, bool pRefresh = true) override;
 
      virtual void hide(bool pHideSubwindows = true) override;
 
      virtual void unhide(bool pUnhideSubwindows = true) 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 setCurrentSubform(int pIndex);
 
      virtual bool setCurrentSubform(const std::string& pTitle);
 
      virtual bool setCurrentSubformByPtr(const std::shared_ptr<cxForm>& pForm);
      virtual bool setCurrentSubformByPtr(cxForm *pForm);
 
      virtual int getCurrentForm() const;
 
      virtual int getSubformIndex(const std::shared_ptr<cxForm>& pForm) const;
      virtual int getSubformIndex(cxForm *pForm) const;
 
      virtual bool hasChanged() const override;
 
      virtual void setChanged(bool pDataChanged) override;
 
      virtual void setSubformEnabled(unsigned pIndex, bool pEnabled);
 
      virtual void setSubformEnabled(const std::string& pTitle, bool pEnabled);
 
      virtual bool subformIsEnabled(unsigned pIndex) const;
 
      virtual bool subformIsEnabled(const std::string& pTitle) 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 setDisableCursorOnShow(bool pDisableCursorOnShow) override;
 
      virtual void clear(bool pRefresh = false) override;
 
      void setAssumeMovingBackwards(bool pAssumeMovingBackwards);
 
      bool getAssumeMovingBackwards() const;
 
      virtual void setEnabled(bool pEnabled) override;
 
      virtual std::string cxTypeStr() const override;
 
   protected:
      void copyCxMultiFormStuff(const cxMultiForm* pThatMultiForm);
 
      long doInputLoop(bool pShowSubforms);
 
      int lowestSubformRow(unsigned pIndex = 0) const;
 
   private:
      typedef std::vector<std::shared_ptr<cxForm> > formPtrContainer;
      formPtrContainer mForms; // Contains pointers to the subforms
      int mCurrentForm = 0;    // The index of the subform that currently has focus
      bool mCycleForm = true;  // Whether or not to cycle to the next or
                               // previous form in the input loop (this
                               // is set to false when setCurrentSubform()
                               // is called)
      // If this is set true, then when focus is set to the multiForm and the
      //  cursor is on the last form, then the cursor on the last form will be
      //  set to the last input on that form (motion is assumed to be moving
      //  backwards).
      bool mAssumeMovingBackwards = true;
 
      // Frees the memory used by the subforms and clears
      //  mForms.
      inline void freeSubforms();
 
      // Runs an input loop for the inputs.  Also sets a boolean for
      //  whether or not to continue the input loop.
      long doInputs(bool& pContinueOn);
 
      // Runs an input loop for the subforms.
      // Parameters:
      //  pShowSubforms: Whether or not to have the subforms show themselves
      //   before running their input loops.
      //  pContinueOn: This will store a boolean for whether or not to
      //   continue the input loop.
      //  pClickedInput: This will store a boolean for whether or not the user
      //   clicked on an input in the multiForm.  This is used by the input
      //   loop to determine whether to go back to looping through the inputs.
      long doSubforms(bool pShowSubforms, bool& pContinueOn, bool& pClickedInput);
 
      // Selects the next form with editable inputs.
      //  Returns whether or not the current form was
      //  the last form in mForms.
      bool selectNextForm();
 
      // Selects the previous form with editable inputs.
      //  Returns whether or not the current form was
      //  the first form in mForms.
      bool selectPrevForm();
 
      // Adds this multiForm's function keys to a subform.
      void addFormFunctionKeysToSubform(std::shared_ptr<cxForm>& pForm);
 
      // Adds this multiForm's quit keys and exit keys to a subform.
      void addQuitAndExitKeysToSubform(std::shared_ptr<cxForm>& pForm);
 
      // Returns whether a subform is enabled and editable (by index).
      //  Note that no bounds checking is done (for optimal
      //  efficiency).
      inline bool subformIsEnabledAndEditable(unsigned int pIndex);
};
 
 
} // namespace cx
 
#endif