cxMultiLineInput.h

Go to the documentation of this file.

// Copyright (c) 2026 E. Oulashin
#ifndef __CXMULTILINEINPUT_H__
#define __CXMULTILINEINPUT_H__
 
/*
 * cxMultiLineInput.h - This class represents a multi-line input with a label.
 *  Logically, this is one big input, and the value will be spread across all
 *  lines.  Wrapping is handled as the user types to the end of each line.
 *  This class is made up of single-line cxInput objects; however, in
 *  retrospect, this seems rather janky; it would be good to just eliminate
 *  cxInput, rename this class to cxInput, and re-do this class so that it is
 *  just a single window and can handle scrolling.
 *
 * Copyright (C) 2005-2007 Michael H. Kinney
 *
 *
 * Date     User    Description
 * 08/23/07 erico   Added a built-in onKeypress function to do per-keypress
 *                  validation for numeric input types, and to allow deriving
 *                  classes to override it to add additional functionality.
 */
 
#include "cxWindow.h"
#include "cxInput.h"
#include "cxInputTypes.h"
#include "cxFunction.h"
#include <signal.h> // For sigaction
#include <string>
#include <vector>
#include <set>
#include <map>
#include <memory>
 
namespace cx {
 
enum eMLIF
{
   eMLIF_COMMA_SEP = 0,
   eMLIF_COMMA_SEP_WITH_DESC
}; // enum for cxMultiLineInputFormat
 
// eInputErrors is an enumeration that specifies an errors state for the
//  input.  If validation fails, the input's mErrorState will be set to
//  one of these errors.  If there is no error, it will be set to eNO_ERROR.
enum eInputErrors
{
   eNO_ERROR,
   eOUT_OF_RANGE,
   eINVALID_VALUE,
   eBLANK,
   eCUSTOM_VALIDATION_FAILED
}; // enum for input errors
 
class cxForm; // Pre-declaration to avoid a circular reference
 
class cxMultiLineInput : public cxWindow
{
   public:
      explicit cxMultiLineInput(cxWindow *pParentWindow = nullptr, int pRow = 0,
                                int pCol = 0, int pHeight = 1,
                                int pWidth = DEFAULT_WIDTH,
                                const std::string& pLabel = "",
                                eBorderStyle pBorderStyle = eBS_NOBORDER,
                                eInputOptions pInputOption = eINPUT_EDITABLE,
                                eInputTypes pInputType = eINPUT_TYPE_TEXT,
                                std::string *pExtValue = nullptr,
                                int pRightLabelOffset = 0,
                                int pRightLabelHeight = 1,
                                int pRightLabelWidth = 7,
                                bool pShowRightLabel = false);
 
      cxMultiLineInput(const cxMultiLineInput& pThatInput);
 
      virtual ~cxMultiLineInput();
 
      cxMultiLineInput& operator =(const cxMultiLineInput& pThatInput);
 
      virtual long show(bool pBringToTop = false, bool pShowSubwindows = false) override;
 
      virtual long showModal(bool pShowSelf = true, bool pBringToTop = true,
                             bool pShowSubwindows = false) override;
 
      void hide(bool pHideSubwindows = false) override;
 
      void unhide(bool pUnhideSubwindows = false) override;
 
      virtual void erase(bool pEraseSubwindows = true) override;
 
      virtual std::string getLabel() const;
 
      virtual void setLabel(const std::string& pLabel);
 
      virtual void clearValue(bool pRefresh = false);
 
      virtual void clear(bool pRefresh = false) override;
 
      virtual std::string getValue() const;
 
      virtual bool setValue(std::string pValue, bool pRefresh = false);
 
      std::string *getExtValue() const { return(mExtValue); }
 
      void setExtValue(std::string *pExtVal, bool pRefresh = false);
 
      virtual void setValidatorStr(const std::string& pValidator);
 
      virtual std::string getValidatorStr() const;
 
      virtual bool textIsValid() const;
 
      virtual bool textIsValid(const std::string& pText) const;
 
      bool getMasked();
 
      void toggleMasking(bool pMasking);
 
      char getMaskChar() const;
 
      void setMaskChar(char pMaskChar);
 
      virtual bool move(int pNewRow, int pNewCol, bool pRefresh = true) override;
 
