home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / vgserv45.zip / BASE / HPTWGS2 / include / fcwexmap.h < prev    next >
Text File  |  2001-03-21  |  52KB  |  1,259 lines
  1. /*****************************************************************************/
  2. /*                                                                           */
  3. /*                           OCO SOURCE MATERIALS                            */
  4. /*                             IBM CONFIDENTIAL                              */
  5. /*                                    OR                                     */
  6. /*                        IBM CONFIDENTIAL RESTRICTED                        */
  7. /*            WHEN COMBINED WITH THE AGGREGATED OCO SOURCE MODULES           */
  8. /*                           FOR THIS PROGRAM PRODUCT                        */
  9. /*                                                                           */
  10. /*   VisualAge Generator Server for OS/2, AIX, HP-UX, SUN, and Windows NT    */
  11. /*                          Version 4.0  5697-C28                            */
  12. /*                    (C) COPYRIGHT IBM CORP. 1994,1998                      */
  13. /*                                                                           */
  14. /*****************************************************************************/
  15. /*****************************************************************************/
  16. /*                                                                           */
  17. /*    Date     Userid          Description of problem                        */
  18. /*                                                                           */
  19. /*  08/24/98   proffer         4070    -  Add support for Sun                */
  20. /*                                                                           */
  21. /*****************************************************************************/
  22. #ifndef FCWEXMAP_H
  23. #define FCWEXMAP_H
  24.  
  25. #include <stddef.h>
  26.  
  27. //-----------------------------------------------------------------------------
  28. // Coordinate class                                                           -
  29. //-----------------------------------------------------------------------------
  30. // This is the base class for all of the coordinate type classes such as      -
  31. // position and size.                                                         -
  32. //-----------------------------------------------------------------------------
  33. class Coord
  34. {
  35.    public:
  36.       enum enum_Coord
  37.       {
  38.          None,
  39.          RowCol,
  40.          Field
  41.       };
  42.       Coord();
  43.       Coord(Coord const& coord);
  44.       Coord(enum_Coord, int y, int x);
  45.       Coord(enum_Coord, char*, int index=1);
  46.       virtual ~Coord();
  47.  
  48.       int                row()    const;
  49.       int                y()      const;
  50.       int                col()    const;
  51.       int                x()      const;
  52.       FCWString          field()  const;
  53.       int                index()  const;
  54.       enum_Coord         type()   const;
  55.  
  56.       Bool       operator < (Coord const&)          const;
  57.       Bool       operator > (Coord const&)          const;
  58.       Bool       operator ==(Coord const&)          const;
  59.       void       operator=( Coord const & );
  60.  
  61.    private:
  62.       Coord::enum_Coord coord_type;
  63.       int               coord_y;
  64.       int               coord_x;
  65.       char*             coord_Name;
  66.       int               coord_index;
  67.       void*             pData;
  68. };
  69.  
  70. //-----------------------------------------------------------------------------
  71. // Position class                                                             -
  72. //-----------------------------------------------------------------------------
  73. // This class defines the position of a map on the screen as well as fields   -
  74. // within a map.                                                              -
  75. //-----------------------------------------------------------------------------
  76. class Position : public Coord
  77. {
  78.    public:
  79.       Position(Position const& pos);
  80.       Position(enum_Coord type=Coord::RowCol, int y=0, int x=0);
  81.       void       operator=( Position const & );
  82.  
  83.    private:
  84.       void* pData;
  85. };
  86.  
  87. //-----------------------------------------------------------------------------
  88. // Size class                                                                 -
  89. //-----------------------------------------------------------------------------
  90. // This class defines the size of a map as well as the size of fields on a    -
  91. // map.                                                                       -
  92. //-----------------------------------------------------------------------------
  93. class Size : public Coord
  94. {
  95.    public:
  96.       Size(Size const& siz);
  97.       Size(enum_Coord type=Coord::RowCol, int cy=0, int cx=0);
  98.       void       operator=( Size const & );
  99.  
  100.    private:
  101.       void* pData;
  102. };
  103.  
  104. //-----------------------------------------------------------------------------
  105. // Fold class                                                                 -
  106. //-----------------------------------------------------------------------------
  107. // This class defines the Fold enumeration values that will be used during map-
  108. // field editing.                                                             -
  109. //-----------------------------------------------------------------------------
  110. class Fold
  111. {
  112.    public:
  113.       enum enum_Fold
  114.       {
  115.          Map,
  116.          Yes,
  117.          No
  118.       };
  119. };
  120.  
  121. //-----------------------------------------------------------------------------
  122. // CursorPosition class                                                       -
  123. //-----------------------------------------------------------------------------
  124. // The CursorPosition class is used to determine the default cursor position  -
  125. // when a map is conversed.                                                   -
  126. //-----------------------------------------------------------------------------
  127. class CursorPosition : public Coord
  128. {
  129.    public:
  130.       CursorPosition();
  131.       CursorPosition(CursorPosition const& cp);
  132.       CursorPosition(enum_Coord type, char* p, int index=1);
  133.       CursorPosition(enum_Coord type, int y, int x);
  134.       void       operator=( CursorPosition const & );
  135.  
  136.    private:
  137.       void* pData;
  138. };
  139.  
  140. //-----------------------------------------------------------------------------
  141. // Justify class                                                              -
  142. //-----------------------------------------------------------------------------
  143. // The Attribute class is used to define the enumerations that are used to    -
  144. // set and query the field's justification.                                   -
  145. //-----------------------------------------------------------------------------
  146. class Justify
  147. {
  148.    public:
  149.       enum enum_Justify
  150.       {
  151.          None,
  152.          Left,
  153.          Right
  154.       };
  155. };
  156.  
  157. //-----------------------------------------------------------------------------
  158. // InputRequired class                                                        -
  159. //-----------------------------------------------------------------------------
  160. // The InputRequired class is used to define if input is required in an edit  -
  161. // field. If input is required, a user message number can be supplied as well.-
  162. //-----------------------------------------------------------------------------
  163. class InputRequired
  164. {
  165.    public:
  166.       InputRequired (Bool bRequired=False, int msgnum=0);
  167.       InputRequired (InputRequired const&);
  168.       ~InputRequired();
  169.  
  170.       Bool      isRequired() const;
  171.       int       msgnum()     const;
  172.       void       operator=( InputRequired const & );
  173.  
  174.    private:
  175.       Bool      ir_bRequired;
  176.       int       ir_msgnum;
  177.       void*     pData;
  178. };
  179.  
  180. //-----------------------------------------------------------------------------
  181. // MinInput class                                                             -
  182. //-----------------------------------------------------------------------------
  183. // The MinInput class is used to define if a minimum amount of input is       -
  184. // required in an edit field. This means that is input is supplied in a field -
  185. // a minimum number of characters must be supplied. A user message number may -
  186. // also be supplied.                                                          -
  187. //-----------------------------------------------------------------------------
  188. class MinInput
  189. {
  190.    public:
  191.       MinInput(int min=0, int msgnum=0);
  192.       MinInput(MinInput const &);
  193.       ~MinInput();
  194.  
  195.       int MinimumInput() const;
  196.       int msgnum()       const;
  197.       void       operator=( MinInput const & );
  198.  
  199.    private:
  200.       int     mi_minimum;
  201.       int     mi_msgnum;
  202.       void*   pData;
  203. };
  204.  
  205. //-----------------------------------------------------------------------------
  206. // EditRoutine class                                                          -
  207. //-----------------------------------------------------------------------------
  208. // The EditRoutine class defines the edit routine for a map field. The edit   -
  209. // routine can be a modulo edit, table edit, or statement group edit.         -
  210. // A user message number may also be supplied.                                -
  211. //-----------------------------------------------------------------------------
  212. class EditRoutine
  213. {
  214.    public:
  215.       enum enum_EditRoutine
  216.       {
  217.          None,
  218.          StatementGroup,
  219.          Table,
  220.          Other
  221.       };
  222.  
  223.       EditRoutine(enum_EditRoutine t=EditRoutine::None, char* pName=NULL, int msgno=0);
  224.       EditRoutine(EditRoutine const &);
  225.       ~EditRoutine();
  226.  
  227.       FCWString        Name()   const;
  228.       int              msgnum() const;
  229.       enum_EditRoutine Type()   const;
  230.       void       operator=( EditRoutine const & );
  231.  
  232.    private:
  233.       EditRoutine::enum_EditRoutine   er_type;
  234.       char*                           er_Name;
  235.       int                             er_msgnum;
  236.       void*                           pData;
  237. };
  238.  
  239. //-----------------------------------------------------------------------------
  240. // Sign class                                                                 -
  241. //-----------------------------------------------------------------------------
  242. // The Sign class is used to define the enumerations that are used to         -
  243. // set and query a numeric field's sign.                                      -
  244. //-----------------------------------------------------------------------------
  245. class Sign
  246. {
  247.    public:
  248.       enum enum_Sign
  249.       {
  250.          None,
  251.          Leading,
  252.          Trailing
  253.       };
  254. };
  255.  
  256. //-----------------------------------------------------------------------------
  257. // NumEdits class                                                             -
  258. //-----------------------------------------------------------------------------
  259. // The NumEdits class is used to define the numeric editing that will be done -
  260. // for output and input edits for a numeric field.                            -
  261. //-----------------------------------------------------------------------------
  262. class NumEdits
  263. {
  264.    public:
  265.       NumEdits();
  266.       NumEdits(NumEdits const&);
  267.       NumEdits(int              decimals,
  268.                Bool             bCurrency,
  269.                Sign::enum_Sign  sign,
  270.                Bool             bSeparators,
  271.                int              msgnum=0);
  272.       ~NumEdits();
  273.  
  274.       int              msgnum() const;
  275.  
  276.       FCWString        format  (FCWString const&, int, char, Bool bZeroEdit=False);
  277.       int              validate(FCWString const&, FCWString&, int);
  278.       void             operator=( NumEdits const & );
  279.  
  280.    private:
  281.       int              ne_decimals;
  282.       Bool             ne_currency;
  283.       Sign::enum_Sign  ne_sign;
  284.       Bool             ne_separators;
  285.       int              ne_msgnum;
  286.       void*            pData;
  287.  
  288.       int              decimals()   const;
  289.       Bool             currency()   const;
  290.       Sign::enum_Sign  sign()       const;
  291.       Bool             separators() const;
  292. };
  293.  
  294. //-----------------------------------------------------------------------------
  295. // MixEdits class                                                             -
  296. //-----------------------------------------------------------------------------
  297. // The MixEdits class is used to define if the SOSI editing is used for       -
  298. // the field and if there is a data type user message associated with this    -
  299. // edit check.                                                                -
  300. //-----------------------------------------------------------------------------
  301. class MixEdits
  302. {
  303.    public:
  304.       MixEdits(Bool bSOSI=False, int msgnum=0);
  305.       MixEdits(MixEdits const &);
  306.       ~MixEdits();
  307.  
  308.       Bool SOSIEditing() const;
  309.       int  msgnum()      const;
  310.       void       operator=( MixEdits const & );
  311.  
  312.    private:
  313.       int     me_SOSI;
  314.       int     me_msgnum;
  315.       void*   pData;
  316. };
  317.  
  318. //-----------------------------------------------------------------------------
  319. // MinMaxValue class                                                          -
  320. //-----------------------------------------------------------------------------
  321. // The MinMaxValue class defines the minimum and maximum value range edit that-
  322. // can be done for numeric fields.                                            -
  323. //-----------------------------------------------------------------------------
  324. class MinMaxValue
  325. {
  326.     public:
  327.        MinMaxValue (char* pMin = NULL,
  328.                     char* pMax = NULL,
  329.                     int   msgnum = 0);
  330.        MinMaxValue (MinMaxValue const &);
  331.        ~MinMaxValue();
  332.  
  333.        char* pMin()   const;
  334.        char* pMax()   const;
  335.        int   msgnum() const;
  336.       void       operator=( MinMaxValue const & );
  337.  
  338.     private:
  339.        char*   mmv_pMin;
  340.        char*   mmv_pMax;
  341.        int     mmv_msgnum;
  342.        void*   pData;
  343. };
  344.  
  345. //-----------------------------------------------------------------------------
  346. // Field class                                                                -
  347. //-----------------------------------------------------------------------------
  348. // The Field class is the base class for all fields including static and      -
  349. // edit fields.                                                               -
  350. //-----------------------------------------------------------------------------
  351. class eMap;                            /* forward references               */
  352. class iMap;
  353.  
  354. class Field
  355. {
  356.    public:
  357.       enum Field_Type
  358.       {
  359.          Sbcs  = 1,
  360.          Mixed = 2,
  361.          Dbcs  = 4
  362.       };
  363.  
  364.  
  365.       virtual FCWString formatOut(iMap*);
  366.       virtual Attribute getAttribute(iMap*);
  367.  
  368.       virtual Bool       isEditField() { return False; }
  369.       virtual Field_Type fieldType()   { return Sbcs; }
  370.  
  371.       Size  const&      size();
  372.       Position const&   position();
  373.  
  374.    protected:
  375.       Field();
  376.       Field(eMap&             rmap,
  377.             char*             pText,
  378.             int               leadingSpace,
  379.             Position const&   pos,
  380.             Size     const&   size,
  381.             Attribute const&  attr);
  382.       virtual ~Field();
  383.  
  384.       void           Set(eMap&             rmap,
  385.                          char*             pText,
  386.                          int               leadingSpace,
  387.                          Position const&   pos,
  388.                          Size     const&   size,
  389.                          Attribute const&  attr);
  390.  
  391.       eMap&          map();
  392.       FCWString      sosiAdjust(FCWString const&);
  393.  
  394.    private:
  395.       eMap*          f_peMap;
  396.       char*          f_pText;
  397.       int            f_leading;
  398.       Position       f_position;
  399.       Size           f_size;
  400.       Attribute      f_attribute;
  401.       void*          pData;
  402.  
  403.       char*          pText();
  404.       int            leading();
  405.       Attribute&     attribute();
  406. };
  407.  
  408. //-----------------------------------------------------------------------------
  409. // STATICCHA class                                                            -
  410. //-----------------------------------------------------------------------------
  411. // The STATICCHA class defines a static sbcs field on the map.                -
  412. //-----------------------------------------------------------------------------
  413. class STATICCHA : public Field
  414. {
  415.    public:
  416.       STATICCHA();
  417.       STATICCHA(eMap &              rmap,
  418.                 char*               pText,
  419.                 int                 leadingSpace,
  420.                 Position const&     pos,
  421.                 Size     const&     size,
  422.                 Attribute const&    attr);
  423.  
  424.       void      Set(eMap &              rmap,
  425.                     char*               pText,
  426.                     int                 leadingSpace,
  427.                     int                 posRow,
  428.                     int                 posCol,
  429.                     int                 size,
  430.                     unsigned char       baseAttr,
  431.                     Color::enum_Color   colorAttr,
  432.                     Hilite::enum_Hilite hiliteAttr,
  433.                     unsigned char       outlineAttr);
  434.  
  435.    private:
  436.       void*     pData;
  437. };
  438.  
  439. //-----------------------------------------------------------------------------
  440. // STATICMIX class                                                            -
  441. //-----------------------------------------------------------------------------
  442. // The STATICMIX class defines a mixed sbcs and dbcs field on the map.        -
  443. //-----------------------------------------------------------------------------
  444. class STATICMIX : public Field
  445. {
  446.    public:
  447.       STATICMIX();
  448.       STATICMIX(eMap &              rmap,
  449.                 char*               pText,
  450.                 int                 leadingSpace,
  451.                 Position const&     pos,
  452.                 Size     const&     size,
  453.                 Attribute const&    attr);
  454.  
  455.       void               Set(eMap &              rmap,
  456.                              char*               pText,
  457.                              int                 leadingSpace,
  458.                              int                 posRow,
  459.                              int                 posCol,
  460.                              int                 size,
  461.                              unsigned char       baseAttr,
  462.                              Color::enum_Color   colorAttr,
  463.                              Hilite::enum_Hilite hiliteAttr,
  464.                              unsigned char       outlineAttr);
  465.  
  466.       virtual Field_Type fieldType()   { return Mixed; }
  467.    private:
  468.       void*     pData;
  469. };
  470.  
  471. //-----------------------------------------------------------------------------
  472. // STATICDBCS class                                                           -
  473. //-----------------------------------------------------------------------------
  474. // The STATICDBCS class defines a dbcs constant field on the map.             -
  475. //-----------------------------------------------------------------------------
  476. class STATICDBCS : public Field
  477. {
  478.    public:
  479.       STATICDBCS();
  480.       STATICDBCS(eMap &              rmap,
  481.                  char*               pText,
  482.                  int                 leadingSpace,
  483.                  Position const&     pos,
  484.                  Size     const&     size,
  485.                  Attribute const&    attr);
  486.  
  487.       void               Set(eMap &              rmap,
  488.                              char*               pText,
  489.                              int                 leadingSpace,
  490.                              int                 posRow,
  491.                              int                 posCol,
  492.                              int                 size,
  493.                              unsigned char       baseAttr,
  494.                              Color::enum_Color   colorAttr,
  495.                              Hilite::enum_Hilite hiliteAttr,
  496.                              unsigned char       outlineAttr);
  497.  
  498.       virtual Field_Type fieldType()   { return Dbcs; }
  499.    private:
  500.       void*     pData;
  501. };
  502.  
  503. //-----------------------------------------------------------------------------
  504. // EditField class                                                            -
  505. //-----------------------------------------------------------------------------
  506. // The EditField class is the base class for all the edit fields on a map.    -
  507. //-----------------------------------------------------------------------------
  508. class Driver;                          /* forward reference                */
  509. class FieldData;                       /* forward reference                */
  510.  
  511. class EditField_Data;
  512.  
  513. class EditField : public Field
  514. {
  515.    protected:
  516.  
  517.       EditField();
  518.       EditField(eMap&                  rmap,
  519.                 char*                  pName,
  520.                 char*                  pText,
  521.                 int                    leadingSpace,
  522.                 Position const&        pos,
  523.                 Size     const&        size,
  524.                 Attribute const&       attr,
  525.                 int                    editOrder,
  526.                 int                    index,
  527.                 char                   fillchar,
  528.                 Justify::enum_Justify  justify,
  529.                 InputRequired const &  inputReq,
  530.                 MinInput const &       minInput,
  531.                 EditRoutine const &    editRoutine);
  532.       virtual ~EditField();
  533.  
  534.       void              Set(eMap&                  rmap,
  535.                             char*                  pName,
  536.                             char*                  pText,
  537.                             int                    leadingSpace,
  538.                             Position const&        pos,
  539.                             Size     const&        size,
  540.                             Attribute const&       attr,
  541.                             int                    editOrder,
  542.                             int                    index,
  543.                             char                   fillchar,
  544.                             Justify::enum_Justify  justify,
  545.                             InputRequired const &  inputReq,
  546.                             MinInput const &       minInput,
  547.                             EditRoutine const &    editRoutine);
  548.  
  549.       char              fillChar();
  550.       Bool              isDBCSField();
  551.       FCWString         justify(FCWString const&, char fill=' ');
  552.       Justify::enum_Justify  justify();
  553.  
  554.       Bool              isRequired();
  555.       int               RequiredMsg();
  556.       int               MinimumInput();
  557.       int               MinimumInputMsg();
  558.  
  559.       virtual int       inputEdits(iMap*, FCWString const&) = 0;
  560.  
  561.       virtual int       minInput(FCWString const&, iMap*);
  562.       virtual int       modulus (FCWString const&);
  563.       virtual int       editRoutine(FCWString const&);
  564.       virtual Bool      fieldIsBlank(iMap*);
  565.       virtual int       foldEdits(FCWString const&, FCWString&);
  566.  
  567.       virtual Bool      foldInput();
  568.  
  569.    public:
  570.  
  571.       virtual Bool      isEditField() { return True; }
  572.       int               editOrder();
  573.       int               index();
  574.       FCWString         Name();
  575.       Bool              isCursorField(iMap*);
  576.       void              setCursor(iMap*, Bool);
  577.       void              resetStatus(iMap*);
  578.       Bool              hasBeenModified(iMap*);
  579.       void              setModified(iMap*, Bool);
  580.  
  581.       virtual int       formatInput(iMap*, FCWString const&, Bool);
  582.       virtual Attribute getAttribute(iMap*);
  583.  
  584.    private:
  585.       char*                  ef_Name;
  586.       int                    ef_editOrder;
  587.       int                    ef_index;
  588.       char                   ef_fillChar;
  589.       Justify::enum_Justify  ef_justify;
  590.       InputRequired          ef_inputRequired;
  591.       MinInput               ef_minInput;
  592.       EditRoutine            ef_editRoutine;
  593.       void*                  pData;
  594.  
  595.       InputRequired&         inputRequired();
  596.       MinInput&              minInput();
  597.       EditRoutine&           editRoutine();
  598. };
  599.  
  600. //-----------------------------------------------------------------------------
  601. // DateMask class                                                             -
  602. //-----------------------------------------------------------------------------
  603. // The DateMask class is the base class for date masks                        -
  604. //-----------------------------------------------------------------------------
  605. class DateMask
  606. {
  607.    public:
  608.       DateMask(int fldsize=0, char* pMask=NULL);
  609.       ~DateMask();
  610.       void       operator=( DateMask const & );
  611.  
  612.       FCWString const&  Mask()        const;
  613.       int               MonthPos()    const;
  614.       int               MonthRelPos() const;
  615.       int               MonthLen()    const;
  616.       int               MonthSeg()    const;
  617.       int               YearPos()     const;
  618.       int               YearRelPos()  const;
  619.       int               YearLen()     const;
  620.       int               YearSeg()     const;
  621.       int               DayPos()      const;
  622.       int               DayRelPos()   const;
  623.       int               DayLen()      const;
  624.       int               DaySeg()      const;
  625.       int               Segments()    const;
  626.       Bool              isGregorian() const;
  627.  
  628.       enum MaskType
  629.       {
  630.          ShortJulian = 0,
  631.          LongJulian  = 1,
  632.          ShortGreg   = 2,
  633.          LongGreg    = 3
  634.       };
  635.  
  636.    private:
  637.       DateMask::MaskType  dm_Type;     /* Date Type                        */
  638.       FCWString           dm_Mask;                     /* The original mask*/
  639.       int                 dm_iMonth;/* Index of the start of the month segment*/
  640.       int                 dm_irMonth;/* index of month segment without separators*/
  641.       int                 dm_lMonth;   /* length of the month segment      */
  642.       int                 dm_sMonth;   /* sequence of the month segment    */
  643.       int                 dm_iYear;/* Index of the start of the year segment*/
  644.       int                 dm_irYear;/* index of year segment without separators*/
  645.       int                 dm_lYear;    /* length of the year segment       */
  646.       int                 dm_sYear;    /* sequence of the year segment     */
  647.       int                 dm_iDay; /* Index of the start of the day segment*/
  648.       int                 dm_irDay;/* index of day segment without separators*/
  649.       int                 dm_lDay;     /* length of the day segment        */
  650.       int                 dm_sDay;     /* sequence of the day segment      */
  651.       int                 dm_iSeg;     /* number of segments in the mask   */
  652.       void*               pData;
  653.  
  654.       MaskType          Type()        const;
  655. };
  656.  
  657. //-----------------------------------------------------------------------------
  658. // EDITNUM class                                                              -
  659. //-----------------------------------------------------------------------------
  660. // The EDITNUM class defines a numeric edit field on a map.                   -
  661. //-----------------------------------------------------------------------------
  662. class EDITNUM : public EditField
  663. {
  664.    public:
  665.  
  666.       EDITNUM();
  667.       EDITNUM (eMap&                  rmap,
  668.                char*                  pName,
  669.                char*                  pText,
  670.                int                    leadingSpace,
  671.                Position const&        pos,
  672.                Size     const&        size,
  673.                Attribute const&       attr,
  674.                int                    editOrder,
  675.                int                    index,
  676.                char                   fillchar,
  677.                Justify::enum_Justify  justify,
  678.                InputRequired const &  inputReq,
  679.                MinInput const &       minInput,
  680.                EditRoutine const &    editRoutine,
  681.                Bool                   zeroEdit,
  682.                NumEdits const &       numEdits,
  683.                MinMaxValue const &    minmax);
  684.  
  685.       EDITNUM (eMap&                  rmap,
  686.                char*                  pName,
  687.                char*                  pText,
  688.                int                    leadingSpace,
  689.                Position const&        pos,
  690.                Size     const&        size,
  691.                Attribute const&       attr,
  692.                int                    editOrder,
  693.                int                    index,
  694.                char                   fillchar,
  695.                Justify::enum_Justify  justify,
  696.                InputRequired const &  inputReq,
  697.                MinInput const &       minInput,
  698.                EditRoutine const &    editRoutine,
  699.                Bool                   zeroEdit,
  700.                char*                  datemask);
  701.       ~EDITNUM();
  702.  
  703.       void Set (eMap&                  rmap,
  704.                 char*                  pName,
  705.                 char*                  pText,
  706.                 int                    leadingSpace,
  707.                 int                    row,
  708.                 int                    col,
  709.                 int                    size,
  710.                 unsigned char          baseAttr,
  711.                 Color::enum_Color      colorAttr,
  712.                 Hilite::enum_Hilite    hiliteAttr,
  713.                 unsigned char          outlineAttr,
  714.                 int                    editOrder,
  715.                 int                    index,
  716.                 char                   fillchar,
  717.                 Justify::enum_Justify  justify,
  718.                 Bool                   bInputReq,
  719.                 int                    irMsgNum,
  720.                 int                    miMin,
  721.                 int                    miMsgno,
  722.                 EditRoutine::enum_EditRoutine       erType,
  723.                 char*                  erName,
  724.                 int                    erMsgno,
  725.                 Bool                   zeroEdit,
  726.                 int                    Decimals,
  727.                 Bool                   bCurrency,
  728.                 Sign::enum_Sign        sign,
  729.                 Bool                   bSeparators,
  730.                 int                    neMsgno,
  731.                 char*                  pMin,
  732.                 char*                  pMax,
  733.                 int                    mmMsgno);
  734.  
  735.       void Set (eMap&                  rmap,
  736.                 char*                  pName,
  737.                 char*                  pText,
  738.                 int                    leadingSpace,
  739.                 int                    row,
  740.                 int                    col,
  741.                 int                    size,
  742.                 unsigned char          baseAttr,
  743.                 Color::enum_Color      colorAttr,
  744.                 Hilite::enum_Hilite    hiliteAttr,
  745.                 unsigned char          outlineAttr,
  746.                 int                    editOrder,
  747.                 int                    index,
  748.                 char                   fillchar,
  749.                 Justify::enum_Justify  justify,
  750.                 Bool                   bInputReq,
  751.                 int                    irMsgNum,
  752.                 int                    miMin,
  753.                 int                    miMsgno,
  754.                 EditRoutine::enum_EditRoutine       erType,
  755.                 char*                  erName,
  756.                 int                    erMsgno,
  757.                 Bool                   zeroEdit,
  758.                 char*                  datemask);
  759.  
  760.       virtual FCWString  formatOut(iMap*);
  761.  
  762.    protected:
  763.  
  764.       virtual int        inputEdits(iMap*, FCWString const&);
  765.       virtual int        minInput(FCWString const&, iMap*);
  766.       virtual int        modulus (FCWString const&);
  767.       virtual Bool       fieldIsBlank(iMap*);
  768.               FCWString  outputEdits(FCWString const&);
  769.               int        numInputEdits(FCWString const&, FCWString&);
  770.               FCWString  dateoEdits(FCWString const&);
  771.               Bool       dateiEdits(FCWString const&, FCWString&);
  772.               int        rangeCheck(FCWString&);
  773.  
  774.    private:
  775.       DateMask           en_datemask;
  776.       Bool               en_zeroEdit;
  777.       NumEdits           en_numEdits;
  778.       MinMaxValue        en_minmax;
  779.       void*              pData;
  780.  
  781.       DateMask&          datemask();
  782.       Bool               zeroEdit();
  783.       NumEdits&          numEdits();
  784.       MinMaxValue&       minMaxValue();
  785. };
  786.  
  787. //-----------------------------------------------------------------------------
  788. // EDITCHA class                                                              -
  789. //-----------------------------------------------------------------------------
  790. // The EDITCHA class defines a CHA edit field on a map.                       -
  791. //-----------------------------------------------------------------------------
  792. class EDITCHA : public EditField
  793. {
  794.    public:
  795.       EDITCHA();
  796.       EDITCHA (eMap&                  rmap,
  797.                char*                  pName,
  798.                char*                  pText,
  799.                int                    leadingSpace,
  800.                Position const&        pos,
  801.                Size     const&        size,
  802.                Attribute const&       attr,
  803.                int                    editOrder,
  804.                int                    index,
  805.                char                   fillchar,
  806.                Justify::enum_Justify  justify,
  807.                InputRequired const &  inputReq,
  808.                MinInput const &       minInput,
  809.                EditRoutine const &    editRoutine,
  810.                Fold::enum_Fold        fold = Fold::Map,
  811.                Bool                   bHexEdits = False);
  812.  
  813.       EDITCHA (eMap&                  rmap,
  814.                char*                  pName,
  815.                char*                  pText,
  816.                int                    leadingSpace,
  817.                Position const&        pos,
  818.                Size     const&        size,
  819.                Attribute const&       attr,
  820.                int                    editOrder,
  821.                int                    index,
  822.                char                   fillchar,
  823.                Justify::enum_Justify  justify,
  824.                InputRequired const &  inputReq,
  825.                MinInput const &       minInput,
  826.                EditRoutine const &    editRoutine,
  827.                char*                  datemask);
  828.       ~EDITCHA();
  829.  
  830.       void Set(eMap&                  rmap,
  831.                char*                  pName,
  832.                char*                  pText,
  833.                int                    leadingSpace,
  834.                int                    posrow,
  835.                int                    poscol,
  836.                int                    size,
  837.                unsigned char          baseAttr,
  838.                Color::enum_Color      colorAttr,
  839.                Hilite::enum_Hilite    hiliteAttr,
  840.                unsigned char          outlineAttr,
  841.                int                    editOrder,
  842.                int                    index,
  843.                char                   fillchar,
  844.                Justify::enum_Justify  justify,
  845.                Bool                   bInputReq,
  846.                int                    irMsgNum,
  847.                int                    miMin,
  848.                int                    miMsgno,
  849.                EditRoutine::enum_EditRoutine       erType,
  850.                char*                  erName,
  851.                int                    erMsgno,
  852.                Fold::enum_Fold        fold = Fold::Map,
  853.                Bool                   bHexEdits = False);
  854.  
  855.       void Set(eMap&                  rmap,
  856.                char*                  pName,
  857.                char*                  pText,
  858.                int                    leadingSpace,
  859.                int                    posrow,
  860.                int                    poscol,
  861.                int                    size,
  862.                unsigned char          baseAttr,
  863.                Color::enum_Color      colorAttr,
  864.                Hilite::enum_Hilite    hiliteAttr,
  865.                unsigned char          outlineAttr,
  866.                int                    editOrder,
  867.                int                    index,
  868.                char                   fillchar,
  869.                Justify::enum_Justify  justify,
  870.                Bool                   bInputReq,
  871.                int                    irMsgNum,
  872.                int                    miMin,
  873.                int                    miMsgno,
  874.                EditRoutine::enum_EditRoutine       erType,
  875.                char*                  erName,
  876.                int                    erMsgno,
  877.                char*                  datemask);
  878.  
  879.       virtual FCWString  formatOut(iMap*);
  880.  
  881.    protected:
  882.  
  883.       virtual int        inputEdits(iMap*, FCWString const&);
  884.       virtual int        modulus   (FCWString const&);
  885.               int        hexEdits  (FCWString&);
  886.               Bool       dateiEdits(FCWString const&, FCWString&);
  887.  
  888.       virtual Bool       foldInput();
  889.  
  890.               FCWString  outputEdits(FCWString const&);
  891.               FCWString  dateoEdits (FCWString const&);
  892.  
  893.    private:
  894.       DateMask         ec_datemask;
  895.       Fold::enum_Fold  ec_fold;
  896.       Bool             ec_hexEdits;
  897.       void*            pData;
  898.  
  899.       DateMask&        datemask();
  900.       Fold::enum_Fold  fold();
  901.       Bool             hexEdits();
  902. };
  903.  
  904. //-----------------------------------------------------------------------------
  905. // EDITMIX class                                                              -
  906. //-----------------------------------------------------------------------------
  907. // The EDITMIX class defines a CHA edit field on a map.                       -
  908. //-----------------------------------------------------------------------------
  909. class EDITMIX : public EditField
  910. {
  911.    public:
  912.       EDITMIX();
  913.       EDITMIX (eMap&                  rmap,
  914.                char*                  pName,
  915.                char*                  pText,
  916.                int                    leadingSpace,
  917.                Position const&        pos,
  918.                Size     const&        size,
  919.                Attribute const&       attr,
  920.                int                    editOrder,
  921.                int                    index,
  922.                char                   fillchar,
  923.                Justify::enum_Justify  justify,
  924.                InputRequired const &  inputReq,
  925.                MinInput const &       minInput,
  926.                EditRoutine const &    editRoutine,
  927.                Fold::enum_Fold        fold = Fold::Map,
  928.                MixEdits const &       mixedits = MixEdits(False));
  929.       ~EDITMIX();
  930.  
  931.       void Set(eMap&                  rmap,
  932.                char*                  pName,
  933.                char*                  pText,
  934.                int                    leadingSpace,
  935.                int                    posrow,
  936.                int                    poscol,
  937.                int                    size,
  938.                unsigned char          baseAttr,
  939.                Color::enum_Color      colorAttr,
  940.                Hilite::enum_Hilite    hiliteAttr,
  941.                unsigned char          outlineAttr,
  942.                int                    editOrder,
  943.                int                    index,
  944.                char                   fillchar,
  945.                Justify::enum_Justify  justify,
  946.                Bool                   bInputReq,
  947.                int                    irMsgNum,
  948.                int                    miMin,
  949.                int                    miMsgno,
  950.                EditRoutine::enum_EditRoutine       erType,
  951.                char*                  erName,
  952.                int                    erMsgno,
  953.                Fold::enum_Fold        fold = Fold::Map,
  954.                Bool                   bMixEdits = False,
  955.                int                    meMsgno = 0);
  956.  
  957.       virtual FCWString  formatOut(iMap*);
  958.       virtual Field_Type fieldType()   { return Mixed; }
  959.  
  960.    protected:
  961.  
  962.       virtual int        inputEdits(iMap*, FCWString const&);
  963.               int        mixEdits  (FCWString const&);
  964.  
  965.       virtual Bool       foldInput();
  966.  
  967.               FCWString  outputEdits(FCWString const&);
  968.  
  969.    private:
  970.       Fold::enum_Fold  em_fold;
  971.       MixEdits         em_mixEdits;
  972.       void*            pData;
  973.  
  974.       Fold::enum_Fold  fold();
  975.       MixEdits&        mixEdits();
  976. };
  977.  
  978. //-----------------------------------------------------------------------------
  979. // EDITDBCS class                                                             -
  980. //-----------------------------------------------------------------------------
  981. // The EDITDBCS class defines a DBCS edit field on a map.                     -
  982. //-----------------------------------------------------------------------------
  983. class EDITDBCS : public EditField
  984. {
  985.    public:
  986.       EDITDBCS();
  987.       EDITDBCS(eMap&                  rmap,
  988.                char*                  pName,
  989.                char*                  pText,
  990.                int                    leadingSpace,
  991.                Position const&        pos,
  992.                Size     const&        size,
  993.                Attribute const&       attr,
  994.                int                    editOrder,
  995.                int                    index,
  996.                char                   fillchar,
  997.                Justify::enum_Justify  justify,
  998.                InputRequired const &  inputReq,
  999.                MinInput const &       minInput,
  1000.                EditRoutine const &    editRoutine);
  1001.  
  1002.       void Set(eMap&                  rmap,
  1003.                char*                  pName,
  1004.                char*                  pText,
  1005.                int                    leadingSpace,
  1006.                int                    posrow,
  1007.                int                    poscol,
  1008.                int                    size,
  1009.                unsigned char          baseAttr,
  1010.                Color::enum_Color      colorAttr,
  1011.                Hilite::enum_Hilite    hiliteAttr,
  1012.                unsigned char          outlineAttr,
  1013.                int                    editOrder,
  1014.                int                    index,
  1015.                char                   fillchar,
  1016.                Justify::enum_Justify  justify,
  1017.                Bool                   bInputReq,
  1018.                int                    irMsgNum,
  1019.                int                    miMin,
  1020.                int                    miMsgno,
  1021.                EditRoutine::enum_EditRoutine       erType,
  1022.                char*                  erName,
  1023.                int                    erMsgno);
  1024.  
  1025.       virtual FCWString  formatOut(iMap*);
  1026.       virtual Field_Type fieldType()   { return Dbcs; }
  1027.  
  1028.    protected:
  1029.  
  1030.       virtual Bool       fieldIsBlank(iMap*);
  1031.       virtual int        inputEdits(iMap*, FCWString const&);
  1032.  
  1033.    private:
  1034.       void*    pData;
  1035.  
  1036. };
  1037.  
  1038. //-----------------------------------------------------------------------------
  1039. // eMap class                                                                 -
  1040. //-----------------------------------------------------------------------------
  1041. // The eMap class defines the external map definition. It contains all of the -
  1042. // external information about a map.                                          -
  1043. //-----------------------------------------------------------------------------
  1044. class MapGroup;                        /* forward reference                */
  1045.  
  1046. class eMap
  1047. {
  1048.    public:
  1049.  
  1050.       eMap(MapGroup&               mg,
  1051.            char*                   pName,
  1052.            Position       const&   pos,
  1053.            Size           const&   size,
  1054.            CursorPosition const&   cursor,
  1055.            char*                   pHelpName,
  1056.            Key::enum_Key           helpkey,
  1057.            ByPassKeys const&       bypasskeys,
  1058.            Fold::enum_Fold         fold,
  1059.            Bool                    bSOSI=False,
  1060.            Bool                    bDBCS=False);
  1061.  
  1062.       virtual ~eMap();
  1063.  
  1064.       virtual Bool  isPrintmap()    { return False; }
  1065.       virtual Bool  isTerminalmap() { return False; }
  1066.  
  1067.       Bool       isFloatMap();
  1068.       Bool       isDBCSMap();
  1069.  
  1070.       void       addField(Field *);
  1071.       void       addField(EditField *);
  1072.  
  1073.       EditField* EZEMSG();
  1074.  
  1075.       Position&        position();
  1076.       Size&            size();
  1077.       CursorPosition&  cursor();
  1078.  
  1079.       ByPassKeys const& BypassKeys();
  1080.       Bool              hasHelpMap();
  1081.       Key::enum_Key     HelpKey();
  1082.       FCWString         helpMap();
  1083.       FCWString         Name();
  1084.       Bool              foldInput();
  1085.  
  1086.       MapGroup&  mapGroup();
  1087.  
  1088.       SLIST(Field*)&     list_pField();
  1089.       SLIST(EditField*)& list_pEditFieldeo();
  1090.       SLIST(EditField*)& list_pEditFieldrc();
  1091.  
  1092.    private:
  1093.       MapGroup*          map_MapGroup;
  1094.       char*              map_Name;
  1095.       Position           map_position;
  1096.       Size               map_size;
  1097.       CursorPosition     map_Cursor;
  1098.       char*              map_HelpName;
  1099.       Key::enum_Key      map_HelpKey;
  1100.       ByPassKeys         map_BypassKeys;
  1101.       Fold::enum_Fold    map_Fold;
  1102.       Bool               map_bSOSI;
  1103.       Bool               map_bDBCS;
  1104.       EditField*         map_pEZEMSG;
  1105.       Bool               map_isFloat;
  1106.  
  1107.       SLIST(Field*)      map_list_pFieldrc; /* order based on row/col order*/
  1108.       SLIST(EditField*)  map_list_pEditFieldrc;/* order based on row/col order*/
  1109.       SLIST(EditField*)  map_list_pEditFieldeo;/* order based on edit order*/
  1110.       void*              pData;
  1111.  
  1112.       Bool               bSOSI();
  1113. };
  1114.  
  1115. //-----------------------------------------------------------------------------
  1116. // TerminalMap class                                                          -
  1117. //-----------------------------------------------------------------------------
  1118. // The TerminalMap class defines the external information about terminal maps -
  1119. //-----------------------------------------------------------------------------
  1120. class TerminalMap : public eMap
  1121. {
  1122.    public:
  1123.       TerminalMap(MapGroup&                mg,
  1124.                   char*                    pName,
  1125.                   Position        const&   pos,
  1126.                   Size            const&   size,
  1127.                   CursorPosition  const&   cursor,
  1128.                   char*                    pHelpName,
  1129.                   Key::enum_Key            helpkey,
  1130.                   ByPassKeys      const&   bypasskeys,
  1131.                   Fold::enum_Fold          fold,
  1132.                   Bool                     bSOSI=False,
  1133.                   Bool                     bDBCS=False);
  1134.  
  1135.       TerminalMap(MapGroup&               mg,
  1136.                   char*                   pName,
  1137.                   int                     posrow,
  1138.                   int                     poscol,
  1139.                   int                     sizerow,
  1140.                   int                     sizecol,
  1141.                   char*                   pCursorFldName,
  1142.                   int                     CursorFldIndx,
  1143.                   char*                   pHelpName,
  1144.                   Key::enum_Key           helpkey,
  1145.                   ByPassKeys const&       bypasskeys,
  1146.                   Fold::enum_Fold         fold,
  1147.                   Bool                    bSOSI=False,
  1148.                   Bool                    bDBCS=False);
  1149.       virtual ~TerminalMap();
  1150.  
  1151.       virtual Bool  isTerminalmap() { return True; }
  1152.  
  1153.    private:
  1154.       void*   pData;
  1155. };
  1156.  
  1157. //-----------------------------------------------------------------------------
  1158. // PrintMap class                                                             -
  1159. //-----------------------------------------------------------------------------
  1160. // The PrintMap class defines the external information about printer maps.    -
  1161. //-----------------------------------------------------------------------------
  1162. class PrintMap : public eMap
  1163. {
  1164.    public:
  1165.       PrintMap(MapGroup&                mg,
  1166.                char*                    pName,
  1167.                Position        const&   pos,
  1168.                Size            const&   size,
  1169.                CursorPosition  const&   cursor,
  1170.                char*                    pHelpName,
  1171.                Key::enum_Key            helpkey,
  1172.                ByPassKeys      const&   bypasskeys,
  1173.                Fold::enum_Fold          fold,
  1174.                Bool                     bSOSI=False,
  1175.                Bool                     bDBCS=False);
  1176.  
  1177.       PrintMap(MapGroup&               mg,
  1178.                char*                   pName,
  1179.                int                     posrow,
  1180.                int                     poscol,
  1181.                int                     sizerow,
  1182.                int                     sizecol,
  1183.                char*                   pCursorFldName,
  1184.                int                     CursorFldIndx,
  1185.                char*                   pHelpName,
  1186.                Key::enum_Key           helpkey,
  1187.                ByPassKeys const&       bypasskeys,
  1188.                Fold::enum_Fold         fold,
  1189.                Bool                    bSOSI=False,
  1190.                Bool                    bDBCS=False);
  1191.  
  1192.       virtual ~PrintMap();
  1193.  
  1194.       virtual Bool  isPrintmap() { return True; }
  1195.  
  1196.    private:
  1197.       void*   pData;
  1198. };
  1199.  
  1200. //-----------------------------------------------------------------------------
  1201. // FloatArea class                                                            -
  1202. //-----------------------------------------------------------------------------
  1203. // This class defines the floating area. There is one floating area for print -
  1204. // maps and one floating area for terminal maps.                              -
  1205. //-----------------------------------------------------------------------------
  1206. class FloatArea
  1207. {
  1208.    public:
  1209.       FloatArea(Position const& pos, Size const& size);
  1210.       FloatArea(int posrow, int poscol, int sizerow, int sizecol);
  1211.       ~FloatArea();
  1212.  
  1213.       Position const & position();
  1214.       Size     const & size();
  1215.  
  1216.    private:
  1217.       Position   fa_position;
  1218.       Size       fa_size;
  1219.       void*      pData;
  1220. };
  1221.  
  1222. //-----------------------------------------------------------------------------
  1223. // MapGroup class                                                             -
  1224. //-----------------------------------------------------------------------------
  1225. // This class defines the map group class. This class basically serves as an  -
  1226. // entry point into the map group and access can be obtained to maps through  -
  1227. // the map group.                                                             -
  1228. //-----------------------------------------------------------------------------
  1229. class MapGroup
  1230. {
  1231.    public:
  1232.  
  1233.       MapGroup(char* pName,
  1234.                FloatArea * pTermArea  = NULL,
  1235.                FloatArea * pPrintArea = NULL);
  1236.       virtual ~MapGroup();
  1237.  
  1238.       eMap*             find(FCWString const& mapname);
  1239.       FloatArea*        TerminalFloatArea();
  1240.       FloatArea*        PrinterFloatArea();
  1241.  
  1242.       void       addMap(eMap*);
  1243.       eMap*      find(FCWString const&)   const;
  1244.  
  1245.       FCWString  Name();
  1246.  
  1247.    private:
  1248.       char*             mg_Name;
  1249.       FloatArea *       mg_pTermArea;
  1250.       FloatArea *       mg_pPrintArea;
  1251.  
  1252.       LIST(eMap *)      mg_list_peMap;
  1253.       void*             pData;
  1254.  
  1255.       LIST(eMap *)&     list_peMap();
  1256. };
  1257.  
  1258. #endif
  1259.