home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 200-299 / ff254.lzh / Etale / txttw.c < prev    next >
C/C++ Source or Header  |  1989-10-19  |  11KB  |  369 lines
  1. /*  txttw.c  -- (part of efr)  Copyright © 1989 by William F. Hammond  */
  2. /*           --  the efr window manager                                */
  3. #ifndef TDM_H
  4. #include "tdm.h"
  5. #endif
  6. /*********************************************************************/
  7. SHORT txttw()   /*  return 0 to quit main  */
  8. {
  9. register LONG idff;
  10. register int ichtx;
  11. static UBYTE promptstring[] =
  12. " <sp>:page+, q:quit, <cr>:line+, b:page-, sN:skip N pp, gN:go to line N ";
  13. static UBYTE goprompt[] =
  14. " n:next(pr), c:stop(pr), q:quit, b:page-, sN:skip N pp, gN:go to line N ";
  15. static UBYTE stdinprompt[] =
  16. " <sp>:page+, q:quit, <cr>:line+, sN:skip N pp, gN:go to line N          ";
  17. static UBYTE endstring[] =
  18. " File End -- q:quit,  b:page-,  sN:skip N pp if N < 0,  gN:go to line N ";
  19. static UBYTE stdinend[] =
  20. " File End -- q:quit  (sorry -- cannot back up \"standard input\")         ";
  21. static UBYTE eofstring[] = " End of File ";
  22. UBYTE chtxt, ltbuf[2][12]; 
  23. struct LinePart *lp;
  24. struct IntuiMessage *msg;
  25. LONG askline, mwwidth, mwheight, difflines, skiplines, tpline;
  26. LONG pnum, pvmode;
  27. ULONG dmax, pagesize, pvstyle;
  28. UWORD scrollsize;
  29. WORD skippages;
  30. SHORT rowpix, txj;
  31. int sltxb;
  32. BYTE letmeback;
  33. UBYTE gtch, prflag;
  34. UBYTE *cgdstr;
  35. rowpix = (SHORT)rp->TxBaseline;
  36. mwwidth = (LONG)(mw->Width);
  37. mwheight = (LONG)(mw->Height);
  38. SetAPen(rp, 1L);
  39. SetBPen(rp, 0L);
  40. SetDrMd(rp, (LONG)JAM2);
  41. Move(rp, 0L, 0L);
  42. ClearScreen(rp);
  43. drawmode = (LONG)JAMX;
  44. pvmode = drawmode;
  45. SetDrMd(rp, drawmode);
  46. style = (ULONG)FS_NORMAL;
  47. pvstyle = style;
  48. savestyle = SetSoftStyle(rp, style, enable);
  49. dmax = (ULONG)(maxline -1);
  50. screenline = 0;
  51. skippages = 0;
  52. difflines = golinem - txtline;
  53. difflines --;
  54. idff = 0L;
  55. if(idff < difflines)
  56.    while( ( ichtx = getc(stream) ) != EOF )
  57.       {
  58.       if(ichtx==0x0a)
  59.          {
  60.          idff ++;
  61.          if(idff >= difflines) break;
  62.          }
  63.       }
  64. txtline = txtline + idff;
  65. letmeback = NULB;
  66. if(txtline == 0) strcpy(pvstr, "");
  67. while(1) /******  perpetual loop dependent on user directions  ******/
  68. {
  69. while( (bfgets(instr, MAXSTRLN+1, stream) != NULL) || (letmeback) )
  70.    {
  71.    instr[MAXSTRLN] = '\0';
  72.    screenline ++;
  73.    txtline ++;
  74.    if(letmeback)
  75.       {
  76.       if(linesize) txtline = MIN(txtline, linesize);
  77.       strcpy(instr, eofstring);
  78.       if(letmeback <= 2) letmeback ++;
  79.       }
  80.    /*  Compute the screenline -- either set it or return  */
  81.    while ( (screenline > maxline) || (letmeback >= 3) )
  82.       {
  83.       skippages = 0;
  84.       if( (tflag) && !(letmeback) )    /*****    time to "type"    *****/
  85.          {
  86.          chtxt = 't';   /*  This pre-empts the other cases  */
  87.          gtch = NULB;
  88.          while(msg = (struct IntuiMessage *)GetMsg(mw->UserPort))
  89.             {
  90.             if(msg->Class == VANILLAKEY) gtch = (UBYTE)msg->Code;
  91.             ReplyMsg(msg);
  92.             }
  93.          if(gtch == CTRL_C)           /*  Ctrl-C signal to quit  */ 
  94.             {
  95.             return 0;
  96.             }
  97.          if(gtch)           /*  This is a pause request -- no prompt  */
  98.             {
  99.             gtch = NULB;
  100.             while(!gtch)
  101.                {
  102.                Wait(1L << mw->UserPort->mp_SigBit);
  103.                
  104.                while(msg = (struct IntuiMessage *)GetMsg(mw->UserPort))
  105.                   {
  106.                   if(msg->Class == VANILLAKEY) gtch = (UBYTE)msg->Code;
  107.                   ReplyMsg(msg);
  108.                   }
  109.                }
  110.             if(gtch == CTRL_C) return 0;
  111.             if(gtch == 'x')    /*  Exit from scrolling mode  */
  112.                {
  113.                tflag = NULB;
  114.                }
  115.             gtch = NULB;
  116.             }
  117.          if(tflag)
  118.             {
  119.             scrollsize = rp->TxHeight;
  120.             ScrollRaster(rp, 0L, (LONG)scrollsize,
  121.                              0L, 0L, mwwidth, mwheight);
  122.             screenline --;
  123.             }
  124.          }
  125.       if(letmeback)      /*  Choose prompt string  */
  126.          {
  127.          if( (linesize) && (linesize < golinem) )
  128.             {
  129.             golinet = (LONG)(linesize - ((ULONG)maxline) + 1L);
  130.             return 1;
  131.             }
  132.          cgdstr = endstring;
  133.          if(stream == stdin) cgdstr = stdinend;
  134.          }
  135.       else
  136.          {
  137.          cgdstr = promptstring;
  138.          if(gflag) cgdstr = goprompt;
  139.          if(stream == stdin) cgdstr = stdinprompt;
  140.          }
  141.       tpline = txtline - (LONG)screenline + 1L;  /* line at top of screen */
  142.       if(letmeback >=2) tpline = tpline - 1L + (LONG)letmeback;
  143.       if( (letmeback) || !(tflag) )   /*  Put prompt together  */
  144.          {
  145.          pnum = txtline - 1L;
  146.          if( (txtline==linesize) && (letmeback >= 2) )
  147.             pnum = txtline;
  148.          if(linesize) pnum = (100L * pnum)/linesize;
  149.          strcpy(errstr, " ");
  150.          ltoa(ltbuf[0], pnum, 10);
  151.          strcat(errstr, ltbuf[0]);
  152.          if(linesize) strcat(errstr, "%");
  153.          sltxb = strlen(errstr);
  154.          txj = (SHORT)(8 - sltxb);
  155.          while(txj > 0)
  156.             {
  157.             errstr[sltxb] = ' ';
  158.             sltxb ++;
  159.             txj --;
  160.             }
  161.          errstr[sltxb] = '\0';
  162.          strcat(errstr, cgdstr);
  163.          askline = 0L;
  164.          chtxt = getdirs(errstr, &skippages);  /***   Ask user   ***/
  165.          if( (chtxt | 0x20) == 't')
  166.             {
  167.             if(letmeback >=3) return 0;
  168.             tflag = ONEB;
  169.             letmeback = NULB;
  170.             /* new */
  171.             askline = tpline;
  172.             chtxt = 'g';
  173.             }
  174.          }
  175.       if ( (chtxt | 0x20) == 'q') return 0;
  176.       if ( (chtxt | 0x20) == 'c') gflag = NULB;  /* need more directions  */
  177.       if (chtxt == '<')
  178.          {
  179.          askline = 1L;
  180.          chtxt = 'g';
  181.          }
  182.       if (chtxt == '>')
  183.          {
  184.          if(letmeback >= 3) return 0;
  185.          if(!(linesize))
  186.             {
  187.             if (filearg == NULL)
  188.                {
  189.                tflag = ONEB;
  190.                letmeback = NULB;
  191.                askline = tpline;
  192.                chtxt = 'g';
  193.                }
  194.             else
  195.                {
  196.                askline = LINETOOBIG;
  197.                chtxt = 'g';
  198.                }
  199.             }
  200.          if(linesize)
  201.             {
  202.             askline = (LONG)(linesize - ((ULONG)maxline) + 1L);
  203.             if (askline <= 0L) askline = 1L;
  204.             chtxt = 'g';
  205.             }
  206.          }
  207.       if ( ( (chtxt | 0x20) == 'n') && (gflag) )
  208.          {
  209.          golinet = tpline;
  210.          return -1;
  211.          }
  212.       if ( ( (chtxt | 0x20) == 'b') || (chtxt == 0x08) )
  213.          {
  214.          skiplines = (LONG)(maxline);
  215.          skiplines --;
  216.          askline = tpline - skiplines;
  217.          if (askline <= 0L) askline = 1L;
  218.          chtxt = 'g'; 
  219.          }
  220.       if ( (chtxt == 0x0a) || (chtxt == 0x0d) )
  221.          {
  222.          if(letmeback >= 3) return 0;
  223.          askline = tpline;
  224.          askline ++;
  225.          if (askline <= 0L) askline = 1L;
  226.          chtxt = 'g';
  227.          }
  228.       if ( (chtxt == 0x20) || (chtxt == 0xa0) )
  229.          {
  230.          if(letmeback >= 3) return 0;
  231.          if(letmeback == 2)
  232.             {
  233.             askline = tpline;
  234.             askline ++;
  235.             if (askline <= 0L) askline = 1L;
  236.             chtxt = 'g';
  237.             }
  238.          else
  239.             {
  240.             askline = txtline - 1L;
  241.             chtxt = 'g';
  242.             }
  243.          }
  244.       if ( (chtxt | 0x20) == 'u')
  245.          {
  246.          askline = tpline - ( (dmax + 1L)/2L );
  247.          if (askline <= 0L) askline = 1L;
  248.          chtxt = 'g';
  249.          }
  250.       if ( (chtxt | 0x20) == 'd')
  251.          {
  252.          if(letmeback >= 3) return 0;
  253.          askline = tpline + ( (dmax + 1L)/2L);
  254.          chtxt = 'g';
  255.          }
  256.       if ( (chtxt | 0x20) == 'g')
  257.          {
  258.          if(!askline)              /*  get askline from user  */
  259.             {
  260.             strcpy(errstr, " ");
  261.             ltoa(ltbuf[0], tpline, 10);
  262.             errsp[0] = ltbuf[0];
  263.             errsp[1] = (UBYTE *)"-";
  264.             pnum = txtline - 1L;
  265.             if( (txtline==linesize) && (letmeback >= 2) )
  266.                pnum = txtline;
  267.             ltoa(ltbuf[1], pnum, 10);
  268.             errsp[2] = ltbuf[1];
  269.             for(txj = 0; txj < 3; txj ++) strcat(errstr, errsp[txj]);
  270.             sltxb = strlen(errstr);
  271.             errstr[sltxb] = '/';
  272.             sltxb ++;
  273.             errstr[sltxb] = '\0';
  274.             if(!linesize)
  275.                {
  276.                errstr[sltxb] = '?';
  277.                sltxb ++;
  278.                errstr[sltxb] = '\0';
  279.                }
  280.             if(linesize)
  281.                {
  282.                ltoa(ltbuf[0], linesize, 10);
  283.                strcat(errstr, ltbuf[0]);
  284.                }
  285.             strcat(errstr, ":  Go to line > ");
  286.             askline = numget(errstr);
  287.             }
  288.          if (askline <= 0L)
  289.             {
  290.             golinet = 1L;
  291.             return 5;
  292.             }
  293.          else if (askline < tpline)
  294.             {
  295.             golinet = askline;     /*  rewind file  */
  296.             return 5;
  297.             }
  298.          else if (askline <= txtline)
  299.             {
  300.             Move(rp, 0L, (LONG)maxrowpix);
  301.             SetDrMd(rp, (LONG)JAM2);        /*  really clear out the prompt   */
  302.             ClearScreen(rp);
  303.             Move(rp, 0L, (LONG)rowpix); /*  re-write the last line in     */
  304.             drawmode = pvmode;          /*  case its subs were scratched  */
  305.             SetDrMd(rp, drawmode);
  306.             style = pvstyle;
  307.             savestyle = SetSoftStyle(rp, style, enable);
  308.             lp = parseline(pvstr, NULL);
  309.             writeline(lp);
  310.             scrollsize = (rp->TxHeight)*( (UWORD)(askline - tpline) );
  311.             ScrollRaster(rp, 0L, (LONG)scrollsize,
  312.                              0L, 0L, mwwidth, mwheight);
  313.             screenline = screenline - ( (UWORD)(askline - tpline) );
  314.             }
  315.          else
  316.             {
  317.             if(letmeback >=3) return 0;
  318.             golinet = askline;     /*  advance without scroll  */
  319.             return 5;
  320.             }
  321.          }
  322.       if ( (chtxt | 0x20) == 's')
  323.          {
  324.          skiplines = (LONG)(skippages * (maxline - 1));
  325.          if (skiplines > 0)
  326.             {
  327.             if(letmeback) return 0;
  328.             skiplines --;
  329.             }
  330.          else skiplines = skiplines - (LONG)maxline;
  331.          golinet = txtline + skiplines;
  332.          return 6;
  333.          }
  334.       }     /*  loop while (screenline > maxline)  */
  335.    rowpix = (screenline * rp->TxHeight) - rp->TxHeight + rp->TxBaseline;
  336.    Move(rp, 0L, (LONG)rowpix);
  337.    /*  Now rowpix is set.              */
  338.    /*  How must this string be cut up? */
  339.    strcpy(pvstr, instr);  /*  save this line in case it is overwritten  */
  340.    pvstyle = style;
  341.    pvmode = drawmode;
  342.    lp = parseline(instr, NULL);       /*  lp = pointer to first LinePart  */
  343.    writeline(lp);
  344.    }     /*****  loop(bfgets(instr)) *****/
  345. letmeback ++;
  346. tflag = NULB;
  347. prflag = NULB;
  348. if (!(linesize))
  349.       {
  350.       linesize = (ULONG)txtline;  /*  only setting of linesize  */
  351.       pagesize = ( (linesize << 1) + dmax)/(dmax << 1);
  352.       prflag = ONEB;
  353.       }
  354. if(prflag)
  355.    {
  356.    ltoa(ltbuf[0], linesize, 10);
  357.    strcpy(errstr, ltbuf[0]);
  358.    errsp[0] = (UBYTE *)" lines, approx. ";
  359.    ltoa(ltbuf[1], pagesize, 10);
  360.    errsp[1] = ltbuf[1];
  361.    errsp[2] = (UBYTE *)" screen pages\xa";
  362.    for(txj = 0; txj < 3; txj ++) strcat(errstr, errsp[txj]);
  363.    fputs(errstr, stdout);
  364.    }
  365. if ( (linesize < golinem) && (letmeback == 1) ) letmeback =2;
  366. }            /*  end of perpetual loop  */
  367. return 0;    /*  never used             */
  368. }
  369.