      virtual void resize(int pNewHeight, int pNewWidth, bool pRefresh = true) override;
 
      virtual bool setKeyFunction(int pKey, const std::shared_ptr<cxFunction>& pFunction) override;
 
      virtual bool setKeyFunction(int pKey, funcPtr4 pFunction,
                                  void *p1, void *p2, void *p3, void *p4,
                                  bool pUseVal, bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true) override;
 
      virtual bool setKeyFunction(int pKey, funcPtr4 pFunction,
                                  void *p1, void *p2, void *p3, void *p4,
                                  bool pUseVal, bool pExitAfterRun,
                                  bool pRunOnLeaveFunction, bool pRunValidator);
 
      virtual bool setKeyFunction(int pKey, funcPtr2 pFunction,
                                  void *p1, void *p2, bool pUseVal,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true) override;
 
      virtual bool setKeyFunction(int pKey, funcPtr2 pFunction,
                                  void *p1, void *p2, bool pUseVal,
                                  bool pExitAfterRun, bool pRunOnLeaveFunction,
                                  bool pRunValidator);
 
      virtual bool setKeyFunction(int pKey, funcPtr0 pFunction,
                                  bool pUseVal,
                                  bool pExitAfterRun = false,
                                  bool pRunOnLeaveFunction = true) override;
 
      virtual bool setKeyFunction(int pKey, funcPtr0 pFunction,
                                  bool pUseVal,
                                  bool pExitAfterRun, bool pRunOnLeaveFunction,
                                  bool pRunValidator);
 
      virtual void addSkipValidatorKey(int pKey);
 
      virtual void removeSkipValidatorKey(int pKey);
 
      virtual bool hasSkipValidatorKey(int pKey) const;
 
      virtual void clearKeyFunction(int pFunctionKey) override;
 
      virtual void clearKeyFunctions() override;
 
      void setLabelColor(e_cxColors pColor);
 
      e_cxColors getLabelColor() const;
 
      void setValueColor(e_cxColors pColor);
 
      e_cxColors getValueColor() const;
 
      virtual void setColor(e_WidgetItems pItem, e_cxColors pColor) override;
 
      virtual int getInputOption() const;
 
      virtual void setInputOption(eInputOptions pInputKind);
 
      void toggleCursor(bool pShowCursor);
 
      static std::string clearInput(void* theInput, void* unused);
 
      virtual bool setValidatorFunction(const std::shared_ptr<cxFunction>& pFunction);
 
      bool setValidatorFunction(funcPtr4 pFunction, void *p1, void *p2,
                                void *p3, void *p4);
 
      bool setValidatorFunction(funcPtr2 pFunction, void *p1, void *p2);
 
      bool setValidatorFunction(funcPtr0 pFunction);
 
      void clearValidatorFunction();
 
      bool isFull() const;
 
      virtual void setOnKeyFunction(const std::shared_ptr<cxFunction>& pFunction);
 
      virtual void setOnKeyFunction(funcPtr4 pFunction, void *p1, void *p2,
                                    void *p3, void *p4);
 
      virtual void setOnKeyFunction(funcPtr2 pFunction, void *p1, void *p2);
 
      virtual void setOnKeyFunction(funcPtr0 pFunction);
 
      virtual void toggleOnKeyFunction(bool pRunOnKeyFunction);
 
      virtual void clearOnKeyFunction();
 
      bool onKeyFunctionEnabled() const;
 
      void setEnterAlwaysExits(bool pEnterAlwaysExits);
 
      bool enterAlwaysExits() const;
 
      virtual int maxValueLen() const;
 
      virtual bool hasFocus() const override;
 
      virtual void setReadOnlyOnLeave(bool pReadOnlyOnLeave);
 
      bool canBeEditable() const;
 
      void setCanBeEditable(bool pCanBeEditable);
 
      void setExitOnFull(bool pExitOnFull);
 
      bool getExitOnFull() const;
 
      virtual void setBorderStyle(eBorderStyle pBorderStyle) override;
 
      virtual bool isAbove(const cxWindow& pThatWindow) const override;
 
      virtual bool isBelow(const cxWindow& pThatWindow) const override;
 
      virtual void bringToTop(bool pRefresh = true) override;
 
      virtual void refreshValue(bool pRefresh = true);
 
