home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / gnu / djgpp / contrib / windows / src / getstr.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-24  |  7.5 KB  |  301 lines
  1. /**********************************************************************
  2.  *  
  3.  *  NAME:           getstr.cpp
  4.  *  
  5.  *  DESCRIPTION:    getstr() etc functions for window lib
  6.  *  
  7.  *  copyright (c) 1987-90 J. Alan Eldridge
  8.  * 
  9.  *  M O D I F I C A T I O N   H I S T O R Y
  10.  *
  11.  *  when        who                 what
  12.  *  -------------------------------------------------------------------
  13.  *  09/05/90    J. Alan Eldridge    created from wgetstr.c (UWin v. 3.10)
  14.  *  
  15.  *  09/06/90    JAE                 limited to one line on screen
  16.  *  
  17.  *  11/29/90    JAE                 modified from UWin++ 1.0
  18.  *
  19.  *********************************************************************/
  20.  
  21. #include    "w.h"
  22.  
  23. //  local defines
  24.  
  25. #define ONE_LINE_ONLY   1       //  string input doesn't line wrap
  26. #define GETSTR_MAX      512     //  buffer size for egetstr()
  27.  
  28. //  default character validation function
  29.  
  30. static int
  31. ok(int c)
  32. {
  33.     return TRUE;
  34. }
  35.  
  36. //  replace one char with another
  37.  
  38. static void
  39. replace(
  40.     uchar   *pStr,
  41.     uchar   srch,
  42.     uchar   rep)
  43. {
  44.     while (pStr = strchr(pStr, srch))
  45.         *pStr++ = rep;
  46. }            
  47.  
  48. int
  49. basewin::editfld(
  50.     uchar   *pBuf,
  51.     int     bMax,
  52.     int     *pTermKeys,
  53.     int     eFlags,
  54.     int     (*OKFunc)(int c),
  55.     int     fillChr)
  56. {
  57.     int     c;
  58.     int     bLen;
  59.     int     ins     =   TRUE;
  60.     int     bPos    =   0;
  61.     int     y, x;
  62.     int     errBeep =   !(eFlags & noErrBeep);
  63.     uchar   *cp;
  64.     
  65.     static int  nlESC[] = { K_NL, K_ESC, K_ILLEGAL };
  66.  
  67. #if ONE_LINE_ONLY
  68.     //  limit to one line of window
  69.     
  70.     if (bMax > xLR - xCur + 1) {
  71.         bMax = xLR - xCur + 1;
  72.         pBuf[bMax] = 0;
  73.     }
  74. #endif
  75.  
  76.     cp = pBuf + (bLen = strlen(pBuf));
  77.  
  78.     //  check for defaults
  79.     
  80.     if (!OKFunc) OKFunc = ok;
  81.     if (!pTermKeys) pTermKeys = nlESC;
  82.     
  83.     //  pad or trim string as necessary
  84.  
  85.     if ((eFlags & trimStr) || fillChr != ' ') {
  86.         while (bLen > 0 && cp[-1] == ' ') {
  87.             bLen--; 
  88.             *--cp = 0;
  89.         }
  90.     }
  91.  
  92.     if ((eFlags & expandStr) && bLen < bMax) {
  93.         while (bLen < bMax) {
  94.             bLen++;
  95.             *cp++ = fillChr;
  96.         }
  97.         *cp = 0;
  98.     }
  99.  
  100.     getpos(y, x);
  101.     put(pBuf);
  102.     setpos(y, x);
  103.     refresh();
  104.     
  105.     while (!findkey(pTermKeys, c = getkey())) {
  106.  
  107.         //  check for field auto-exit (data entry forms...)
  108.  
  109.         if ((eFlags & autoTab) == autoTab) {
  110.             if (((c == K_RIGHT || c == ' ') && bPos == bMax) || c == K_TAB
  111.                     || c == K_NL)
  112.                 return K_TAB;
  113.             else if (((c == K_LEFT || c == K_BACK) && !bPos) || c == K_BACKTAB)
  114.                 return K_BACKTAB;
  115.         } 
  116.  
  117.         //  try to process a self-insert character
  118.         
  119.         if (isascii(c) && isprint(c) && OKFunc(c)) {
  120.             if (eFlags & zapField) {
  121.                 int     y, x, f;
  122.                 
  123.                 while (bPos > 0) {
  124.                     bPos--;
  125.                     BS();
  126.                 }
  127.                 getpos(y, x);
  128.                 f = (eFlags & expandStr) ? fillChr : 0;
  129.                 while (bLen > 0) {
  130.                     pBuf[--bLen] = f;
  131.                     put(fillChr);
  132.                 }
  133.                 if (eFlags & expandStr)
  134.                     bLen = bMax;
  135.                 setpos(y, x);
  136.             }
  137.             if (bPos >= bLen) {
  138.                 if (bLen < bMax) {
  139.                     pBuf[bLen++] = c;
  140.                     pBuf[++bPos] = 0;
  141.                     put(c);
  142.                 } else if (errBeep) {
  143.                     beep();
  144.                 }
  145.             } else if (ins) {
  146.                 if (bLen < bMax || (bLen == bMax && pBuf[bLen-1] == fillChr)) {
  147.                     int     n, y, x;
  148.  
  149.                     for (n = bLen - (bLen >= bMax); n > bPos; n--)
  150.                         pBuf[n] = pBuf[n - 1];
  151.                     put(pBuf[bPos] = c);
  152.                     if (bLen < bMax)
  153.                         pBuf[++bLen] = 0;
  154.                     getpos(y, x);
  155.                     put(pBuf + (++bPos));
  156.                     setpos(y, x);
  157.                 } else if (errBeep) {
  158.                     beep();
  159.                 }
  160.             } else {
  161.                 put(pBuf[bPos++] = c);
  162.             }
  163.             refresh();
  164.             eFlags &= ~zapField;
  165.             continue;   //  done with self-insert char
  166.         }
  167.  
  168.         //  it's either an editing char or illegal
  169.         
  170.         switch (c) {
  171.         case K_LEFT:
  172.             if (bPos > 0) {
  173.                 bPos--;
  174.                 BS();
  175.             } else if (errBeep) {
  176.                 beep();
  177.             }
  178.             break;
  179.         case K_RIGHT:
  180.             if (bPos < bLen) {
  181.                 bPos++;
  182.                 put(get());
  183.             } else if (errBeep) {
  184.                 beep();
  185.             }
  186.             break;
  187.         case K_HOME:
  188.             while (bPos > 0) {
  189.                 bPos--;
  190.                 BS();
  191.             }
  192.             break;
  193.         case K_END:
  194.             while (bPos < bLen) {
  195.                 bPos++;
  196.                 put(get());
  197.             }
  198.             break;
  199.         case K_INS:
  200.             ins = !ins;
  201.             break;
  202.         case K_CTLX:
  203.             //  ctl-x cancels the entire line (unix)
  204.             {
  205.                 int     y, x, f;
  206.  
  207.                 while (bPos > 0) {
  208.                     bPos--;
  209.                     BS();
  210.                 }
  211.                 f = (eFlags & expandStr) ? fillChr : 0;
  212.                 getpos(y, x);
  213.                 while (bLen > 0) {
  214.                     pBuf[--bLen] = f;
  215.                     put(fillChr);
  216.                 }
  217.                 if (eFlags & expandStr)
  218.                     bLen = bMax;
  219.                 setpos(y, x);
  220.             }
  221.             break;
  222.         case K_BS:
  223.         case K_DEL:
  224.             if (c == K_BS)
  225.                 if (bPos > 0) {
  226.                     bPos--;
  227.                     BS();
  228.                 } else {
  229.                     if (errBeep)
  230.                         beep();
  231.                     break;
  232.                 }
  233.             if (bPos < bLen && bLen > 0) {
  234.                 int     p, y, x;
  235.  
  236.                 for (p = bPos; p < bLen-1; p++)
  237.                     pBuf[p] = pBuf[p+1];
  238.                 pBuf[p] = fillChr;
  239.                 getpos(y,x);
  240.                 put(pBuf+bPos);
  241.                 setpos(y,x);
  242.                 if (eFlags & trimStr) {
  243.                     pBuf[p] = 0;
  244.                     bLen--;
  245.                 }
  246.             } else if (errBeep) {
  247.                 beep();
  248.             }
  249.             break;
  250.         default:
  251.             if (errBeep)
  252.                 beep();
  253.             break;
  254.         }
  255.  
  256.         refresh();
  257.         eFlags &= ~zapField;
  258.     }
  259.  
  260.     if (fillChr != ' ')
  261.         replace(pBuf, fillChr, ' ');
  262.         
  263.     if (eFlags & trimStr) {
  264.         while (bLen > 0 && pBuf[bLen-1] == ' ')
  265.             pBuf[--bLen] = 0;
  266.     }
  267.  
  268.     setpos(y, x);
  269.     put(pBuf);
  270.  
  271.     return c;
  272. }
  273.  
  274. int
  275. basewin::egetstr(
  276.     uchar   *pBuf)
  277. {
  278.     static int  nl[] = { K_NL, K_ILLEGAL };
  279.  
  280.     int     retVal;
  281.     char    bufLocal[GETSTR_MAX];
  282.     
  283.     strncpy(bufLocal, pBuf, GETSTR_MAX);
  284.     bufLocal[GETSTR_MAX-1] = 0;
  285.     retVal = editfld(bufLocal, GETSTR_MAX-1, nl, trimStr, ok);
  286.     strcpy(pBuf, bufLocal);
  287.     if (retVal == K_NL) {
  288.         NL();
  289.         refresh();
  290.     }
  291.     return retVal;
  292. }
  293.     
  294. int
  295. basewin::getstr(
  296.     uchar   *pBuf)
  297. {
  298.     pBuf[0] = 0;
  299.     return egetstr(pBuf);
  300. }            
  301.