home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 235_01 / ovprompt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-18  |  10.5 KB  |  338 lines
  1. /*  015  14-Feb-87  ovprompt.c
  2.  
  3.         Copyright (c) 1987 by Blue Sky Software.  All rights reserved.
  4.  
  5.    Note, some of these routines use putchr() and putstr() instead of
  6.    disp_*() because on an IBM PC type system, putchr() will update
  7.    the hardware cursor position while the disp_*() routines MAY not.
  8.    The put*() routines can be #defined to be disp_*() routines if the
  9.    disp_*() routines update the hardware cursor position.
  10. */
  11.  
  12.  
  13. #include <ctype.h>
  14. #include <setjmp.h>
  15. #include "ov.h"
  16.  
  17. extern int brkhit;
  18. extern int errno;
  19. extern int sys_nerr;
  20. extern char *sys_errlist[];
  21.  
  22. static char *boxsave;
  23. static int box_row, box_rows, box_col, box_cols, reply_row, reply_col;
  24.  
  25. static char reply[MAX_REPLY+1];        /* buffer for user replys */
  26.  
  27. static char *esc2quit = "Press ESC to quit";
  28. static char *esc2cont = "Press ESC to continue";
  29.  
  30. extern jmp_buf back_to_main;
  31.  
  32. int ALTCALL kilbox(), ALTCALL makbox();
  33.  
  34.  
  35. /******************************************************************************
  36.                              P R O M P T
  37.  *****************************************************************************/
  38.  
  39.  
  40. char * ALTCALL
  41. prompt(t,s,ps,ip,rlen) /* prompt user, and read string reply */
  42. char *t, *s;           /* prompt box title, prompt string */
  43. char *ps;              /* initial prompt string */
  44. int ip;                /* initial position in initial string */
  45. int rlen;              /* length of reply allowed */
  46. {
  47.    char *sp;
  48.  
  49.    /* create the dialog box with the prompt */
  50.  
  51.    makbox(FIRST_NROW+4,t,s,rlen,esc2quit);
  52.  
  53.    sp = read_str(rlen,ps,ip);          /* read the users reply */
  54.  
  55.    setvattrib(DIS_NORM);               /* restore default video attrib */
  56.  
  57.    kilbox();                           /* remove the dialog box */
  58.  
  59.    return(sp);                         /* return the string */
  60. }
  61.  
  62.  
  63. /*****************************************************************************
  64.                                A S K
  65.  *****************************************************************************/
  66.  
  67. ask(s)                 /* prompt user, and read single char reply */
  68. char *s;
  69. {
  70.    int ch;
  71.  
  72.    makbox(FIRST_NROW+4,"",s,1,"");     /* create dialog box with prompt */
  73.  
  74.    showcursor();                       /* so user knows where he is */
  75.  
  76.    ch = getchr();                      /* get a single character */
  77.  
  78.    hidecursor();                       /* don't need this anymore */
  79.  
  80.    setvattrib(DIS_NORM);               /* restore default video attrib */
  81.  
  82.    kilbox();                           /* remove the dialog box */
  83.  
  84.    return(ch);                         /* and tell user what was read */
  85. }
  86.  
  87.  
  88. /*****************************************************************************
  89.                              B R K O U T
  90.  *****************************************************************************/
  91.  
  92. brkout() {     /* see if user wants to break out of some operation */
  93.  
  94.    register int ch;
  95.  
  96.    /* The user can break out of some operations by signaling an interrupt -
  97.       we consider a ^C, ^U (for old WordStar users), or ESC to be an
  98.       interrupt signal */
  99.  
  100.    if ((ch = peekchr()) == ('C' - 0x40) || ch == ('U' - 0x40) || ch == 27) {
  101.          ch = getchr();                /* flush char from buffer */
  102.          brkhit = 1;                   /* use code below to interrupt */
  103.    }
  104.  
  105.    /* The brkhit flag is set above if certain keys hit, it may also be set
  106.       by the int 23h trap (^C) which is another way to interrupt */
  107.  
  108.    if (brkhit) {
  109.       brkhit = 0;
  110.       ch = ask("Interrupt? (Y/n): ");
  111.       if (yes(ch))
  112.          return(1);            /* yes, break out (interrupt) */
  113.    }
  114.  
  115.    return(0);                  /* doesn't want to interrupt */
  116. }
  117.  
  118.  
  119. /*****************************************************************************
  120.                              R E A D _ S T R
  121.  *****************************************************************************/
  122.  
  123. char * ALTCALL
  124. read_str(rlen,initial,offset)  /* read a string of length rlen */
  125. int rlen, offset;
  126. char *initial;
  127. {
  128.    register int ch;
  129.    register char *cp;
  130.    int insert = FALSE;
  131.    char *defval, *endp;
  132.  
  133.    defval = initial ? initial : "";    /* set the initial (default) value */
  134.    strcpyfill(reply,defval,rlen,' ');  /*   into the reply buffer */
  135.    *(endp = reply + rlen)  = '\0';     /* terminate the reply */
  136.  
  137.    showcursor();                       /* let user see where the cursor is */
  138.  
  139.    cp = reply;                         /* start at the begining */
  140.    for (; offset; --offset)            /* skip to callers offset position */
  141.       putchr(*cp++);
  142.  
  143.    while ((ch = getchr()) != '\r' && ch != ESC_KEY) {
  144.  
  145.       if (ch == DEL) {                         /* delete current char key? */
  146.          if (cp < endp) {
  147.             strncpy(cp,cp+1,rlen-(cp-reply)-1);
  148.             *(endp-1) = ' ';
  149.             putstr_nomove(cp);
  150.          } else
  151.             beep();
  152.          continue;
  153.       }
  154.  
  155.       if (ch == RUBOUT) {                      /* rubout? */
  156.          if (cp > reply) {
  157.             strncpy(cp-1,cp,rlen-(cp-reply));
  158.             *(endp-1) = ' ';
  159.             putchr('\b');
  160.             putstr_nomove(--cp);
  161.          } else
  162.             beep();
  163.          continue;
  164.       }
  165.  
  166.       if (ch == LEFT) {                        /* left arrow? */
  167.          if (cp > reply) {
  168.             --cp;
  169.             putchr('\b');
  170.          } else
  171.             beep();
  172.          continue;
  173.       }
  174.  
  175.       if (ch == RIGHT) {                       /* right arrow? */
  176.          if (cp < endp)
  177.             putchr(*cp++);
  178.          else
  179.             beep();
  180.          continue;
  181.       }
  182.  
  183.       if (ch == INS) {                         /* insert mode key? */
  184.          insert ^= 1;
  185.          continue;
  186.       }
  187.  
  188.       if (ch < ' ' || ch > 0x7f) {             /* don't enter weird chars */
  189.          beep();
  190.          continue;
  191.       }
  192.  
  193.       if (cp < endp) {                         /* add char unless at end */
  194.  
  195.          if (insert) {
  196.             reply[rlen-1] = '\0';
  197.             memcpy(cp+1,cp,rlen-(cp-reply)-1); /* watches for overlap */
  198.          }
  199.  
  200.          *cp++ = ch;
  201.          putchr(ch);
  202.  
  203.          if (insert)
  204.             putstr_nomove(cp);
  205.  
  206.       } else
  207.          beep();
  208.  
  209.    }
  210.  
  211.    hidecursor();                       /* done, get rid of the cursor */
  212.  
  213.    /* if the user didn't escape out, remove trailing blanks from string and
  214.       pass it back to caller.  If he/she did escape, return a null string. */
  215.  
  216.    if (ch != ESC_KEY) {
  217.       for (cp = reply + rlen - 1; cp >= reply && *cp == ' '; )
  218.          *cp-- = '\0';
  219.       return(reply);
  220.    } else
  221.       return("");
  222. }
  223.  
  224.  
  225. /*****************************************************************************
  226.                           S H O W _ E R R O R
  227.  *****************************************************************************/
  228.  
  229. show_error(show_dos,ljmp,count,m1)     /* show user an error msg */
  230. int show_dos, ljmp, count;
  231. char *m1;
  232. {
  233.    char **mp, fullmsg[SCREEN_COLS*2+1];
  234.  
  235.    /* create one string from callers strings */
  236.  
  237.    mp = &m1;                           /* variable # arguments, point to 1st */
  238.    *fullmsg = '\0';                    /* clear full msg area */
  239.  
  240.    for ( ; count; count--, mp++)       /* concat each char string */
  241.       strcat(fullmsg,*mp);
  242.  
  243.    /* if caller wants DOS msg, include that too */
  244.  
  245.    if (show_dos && errno <= sys_nerr)
  246.       strcat(fullmsg,sys_errlist[errno]);
  247.  
  248.    makbox(FIRST_NROW+4,"",fullmsg,0,esc2cont);  /* create dialog box with msg */
  249.    setvattrib(DIS_NORM);
  250.  
  251.    beep();                             /* make sure user is awake */
  252.    while (getchr() != 27) ;            /* wait for an ESC */
  253.  
  254.    kilbox();                           /* remove the dialog box */
  255.  
  256.    if (ljmp)                           /* longjmp back to main if a longjmp */
  257.       longjmp(back_to_main,ljmp);      /*   code was given */
  258. }
  259.  
  260.  
  261. /*****************************************************************************
  262.                              M A K B O X
  263.  *****************************************************************************/
  264.  
  265. static int ALTCALL
  266. makbox(frow,title,msg,rlen,lastmsg)    /* make a dialog box on the screen */
  267. int frow, rlen;
  268. char *msg, *title, *lastmsg;
  269. {
  270.    register int i;
  271.    int lm, ll, llr, rl = 0;
  272.  
  273.    box_row = frow;                     /* save starting row # */
  274.  
  275.    /* determine the number of rows/cols and start column for the dialog box */
  276.  
  277.    box_rows = 5;
  278.    if ((i = rlen + (lm = strlen(msg))) > SCREEN_COLS - 4) {
  279.       box_rows += 2;
  280.       i = rl = lm > rlen ? lm : rlen;  /* when rl is NZ, reply on sep line */
  281.    }
  282.  
  283.    if (ll = strlen(lastmsg)) {         /* is a last line msg specified? */
  284.       box_rows += 2;
  285.       i = ll > i ? ll : i;
  286.       llr = box_row + box_rows - 2;
  287.    }
  288.  
  289.    box_cols = i + 4;
  290.    box_col = (SCREEN_COLS - box_cols) >> 1;
  291.  
  292.    /* popup the dialog box and display prompt string */
  293.  
  294.    boxsave = (char *) Malloc(box_rows * box_cols * 2);
  295.  
  296.    setvattrib(DIS_BOX);
  297.    popup(frow,box_col,box_rows,box_cols,boxsave);
  298.  
  299.    if (strlen(title)) {                   /* display box title if any */
  300.       disp_char_at(' ',frow,box_col+2);
  301.       disp_str(title);
  302.       disp_char(' ');
  303.    }
  304.  
  305.    disp_str_at(msg,box_row+2,box_col+2);  /* display prompt string */
  306.  
  307.    if (ll)                                /* display last line msg if any */
  308.       disp_str_at(lastmsg,llr,(SCREEN_COLS - ll) >> 1);
  309.  
  310.    reply_row = box_row + 2;               /* display row containing the reply */
  311.    reply_col = box_col + 2 + lm;          /* display col where reply starts */
  312.  
  313.    if (rl) {                           /* adjust reply area address if */
  314.       reply_row += 2;                  /*   more than one line is being used */
  315.       reply_col = box_col + 2;
  316.    }
  317.  
  318.    gotorc(reply_row,reply_col);        /* position at reply area */
  319.  
  320.    if (rlen) {
  321.       setvattrib(DIS_HIBOX);           /* display the reply field in hilite */
  322.       disp_rep(' ',rlen);              /* so user knows how big is is */
  323.       gotorc(reply_row,reply_col);     /* return to start of reply area */
  324.    }
  325. }
  326.  
  327.  
  328. /*****************************************************************************
  329.                             K I L B O X
  330.  *****************************************************************************/
  331.  
  332. static int ALTCALL
  333. kilbox() {             /* remove that dialog box that makbox() built */
  334.  
  335.    popdwn(box_row,box_col,box_rows,box_cols,boxsave);    /* nothing to it */
  336.    free(boxsave);
  337. }
  338.