      void trapNonAssignedFKeys(bool pTrapNonAssignedFKeys);
 
      virtual bool runOnFocusFunction(std::string *pFunctionRetval = nullptr) override;
 
      void runFieldFunction(int pKey);
 
      int getInputLen() 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 enableInputLoop(bool pDoInputLoop);
 
      virtual bool inputLoopEnabled() const;
 
      virtual void setEditable(bool pEditable);
 
      virtual bool isEditable() const;
 
      bool getAutoWrapAtBeginning() const;
 
      void setAutoWrapAtBeginning(bool pWrapAtBeginning);
 
      bool getSkipIfReadOnly() const;
 
      void setSkipIfReadOnly(bool pSkipIfReadOnly);
 
      virtual void setDisableCursorOnShow(bool pDisableCursorOnShow) override;
 
      cxForm* getParentForm() const;
 
      virtual void setValidateOnReverse(bool pValidateOnReverse);
 
      virtual bool getValidateOnReverse() const;
 
      virtual void setLastKey(int pLastKey) override;
 
      virtual bool modalGetsKeypress() const override;
 
      virtual void setEnabled(bool pEnabled) override;
 
      virtual void quitNow(bool pMoveForward);
 
      virtual void quitNow() override;
 
      virtual void exitNow(bool pMoveForward);
 
      virtual void exitNow() override;
 
      virtual void toggleValidatorFunction(bool pRunValidatorFunction);
 
      virtual bool getUseValidatorFunction() const;
 
      virtual cxWindow* getParent() const override;
 
      virtual bool ranFunctionAndShouldExit() 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 bool getCursorLeftAlign() const;
 
      virtual void setCursorLeftAlign(bool pCursorLeftAlign);
 
      bool getExitOnBackspaceAtFront() const;
 
      void setExitOnBackspaceAtFront(bool pExitOnBackspaceAtFront);
 
      virtual std::string runValidatorFunction() const;
 
      virtual bool hasNavKey(int pKey) const;
 
      virtual void addNavKey(int pKey);
 
      virtual void removeNavKey(int pKey);
 
      virtual void removeNavKeys();
 
      virtual void getNavKeys(std::set<int>& pNavKeys) const;
 
      virtual void setTimeout(int pTimeout);
 
      int getTimeout() const;
 
      virtual std::string cxTypeStr() const override;
 
      eInputTypes getInputType() const;
 
      virtual void setInputType(eInputTypes pInputType);
 
      long double getRangeLowDouble() const;
 
      void setRangeLowDouble(const long double &pRangeLowDouble);
 
      long double getRangeHighDouble() const;
 
      void setRangeHighDouble(const long double &pRangeHighDouble);
 
      long int getRangeLowInt() const;
 
      void setRangeLowInt(const long int &pRangeLowInt);
 
      long int getRangeHighInt() const;
 
      void setRangeHighInt(const long int &pRangeHighInt);
 
      void getRangeDouble(long double &pLow, long double &pHigh) const;
 
      void setRangeDouble(const long double &pLow, const long double &pHigh);
 
      void getRangeInt(long int &pLow, long int &pHigh);
 
      void setRangeInt(const long int &pLow, const long int &pHigh);
 
      virtual std::string inputValidator();
 
      virtual std::string onKeypress();
 
      virtual void useBuiltInValidator();
 
      virtual bool usingBuiltInValidator() const;
 
      virtual void useBuiltInOnKeyFunction();
 
      virtual bool usingBuiltInOnKeyFunction() const;
 
      void validatorFuncMessageBox(bool pEnable);
 
      bool validatorFuncMessageBox() const;
 
      virtual void addValidOptions(const std::string& pValidOptions,
                                   bool pValidate = true);
 
      virtual void setValidOptions(const std::string& pValidOptions,
                                   bool pValidate = true);
 
      virtual void setValidOptions(const std::map<std::string, std::string>& pValidOptions,
                                   bool pValidate = true);
 
      virtual void addValidOption(const std::string& pValidOption,
                                  const std::string& pRightLabelText = "",
                                  bool pValidate = true);
 
      virtual void getValidOptions(std::map<std::string, std::string>& pValidOptions) const;
 
      std::string getValidOptionStrings(const eMLIF& pMLIF=eMLIF_COMMA_SEP) const;
 
