home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / BBS / MISC / HSRC_117.ZIP / ENTRY.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-09  |  11.8 KB  |  595 lines
  1. /* entry.c */
  2.  
  3. #include <stdio.h>
  4. #include <ctype.h>
  5. #include <stdlib.h>
  6. #include <alloc.h>
  7. #include <mem.h>
  8. #include <string.h>
  9. #include <conio.h>
  10. #include <dos.h>
  11. #include "twindow.h"
  12. #include "keys.h"
  13.  
  14. #define FIELDCHAR '_'
  15. int insert_mode=FALSE;
  16. extern int helpkey;
  17. extern unsigned char usemouse;
  18.  
  19. /* Local prototypes */
  20. extern void pascal print_clock(void);
  21. void pascal addfield(WINDOW *wnd,FIELD *fld);
  22. void pascal data_value(WINDOW *wnd,FIELD *fld);
  23. void pascal insert_status(void);
  24. int pascal read_field(WINDOW *wnd,FIELD *fld);
  25. void pascal right_justify(char *s);
  26. void pascal right_justify_zero_fill(char *s);
  27. int pascal validate_date(char *s);
  28. int pascal endstroke(int c);
  29. int pascal spaces(char *c);
  30.  
  31. /* Initialize a template */
  32. void pascal init_template(WINDOW *wnd) {
  33.  
  34.     FIELD *fld,*fl;
  35.  
  36.     fld=FHEAD;
  37.     while (fld) {
  38.         fl=fld->fnxt;
  39.         free(fld);
  40.         fld=fl;
  41.     }
  42.     FHEAD=NULL;
  43. }
  44.  
  45. /* Establish a field in a template */
  46. FIELD * pascal establish_field(wnd,cl,rw,msk,bf,ty)
  47. WINDOW *wnd;
  48. int rw;
  49. int cl;
  50. char *msk;
  51. char *bf;
  52. int ty;
  53. {
  54.     FIELD *fld;
  55.  
  56.     if ((fld=malloc(sizeof(FIELD)))==NULL)
  57.         return NULL;
  58.     fld->fmask=msk;
  59.     fld->frow=rw;
  60.     fld->fcol=cl;
  61.     fld->fbuff=bf;
  62.     fld->ftype=ty;
  63.     fld->fprot=0;
  64.     fld->fnxt=fld->fprv=NULL;
  65.     fld->fvalid=NULL;
  66.     fld->fhelp=NULL;
  67.     fld->fhwin=NULL;
  68.     fld->flx=fld->fly=0;
  69.     addfield(wnd,fld);
  70.     return fld;
  71. }
  72.  
  73. /* Add a field to the end of the list */
  74. static void pascal addfield(WINDOW *wnd,FIELD *fld) {
  75.  
  76.     if (FTAIL) {
  77.         fld->fprv=FTAIL;
  78.         FTAIL->fnxt=fld;
  79.     }
  80.     FTAIL=fld;
  81.     if(!FHEAD)
  82.         FHEAD=fld;
  83. }
  84.  
  85. /* Display a data field */
  86. static void pascal disp_field(WINDOW *wnd,char *bf,char *msk) {
  87.  
  88.     while (*msk) {
  89.         wputcharaw (wnd,*msk !=FIELDCHAR ? *msk : *bf++);
  90.         msk++;
  91.     }
  92. }
  93.  
  94. /* Display the data value in a field */
  95. static void pascal data_value(WINDOW *wnd,FIELD *fld) {
  96.  
  97.     wcursor(wnd,fld->fcol,fld->frow);
  98.     disp_field(wnd,fld->fbuff,fld->fmask);
  99. }
  100.  
  101. /* Display all the fields in a window */
  102. void pascal field_tally(WINDOW *wnd)
  103. {
  104.     FIELD *fld;
  105.  
  106.     fld=FHEAD;
  107.     while(fld != NULL) {
  108.         data_value(wnd,fld);
  109.         fld=fld->fnxt;
  110.     }
  111. }
  112.  
  113. /* Set a field's help window */
  114. void pascal field_window(FIELD *fld,char *hwin,int x,int y) {
  115.  
  116.     fld->fhwin=hwin;
  117.     fld->flx=x;
  118.     fld->fly=y;
  119. }
  120.  
  121. /* Clear a template to all blanks */
  122. void pascal clear_template (WINDOW *wnd) {
  123.  
  124.     FIELD *fld;
  125.     char *bf,*msk;
  126.  
  127.     fld=FHEAD;
  128.     while (fld != NULL) {
  129.         bf=fld->fbuff;
  130.         msk=fld->fmask;
  131.         while (*msk) {
  132.             if(*msk==FIELDCHAR)
  133.                 *bf++=' ';
  134.             msk++;
  135.         }
  136.         fld=fld->fnxt;
  137.     }
  138.     field_tally(wnd);
  139. }
  140.  
  141. /* Prepare a template to end in blanks */
  142. void pascal prep_template (WINDOW *wnd) {
  143.  
  144.     FIELD *fld;
  145.     char *bf,*msk;
  146.  
  147.     fld=FHEAD;
  148.     while (fld != NULL) {
  149.         bf=fld->fbuff;
  150.         msk=fld->fmask;
  151.         while((*bf!=0) && (*msk!=0)) {
  152.             if (*msk!=FIELDCHAR) {
  153.                 msk++;
  154.                 continue;
  155.             }
  156.             if (*msk==0) {
  157.                 break;
  158.             }
  159.             bf++;
  160.             msk++;
  161.         }
  162.         while (*msk) {
  163.             if(*msk==FIELDCHAR)
  164.                 *bf++=' ';
  165.             msk++;
  166.         }
  167.         *bf=0;
  168.         fld=fld->fnxt;
  169.     }
  170.     field_tally(wnd);
  171. }
  172.  
  173. /* Set insert/exchange cursor shape */
  174. static void pascal insert_status() {
  175.     set_cursor_type(insert_mode ? 0x0106 : 0x0607);
  176. }
  177.  
  178. /* Read a field from the keyboard */
  179. static int pascal read_field (WINDOW *wnd,FIELD *fld) {
  180.  
  181.     char *mask=fld->fmask,*buff=fld->fbuff;
  182.     int done=FALSE,c,column;
  183.  
  184.     column=fld->fcol;
  185.     while(*mask!=FIELDCHAR) {
  186.         column++;
  187.         mask++;
  188.     }
  189.     while (TRUE) {
  190.         wcursor(wnd,column,fld->frow);
  191.         c=0;
  192.         SHOWMOUSE;
  193.         CONFINEMOUSE(wnd);
  194.         while(!kbhit()) {
  195.           if(usemouse) {
  196.  
  197.                 union REGS rg;
  198.  
  199.                 rg.x.ax=3;
  200.                 int86(0x33,&rg,&rg);
  201.                 move_mouse(rg.x.cx/8,rg.x.dx/8);
  202.                 rg.x.ax=5;
  203.                 rg.x.bx=0;          /* Check left button */
  204.                 int86(0x33,&rg,&rg);
  205.                 if(rg.x.bx) {       /* Button pressed */
  206.                     rg.x.cx/=8;     /* Mouse x */
  207.                     rg.x.dx/=8;     /* Mouse y */
  208.                     if(rg.x.cx==COL && rg.x.dx==ROW) {
  209.                         c=ESC;
  210.                         break;
  211.                     }
  212.                     if(rg.x.dx==ROW && rg.x.cx==COL+WIDTH-1) {
  213.                         c=PGUP;
  214.                         break;
  215.                     }
  216.                     if(rg.x.cx==COL && rg.x.dx==ROW+HEIGHT-1) {
  217.                         c=PGDN;
  218.                         break;
  219.                     }
  220.                     if(rg.x.cx==COL+WIDTH-1 & rg.x.dx==ROW+HEIGHT-1) {
  221.                         c=F10;
  222.                         break;
  223.                     }
  224.                     if(!c) {
  225.                         c=get_screen_char(rg.x.cx,rg.x.dx);
  226.                         if((c=='-' || c=='X') && toupper(fld->ftype)=='O') {
  227.                             if(c=='-') c='X';
  228.                             else c='-';
  229.                         }
  230.                     }
  231.                     if(!isdigit(c) && (toupper(fld->ftype)!='O' && toupper(fld->ftype)!='A')) c=0;
  232.                     if(c) break;
  233.                 }
  234.                 rg.x.ax=3;
  235.                 int86(0x33,&rg,&rg);
  236.                 move_mouse(rg.x.cx/8,rg.x.dx/8);
  237.                 rg.x.ax=5;
  238.                 rg.x.bx=1;
  239.                 int86(0x33,&rg,&rg);
  240.                 if(rg.x.bx) {
  241.                     c=ESC;
  242.                     break;
  243.                 }
  244.                 rg.x.ax=3;
  245.                 int86(0x33,&rg,&rg);
  246.                 move_mouse(rg.x.cx/8,rg.x.dx/8);
  247.                 rg.x.ax=5;
  248.                 rg.x.bx=2;
  249.                 int86(0x33,&rg,&rg);
  250.                 if(rg.x.bx) {
  251.                     c=DN;
  252.                     break;
  253.                 }
  254.           }
  255. #ifdef USECLOCK
  256.           print_clock();
  257. #endif
  258.         }
  259.         HIDEMOUSE;
  260.         if(!c)c=get_char();
  261.         if(fld->ftype=='A' || fld->ftype=='O') c=toupper(c);
  262.         clear_message();
  263.         switch(c) {
  264.             case '\b':
  265.             case BS:
  266.                 if(buff==fld->fbuff) {
  267.                     done=c==BS;
  268.                     break;
  269.                 }
  270.                 --buff;
  271.                 do {
  272.                     --mask;
  273.                     --column;
  274.                 } while (*mask !=FIELDCHAR);
  275.                 if (c==BS) break;
  276.             case DEL:
  277.                 if(fld->ftype!='O') {
  278.                     movmem(buff+1,buff,strlen(buff));
  279.                     *(buff+strlen(buff))=' ';
  280.                     wcursor(wnd,column,fld->frow);
  281.                     disp_field(wnd,buff,mask);
  282.                 }
  283.                 break;
  284.             case CTRL_Y:
  285.                 strset(buff,' ');
  286.                 disp_field(wnd,buff,mask);
  287.                 break;
  288.             case CTRL_RIGHT:
  289.                 do {
  290.                     column++;
  291.                     mask++;
  292.                     if(*mask==FIELDCHAR)buff++;
  293.                 } while(*buff==' ' && *mask);
  294.                 if(*mask) {
  295.                     do {
  296.                         column++;
  297.                         mask++;
  298.                         if(*mask==FIELDCHAR)buff++;
  299.                     }    while(*buff!=' ' && *mask);
  300.                 }
  301.                 break;
  302.             case CTRL_LEFT:
  303.                 if(mask>fld->fmask) {
  304.                     do {
  305.                         --column;
  306.                         --mask;
  307.                         if(*mask==FIELDCHAR)--buff;
  308.                     } while(*buff==' ' && mask>fld->fmask);
  309.                 }
  310.                 if(mask>fld->fmask) {
  311.                     do {
  312.                         --column;
  313.                         --mask;
  314.                         if(*mask==FIELDCHAR)--buff;
  315.                     } while(*buff!=' ' && mask>fld->fmask);
  316.                 }
  317.                 break;
  318.             case END:
  319.                 column=fld->fcol;
  320.                 mask=fld->fmask;
  321.                 buff=fld->fbuff;
  322.                 do {
  323.                     column++;
  324.                     mask++;
  325.                     if(*mask==FIELDCHAR)buff++;
  326.                 } while(*mask);
  327.                 while(*buff==' ' && mask>fld->fmask) {
  328.                     --column;
  329.                     --mask;
  330.                     if(*mask==FIELDCHAR)--buff;
  331.                 }
  332.                 if(*buff!=' ') buff++;
  333.                 break;
  334.             case HOME:
  335.                 column=fld->fcol;
  336.                 mask=fld->fmask;
  337.                 buff=fld->fbuff;
  338.                 while(*mask!=FIELDCHAR) {
  339.                     column++;
  340.                     mask++;
  341.                 }
  342.                 break;
  343.             case FWD:
  344.                 do {
  345.                     column++;
  346.                     mask++;
  347.                 } while(*mask && *mask!=FIELDCHAR);
  348.                 buff++;
  349.                 break;
  350.             case INS:
  351.                 insert_mode ^= TRUE;
  352.                 insert_status();
  353.                 break;
  354.             case '.':
  355.                 if (fld->ftype=='C') {
  356.                     if (*mask++ && *buff==' ') {
  357.                         *buff++='0';
  358.                         if (*mask++ && *buff==' ')
  359.                             *buff++='0';
  360.                     }
  361.                     right_justify(fld->fbuff);
  362.                     wcursor(wnd,fld->fcol,fld->frow);
  363.                     disp_field(wnd,fld->fbuff,fld->fmask);
  364.                     column=fld->fcol+strlen(fld->fmask)-2;
  365.                     mask=fld->fmask+strlen(fld->fmask)-2;
  366.                     buff=fld->fbuff+strlen(fld->fbuff)-2;
  367.                     break;
  368.                 }
  369.             default:
  370.                 if (endstroke(c)) {
  371.                     done=TRUE;
  372.                     break;
  373.                 }
  374.                 if (toupper(fld->ftype)!='A'&&toupper(fld->ftype)!='O'&&!isdigit(c)) {
  375.                     error_message("Numbers only");
  376.                     break;
  377.                 }
  378.                 if (toupper(fld->ftype)=='O'&& c!='X') c='-';
  379.                 if (insert_mode && fld->ftype!='O') {
  380.                     movmem(buff,buff+1,strlen(buff)-1);
  381.                     disp_field(wnd,buff,mask);
  382.                     wcursor(wnd,column,fld->frow);
  383.                 }
  384.                 *buff++=c;
  385.                 wputcharaw(wnd,c);
  386.                 do {
  387.                     column++;
  388.                     mask++;
  389.                 } while(*mask && *mask!=FIELDCHAR);
  390.                 if(!*mask)
  391.                     c=FWD;
  392.                 break;
  393.             }
  394.             if (!*mask) done=TRUE;
  395.             if(done) {
  396.                 if(fld->ftype=='D' && c!=ESC && validate_date(fld->fbuff)!=OK) {
  397.                   return ERROR;
  398.                 }
  399.                 break;
  400.             }
  401.         }
  402.         if(c!=ESC && toupper(fld->ftype)!='A') {
  403.             if(fld->ftype=='C') {
  404.                 if(*mask++ && *buff==' ') {
  405.                     *buff++='0';
  406.                     if(*mask++ && *buff==' ')
  407.                         *buff++='0';
  408.                 }
  409.             }
  410.             if (fld->ftype=='Z' || fld->ftype=='D') right_justify_zero_fill(fld->fbuff);
  411.             else right_justify(fld->fbuff);
  412.             wcursor(wnd,fld->fcol,fld->frow);
  413.             disp_field(wnd,fld->fbuff,fld->fmask);
  414.         }
  415.         return c;
  416. }
  417.  
  418. /* Test C for an ending keystroke */
  419. static int pascal endstroke(int c) {
  420.  
  421.     switch(c) {
  422.         case '\r':
  423.         case '\n':
  424.         case '\t':
  425.         case ESC:
  426.         case ALT_F1:
  427.         case ALT_F2:
  428.         case ALT_F3:
  429.         case ALT_F4:
  430.         case ALT_F5:
  431.         case ALT_F6:
  432.         case ALT_F7:
  433.         case ALT_F8:
  434.         case ALT_F9:
  435.         case ALT_F10:
  436.         case F1:
  437.         case F2:
  438.         case F3:
  439.         case F4:
  440.         case F5:
  441.         case F6:
  442.         case F7:
  443.         case F8:
  444.         case F9:
  445.         case F10:
  446.         case CTRL_PGUP:
  447.         case CTRL_PGDN:
  448.         case CTRL_END:
  449.         case CTRL_HOME:
  450.         case PGUP:
  451.         case PGDN:
  452.         case HOME:
  453.         case END:
  454.         case UP:
  455.         case DN:
  456.             return TRUE;
  457.         default:
  458.             return FALSE;
  459.     }
  460. }
  461.  
  462. /* Right justify, space fill */
  463. static void pascal right_justify(char *s)
  464. {
  465.     int len;
  466.  
  467.     len=strlen(s);
  468.  
  469. /*    while(*s==' ' || *s=='0' && len) {
  470. */
  471.  
  472.     while(*s==' '&& len) {
  473.         len--;
  474.         *s++=' ';
  475.     }
  476.  
  477. /*
  478.     if(len)
  479.         while(*(s+(len-1)) == ' ') {
  480.             movmem(s,s+1,len-1);
  481.             *s=' ';
  482.         }
  483. */
  484.  
  485. }
  486.  
  487. /* Right justify,zero fill */
  488. static void pascal right_justify_zero_fill(char *s)
  489. {
  490.     int len;
  491.  
  492.     if(spaces(s))
  493.         return;
  494.     len=strlen(s);
  495.     while(*(s+len-1)==' ') {
  496.         movmem(s,s+1,len-1);
  497.         *s='0';
  498.     }
  499. }
  500.  
  501. /* Test for spaces */
  502. int pascal spaces(char *c)
  503. {
  504.     while(*c==' ')
  505.         c++;
  506.     return !*c;
  507. }
  508.  
  509. /* Validate a date */
  510. static int pascal validate_date(char *s)
  511. {
  512.     static char days[]=
  513.         {31,28,31,30,31,30,31,31,30,31,30,31};
  514.     char date[15];
  515.     int mo;
  516.  
  517.     strcpy(date,s);
  518.     if(spaces(date))
  519.         return OK;
  520.     days[1]=(char)atoi(date+4%4) ? 28:29;
  521.     *(date+4)='\0';
  522.     mo=atoi(date+3);
  523.     *(date+2)='\0';
  524.     if(mo && mo<13 && atoi(date) && (char)atoi(date)<=days[mo-1])
  525.         return OK;
  526.     error_message("Invalid date");
  527.     return ERROR;
  528. }
  529.  
  530. /* Process data entry for a screen template */
  531. int pascal data_entry (WINDOW *wnd)
  532. {
  533.     FIELD *fld;
  534.     int exitcode,isvalid,done=FALSE,oldhelpkey=helpkey;
  535.  
  536.     field_tally(wnd);
  537.     fld=FHEAD;
  538.     /* Collect data from keyboard into screen */
  539.     while(fld!=NULL && done==FALSE) {
  540.         set_help(fld->fhwin,fld->flx,fld->fly);
  541.         helpkey=(fld->fhelp) ? 0 : oldhelpkey;
  542.         wcursor(wnd,fld->fcol,fld->frow);
  543.         if(fld->fprot==FALSE) {
  544.             reverse_video(wnd);
  545.             data_value(wnd,fld);
  546.             wcursor(wnd,fld->fcol,fld->frow);
  547.             exitcode=read_field(wnd,fld);
  548.             isvalid=(exitcode != ESC && fld->fvalid) ? (*(fld->fvalid))(fld->fbuff) : OK;
  549.         }
  550.         else {
  551.             exitcode=FWD;
  552.             isvalid=OK;
  553.         }
  554.         if(isvalid == OK) {
  555.             normal_video(wnd);
  556.             data_value(wnd,fld);
  557.             switch(exitcode) {     /* Passed edit */
  558.                 case F1:    if (fld->fhelp) {
  559.                                 (*(fld->fhelp))(fld->fbuff);
  560.                                 data_value(wnd,fld);
  561.                             }
  562.                             break;
  563.                 case DN:
  564.                 case '\r':
  565.                 case FWD:    fld=fld->fnxt;
  566.                             if(fld==NULL) {
  567.                                 if (exitcode=='\r') {
  568.                                     exitcode=F10;
  569.                                     done=TRUE;
  570.                                 }
  571.                                 else fld=FHEAD;
  572.                             }
  573.                             break;
  574.                 case UP:
  575.                 case BS:    fld=fld->fprv;
  576.                             if(fld==NULL)
  577.                                 fld=FTAIL;
  578.                             break;
  579.                 default:    done=endstroke(exitcode);
  580.                             break;
  581.             }
  582.         }
  583.     }
  584.     helpkey=oldhelpkey;
  585.     return(exitcode);
  586. }
  587.  
  588. /* Display a window prompt */
  589. void pascal wprompt(WINDOW *wnd,int x,int y,char *s) {
  590.  
  591.     wcursor(wnd,x,y);
  592.     wprintfraw(wnd,s);
  593. }
  594.  
  595.