home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / math / pac / ledit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-05  |  7.0 KB  |  242 lines
  1. /* ledit.c */
  2. /**********************************************************************
  3. *    File Name     : ledit.c
  4. *    Function      : line (window) editor of pac
  5. *    Author        : Istvan Mohos, 1987
  6. ***********************************************************************/
  7.  
  8. #include "defs.h"
  9.  
  10. ledit(retbuf,Map,line_y,lbound,rbound,video,stripspace,intact)
  11. char *retbuf, *Map;
  12. int line_y, lbound, rbound, video, stripspace, intact;
  13. {
  14.     char c;
  15.     register int ri;
  16.     int rj;
  17.     int lchar, rchar;
  18.     int tbound, bbound;
  19.     int control = 1, retval = 0, first = 1;
  20.     int insert = 0;
  21.     char *rp;
  22.     static char *fid = "ledit";
  23.  
  24.     _TR
  25.  
  26.     if (line_y) {
  27.         CY = tbound = bbound = line_y;
  28.         CX = lbound;
  29.     }
  30.     else {
  31.         /* calculator window */
  32.         CY = tbound = UTOP;
  33.         bbound = UBOT;
  34.         CX = ULEFT;
  35.     }
  36.         
  37.     move(CY, CX);
  38.     pfresh();
  39.  
  40.     while(control) {
  41.         c = fgetc(stdin) & 127;
  42.         if (c == 10 || c == 13)
  43.             break;
  44.         if (c == 17 || c == 19)
  45.             continue;
  46.         if (!intact && first && c > 31) {
  47.             standout();
  48.             mvaddstr(MSG, MSGLEFT, Sp34); /* clear any error messages */
  49.             standend();
  50.             first = 0;
  51.             if (line_y)
  52.                 clear_wline(tbound, lbound, rbound, video, 1);
  53.             else
  54.                 clear_wline(UTOP, lbound, rbound, video, 3);
  55.         }
  56.  
  57.         if (video)
  58.             standout();
  59.         switch(*(Map+c)) {
  60.  
  61.             default:                /* do nothing */
  62.             case 0:
  63.                 break;
  64.  
  65.             case 1:                 /* exit */
  66.                 go_away(ZERO, 0);
  67.  
  68.             case 2:                 /* addch */
  69.                 if (insert) {
  70.                     for (rj = bbound; rj >= CY + 1; rj--) {
  71.                         for (ri = rbound; ri >= lbound + 1; ri--)
  72.                             mvaddch(rj, ri, stdscr->_y[rj][ri - 1]);
  73.                         mvaddch(rj, ri, stdscr->_y[rj - 1][rbound]);
  74.                     }
  75.                     for (ri = rbound; ri >= CX + 1; ri--)
  76.                         mvaddch(CY, ri, stdscr->_y[CY][ri - 1]);
  77.                 }
  78.                 mvaddch(CY,CX,c);
  79.                 if(++CX > rbound)
  80.                     if (++CY <= bbound)
  81.                         CX = lbound;
  82.                     else {
  83.                         --CY;
  84.                         --CX;
  85.                     }
  86.                 move(CY,CX);
  87.                 break;
  88.  
  89.             case 21:                /* ignore to EOL */
  90.                 while((c = fgetc(stdin) & 127) != 10 && c != 13);
  91.                 ungetc(c, stdin);
  92.                 break;
  93.  
  94.             case 3:                 /* move left */
  95.                 if (--CX < lbound)
  96.                     ++CX;
  97.                 move(CY, CX);
  98.                 break;
  99.  
  100.             case 4:                 /* move right */
  101.                 if (++CX > rbound)
  102.                     --CX;
  103.                 move(CY, CX);
  104.                 break;
  105.  
  106.             case 13:                /* move up */
  107.                 if (--CY < tbound)
  108.                     ++CY;
  109.                 move(CY, CX);
  110.                 break;
  111.  
  112.             case 14:                /* move down */
  113.                 if (++CY > bbound)
  114.                     --CY;
  115.                 move(CY, CX);
  116.                 break;
  117.  
  118.             case 15:                /* move down and left */
  119.                 if (++CY <= bbound)
  120.                     CX = lbound;
  121.                 else
  122.                     --CY;
  123.                 move(CY, CX);
  124.                 break;
  125.  
  126.             case 7:                 /* clear; exit */
  127.                 clearstack(0);
  128.                 Amt = Rate = Years = 0.;
  129.                 go_away("I", 0);
  130.  
  131.             case 8:                 /* wants parent to pop */
  132.                 retval = 1;
  133.                 control = 0;
  134.                 break;
  135.  
  136.             case 9:                 /* wants parent to push */
  137.                 retval = 2;
  138.                 control = 0;
  139.                 break;
  140.  
  141.             /* give back last c, read buffer */
  142.             case 12:
  143.                 retval = c;
  144.                 control = 0;
  145.                 break;
  146.  
  147.             /* give back last c, skip buffer */
  148.             case 17:
  149.                 pfresh();
  150.                 TR_
  151.                 return(c);
  152.  
  153.             case 10:                /* fill to eol with spaces */
  154.                 for (ri = CX; ri <= rbound; ri++)
  155.                     addch(' ');
  156.                 for (rj = tbound + 1; rj <= bbound; rj++) {
  157.                     move(rj, lbound);
  158.                     for (ri = CX; ri <= rbound; ri++)
  159.                         addch(' ');
  160.                 }
  161.                 move(CY,CX);
  162.                 break;
  163.  
  164.             /* curr line: delete char and move 1 pos to left */
  165.             case 11:
  166.                 for (ri = CX + 1; ri <= rbound; ri++)
  167.                     addch(stdscr->_y[CY][ri]);
  168.                 addch(' ');
  169.                 if (--CX < lbound)
  170.                      ++CX;
  171.                 move(CY,CX);
  172.                 break;
  173.  
  174.             /* across lines: delete char and move 1 pos to left */
  175.             case 16:
  176.                 for (ri = CX + 1; ri <= rbound; ri++)
  177.                     addch(stdscr->_y[CY][ri]);
  178.                 for (rj = CY + 1; rj <= bbound; rj++) {
  179.                     addch(stdscr->_y[rj][lbound]);
  180.                     move(rj, lbound);
  181.                     for (ri = lbound + 1; ri <= rbound; ri++)
  182.                         addch(stdscr->_y[rj][ri]);
  183.                 }
  184.                 addch(' ');
  185.                 if (--CX < lbound)
  186.                      ++CX;
  187.                 move(CY,CX);
  188.                 break;
  189.  
  190.             case 18 :
  191.                 clearok(curscr, TRUE);
  192.                 break;                /* ^R redraw */
  193.  
  194.             case 19 :
  195.                 insert = 1;
  196.                 break;
  197.  
  198.             case 20 :
  199.                 insert = 0;
  200.                 break;
  201.         }
  202.         standend();
  203.         pfresh();
  204.     }
  205.  
  206.     rp = retbuf; 
  207.     if (stripspace) { /* single line implementation only */
  208.         /* find first non-space from the left */
  209.         for (ri = lbound; ri <= rbound; ri++)
  210.             if ((stdscr->_y[CY][ri] & 127) > 32)
  211.                 break;
  212.         if ((lchar = ri) > rbound) {
  213.             *rp = '\0';
  214.             pfresh();
  215.             TR_
  216.             return(retval);
  217.         }
  218.     
  219.         /* find first non-space from the right */
  220.         for (ri = rbound; ri >= lbound; ri--)
  221.             if ((stdscr->_y[CY][ri] & 127) > 32)
  222.                 break;
  223.         rchar = ri;
  224.     
  225.         /* give back everything in between */
  226.         for (ri = lchar; ri <= rchar; ri++)
  227.                 *rp++ = stdscr->_y[CY][ri] & 127;
  228.     }
  229.     else
  230.         for (rj = tbound; rj <= bbound; rj++)
  231.             for (ri = lbound; ri <= rbound; ri++)
  232.                 *rp++ = stdscr->_y[rj][ri] & 127;
  233.     *rp = '\0';
  234.     pfresh();
  235.  
  236.     if (Trace && Tf != NULL)
  237.         fprintf(Tf, "[%s]\n", retbuf);
  238.     TR_
  239.     return(retval);
  240. }
  241.  
  242.