home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / code / bcpp / file3 / input.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  10.8 KB  |  439 lines
  1. /*  Copyright (C) 1993   Marc Stern  (internet: stern@mble.philips.be)  */
  2.  
  3. class TStreamable;
  4. #include <values.h>
  5. #include "strings.h"
  6.  
  7.  
  8. #if defined(Uses_TInputKey) && ! defined(__TInputKey)
  9. #define __TInputKey
  10. // Same as TInputLine, except invalid if empty
  11.  
  12. class TInputKey : public TInputLine
  13. {
  14.  
  15. public:
  16.  
  17.     TInputKey( const TRect&, int len );
  18.     TInputKey( int x, int y, int len );
  19.     virtual Boolean valid( ushort );
  20.  
  21. protected:
  22.  
  23.     TInputKey( StreamableInit ) : TInputLine( streamableInit ) {};
  24.  
  25. private:
  26.  
  27.     virtual const char *streamableName() const
  28.         { return name; }
  29.  
  30. public:
  31.  
  32.     static const char * const name;
  33.     static TStreamable *build();
  34.  
  35. };
  36.  
  37.  
  38. inline ipstream& operator >> ( ipstream& is, TInputKey& cl )
  39.     { return is >> (TStreamable&)cl; }
  40. inline ipstream& operator >> ( ipstream& is, TInputKey*& cl )
  41.     { return is >> (void *&)cl; }
  42. inline opstream& operator << ( opstream& os, TInputKey& cl )
  43.     { return os << (TStreamable&)cl; }
  44. inline opstream& operator << ( opstream& os, TInputKey* cl )
  45.     { return os << (TStreamable *)cl; }
  46.  
  47. #endif // Uses_TInputKey
  48.  
  49.  
  50.  
  51. #if defined(Uses_TInputPasswd) && ! defined(__TInputPasswd)
  52. #define __TInputPasswd
  53. // Same as TInputLine, but display only '*'
  54.  
  55. class TInputPasswd : public TInputLine
  56. {
  57.  
  58. public:
  59.  
  60.     TInputPasswd( const TRect&, int len );
  61.     TInputPasswd( int x, int y, int len );
  62.     virtual void draw( void );
  63.  
  64. protected:
  65.  
  66.     TInputPasswd( StreamableInit ) : TInputLine( streamableInit ) {};
  67.  
  68. private:
  69.  
  70.     virtual const char *streamableName() const
  71.         { return name; }
  72.  
  73. public:
  74.  
  75.     static const char * const name;
  76.     static TStreamable *build();
  77.  
  78. };
  79.  
  80.  
  81. inline ipstream& operator >> ( ipstream& is, TInputPasswd& cl )
  82.     { return is >> (TStreamable&)cl; }
  83. inline ipstream& operator >> ( ipstream& is, TInputPasswd*& cl )
  84.     { return is >> (void *&)cl; }
  85. inline opstream& operator << ( opstream& os, TInputPasswd& cl )
  86.     { return os << (TStreamable&)cl; }
  87. inline opstream& operator << ( opstream& os, TInputPasswd* cl )
  88.     { return os << (TStreamable *)cl; }
  89.  
  90.  
  91. ushort inputPasswdBoxRect( const TRect &bounds,
  92.                            const char *Title,
  93.                            const char *aLabel,
  94.                            char *s,
  95.                            uchar limit );
  96.  
  97.  
  98. ushort inputPasswdBox( const char *Title, const char *aLabel, char *s, uchar limit );
  99.  
  100.  
  101. #endif // Uses_TInputPasswd
  102.  
  103.  
  104.  
  105. #if defined(Uses_TInputRegExp) && ! defined(__TInputRegExp)
  106. #define __TInputRegExp
  107. // Accepts only regular expression-matching input
  108.  
  109. class TInputRegExp: public TInputLine
  110. {
  111.  
  112. public:
  113.  
  114. #pragma warn -bei
  115.     TInputRegExp( const TRect&, int , const char * = 0, const char * = 0, casetype = 0 );
  116.     TInputRegExp( int x, int y, int , const char * = 0, const char * = 0, casetype = 0 );
  117.     ~TInputRegExp();
  118.     virtual void setState( ushort, Boolean );
  119.     virtual void handleEvent( TEvent& );
  120.     virtual Boolean valid( ushort );
  121.  
  122. protected:
  123.  
  124.     TInputRegExp( StreamableInit ) : TInputLine( streamableInit ) {};
  125.  
  126. private:
  127.  
  128.     virtual void init( const char *aSet, const char *aRegexp, casetype aNewcase );
  129.     char *set, *regexp;
  130.     casetype newcase;
  131.  
  132.     virtual const char *streamableName() const
  133.         { return name; }
  134.  
  135. public:
  136.  
  137.     static const char * const name;
  138.     static TStreamable *build();
  139.     static char *invMsg;
  140. };
  141.  
  142.  
  143. inline ipstream& operator >> ( ipstream& is, TInputRegExp& cl )
  144.     { return is >> (TStreamable&)cl; }
  145. inline ipstream& operator >> ( ipstream& is, TInputRegExp*& cl )
  146.     { return is >> (void *&)cl; }
  147. inline opstream& operator << ( opstream& os, TInputRegExp& cl )
  148.     { return os << (TStreamable&)cl; }
  149. inline opstream& operator << ( opstream& os, TInputRegExp* cl )
  150.     { return os << (TStreamable *)cl; }
  151.  
  152. #endif //  Uses_TInputRegExp
  153.  
  154.  
  155. #if defined(Uses_TInputInt) && ! defined(__TInputInt)
  156. #define __TInputInt
  157. // Accepts only valid numeric input (int) between Min and Max
  158.  
  159. class TInputInt : public TInputRegExp
  160. {
  161.  
  162. public:
  163.  
  164.     TInputInt( const TRect&, int len = 7, int min = -MAXINT, int max = MAXINT );
  165.     TInputInt( int x, int y, int len = 7, int min = -MAXINT, int max = MAXINT );
  166.     virtual ushort dataSize();
  167.     virtual void getData( void *);
  168.     virtual void setData( void *);
  169.     virtual Boolean valid( ushort );
  170.     int min;
  171.     int max;
  172.  
  173. protected:
  174.  
  175.     TInputInt( StreamableInit ) : TInputRegExp( streamableInit ) {};
  176.     virtual void write( opstream& );
  177.     virtual void *read( ipstream& );
  178.  
  179. private:
  180.  
  181.     virtual const char *streamableName() const
  182.         { return name; }
  183.  
  184. public:
  185.  
  186.     static const char * const name;
  187.     static TStreamable *build();
  188.  
  189. };
  190.  
  191. inline ipstream& operator >> ( ipstream& is, TInputInt& cl )
  192.     { return is >> (TStreamable&)cl; }
  193. inline ipstream& operator >> ( ipstream& is, TInputInt*& cl )
  194.     { return is >> (void *&)cl; }
  195. inline opstream& operator << ( opstream& os, TInputInt& cl )
  196.     { return os << (TStreamable&)cl; }
  197. inline opstream& operator << ( opstream& os, TInputInt* cl )
  198.     { return os << (TStreamable *)cl; }
  199.  
  200. #endif // Uses_TInputInt
  201.  
  202.  
  203.  
  204.  
  205.  
  206. #if defined(Uses_TInputLong) && ! defined(__TInputLong)
  207. #define __TInputLong
  208. // Accepts only valid numeric input (long) between Min and Max
  209.  
  210. class TInputLong : public TInputRegExp
  211. {
  212.  
  213. public:
  214.  
  215.     TInputLong( const TRect&, int len = 12, long min = -MAXLONG, long max = MAXLONG );
  216.     TInputLong( int x, int y, int len = 12, long min = -MAXLONG, long max = MAXLONG );
  217.     virtual ushort dataSize();
  218.     virtual void getData( void *);
  219.     virtual void setData( void *);
  220.     virtual Boolean valid( ushort );
  221.     long min;
  222.     long max;
  223.  
  224. protected:
  225.  
  226.     TInputLong( StreamableInit ) : TInputRegExp( streamableInit ) {};
  227.     virtual void write( opstream& );
  228.     virtual void *read( ipstream& );
  229.  
  230. private:
  231.  
  232.     virtual const char *streamableName() const
  233.         { return name; }
  234.  
  235. public:
  236.  
  237.     static const char * const name;
  238.     static TStreamable *build();
  239.  
  240. };
  241.  
  242. inline ipstream& operator >> ( ipstream& is, TInputLong& cl )
  243.     { return is >> (TStreamable&)cl; }
  244. inline ipstream& operator >> ( ipstream& is, TInputLong*& cl )
  245.     { return is >> (void *&)cl; }
  246. inline opstream& operator << ( opstream& os, TInputLong& cl )
  247.     { return os << (TStreamable&)cl; }
  248. inline opstream& operator << ( opstream& os, TInputLong* cl )
  249.     { return os << (TStreamable *)cl; }
  250.  
  251. #endif // Uses_TInputLong
  252.  
  253.  
  254.  
  255.  
  256.  
  257. #if defined(Uses_TInputDouble) && ! defined(__TInputDouble)
  258. #define __TInputDouble
  259. // Accepts only valid numeric input between Min and Max
  260.  
  261. class TInputDouble : public TInputRegExp
  262. {
  263.  
  264. public:
  265.  
  266.     TInputDouble( const TRect&, int len = 15, double min = -MAXDOUBLE, double max = MAXDOUBLE );
  267.     TInputDouble( int x, int y, int len = 15, double min = -MAXDOUBLE, double max = MAXDOUBLE );
  268.     virtual ushort dataSize();
  269.     virtual void getData( void *);
  270.     virtual void setData( void *);
  271.     virtual Boolean valid( ushort );
  272.     double min;
  273.     double max;
  274.  
  275. protected:
  276.  
  277.     TInputDouble( StreamableInit ) : TInputRegExp( streamableInit ) {};
  278.     virtual void write( opstream& );
  279.     virtual void *read( ipstream& );
  280.  
  281. private:
  282.  
  283.     virtual const char *streamableName() const
  284.         { return name; }
  285.  
  286. public:
  287.  
  288.     static const char * const name;
  289.     static TStreamable *build();
  290.  
  291. };
  292.  
  293. inline ipstream& operator >> ( ipstream& is, TInputDouble& cl )
  294.     { return is >> (TStreamable&)cl; }
  295. inline ipstream& operator >> ( ipstream& is, TInputDouble*& cl )
  296.     { return is >> (void *&)cl; }
  297. inline opstream& operator << ( opstream& os, TInputDouble& cl )
  298.     { return os << (TStreamable&)cl; }
  299. inline opstream& operator << ( opstream& os, TInputDouble* cl )
  300.     { return os << (TStreamable *)cl; }
  301.  
  302. #endif //  Uses_TInputDouble
  303.  
  304.  
  305.  
  306. #if defined(Uses_TInputHexa) && ! defined(__TInputHexa)
  307. #define __TInputHexa
  308. // Accepts only valid hexadecimal string input
  309.  
  310. class TInputHexa : public TInputRegExp
  311. {
  312.  
  313. public:
  314.  
  315.     TInputHexa( const TRect&, int len );
  316.     TInputHexa( int x, int y , int len );
  317.  
  318. protected:
  319.  
  320.     TInputHexa( StreamableInit ) : TInputRegExp( streamableInit ) {};
  321.  
  322. private:
  323.  
  324.     virtual const char *streamableName() const
  325.         { return name; }
  326.  
  327. public:
  328.  
  329.     static const char * const name;
  330.     static TStreamable *build();
  331.  
  332. };
  333.  
  334. inline ipstream& operator >> ( ipstream& is, TInputHexa& cl )
  335.     { return is >> (TStreamable&)cl; }
  336. inline ipstream& operator >> ( ipstream& is, TInputHexa*& cl )
  337.     { return is >> (void *&)cl; }
  338. inline opstream& operator << ( opstream& os, TInputHexa& cl )
  339.     { return os << (TStreamable&)cl; }
  340. inline opstream& operator << ( opstream& os, TInputHexa* cl )
  341.     { return os << (TStreamable *)cl; }
  342.  
  343. #endif // Uses_TInputHexa
  344.  
  345.  
  346.  
  347.  
  348.  
  349. #if defined(Uses_TInputDate) && ! defined(__TInputDate)
  350. #define __TInputDate
  351. // Accepts only valid date input
  352.  
  353. class TInputDate: public TInputRegExp
  354. {
  355.  
  356. public:
  357.  
  358.     TInputDate( const TRect& );
  359.     TInputDate( int x, int y );
  360.     virtual Boolean valid( ushort );
  361.  
  362. public:
  363.  
  364.     static const char * const name;
  365.  
  366. };
  367. #endif //  Uses_TInputDate
  368.  
  369.  
  370. #if defined(Uses_TInputCalcul) && ! defined(__TInputCalcul)
  371. #define __TInputCalcul
  372.  
  373. // Accepts a calculation string
  374.  
  375. class TInputCalcul : public TInputRegExp
  376. {
  377.  
  378. public:
  379.  
  380.     TInputCalcul( const TRect&, int len );
  381.     TInputCalcul( int x, int y, int len );
  382.     virtual Boolean valid( ushort );
  383.  
  384. protected:
  385.  
  386.     TInputCalcul( StreamableInit ) : TInputRegExp( streamableInit ) {};
  387.  
  388. private:
  389.  
  390.     virtual const char *streamableName() const
  391.         { return name; }
  392.  
  393. public:
  394.  
  395.     static const char * const name;
  396.     static TStreamable *build();
  397.  
  398. };
  399.  
  400.  
  401. inline ipstream& operator >> ( ipstream& is, TInputCalcul& cl )
  402.     { return is >> (TStreamable&)cl; }
  403. inline ipstream& operator >> ( ipstream& is, TInputCalcul*& cl )
  404.     { return is >> (void *&)cl; }
  405. inline opstream& operator << ( opstream& os, TInputCalcul& cl )
  406.     { return os << (TStreamable&)cl; }
  407. inline opstream& operator << ( opstream& os, TInputCalcul* cl )
  408.     { return os << (TStreamable *)cl; }
  409.  
  410. #endif // Uses_TInputCalcul
  411.  
  412.  
  413. #if defined(Uses_TStaticInputLine) && ! defined(__TStaticInputLine)
  414. #define __TStaticInputLine
  415.  
  416. // Accepts a static string
  417.  
  418. class TStaticInputLine : public TInputRegExp
  419. {
  420. protected:
  421.            TGenCollection *list;
  422.  
  423. public:
  424.            TStaticInputLine( const TRect&, int, TGenCollection *aList );
  425.            TStaticInputLine( int, int, int, TGenCollection *aList );
  426.  
  427. //           virtual TPalette& getPalette() const;
  428.            virtual void setData( void *rec );
  429.            virtual void handleEvent( TEvent& event );
  430.            virtual Boolean valid( ushort command );
  431.            virtual void newList( TGenCollection *aList );
  432.  
  433. public:
  434.            static const char * const near name;
  435.            char  testChar[255];
  436. };
  437.  
  438. #endif
  439.