home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / screen / formge / iolib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-20  |  17.8 KB  |  633 lines
  1. #include <alloc.h>
  2. #include <dos.h>
  3. #include <mem.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <conio.h>
  8.  
  9. /*=========================================================================*/
  10. /*  iolib.c   -- library of i/o functions for use from Turbo C             */
  11. /*               by John Queern, Belleville, IL (public domain)            */
  12. /*=========================================================================*/
  13.  
  14. /* function prototypes */
  15.  
  16. char *strdel(char st[],int start,int count);/* delete substring from string */
  17. int nonblank (char *st);                    /* return true if st not blank */
  18. void stub(void);                            /* make sound to signify stub */
  19. void binit(int buffs);                      /* initialize video buffers */
  20. void savescreen(int i);                     /* save screen to buff i */
  21. void restorescreen(int i);                  /* restore screen from buff i */
  22. void copyscreen(int i,int j);               /* copy buff i to buff j */
  23. void bclear(int b);                         /* clear buff b */
  24. void bwrite(int b,int x,int y,char st[]);   /* write st to buff b at x,y */
  25. void border(int color);                     /* set border color */
  26. void pad(char st[],int len);                /* pad a string to length len */
  27. void trim(char st[]);                       /* trim off trailing blanks, \n's */
  28. char *lcase(char st[]);                     /* convert string to l.case */
  29. char *ucase(char st[]);                     /* convert string to u.case */
  30. int getstring(int x,int y,int *c,           /* wordStar-like string input */
  31.    char st[],int len);                      /*    routine */
  32. int getint(int x,int y,int *i,int w);       /* integer input routine */
  33. int getachar(int x,int y,char *ch);         /* char input routine */
  34. int getfloat(int x,int y, float *f,         /* float input routine */
  35.     int w, int d);
  36.  
  37. /** see ioed.c for additional editor-in-a-box functions **/
  38.  
  39. /*=========================================================================*/
  40.  
  41. /* definitions and declarations */
  42.  
  43. #define TRUE  1
  44. #define FALSE 0
  45. #define MAXBUFFERS 10    /* max screen buffers to permit */
  46.  
  47. typedef unsigned char vscreen[4000];
  48. typedef vscreen  far *vptr;
  49.  
  50. vptr    sbuff[MAXBUFFERS];      /* screen buffer pointers */
  51. char    monochrome=0;           /* mono flag */
  52. char    insert=0;               /* insert/overwrite flag */
  53. int     insertx=60,inserty=1;   /* location of insert/overwrite message */
  54. int     colx=0,coly=0;          /* location of column info, if present */
  55. int     trimblanks=0;           /* make true for getstring to trim blanks */
  56. int     colons=0;               /* make true for getstring to use colons */
  57. int        nobeep=0;               /* make true to suppress end-field beep */
  58. int     bfore=15,bback=0;       /* buffer foreground, background colors */
  59. int     buffers=0;              /* actual buffers initialized */
  60.  
  61. /*=========================================================================*/
  62.  
  63. char *strdel(char st[],int start,int count)
  64. /* delete <count> chars from string <st> starting at <start> */
  65. {
  66.    int i,l;
  67.  
  68.    l = strlen(st);
  69.    for (i=start;i<l;i++) st[i] = st[i+count];
  70.    return(st);
  71. }
  72.  
  73. /*=========================================================================*/
  74.  
  75. int nonblank (char *st)
  76. /* check a string to see if it contains anything except blanks; return
  77.    1 (=TRUE) if the string contains something nonblank; 0 (=FALSE) otherwise */
  78. {
  79.    int flag;
  80.    flag = FALSE;  /* assume everything is blank */
  81.    while ((*st!=0) && (flag==FALSE)) {
  82.      flag=((*st!=' ') && (*st!=0));
  83.      st++;
  84.    }
  85.    return flag;
  86. }
  87.  
  88. /*========================================================================*/
  89.  
  90. void stub(void)
  91. /* handy function to represent missing functions during testing */
  92. {
  93.   int i;
  94.  
  95.   for (i=0;i<10;i++) {
  96.     sound(400);
  97.     delay(50);
  98.     sound(200);
  99.     delay(50);
  100.   }
  101.   nosound();
  102. }
  103.  
  104. /*========================================================================*/
  105.  
  106.  
  107. void binit(int buff)  /* initialize video buffers */
  108. {
  109.    int i;
  110.    union REGS regs;
  111.  
  112.    if (buff>MAXBUFFERS) buff=MAXBUFFERS;
  113.    for ( i = buffers; i < buff; ++i ) {
  114.       sbuff[i] = (vptr)calloc(1,sizeof(*sbuff[i]));
  115.    }
  116.  
  117.    /* if first time through, determine whether display is monochrome or color */
  118.    if (buffers==0) {
  119.         regs.x.ax = 0;
  120.         int86(17,®s,®s);  /*equipment list call*/
  121.         if ( (regs.h.al & 48) == (48) ) {
  122.             monochrome = TRUE;
  123.         }
  124.         else {
  125.             monochrome = FALSE;
  126.         }
  127.    }
  128.    buffers = buff;
  129. }
  130.  
  131. /*====================================================*/
  132.  
  133. void savescreen(int i)
  134. {
  135.    unsigned char b;
  136.  
  137.    if (i>=buffers) binit(i+1);
  138.  
  139.    b = peek(0,1125);
  140.    outportb(984,(b & 240) | 1);  /*blank screen*/
  141.    if ( monochrome ) {
  142.       movedata(0xb000,0,FP_SEG(sbuff[i]),FP_OFF(sbuff[i]),4000);
  143.    }
  144.    else {
  145.       movedata(0xb800,0,FP_SEG(sbuff[i]),FP_OFF(sbuff[i]),4000);
  146.    }
  147.    outportb(984,b);
  148. }
  149.  
  150. /*====================================================*/
  151.  
  152. void restorescreen(int i)
  153. {
  154.    unsigned char b;
  155.  
  156.    if (i>=buffers)  binit(i+1);
  157.  
  158.    b = peek(0,1125); /*DOS video mode byte reference*/
  159.    outportb(984,(b & 240) | 1);  /*blank screen*/
  160.    if ( monochrome ) {
  161.       movedata(FP_SEG(sbuff[i]),FP_OFF(sbuff[i]),0xb000,0,4000);
  162.    }
  163.    else {
  164.       movedata(FP_SEG(sbuff[i]),FP_OFF(sbuff[i]),0xb800,0,4000);
  165.    }
  166.    poke(0,1125,b & 223);
  167.    outportb(984,b & 223);
  168. }
  169.  
  170. /*====================================================*/
  171.  
  172. void copyscreen(int i,int j)
  173. {
  174.  
  175.    if (i>=buffers || j>=buffers) binit(max(i,j)+1);
  176.  
  177.    if ((i<0) || (i>4)) {
  178.       return;
  179.    }
  180.    movedata(FP_SEG(sbuff[i]),FP_OFF(sbuff[i]),
  181.      FP_SEG(sbuff[j]),FP_OFF(sbuff[j]),4000);
  182. }
  183. /*====================================================*/
  184.  
  185. void bclear(int b)
  186. {
  187.    int i;
  188.  
  189.    if (b>=buffers) binit(b+1);
  190.  
  191.    i = 0;
  192.    while ( i < 4000 ) {
  193.       (*sbuff[b])[i] = 32;  /*ASCII blank*/
  194.       (*sbuff[b])[i + 1] = (bback) * 16 + bfore;
  195.       i += 2;
  196.    }
  197. }  /*bclear*/
  198.  
  199. /*====================================================*/
  200.  
  201. void bwrite(int b,int x,int y,char st[])
  202. {
  203.    int i;
  204.    int p;
  205.  
  206.    if (b>=buffers) binit(b+1);
  207.  
  208.    p = ((y - 1) * 160) + ((x - 1) * 2) ;  /*starting position in buffer*/
  209.    for ( i = 0; i < strlen(st); i++) {
  210.       (*sbuff[b])[p] = st[i];
  211.       (*sbuff[b])[p + 1] = (bback) * 16 + bfore;
  212.       p += 2;
  213.    } /*for i*/
  214. }  /*bwrite*/
  215.  
  216. /*=========================================================================*/
  217.  
  218. void border(int color)
  219. {
  220.    union REGS regs;
  221.  
  222.    regs.h.ah = 11; /*set color palette*/
  223.    regs.h.bh = 0;
  224.    regs.h.bl = color;
  225.    int86(16,®s,®s); /*video services*/
  226.  
  227. } /*border*/
  228.  
  229. /*=========================================================================*/
  230.  
  231. void pad(char st[],int len)
  232. /* pad the length of string st to len chars */
  233. {
  234.    char *cp;
  235.    int i;
  236.  
  237.    /* find end of string */
  238.    for (cp=st,i=0; (*cp != 0) && (i<len); cp++,i++);
  239.    /* if not long enough, pad it */
  240.    while (i<len) {
  241.      *(cp++)=' ';
  242.      i++;
  243.    }
  244.    /* and reterminate it */
  245.    *cp=0;
  246. }
  247.  
  248. /*=========================================================================*/
  249.  
  250. void trim(char st[])
  251. /* trim trailing blanks and/or \n's off of string st */
  252. {
  253.     int i;
  254.  
  255.     if ( st[0] != 0 ) {
  256.        i = strlen(st)-1;
  257.        while ( (i >= 0) &&
  258.          ((st[i] == ' ') || (st[i] == '\n')) )
  259.          i--;
  260.        if ((st[i] == ' ') || (st[i] == '\n')) st[i]=0;
  261.        else st[i+1]=0;
  262.     }
  263.  
  264. }
  265.  
  266. /*=========================================================================*/
  267.  
  268. char *lcase(char st[])
  269. /* trim and convert string st to lower case */
  270. {
  271.    trim(st);
  272.    while (*st != NULL) tolower(*(st++));
  273.    return(st);
  274. }
  275. /*=========================================================================*/
  276.  
  277. char *ucase(char st[])
  278. /* trim and convert string st to upper case */
  279. {
  280.    trim(st);
  281.    while (*st != NULL) toupper(*(st++));
  282.    return(st);
  283. }
  284.  
  285. /*========================================================================*/
  286.  
  287. int getstring(int x,int y,int *c,char st[],int len)
  288. /* x,y are the position where the field begins; c is the cursor column
  289.    within the field (0 for 1st position); c is updated by getstring() */
  290. /* return codes (based on exit keystroke):
  291.     0:    CR, original entry changed
  292.     1:    CR, original entry unchanged
  293.     2:    Esc
  294.     3:    up arrow, ctrl-e
  295.     4:    left arrow, ctrl-s
  296.     5:    right arrow, ctrl-d
  297.     6:    down arrow, ctrl-x
  298.     7:    ctrl-w
  299.     8:    End
  300.     9:    PgUp, ctrl-r
  301.    10:    PgDn, ctrl-c
  302.    11-20: F1..F10
  303.    21:    ctrl-y
  304.    22:    ctrl-z
  305.    23:    ctrl-n
  306.    24:    Home
  307.    25:    ctrl-b
  308.    26:    ctrl-u
  309. */
  310. {
  311.    int _fret, i, n, p, nn;
  312.    char ch, c2, ch2, *cp;
  313.    char *blankfield,*model;
  314.  
  315.    if (colons) {
  316.      gotoxy(x - 1,y);
  317.      cprintf("%c", ':');
  318.      gotoxy(x + len,y);
  319.      cprintf("%c", ':');
  320.    }
  321.  
  322.    gotoxy(insertx,inserty);
  323.    if ( insert )
  324.         cputs(" INSERT    ");
  325.    else
  326.         cputs(" OVERWRITE ");
  327.  
  328.    model=(char *)calloc(1,len+1);
  329.    strcpy(model,st);  /* make reference copy */
  330.    gotoxy(x,y);
  331.    blankfield=(char *)calloc(1,len+1);
  332.    blankfield[0]=0;
  333.    pad(blankfield,len);
  334.    pad(st,len);
  335.  
  336.    cputs(st);
  337.  
  338.    n = *c;
  339.    do {
  340.       gotoxy(x + n,y);
  341.       ch = getch();
  342.  
  343.       /*handle special characters*/
  344.       if ( ch == 0 ) {  /* IBM PC special char sequence */
  345.          c2 = getch();  /* get second char */
  346.          /* return predefined exit codes for F1..F10  (11..20) */
  347.          if ((c2 >= 59) && (c2 <= 68)) {
  348.             _fret = c2 - 48;
  349.             goto L99;
  350.          }
  351.          switch ( c2 ) {
  352.             case 72 :        /* up arrow */
  353.                ch = 5;       /* convert to ctrl-e */
  354.                break;
  355.             case 80 :        /* down arrow */
  356.                ch = 24;      /* convert to ctrl-x */
  357.                break;
  358.             case 75 :        /* left arrow */
  359.                ch = 19;      /* convert to ctrl-s */
  360.                break;
  361.             case 77 :        /* right arrow */
  362.                ch = 4;       /* convert to ctrl-d */
  363.                break;
  364.             case 73 :        /* PgUp */
  365.                ch = 18;      /* convert to ctrl-r */
  366.                break;
  367.             case 81 :        /* PgDn */
  368.                ch = 3;       /* convert to ctrl-c */
  369.                break;
  370.             case 82 :        /* Ins */
  371.                ch = 22;      /* convert to ctrl-v */
  372.                break;
  373.             case 83 :        /* Del */
  374.                ch = 7;       /* convert to ctrl-g */
  375.                break;
  376.             case 79 :        /* End */
  377.                _fret = 8;
  378.                goto L99;
  379.             case 71 :        /* Home */
  380.                _fret =  24;  /* return code 24 */
  381.                goto L99;
  382.             default:
  383.                ch = 0;
  384.                break;
  385.          }  /* switch */
  386.       }    /* if special */
  387.  
  388.       switch ( ch ) {        /* Esc */
  389.          case 27 :
  390.                _fret = 2;
  391.                goto L99;
  392.          case 13 :           /* CR */
  393.                if (strcmp(st,model)==0) _fret = 1;
  394.                else _fret = 0;
  395.                if (y<25) (y)++;
  396.                goto L99;
  397.          case 5 :            /* ctrl-e */
  398.                _fret = 3;
  399.                goto L99;
  400.          case 19 :           /* ctrl-s */
  401.                 if ( n == 0 ) {
  402.                   _fret = 4;
  403.                   goto L99;
  404.                 }
  405.                 else n--;
  406.                 break;
  407.          case 4 :            /* ctrl-d */
  408.                 if ( n == len-1 ) {
  409.                   _fret = 5;
  410.                   goto L99;
  411.                 }
  412.                 else n++;
  413.                 break;
  414.          case 21 :           /* ctrl-u */
  415.                _fret = 26;
  416.                goto L99;
  417.          case 24 :           /* ctrl-x */
  418.                _fret = 6;
  419.                goto L99;
  420.          case 23 :           /* ctrl-w */
  421.                _fret = 7;
  422.                goto L99;
  423.          case 18 :           /* ctrl-r */
  424.                _fret = 9;
  425.                goto L99;
  426.          case 3 :            /* ctrl-c */
  427.                _fret = 10;
  428.                goto L99;
  429.          case 25 :           /* ctrl-y */
  430.                strcpy(st,blankfield);
  431.                n = 0;
  432.                gotoxy(x,y);
  433.                cputs(blankfield);
  434.               _fret = 21;
  435.               goto L99;
  436.          case 26 :           /* ctrl-z */
  437.               _fret = 22;
  438.               goto L99;
  439.          case 2  :           /* ctrl-b */
  440.               _fret = 25;
  441.               goto L99;
  442.          case 14 :           /* ctrl-n */
  443.               _fret = 23;
  444.               goto L99;
  445.          case 22 :           /* ctrl-v */
  446.                insert = !(insert);
  447.                gotoxy(insertx,inserty);
  448.                if ( insert )
  449.                   cputs(" INSERT    ");
  450.                else
  451.                   cputs(" OVERWRITE ");
  452.                break;
  453.          case 7 :            /* ctrl-g */
  454.                for ( i = n; i < len - 1; i++ )
  455.                   st[i] = st[i + 1];
  456.                st[len - 1] = ' ';
  457.                gotoxy(x,y);
  458.                cputs(st);
  459.                break;
  460.          case 20 :           /* ctrl-t */
  461.                p = n;
  462.                if (st[n] == ' ' )
  463.                   while ( (p < len-1) && (st[p] == ' ') ) p++;
  464.                else
  465.                   while ( (p < len-1) && (st[p] != ' ') ) p++;
  466.                strdel(st,n,(p-n));
  467.                pad(st,len);
  468.                gotoxy(x,y);
  469.                cputs(st);
  470.                break;
  471.         case 9 :              /* ctrl-i or TAB */
  472.                n++;
  473.                while ((n<len-1) && (5 * (n / 5) != n)) n++;
  474.                gotoxy(x + n,y);
  475.                break;
  476.         case 17:             /* ctrl-q */
  477.                 ch2=getch();
  478.                 ch2=toupper(ch2);
  479.                 if ((ch2 =='D') || (ch2==4)) {  /* end of line */
  480.                     n=len-1;
  481.                     while ((st[n-1]==' ') && (n>0)) n--;
  482.                     if (n<len-1) n++;
  483.                 }
  484.                 else if ((ch2 == 'S') || (ch==13)) { /* beg of line */
  485.                     n=1;
  486.                     while ((st[n-1]==' ') && (n<len-1)) n++;
  487.                 }
  488.                 else if ((ch2=='R') || (ch2==12)) {
  489.                   _fret=9;
  490.                   goto L99;
  491.                 }
  492.                 else if ((ch2=='C') || (ch2== 3)) {
  493.                   _fret=10;
  494.                   goto L99;
  495.                 }
  496.                 else putch(7);
  497.                 break;
  498.          case 1 :            /* ctrl-a */
  499.                while ( (n > 0) && (st[n] != ' ')) n--;
  500.                while ( (n > 0) && (st[n] == ' ')) n--;
  501.                while ( (n > 0) && (st[n] != ' ' )) n--;
  502.                if ( st[n] == ' ') n++;
  503.                gotoxy(x + n,y);
  504.                break;
  505.          case 6 :            /* ctrl-f */
  506.                /* find end of current word */
  507.                while ( (n < len - 1) && (st[n] != ' ') ) n++;
  508.                nn = n;
  509.                /* find beginning of nextg word */
  510.                while ( (n < len-1) && (st[n] == ' ') ) n++;
  511.                if ( n == len -1) {    /* no next word: back up */
  512.                  n = nn;
  513.                  if (n<len-1) n++;
  514.                }
  515.                gotoxy(x + n,y);
  516.                break;
  517.          default:
  518.            {
  519.            if ((insert) && !((ch >= 8) && (ch <= 13))){
  520.                   for ( i = len - 1; i > n ; i-- )
  521.                      st[i] = st[i - 1];
  522.                   st[n] = ch;
  523.                   gotoxy(x,y);
  524.                   cputs(st);
  525.                }
  526.                else {
  527.                   if (!((ch >= 8) && (ch <= 13)) ) {
  528.                      st[n] = ch;
  529.                      putch(ch);
  530.                   }
  531.                }
  532.                if ( (ch == '\x08') && (n > 0) )   /*backing up*/
  533.                   n--;
  534.                else if (ch != '\x08')
  535.                   n++;
  536.             }
  537.             break;
  538.       } /*switch/case*/
  539.  
  540.       if (colx != 0) {
  541.         gotoxy(colx,coly);
  542.         printf("%3d",n+1);
  543.       }
  544.  
  545.    } while ( ! ((ch == '\x0D') || (n > len-1)) );
  546.    if ( n >= len-1 && !nobeep)  {
  547.       sound(200);
  548.       delay(150);
  549.       nosound();
  550.    }
  551.    _fret = 0;
  552.  
  553. L99:
  554.  
  555.    if (trimblanks) {
  556.      if ( st[0] != 0 ) {
  557.        i = len-1;
  558.        while ( (i >= 0) && (st[i] == ' ') ) i--;
  559.        if (st[i] == ' ') st[i]=0;
  560.        else st[i+1]=0;
  561.      }
  562.    }
  563.  
  564.    (*c) = n;  /* update cursor position */
  565.    return(_fret);
  566.  
  567. } /*getstring*/
  568.  
  569. /*=========================================================================*/
  570.  
  571. int getint(int x,int y,int *i,int w)
  572. {
  573.    int retcd,ret,col;
  574.    char temp[80],format[20];
  575.    col=0;
  576.  
  577.    do {
  578.      sprintf(format,"%%%dd",w);
  579.      sprintf(temp,format,*i);
  580.      retcd = getstring(x,y,&col,temp,w);
  581.      trim(temp);
  582.      ret = sscanf(temp, "%d", i);
  583.      if (ret==0) putch('\a');
  584.    }
  585.    while (ret == 0);
  586.    sprintf(temp,format,*i);
  587.    gotoxy(x,y);
  588.    cputs(temp);
  589.  
  590.    return(retcd);
  591. }  /* getint */
  592.  
  593. /*=========================================================================*/
  594.  
  595. int getachar(int x,int y,char *ch)
  596. {
  597.   int   retval,col;
  598.   char  temp[2];
  599.  
  600.   col=0;
  601.   temp[0]=*ch;
  602.   temp[1]=0;
  603.   retval = getstring(x,y,&col,temp,1);
  604.   *ch = temp[0];
  605.   return(retval);
  606. }
  607.  
  608. /*========================================================================*/
  609.  
  610. int getfloat(int x,int y, float *f, int w, int d)
  611. {
  612.    int retcd,ret,col;
  613.    char temp[80],format[20];
  614.    col=0;
  615.  
  616.    do {
  617.      sprintf(format,"%%%d.%df",w,d);
  618.      sprintf(temp,format,*f);
  619.      retcd = getstring(x,y,&col,temp,w);
  620.      trim(temp);
  621.      ret = sscanf(temp, "%f", f);
  622.      if (ret==0) putch('\a');
  623.    }
  624.    while (ret == 0);
  625.    sprintf(temp,format,*f);
  626.    gotoxy(x,y);
  627.    cputs(temp);
  628.  
  629.    return(retcd);
  630. }  /* getfloat */
  631.  
  632.  
  633.