      void getValidOptionStrings(std::set<std::string>& pValidOptionStrings) const;
 
      virtual bool hasValidOptionString(const std::string& pStr) const;
 
      virtual std::string getValidOptionHelpText(const std::string& pInput) const;
 
      virtual void clearValidOptions();
 
      virtual bool autoFillFromValidOptions(bool pRefresh = false);
 
      virtual void setForceUpper(bool pForceUpper);
 
      virtual bool getForceUpper() const;
 
      virtual void setAllowBlank(bool pAllowBlank);
 
      virtual bool getAllowBlank() const;
 
      virtual void setExtendedHelp(const std::string& pExtendedHelp);
 
      virtual std::string getExtendedHelp() const;
 
      virtual void setExtendedHelpColor(e_cxColors pColor);
 
      virtual e_cxColors getExtendedHelpColor() const;
 
      virtual void setExtendedHelpAttribute(attr_t pAttr);
 
      virtual attr_t getExtendedHelpAttribute() const;
 
      virtual void autoGenerateExtendedHelp(bool pAutoGenerateExtendedHelp);
 
      virtual bool autoGenerateExtendeHelp() const;
 
      virtual void setExtendedHelpKey(int pKey);
 
      virtual void addExtendedHelpKey(int pKey);
 
      virtual void setExtendedHelpKeys(const std::set<int>& pKeys);
 
      virtual std::set<int> getExtendedHelpKeys() const;
 
      virtual std::string getExtendedHelpKeyStrings() const;
 
      virtual void clearExtendedHelpKeys();
 
      virtual void setUseExtendedHelpKeys(bool pUseExtendedHelpKey);
 
      virtual bool getUseExtendedHelpKeys() const;
 
      virtual bool keyIsExtendedHelpKey(int pKey) const;
 
      virtual void setShowRightLabel(bool pShowRightLabel);
 
      virtual bool getShowRightLabel() const;
 
      virtual void setRightLabelOffset(int pOffset, bool pRefresh = false);
 
      virtual int getRightLabelOffset() const;
 
      virtual int getRightLabelTop() const;
 
      virtual int getRightLabelLeft() const;
 
      virtual int getRightLabelBottom() const;
 
      virtual int getRightLabelRight() const;
 
      virtual int getRightLabelHeight() const;
 
      virtual int getRightLabelWidth() const;
 
      virtual void setRightLabelWidth(int pWidth, bool pRefresh = false);
 
      virtual void setRightLabelHeight(int pHeight, bool pRefresh = false);
 
      virtual void resizeRightLabel(int pHeight, int pWidth, bool pRefresh = false);
 
      virtual void setRightLabel(const std::string& pText, bool pRefresh = false);
 
      virtual void setRightLabel(int pOffset, const std::string& pText, bool pRefresh = false);
 
      virtual std::string getRightLabel() const;
 
      virtual void getRightLabelSize(int& pHeight, int& pWidth);
 
      virtual e_cxColors getRightLabelColor() const;
 
      virtual void setRightLabelColor(e_cxColors pColor);
 
      virtual void setRightLabelAttr(attr_t pAttr);
 
      virtual void setMaxInputLength(int pLength);
 
      virtual int getMaxInputLength() const;
 
      virtual eInputErrors getErrorState() const;
 
      virtual void setErrorState(eInputErrors pErrorState);
 
      virtual bool getUseClearKey() const;
 
      virtual void setUseClearKey(bool pUseClearKey);
 
      virtual void additionalOnClear();
 
      virtual bool rightLabelEnabled() const;
 
      bool validatorFunctionIsSet() const;
 
   protected:
      std::shared_ptr<cxFunction> mValidatorFunction;
 
      bool mRunFocusFunctions = true;
 
      void copyCxMultiLineInputStuff(const cxMultiLineInput *pThatInput);
 
      long doInputLoop(bool pShowInputs, bool& pRunOnLeaveFunction);
 
      bool focusFunctionsWillRun() const;
 
      void runFocusFunctions(bool pRunFocusFunctions);
 
      void setParentForm(cxForm *pParentForm);
 
      bool searchParentFormsForFKey(int pFunctionKey,
                                    bool pIncludeNavigationalKeys = false);
 
