OnError (flag ? ::post_form(form) : ::unpost_form (form));  }  // Decorations  inline void frame(const char *title=NULL, const char* btitle=NULL) {    if (b_framed)      NCursesPanel::frame(title,btitle);    else      OnError(E_SYSTEM_ERROR);  }  inline void boldframe(const char *title=NULL, const char* btitle=NULL) {    if (b_framed)      NCursesPanel::boldframe(title,btitle);    else      OnError(E_SYSTEM_ERROR);  }  inline void label(const char *topLabel, const char *bottomLabel) {    if (b_framed)      NCursesPanel::label(topLabel,bottomLabel);    else      OnError(E_SYSTEM_ERROR);  }  // -----  // Hooks  // -----  // Called after the form gets repositioned in its window.  // This is especially true if the form is posted.  virtual void On_Form_Init();  // Called before the form gets repositioned in its window.  // This is especially true if the form is unposted.  virtual void On_Form_Termination();  // Called after the field became the current field  virtual void On_Field_Init(NCursesFormField& field);  // Called before this field is left as current field.  virtual void On_Field_Termination(NCursesFormField& field);  // Calculate required window size for the form.  void scale(int& rows, int& cols) const {    OnError(::scale_form(form,&rows,&cols));  }  // Retrieve number of fields in the form.  int count() const {    return ::field_count(form);  }  // Make the page the current page of the form.  void set_page(int page) {    OnError(::set_form_page(form,page));  }  // Retrieve current page number  int page() const {    return ::form_page(form);  }  // Switch on the forms options  inline void options_on (Form_Options options) {    OnError (::form_opts_on (form, options));  }  // Switch off the forms options  inline void options_off (Form_Options options) {    OnError (::form_opts_off (form, options));  }  // Retrieve the forms options  inline Form_Options options () const {    return ::form_opts (form);  }  // Set the forms options  inline void set_options (Form_Options options) {    OnError (::set_form_opts (form, options));  }  // Are there more data in the current field after the data shown  inline bool data_ahead() const {    return ::data_ahead(form);  }  // Are there more data in the current field before the data shown  inline bool data_behind() const {    return ::data_behind(form);  }  // Position the cursor to the current field  inline void position_cursor () {    OnError (::pos_form_cursor (form));  }  // Set the current field  inline void set_current(NCursesFormField& F) {    OnError (::set_current_field(form, F.field));  }  // Provide a default key virtualization. Translate the keyboard  // code c into a form request code.  // The default implementation provides a hopefully straightforward  // mapping for the most common keystrokes and form requests.  virtual int virtualize(int c);  // Operators  inline NCursesFormField* operator[](int i) const {    if ( (i < 0) || (i >= ::field_count (form)) )      OnError (E_BAD_ARGUMENT);    return my_fields[i];  }  // Perform the menu's operation  // Return the field where you left the form.  virtual NCursesFormField* operator()(void);  // Exception handlers. The default is a Beep.  virtual void On_Request_Denied(int c) const;  virtual void On_Invalid_Field(int c) const;  virtual void On_Unknown_Command(int c) const;};//// -------------------------------------------------------------------------// This is the typical C++ typesafe way to allow to attach// user data to a field of a form. Its assumed that the user// data belongs to some class T. Use T as template argument// to create a UserField.// -------------------------------------------------------------------------template<class T> class NCURSES_IMPEXP NCursesUserField : public NCursesFormField{public:  NCursesUserField (int rows,		    int cols,		    int first_row = 0,		    int first_col = 0,		    const T* p_UserData = (T*)0,		    int offscreen_rows = 0,		    int additional_buffers = 0)    : NCursesFormField (rows, cols,			first_row, first_col,			offscreen_rows, additional_buffers) {      if (field)	OnError(::set_field_userptr(field,(void *)p_UserData));  }  virtual ~NCursesUserField() {};  inline const T* UserData (void) const {    return (const T*)::field_userptr (field);  }  inline virtual void setUserData(const T* p_UserData) {    if (field)      OnError (::set_field_userptr (field, (void *)p_UserData));  }};//// -------------------------------------------------------------------------// The same mechanism is used to attach user data to a form// -------------------------------------------------------------------------//template<class T> class NCURSES_IMPEXP NCursesUserForm : public NCursesForm{protected:  // 'Internal' constructor, builds an object without association to a  // field array.  NCursesUserForm( int  lines,		   int  cols,		   int  begin_y = 0,		   int  begin_x = 0,		   const T* p_UserData = (T*)0)    : NCursesForm(lines,cols,begin_y,begin_x) {      if (form)	set_user ((void *)p_UserData);  }public:  NCursesUserForm (NCursesFormField Fields[],		   const T* p_UserData = (T*)0,		   bool with_frame=FALSE,		   bool autoDelete_Fields=FALSE)    : NCursesForm (Fields, with_frame, autoDelete_Fields) {      if (form)	set_user ((void *)p_UserData);  };  NCursesUserForm (NCursesFormField Fields[],		   int lines,		   int cols,		   int begin_y = 0,		   int begin_x = 0,		   const T* p_UserData = (T*)0,		   bool with_frame=FALSE,		   bool autoDelete_Fields=FALSE)    : NCursesForm (Fields, lines, cols, begin_y, begin_x,		   with_frame, autoDelete_Fields) {      if (form)	set_user ((void *)p_UserData);  };  virtual ~NCursesUserForm() {  };  inline T* UserData (void) const {    return (T*)get_user ();  };  inline virtual void setUserData (const T* p_UserData) {    if (form)      set_user ((void *)p_UserData);  }};//// -------------------------------------------------------------------------// Builtin Fieldtypes// -------------------------------------------------------------------------//class NCURSES_IMPEXP Alpha_Field : public NCursesFieldType {private:  int min_field_width;  void set(NCursesFormField& f) {    OnError(::set_field_type(f.get_field(),fieldtype,min_field_width));  }public:  Alpha_Field(int width)    : NCursesFieldType(TYPE_ALPHA),      min_field_width(width) {  }};class NCURSES_IMPEXP Alphanumeric_Field : public NCursesFieldType {private:  int min_field_width;  void set(NCursesFormField& f) {    OnError(::set_field_type(f.get_field(),fieldtype,min_field_width));  }public:  Alphanumeric_Field(int width)    : NCursesFieldType(TYPE_ALNUM),      min_field_width(width) {  }};class NCURSES_IMPEXP Integer_Field : public NCursesFieldType {private:  int precision;  long lower_limit, upper_limit;  void set(NCursesFormField& f) {    OnError(::set_field_type(f.get_field(),fieldtype,			     precision,lower_limit,upper_limit));  }public:  Integer_Field(int prec, long low=0L, long high=0L)    : NCursesFieldType(TYPE_INTEGER),      precision(prec), lower_limit(low), upper_limit(high) {  }};class NCURSES_IMPEXP Numeric_Field : public NCursesFieldType {private:  int precision;  double lower_limit, upper_limit;  void set(NCursesFormField& f) {    OnError(::set_field_type(f.get_field(),fieldtype,			     precision,lower_limit,upper_limit));  }public:  Numeric_Field(int prec, double low=0.0, double high=0.0)    : NCursesFieldType(TYPE_NUMERIC),      precision(prec), lower_limit(low), upper_limit(high) {  }};class NCURSES_IMPEXP Regular_Expression_Field : public NCursesFieldType {private:  char* regex;  void set(NCursesFormField& f) {    OnError(::set_field_type(f.get_field(),fieldtype,regex));  }public:  Regular_Expression_Field(const char *expr)    : NCursesFieldType(TYPE_REGEXP) {      regex = new char[1 + ::strlen(expr)];      (::strcpy)(regex,expr);  }  ~Regular_Expression_Field() {    delete[] regex;  }};class NCURSES_IMPEXP Enumeration_Field : public NCursesFieldType {private:  const char** list;  int case_sensitive;  int non_unique_matches;  void set(NCursesFormField& f) {    OnError(::set_field_type(f.get_field(),fieldtype,			     list,case_sensitive,non_unique_matches));  }public:  Enumeration_Field(const char* enums[],		    bool case_sens=FALSE,		    bool non_unique=FALSE)    : NCursesFieldType(TYPE_ENUM),      list(enums),      case_sensitive(case_sens?-1:0),      non_unique_matches(non_unique?-1:0) {  }};class NCURSES_IMPEXP IPV4_Address_Field : public NCursesFieldType {private:  void set(NCursesFormField& f) {    OnError(::set_field_type(f.get_field(),fieldtype));  }public:  IPV4_Address_Field() : NCursesFieldType(TYPE_IPV4) {  }};//// -------------------------------------------------------------------------// Abstract base class for User-Defined Fieldtypes// -------------------------------------------------------------------------//class NCURSES_IMPEXP UserDefinedFieldType : public NCursesFieldType {  friend class UDF_Init; // Internal helper to set up staticsprivate:  // For all C++ defined fieldtypes we need only one generic lowlevel  // FIELDTYPE* element.  static FIELDTYPE* generic_fieldtype;protected:  // This are the functions required by the low level libforms functions  // to construct a fieldtype.  static bool fcheck(FIELD *, const void*);  static bool ccheck(int c, const void *);  static void* makearg(va_list*);  void set(NCursesFormField& f) {    OnError(::set_field_type(f.get_field(),fieldtype,&f));  }protected:  // Redefine this function to do a field validation. The argument  // is a reference to the field you should validate.  virtual bool field_check(NCursesFormField& f) = 0;  // Redefine this function to do a character validation. The argument  // is the character to be validated.  virtual bool char_check (int c) = 0;public:  UserDefinedFieldType() : NCursesFieldType(generic_fieldtype) {  }};//// -------------------------------------------------------------------------// Abstract base class for User-Defined Fieldtypes with Choice functions// -------------------------------------------------------------------------//class NCURSES_IMPEXP UserDefinedFieldType_With_Choice : public UserDefinedFieldType {  friend class UDF_Init; // Internal helper to set up staticsprivate:  // For all C++ defined fieldtypes with choice functions we need only one  // generic lowlevel FIELDTYPE* element.  static FIELDTYPE* generic_fieldtype_with_choice;  // This are the functions required by the low level libforms functions  // to construct a fieldtype with choice functions.  static bool next_choice(FIELD*, const void *);  static bool prev_choice(FIELD*, const void *);protected:  // Redefine this function to do the retrieval of the next choice value.  // The argument is a reference to the field tobe examined.  virtual bool next    (NCursesFormField& f) = 0;  // Redefine this function to do the retrieval of the previous choice value.  // The argument is a reference to the field tobe examined.  virtual bool previous(NCursesFormField& f) = 0;public:  UserDefinedFieldType_With_Choice() {    fieldtype = generic_fieldtype_with_choice;  }};#endif // NCURSES_CURSESF_H_incl