home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a067 / 1.img / GRUMP501.EXE / GRUMPR.CH < prev    next >
Encoding:
Text File  |  1991-08-25  |  14.9 KB  |  258 lines
  1. /*
  2.     File:    GRUMPR.CH
  3.     System:  GRUMPFISH LIBRARY
  4.     Author:  Greg Lief
  5.     Dialect: Clipper 5.01
  6.     Copyright (c) 1988-91, Greg Lief
  7.     Header file to be used in conjunction with GrumpLib @..GGET and GREAD
  8. */
  9.  
  10. //───── manifest constants for GFTimeout() function
  11. #define TIME_OUT      1
  12. #define EXIT_EVENT    2
  13. #define WARNING       3
  14. #define WARN_EVENT    4
  15.  
  16. //───── ARRAY (and optional NOEDIT) clause
  17. #xcommand @ <row>, <col> GGET <var>                                     ;
  18.                         [PICTURE <pic>]                                 ;
  19.                         [VALID <valid>]                                 ;
  20.                         [ARRAY <array>]                                 ;
  21.                         [<noedit:NOEDIT>]                               ;
  22.                         [MESSAGE <message>]                             ;
  23.                         [COLOR <color>]                                 ;
  24.                                                                         ;
  25.       => SetPos( <row>, <col> )                                         ;
  26.        ; AAdd(                                                          ;
  27.                GetList,                                                 ;
  28.                _GET_( <var>, <(var)>, <pic>, <{valid}>, )               ;
  29.              )                                                     ;    ;
  30.        Atail(GetList):preblock :=                                       ;
  31.        { | g | g:varPut(padr(<array>\[max(apick(,,,,<array>,,,,,,,,     ;
  32.        max(ascan(<array>, trim(g:varGet())), 1)), 1)],                  ;
  33.        len(g:varGet()))), ! <.noedit.> }                           ;    ;
  34.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  35.        { | get, key | getapplykey(get, key) } ) }                       ;
  36.        [ ; Atail(GetList):colorDisp( <color> )]                         ;
  37.        [ ; Atail(GetList):cargo := { <message> } ]
  38.  
  39.  
  40. //───── PROPER clause
  41. #xcommand @ <row>, <col> GGET <var>                                     ;
  42.                         [PICTURE <pic>]                                 ;
  43.                         [VALID <valid>]                                 ;
  44.                         [WHEN <when>]                                   ;
  45.                         [PROPER]                                        ;
  46.                         [MESSAGE <message>]                             ;
  47.                         [COLOR <color>]                                 ;
  48.                                                                         ;
  49.       => SetPos( <row>, <col> )                                         ;
  50.        ; AAdd(                                                          ;
  51.                GetList,                                                 ;
  52.                _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}>)       ;
  53.              )                                                     ;    ;
  54.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  55.        { | get, key | gkeyproper(get, key) } ) }                        ;
  56.        [ ; Atail(GetList):colorDisp( <color> )]                         ;
  57.        [ ; Atail(GetList):cargo := { <message> } ]
  58.  
  59.  
  60. //───── LIST clause
  61. #xcommand @ <row>, <col> GGET <var>                                     ;
  62.                         [PICTURE <pic>]                                 ;
  63.                         [VALID <valid>]                                 ;
  64.                         [LIST <list>]                                   ;
  65.                         [WHEN <when>]                                   ;
  66.                         [MESSAGE <message>]                             ;
  67.                         [COLOR <color>]                                 ;
  68.                                                                         ;
  69.       => SetPos( <row>, <col> )                                         ;
  70.        ; AAdd(                                                          ;
  71.                GetList,                                                 ;
  72.                _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}>)       ;
  73.              )                                                     ;    ;
  74.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  75.        { | get, key | gkeylist(get, key) } ) }                          ;
  76.        [ ; Atail(GetList):colorDisp( <color> )]                         ;
  77.        [ ; Atail(GetList):cargo := { <message>, <list> } ]
  78.  
  79.  
  80. //───── STEP clause
  81. #xcommand @ <row>, <col> GGET <var>                                     ;
  82.                         [PICTURE <pic>]                                 ;
  83.                         [VALID <valid>]                                 ;
  84.                         [WHEN <when>]                                   ;
  85.                         [STEP]                                          ;
  86.                         [MESSAGE <message>]                             ;
  87.                         [COLOR <color>]                                 ;
  88.                                                                         ;
  89.       => SetPos( <row>, <col> )                                         ;
  90.        ; AAdd(                                                          ;
  91.                GetList,                                                 ;
  92.                _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}>)       ;
  93.              )                                                     ;    ;
  94.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  95.        { | get, key | gkeystep(get, key) } ) }                          ;
  96.        [ ; Atail(GetList):colorDisp( <color> )]                         ;
  97.        [ ; Atail(GetList):cargo := { <message> } ]
  98.  
  99.  
  100. //───── PASSWORD clause, using default character ("*")
  101. #xcommand @ <row>, <col> GGET <var>                                     ;
  102.                         [PICTURE <pic>]                                 ;
  103.                         [VALID <valid>]                                 ;
  104.                         [WHEN <when>]                                   ;
  105.                         [PASSWORD ]                                     ;
  106.                         [MESSAGE <message>]                             ;
  107.                         [COLOR <color>]                                 ;
  108.                                                                         ;
  109.       => SetPos( <row>, <col> )                                         ;
  110.        ; AAdd(                                                          ;
  111.                GetList,                                                 ;
  112.                _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}>)       ;
  113.              )                                                     ;    ;
  114.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  115.        { | get, key | gkeypass(get, key) } ) }                     ;    ;
  116.        ATail(Getlist):picture := "@P*"                                  ;
  117.        [ ; Atail(GetList):colorDisp( <color> )]                         ;
  118.        [ ; Atail(GetList):cargo := { <message> } ]
  119.  
  120.  
  121. //───── PASSWORD clause with user-defined override character
  122. #xcommand @ <row>, <col> GGET <var>                                     ;
  123.                         [PICTURE <pic>]                                 ;
  124.                         [VALID <valid>]                                 ;
  125.                         [WHEN <when>]                                   ;
  126.                         [PASSWORD <char>]                               ;
  127.                         [MESSAGE <message>]                             ;
  128.                         [COLOR <color>]                                 ;
  129.                                                                         ;
  130.       => SetPos( <row>, <col> )                                         ;
  131.        ; AAdd(                                                          ;
  132.                GetList,                                                 ;
  133.                _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}>)       ;
  134.              )                                                     ;    ;
  135.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  136.        { | get, key | gkeypass(get, key) } ) }                     ;    ;
  137.        ATail(Getlist):picture := "@P" + <char>                          ;
  138.        [ ; Atail(GetList):colorDisp( <color> )]                         ;
  139.        [ ; Atail(GetList):cargo := { <message> } ]
  140.  
  141.  
  142. //───── CALCULATOR clause (with message)
  143. #xcommand @ <row>, <col> GGET <var>                                     ;
  144.                         [PICTURE <pic>]                                 ;
  145.                         [VALID <valid>]                                 ;
  146.                         [WHEN <when>]                                   ;
  147.                         [<calc:CALCULATOR>]                             ;
  148.                         [COLOR <color>]                                 ;
  149.                         [MESSAGE <message>]                             ;
  150.                                                                         ;
  151.       => SetPos( <row>, <col> )                                         ;
  152.        ; AAdd(                                                          ;
  153.                GetList,                                                 ;
  154.                _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}> )      ;
  155.              )                                                     ;    ;
  156.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  157.        { | get, key | gkeycalc(get, key) } ) }                          ;
  158.        [ ; Atail(GetList):cargo := { <message>, #<calc> } ]             ;
  159.        [ ; Atail(GetList):colorDisp( <color> )]
  160.  
  161.  
  162. //───── CALCULATOR clause (without message)
  163. #xcommand @ <row>, <col> GGET <var>                                     ;
  164.                         [PICTURE <pic>]                                 ;
  165.                         [VALID <valid>]                                 ;
  166.                         [WHEN <when>]                                   ;
  167.                         [<calc:CALCULATOR>]                             ;
  168.                         [COLOR <color>]                                 ;
  169.                                                                         ;
  170.       => SetPos( <row>, <col> )                                         ;
  171.        ; AAdd(                                                          ;
  172.                GetList,                                                 ;
  173.                _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}> )      ;
  174.              )                                                     ;    ;
  175.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  176.        { | get, key | gkeycalc(get, key) } ) }                          ;
  177.        [ ; Atail(GetList):cargo := { , #<calc> } ]                      ;
  178.        [ ; Atail(GetList):colorDisp( <color> )]
  179.  
  180.  
  181. //───── to allow SAY and GET in same statement
  182. #xcommand @ <row>, <col> SAY <sayxpr>                                   ;
  183.                         [<sayClauses,...>]                              ;
  184.                         GGET <var>                                      ;
  185.                         [<getClauses,...>]                              ;
  186.                                                                         ;
  187.       => @ <row>, <col> SAY <sayxpr> [<sayClauses>]                     ;
  188.        ; @ Row(), Col()+1 GGET <var> [<getClauses>]
  189.  
  190. //───── MESSAGE clause only
  191. #xcommand @ <row>, <col> GGET <var>                                     ;
  192.                         [PICTURE <pic>]                                 ;
  193.                         [VALID <valid>]                                 ;
  194.                         [WHEN <when>]                                   ;
  195.                         [COLOR <color>]                                 ;
  196.                         [MESSAGE <message>]                             ;
  197.                                                                         ;
  198.       => SetPos( <row>, <col> )                                         ;
  199.        ; AAdd(                                                          ;
  200.                GetList,                                                 ;
  201.                _GET_( <var>, <(var)>, <pic>, <{valid}>, <{when}> )      ;
  202.              )                                                     ;    ;
  203.        ATail(GetList):reader := { | g | GFReader(g,                     ;
  204.        { | get, key | getapplykey(get, key) } ) }                       ;
  205.        [ ; Atail(GetList):colorDisp( <color> )]                         ;
  206.        [ ; Atail(GetList):cargo := { <message> } ]
  207.  
  208.  
  209. //───── @..GET..RANGE (preprocessed to @..GET..VALID)
  210.  
  211. #command @ <row>, <col> GGET <var>                                      ;
  212.                         [<clauses,...>]                                 ;
  213.                         RANGE <lo>, <hi>                                ;
  214.                         [<moreClauses,...>]                             ;
  215.                                                                         ;
  216.       => @ <row>, <col> GGET <var>                                      ;
  217.                         [<clauses>]                                     ;
  218.                         VALID {|_1| RangeCheck(_1,, <lo>, <hi>)}        ;
  219.                         [<moreClauses>]
  220.  
  221. #xcommand READ                       ;
  222.           TIMEOUT <seconds>          ;
  223.           [EXITEVENT <exitevent>]    ;
  224.           [WARNING <warnsecs>]       ;
  225.           [WARNEVENT <warnevent>]    ;
  226.           [<validation:VALIDATION>]  ;
  227.                                   => ;
  228.           gftimeout(TIME_OUT, <seconds> )             ;
  229.           [ ; gftimeout(EXIT_EVENT, <{exitevent}>) ] ;
  230.           [ ; gftimeout(WARNING, <warnsecs>) ]       ;
  231.           [ ; gftimeout(WARN_EVENT, <{warnevent}>) ] ;
  232.           ; ReadModal( getlist )                     ;
  233.           [; gfvalid(getlist, <.validation.>)   ]    ;
  234.           ; getlist := {}                            ;
  235.           ; gftimeout()
  236.  
  237. #xcommand READ VALIDATION                            ;
  238.                                                   => ;
  239.           ReadModal( getlist )                       ;
  240.           ; gfvalid(getlist)                         ;
  241.           ; getlist := {}
  242.  
  243. //───── directives for READ CYCLE and INITIAL clauses
  244. //───── currently disabled, so don't try to use them!
  245. /*
  246. #xcommand GREAD [<cycle: CYCLE>] [INITIAL <initial>]           => ;
  247.           GReadModal(GetList, <.cycle.>, <initial>) ; GetList := {}
  248.  
  249. #xcommand GREAD [<cycle: CYCLE>] [INITIAL <initial>] SAVE      => ;
  250.           GReadModal(GetList, <.cycle.>, <initial>)
  251.  
  252. //───── the following command is necessary because it must call the
  253. //───── KillRead() function in GFGETSYS.PRG rather than GETSYS.PRG
  254. #xcommand CLEAR GGETS                                                   ;
  255.       => GFKillRead()                                                   ;
  256.        ; GetList := {}
  257. */
  258.