      void freeInputs();
 
      virtual bool handleFunctionForLastKey(bool *pFunctionExists = nullptr,
                                            bool *pRunOnLeaveFunction = nullptr) override;
 
      virtual void enableAttrs(WINDOW *pWin, e_WidgetItems pItem) override;
 
      virtual void disableAttrs(WINDOW *pWin, e_WidgetItems pItem) override;
 
   private:
      friend class cxForm; // Because that class uses this class
      friend class cxInput;
 
      typedef std::vector<std::shared_ptr<cxInput> > cxInputPtrContainer;
      cxInputPtrContainer mInputs; // The collection of single-line inputs
      // mExtValue points to an "external" location to load/store the user's
      // input (basically, it will be used for user input storage as well as
      // mValue, but the value in this input will always be the what mExtValue
      // contains).  If nullptr, then it won't be used.
      std::string *mExtValue;
      int mCurrentInputLine = 0; // The index of the current single-line input
      // If mEnterAlwaysExits is true, enter will exit the input loop if
      // the cursor is in the middle of one of the input lines; if
      // false, enter will go to the next input line and stay in
      // the input loop until the user presses enter on the last line.
      bool mEnterAlwaysExits = true;
      bool mReadOnlyOnLeave = false;     // Make the input read-only when leaving showModal()?
      bool mExitOnFull = true;           // Whether to exit automatically when full
      bool mDoInputLoop = true;          // Whether to run the input loop on focus
      bool mSkipIfReadOnly = true;       // Don't wait for input if read-only?
      bool mRunValidatorFunction = true; // Controls whether or not the validator function should run
      bool mUseClearKey = true;          // Use built-in clear key?
 
      // Whether or not to run the validator function when the user is
      //  navigating in reverse (i.e., with the up arrow or shift-tab).
      bool mValidateOnReverse = true;
 
      // mParentForm is a pointer to a cxForm, in case the input appears on a
      //  cxForm.  This can be null.
      cxForm *mParentForm = nullptr;
 
      // If mApplyAttrDefaults is true, some attributes will be applied to
      //  the input when its kind is set.
      bool mApplyAttrDefaults = true;
 
      // mRanFunctionAndShouldExit keeps track of whether the input ran a key
      //  function that was set up to have the input exit when it was done.
      bool mRanFunctionAndShouldExit = false;
 
      // mSkipValidatorKeys keeps track of keys used with key functions where
      //  we don't want to run the validator function.
      std::set<int> mSkipValidatorKeys;
 
      // A set of keys that are designated as "navigation keys" -
      //  Normally, when the user presses a key, a cxMultiLineInput will check
      //  its parent window (if it's on a cxForm or cxPanel) to see if it has
      //  a function associated with that key, and if so, the input will exit
      //  its input loop without running its validator.  However, navigational
      //  keys are an exception, because usually you would want to run the
      //  validator function to run before the user leaves the input.  The
      //  default navigational keys are pageUp, pageDown, arrow keys, tab, and
      //  shift-tab.
      std::set<int> mNavKeys;
 
      // mInputType defines the type of input (text, numeric floating point, or
      //  numeric whole).  This specifies which type of validation should be
      //  used.
      eInputTypes mInputType;
 
      // mValidOptionStrings contains strings enumerating all the possible
      //  values for the input that are valid.  If this is empty, that means
      //  anything is valid.  This is a map - The key is the valid string, and
      //  the value is help text that goes along with it.
      std::map<std::string, std::string> mValidOptionStrings;
      // mAutoGenerateExtendedHelp specifies whether or not the extended help
      //  should be auto-generated from the list of valid input strings and
      //  their help texts.
      bool mAutoGenerateExtendedHelp = false;
 
      // mRangeLowDouble and mRangeHighDouble define low & high numeric values
      //  for floating-point numeric range validation.  If both are 0, that
      //  means any number is valid.
      long double mRangeLowDouble = 0.0;
      long double mRangeHighDouble = 0.0;
      // mRagneLowInt and mRangeLowHigh define low & high numeric values for
      //  whole numeric range validation.  If both are 0, that means any number
      //  is valid.
      long int mRangeLowInt = 0;
      long int mRangeHighInt = 0;
 
      // This bool specifies whether or not the validator function should
      //  display a message box when the input is invalid.
      bool mValidatorFuncMessageBox = false;
 
      bool mAllowBlank = true; // Allow a blank value?
 
      // mExtendedHelp can contain long or more verbose help text.  You can
      //  also set the color & attribute for the extended help text.
      std::string mExtendedHelp;
      e_cxColors mExtendedHelpColor;
      attr_t mExtendedHelpAttribute = A_NORMAL;
      // mExtendedHelpKeys specifies keys that can be pressed to display the
      //  extended help.  mUseExtendedHelpKeys specifies whether or not to
      //  use them.
      std::set<int> mExtendedHelpKeys;
      bool mUseExtendedHelpKeys = true;
 
      // mRightLabel is a window that will display an additional label to
      //  the right of the input.  mRightLabelOffset is the distance between
      //  the input and mRightLabel.
      //cxWindow mRightLabel;
      std::unique_ptr<cxWindow> mRightLabel;
      int mRightLabelOffset;
      bool mShowRightLabel; // Whether or not to display the right label
 
      int mMaxInputLength = 32000;  // The maximum length of input acceptable
 
      // mErrorState specifies a current error for the input (i.e., if
      //  validation failed).
      eInputErrors mErrorState = eNO_ERROR;
 
      // Disable the use of setHotkeyHighlighting from the
      //  outside.
      void setHotkeyHighlighting(bool pMessageUnderlines) override;
 
      // Fills mWindow with the current window text, but does not actually
      //  show it.
      virtual void draw() override;
 
      // Returns whether or not what's on the screen differs from the member
      //  data.
      bool scrDiff();
 
      // This is for copying a cxMultiLineInput - This copies
      //  cxValidatorFunction.
      void copyValidatorFunction(const cxMultiLineInput& pThatInput);
 
      // This is a helper for setInputType() - This Returns whether
      //  intOnKeyValidator() or floatingPtOnKeyValidator() from cxValidators
      //  are set up as onKey functions for the input.
      bool usingOnKeyNumericValidator() const;
 
      // Static cxWidgets function for validation - This calls inputValidator()
      //  for a cxMultiLineInput.
      //
      // Parameters:
      //  theInput: A pointer to the cxMultiLineInput
      //  unused: Not used
      static std::string inputValidatorStatic(void *theInput, void *unused);
 
      // Static cxWidgets onKeypress function - This calls onKeypress() for
      //  a cxMultiLineInput.
      //
      // Parameters:
      //  theInput: A pointer to the cxMultiLineInput
      //  unused: Not used
      static std::string onKeypressStatic(void *theInput, void *unused);
 
      // This will generate mExtendedHelp based on mValidOptionStrings, if
      //  mValidOptionStrings has anything in it.
      void generateExtendedHelp();
 
      // Validates a string against mValidOptionStrings.  If mValidOptionStrings
      //  is empty, or if the string is in it, this will return true.  If
      //  mValidOptionStrings is not empty and the string isn't in it, this
      //  will return false.
      bool checkValidOptionStrings(const std::string& pValue);
 
      // This is a helper for validation.  For a numeric input type, this
      //  returns whether or not a value is within the set valid range.  If
      //  both the low & high range values are 0, this will assume that any
      //  number is valid and will return true.  For a non-numeric input type,
      //  this will return true.  If the given value does not contain a valid
      //  number, this will return false.
      //
      // Parameters:
      //  pValue: A value to check
      bool valueInRange(const std::string& pValue) const;
 
      // Word-wraps the text from the current line (mCurrentInputLine) downward
      // through subsequent lines.  If text overflows the last visible line,
      // the overflow is discarded (the caller should handle dynamic line
      // addition if needed).
      //
      // Parameters:
      //  pFromLine: The line index to start reflowing from
      void reflowFrom(int pFromLine);
 
      // Gets the full text content from all input lines, concatenated.
      // Unlike getValue(), this always concatenates without newlines.
      std::string getAllText() const;
 
      // Sets all text by distributing it across lines with word wrapping.
      // Unlike setValue(), this always word-wraps the text.
      void setAllTextWrapped(const std::string& pText);
 
      // Whether word wrapping is enabled (default true)
      bool mWordWrap = true;
};
 
 
} // namespace cx
 
#endif