home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / term43-source.lha / Extras / Source / term-Source.lha / termReviewBuffer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-07  |  35.4 KB  |  1,834 lines
  1. /*
  2. **    termReviewBuffer.c
  3. **
  4. **    Support routines for the review buffer
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* Handy signal masks. */
  13.  
  14. #define SIG_REVIEWPORT        (1L << ReviewPort -> mp_SigBit)
  15. #define SIG_REVIEWWINDOW    (1L << ReviewWindow -> UserPort -> mp_SigBit)
  16.  
  17.     /* Menu item codes. */
  18.  
  19. enum    {    MEN_SEARCH,MEN_REPEAT,MEN_CLEARBUF,MEN_QUITBUF };
  20.  
  21.     /* Gadget ID codes. */
  22.  
  23. enum    {    GAD_SCROLLER, GAD_UP, GAD_DOWN };
  24.  
  25. STATIC struct NewMenu ReviewMenu[] =
  26. {
  27.     { NM_TITLE, NULL,         0 , 0, 0, (APTR)0},
  28.     {  NM_ITEM, NULL,         0 , 0, 0, (APTR)MEN_SEARCH},
  29.     {  NM_ITEM, NULL,         0 , 0, 0, (APTR)MEN_REPEAT},
  30.     {  NM_ITEM, NM_BARLABEL,     0 , 0, 0, (APTR)0},
  31.     {  NM_ITEM, NULL,         0 , 0, 0, (APTR)MEN_CLEARBUF},
  32.     {  NM_ITEM, NM_BARLABEL,     0 , 0, 0, (APTR)0},
  33.     {  NM_ITEM, NULL,         0 , 0, 0, (APTR)MEN_QUITBUF},
  34.  
  35.     { NM_END, 0,             0 , 0, 0, (APTR)0}
  36. };
  37.  
  38.     /* Local routines. */
  39.  
  40. STATIC VOID        ReviewUpdatePot(VOID);
  41. STATIC VOID __stdargs    ReviewWrites(STRPTR String,...);
  42. STATIC VOID __regargs     PrintReviewLine(STRPTR Buffer,LONG Line);
  43. STATIC VOID __regargs     RefreshReview(LONG Top);
  44. STATIC VOID __regargs    ScrollReview(LONG Top);
  45. STATIC BYTE        ReviewQuery(VOID);
  46. STATIC UBYTE __regargs    GetReviewChar(BYTE WaitForIt);
  47.  
  48.     /* Local variables. */
  49.  
  50. STATIC struct Menu        *ReviewMenuStrip;
  51.  
  52. STATIC struct IBox         ReviewBox = { -1 };
  53. STATIC struct IOStdReq        *ReviewWriteRequest,
  54.                 *ReviewReadRequest;
  55.  
  56. STATIC struct MsgPort        *ReviewPort,
  57.                 *ReviewWritePort;
  58.  
  59. STATIC struct Gadget        *Scroller,
  60.                 *UpArrow,
  61.                 *DownArrow;
  62.  
  63. STATIC UWORD             RightBorderWidth;
  64.  
  65. STATIC struct Image        *UpImage,
  66.                 *DownImage;
  67.  
  68. STATIC UBYTE             ReviewChar;
  69. STATIC LONG             ReviewColumns,ReviewLines,
  70.                  ReviewTop = -1,ReviewGlobalLines;
  71.  
  72. STATIC BYTE             SearchForward    = TRUE,
  73.                  IgnoreCase    = TRUE,
  74.                  WholeWords    = FALSE;
  75.  
  76. STATIC UBYTE            *ReviewLineWidths;
  77. STATIC LONG             ReviewMaxLines;
  78.  
  79. STATIC struct MsgQueue        *ReviewQueue;
  80. STATIC struct Process        *ReviewProcess;
  81.  
  82. STATIC WORD             ReviewPen;
  83. STATIC BYTE             ReviewSignal;
  84.  
  85. STATIC struct TextFont        *LocalFont;
  86. STATIC struct TTextAttr         LocalTextFont;
  87. STATIC UBYTE __far         LocalTextFontName[MAX_FILENAME_LENGTH];
  88.  
  89.     /* ReviewDeleteScroller(VOID):
  90.      *
  91.      *    Delete scroller and arrow buttons.
  92.      */
  93.  
  94. STATIC VOID
  95. ReviewDeleteScroller(VOID)
  96. {
  97.     if(Scroller)
  98.     {
  99.         DisposeObject(Scroller);
  100.  
  101.         Scroller = NULL;
  102.     }
  103.  
  104.     if(UpArrow)
  105.     {
  106.         DisposeObject(UpArrow);
  107.  
  108.         UpArrow = NULL;
  109.     }
  110.  
  111.     if(DownArrow)
  112.     {
  113.         DisposeObject(DownArrow);
  114.  
  115.         DownArrow = NULL;
  116.     }
  117.  
  118.     if(UpImage)
  119.     {
  120.         DisposeObject(UpImage);
  121.  
  122.         UpImage = NULL;
  123.     }
  124.  
  125.     if(DownImage)
  126.     {
  127.         DisposeObject(DownImage);
  128.  
  129.         DownImage = NULL;
  130.     }
  131. }
  132.  
  133.     /* ReviewCreateScroller(struct Screen *Screen):
  134.      *
  135.      *    Create scroller and arrow buttons.
  136.      */
  137.  
  138. STATIC BYTE __regargs
  139. ReviewCreateScroller(struct Screen *Screen)
  140. {
  141.     struct DrawInfo    *DrawInfo;
  142.     BYTE         Result = FALSE;
  143.  
  144.     if(DrawInfo = GetScreenDrawInfo(Screen))
  145.     {
  146.         struct Image    *SizeImage;
  147.         ULONG         SizeWidth,
  148.                  SizeHeight,
  149.                  ArrowHeight;
  150.         UWORD         SizeType;
  151.  
  152.         if(Screen -> Flags & SCREENHIRES)
  153.         {
  154.             SizeWidth    = 18;
  155.             SizeHeight    = 10;
  156.  
  157.             SizeType    = SYSISIZE_MEDRES;
  158.         }
  159.         else
  160.         {
  161.             SizeWidth    = 13;
  162.             SizeHeight    = 11;
  163.  
  164.             SizeType    = SYSISIZE_LOWRES;
  165.         }
  166.  
  167.         if(SizeImage = (struct Image *)NewObject(NULL,"sysiclass",
  168.             SYSIA_Size,    SizeType,
  169.             SYSIA_Which,    SIZEIMAGE,
  170.             SYSIA_DrawInfo,    DrawInfo,
  171.         TAG_DONE))
  172.         {
  173.             GetAttr(IA_Width,    SizeImage,&SizeWidth);
  174.             GetAttr(IA_Height,    SizeImage,&SizeHeight);
  175.  
  176.             DisposeObject(SizeImage);
  177.  
  178.             RightBorderWidth = SizeWidth;
  179.  
  180.             if(UpImage = (struct Image *)NewObject(NULL,"sysiclass",
  181.                 SYSIA_Size,    SizeType,
  182.                 SYSIA_Which,    UPIMAGE,
  183.                 SYSIA_DrawInfo,    DrawInfo,
  184.             TAG_DONE))
  185.             {
  186.                 GetAttr(IA_Height,UpImage,&ArrowHeight);
  187.  
  188.                 if(DownImage = (struct Image *)NewObject(NULL,"sysiclass",
  189.                     SYSIA_Size,    SizeType,
  190.                     SYSIA_Which,    DOWNIMAGE,
  191.                     SYSIA_DrawInfo,    DrawInfo,
  192.                 TAG_DONE))
  193.                 {
  194.                     if(Scroller = NewObject(NULL,"propgclass",
  195.                         GA_ID,        GAD_SCROLLER,
  196.  
  197.                         GA_Top,        Screen -> WBorTop + Screen -> Font -> ta_YSize + 2,
  198.                         GA_RelHeight,    -(Screen -> WBorTop + Screen -> Font -> ta_YSize + 2 + SizeHeight + 1 + 2 * ArrowHeight),
  199.                         GA_Width,    SizeWidth - 8,
  200.                         GA_RelRight,    -(SizeWidth - 5),
  201.  
  202.                         GA_Immediate,    TRUE,
  203.                         GA_FollowMouse,    TRUE,
  204.                         GA_RelVerify,    TRUE,
  205.                         GA_RightBorder,    TRUE,
  206.  
  207.                         PGA_Freedom,    FREEVERT,
  208.                         PGA_NewLook,    TRUE,
  209.                         PGA_Borderless,    TRUE,
  210.  
  211.                         PGA_Visible,    1,
  212.                         PGA_Total,    1,
  213.                     TAG_DONE))
  214.                     {
  215.                         STATIC struct TagItem ArrowMappings[] = { GA_ID,GA_ID,TAG_END };
  216.  
  217.                         if(UpArrow = NewObject(NULL,"buttongclass",
  218.                             GA_ID,        GAD_UP,
  219.  
  220.                             GA_Image,    UpImage,
  221.                             GA_RelRight,    -(SizeWidth - 1),
  222.                             GA_RelBottom,    -(SizeHeight - 1 + 2 * ArrowHeight),
  223.                             GA_Height,    ArrowHeight,
  224.                             GA_Width,    SizeWidth,
  225.                             GA_Immediate,    TRUE,
  226.                             GA_RelVerify,    TRUE,
  227.                             GA_Previous,    Scroller,
  228.                             GA_RightBorder,    TRUE,
  229.  
  230.                             ICA_TARGET,    ICTARGET_IDCMP,
  231.                             ICA_MAP,    ArrowMappings,
  232.                         TAG_DONE))
  233.                         {
  234.                             if(DownArrow = NewObject(NULL,"buttongclass",
  235.                                 GA_ID,        GAD_DOWN,
  236.  
  237.                                 GA_Image,    DownImage,
  238.                                 GA_RelRight,    -(SizeWidth - 1),
  239.                                 GA_RelBottom,    -(SizeHeight - 1 + ArrowHeight),
  240.                                 GA_Height,    ArrowHeight,
  241.                                 GA_Width,    SizeWidth,
  242.                                 GA_Immediate,    TRUE,
  243.                                 GA_RelVerify,    TRUE,
  244.                                 GA_Previous,    UpArrow,
  245.                                 GA_RightBorder,    TRUE,
  246.  
  247.                                 ICA_TARGET,    ICTARGET_IDCMP,
  248.                                 ICA_MAP,    ArrowMappings,
  249.                             TAG_DONE))
  250.                                 Result = TRUE;
  251.                         }
  252.                     }
  253.                 }
  254.             }
  255.         }
  256.  
  257.         FreeScreenDrawInfo(Screen,DrawInfo);
  258.     }
  259.  
  260.     return(Result);
  261. }
  262.  
  263.     /* ReviewUpdatePot():
  264.      *
  265.      *    Update size and position of the scroller gadget.
  266.      */
  267.  
  268. STATIC VOID
  269. ReviewUpdatePot()
  270. {
  271.     if(ReviewGlobalLines)
  272.     {
  273.         SetGadgetAttrs(Scroller,ReviewWindow,NULL,
  274.             PGA_Top,    ReviewTop,
  275.             PGA_Visible,    ReviewLines,
  276.             PGA_Total,    ReviewGlobalLines,
  277.         TAG_DONE);
  278.     }
  279. }
  280.  
  281.     /* ReviewUp(LONG Count):
  282.      *
  283.      *    Move the contents of the review buffer up.
  284.      */
  285.  
  286. STATIC VOID __regargs
  287. ReviewUp(LONG Count)
  288. {
  289.     if(BufferLines)
  290.     {
  291.         if(Count == 1)
  292.         {
  293.             if(ReviewTop)
  294.             {
  295.                 WORD i;
  296.  
  297.                 for(i = ReviewMaxLines - 2 ; i >= 0 ; i--)
  298.                     ReviewLineWidths[i + 1] = ReviewLineWidths[i];
  299.  
  300.                 ReviewTop--;
  301.  
  302.                 ReviewWrites("\33[T");
  303.  
  304.                 ObtainSemaphore(BufferSemaphore);
  305.  
  306.                 PrintReviewLine(BufferLines[ReviewTop],1);
  307.  
  308.                 ReviewUpdatePot();
  309.  
  310.                 ReleaseSemaphore(BufferSemaphore);
  311.             }
  312.         }
  313.         else
  314.         {
  315.             LONG NewTop = ReviewTop;
  316.  
  317.             if(NewTop >= Count)
  318.                 NewTop -= Count;
  319.             else
  320.                 NewTop = 0;
  321.  
  322.             if(NewTop != ReviewTop)
  323.             {
  324.                 ScrollReview(NewTop);
  325.  
  326.                 ReviewUpdatePot();
  327.             }
  328.         }
  329.     }
  330. }
  331.  
  332.     /* ReviewDown(LONG Count):
  333.      *
  334.      *    Move the contents of the review buffer down.
  335.      */
  336.  
  337. STATIC VOID __regargs
  338. ReviewDown(LONG Count)
  339. {
  340.     if(BufferLines)
  341.     {
  342.         if(Count == 1)
  343.         {
  344.             if(ReviewTop + ReviewLines < Lines)
  345.             {
  346.                 LONG Last;
  347.                 WORD i;
  348.  
  349.                 for(i = 0 ; i < ReviewMaxLines - 1 ; i++)
  350.                     ReviewLineWidths[i] = ReviewLineWidths[i + 1];
  351.  
  352.                 ReviewTop++;
  353.  
  354.                 ReviewWrites("\33[S");
  355.  
  356.                 ObtainSemaphore(BufferSemaphore);
  357.  
  358.                 if((Last = ReviewTop + ReviewLines) < Lines)
  359.                     PrintReviewLine(BufferLines[Last],ReviewLines + 1);
  360.  
  361.                 ReviewUpdatePot();
  362.  
  363.                 ReleaseSemaphore(BufferSemaphore);
  364.             }
  365.         }
  366.         else
  367.         {
  368.             LONG NewTop = ReviewTop;
  369.  
  370.             if((NewTop + Count + ReviewLines) > Lines)
  371.             {
  372.                 if((NewTop = Lines - ReviewLines) < 0)
  373.                     NewTop = 0;
  374.             }
  375.             else
  376.                 NewTop += Count;
  377.  
  378.             if(NewTop != ReviewTop)
  379.             {
  380.                 ScrollReview(NewTop);
  381.  
  382.                 ReviewUpdatePot();
  383.             }
  384.         }
  385.     }
  386. }
  387.  
  388.     /* ReviewWrites(STRPTR String,...):
  389.      *
  390.      *    Write a string into the review buffer window.
  391.      */
  392.  
  393. STATIC VOID __stdargs
  394. ReviewWrites(STRPTR String,...)
  395. {
  396.     va_list    VarArgs;
  397.  
  398.     va_start(VarArgs,String);
  399.     VSPrintf(SharedBuffer,String,VarArgs);
  400.     va_end(VarArgs);
  401.  
  402.     ReviewWriteRequest -> io_Command    = CMD_WRITE;
  403.     ReviewWriteRequest -> io_Data        = SharedBuffer;
  404.     ReviewWriteRequest -> io_Length        = -1;
  405.  
  406.     DoIO(ReviewWriteRequest);
  407. }
  408.  
  409.     /* FilterReviewLine(register STRPTR Line,register LONG Length):
  410.      *
  411.      *    Replace non-printable characters in the text line
  412.      *    to be printed.
  413.      */
  414.  
  415.  
  416. STATIC STRPTR __regargs
  417. FilterReviewLine(register STRPTR Line,register LONG Length)
  418. {
  419.     STATIC UBYTE __far ISO[256] =
  420.     {
  421.          46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  422.          46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  423.          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  424.          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  425.          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  426.          80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
  427.          96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
  428.         112,113,114,115,116,117,118,119,120,121,122,123,124,125,126, 46,
  429.          46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  430.          46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  431.         160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
  432.         176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
  433.         192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  434.         208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
  435.         224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
  436.         240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
  437.     };
  438.  
  439.     STATIC UBYTE __far TempBuffer[256];
  440.  
  441.     register STRPTR Destination = TempBuffer;
  442.  
  443.     while(Length--)
  444.         *Destination++ = ISO[*Line++];
  445.  
  446.     return(TempBuffer);
  447. }
  448.  
  449.     /* PrintReviewLine(STRPTR Buffer,LONG Line):
  450.      *
  451.      *    Write the contents of a buffer line into the review buffer window.
  452.      */
  453.  
  454. STATIC VOID __regargs
  455. PrintReviewLine(STRPTR Buffer,LONG Line)
  456. {
  457.     WORD Length = Buffer[-1];
  458.  
  459.     if(Length > ReviewColumns)
  460.         Length = ReviewColumns;
  461.  
  462.     ReviewWrites("\33[%ldH",Line);
  463.  
  464.     ReviewWriteRequest -> io_Command    = CMD_WRITE;
  465.     ReviewWriteRequest -> io_Data        = FilterReviewLine(Buffer,Length);
  466.     ReviewWriteRequest -> io_Length        = Length;
  467.  
  468.     DoIO(ReviewWriteRequest);
  469.  
  470.     if(Length < ReviewLineWidths[Line - 1])
  471.         ReviewWrites("\33[0K");
  472.  
  473.     ReviewLineWidths[Line - 1] = Length;
  474. }
  475.  
  476.     /* RefreshReview(LONG Top):
  477.      *
  478.      *    Refresh the contents of the review buffer window.
  479.      */
  480.  
  481. STATIC VOID __regargs
  482. RefreshReview(LONG Top)
  483. {
  484.     LONG i,Last,Line = 0;
  485.  
  486.     ObtainSemaphore(BufferSemaphore);
  487.  
  488.     ReviewGlobalLines = Lines;
  489.  
  490.     if((Last = Top + ReviewLines + 1) >= Lines)
  491.     {
  492.         Last = Lines;
  493.  
  494.         if((Top = Last - ReviewLines) < 0)
  495.             Top = 0;
  496.  
  497.         ReviewTop = Top;
  498.     }
  499.  
  500.     if(BufferLines)
  501.     {
  502.         for(i = Top ; i < Last ; i++)
  503.             PrintReviewLine(BufferLines[i],++Line);
  504.     }
  505.  
  506.     if(Line <= ReviewLines)
  507.     {
  508.         if(Line)
  509.         {
  510.             for(i = Line - 1 ; i < ReviewLines ; i++)
  511.                 ReviewLineWidths[i] = 0;
  512.         }
  513.  
  514.         if(Screen)
  515.             ReviewWrites("\33[0J\33[3%ldm",ReviewPen);
  516.         else
  517.             ReviewWrites("\33[0J");
  518.     }
  519.  
  520.     ReleaseSemaphore(BufferSemaphore);
  521. }
  522.  
  523.     /* MoveUp(VOID):
  524.      *
  525.      *    Move the review buffer contents up a line.
  526.      */
  527.  
  528. STATIC VOID
  529. MoveUp(VOID)
  530. {
  531.     LONG i;
  532.  
  533.     for(i = 0 ; i < ReviewMaxLines - 1 ; i++)
  534.         ReviewLineWidths[i] = ReviewLineWidths[i + 1];
  535.  
  536.     ReviewWrites("\33[S");
  537.  
  538.     ObtainSemaphore(BufferSemaphore);
  539.     PrintReviewLine(BufferLines[ReviewTop + ReviewLines],ReviewLines + 1);
  540.     ReleaseSemaphore(BufferSemaphore);
  541. }
  542.  
  543.     /* ScrollReview(LONG Top):
  544.      *
  545.      *    Refresh the contents of the review buffer window, reprint
  546.      *    as few lines as possible.
  547.      */
  548.  
  549. STATIC VOID __regargs
  550. ScrollReview(LONG Top)
  551. {
  552.     LONG i,Last,Line = 0,Delta,Total;
  553.  
  554.     ObtainSemaphore(BufferSemaphore);
  555.  
  556.     ReviewGlobalLines = Lines;
  557.  
  558.     Delta = Top - ReviewTop;
  559.  
  560.     ReviewTop = Top;
  561.  
  562.     if((Last = Top + ReviewLines + 1) >= Lines)
  563.         Last = Lines;
  564.  
  565.     Total = Last - Top;
  566.  
  567.     if(ABS(Delta) < ReviewLines)
  568.     {
  569.         if(!Delta)
  570.         {
  571.             ReleaseSemaphore(BufferSemaphore);
  572.  
  573.             return;
  574.         }
  575.         else
  576.         {
  577.             if(Delta < 0)
  578.             {
  579.                 Last = Top - Delta;
  580.  
  581.                 for(i = ReviewMaxLines - 1 ; i > -Delta ; i--)
  582.                     ReviewLineWidths[i] = ReviewLineWidths[i + Delta];
  583.  
  584.                 ReviewWrites("\33[%ldT",-Delta);
  585.             }
  586.             else
  587.             {
  588.                 for(i = Delta ; i < ReviewMaxLines ; i++)
  589.                     ReviewLineWidths[i - Delta] = ReviewLineWidths[i];
  590.  
  591.                 Top += ReviewLines - Delta;
  592.                 Line = ReviewLines - Delta;
  593.  
  594.                 ReviewWrites("\33[%ldS",Delta);
  595.             }
  596.         }
  597.     }
  598.  
  599.     if(BufferLines)
  600.     {
  601.         for(i = Top ; i < Last ; i++)
  602.             PrintReviewLine(BufferLines[i],++Line);
  603.     }
  604.  
  605.     if(Total <= ReviewLines)
  606.         ReviewWrites("\33[0J");
  607.  
  608.     ReleaseSemaphore(BufferSemaphore);
  609. }
  610.  
  611.     /* ReviewQuery():
  612.      *
  613.      *    Update the current review buffer window dimensions.
  614.      */
  615.  
  616. STATIC BYTE
  617. ReviewQuery()
  618. {
  619.     struct ConUnit    *Unit = (struct ConUnit *)ReviewWriteRequest -> io_Unit;
  620.     BYTE         Refresh = FALSE;
  621.  
  622.     memset(ReviewLineWidths,0,ReviewMaxLines);
  623.  
  624.     if(ReviewColumns != Unit -> cu_XMax)
  625.     {
  626.         Refresh = TRUE;
  627.  
  628.         ReviewColumns = Unit -> cu_XMax;
  629.     }
  630.  
  631.     if(ReviewLines != Unit -> cu_YMax)
  632.     {
  633.         Refresh = TRUE;
  634.  
  635.         if(Unit -> cu_YMax < ReviewGlobalLines)
  636.         {
  637.             LONG Delta = Unit -> cu_YMax - ReviewLines;
  638.  
  639.             ReviewLines = Unit -> cu_YMax;
  640.  
  641.             if(Delta > 0)
  642.             {
  643.                 if((ReviewTop = ReviewTop - Delta) < 0)
  644.                     ReviewTop = 0;
  645.             }
  646.             else
  647.             {
  648.                 ReviewTop -= Delta;
  649.  
  650.                 if(ReviewTop + ReviewLines > ReviewGlobalLines)
  651.                     ReviewTop = ReviewGlobalLines - ReviewLines;
  652.             }
  653.         }
  654.         else
  655.         {
  656.             ReviewTop    = 0;
  657.             ReviewLines    = ReviewGlobalLines;
  658.         }
  659.     }
  660.  
  661.     if(Refresh)
  662.         ReviewUpdatePot();
  663.  
  664.     return(Refresh);
  665. }
  666.  
  667.     /* GetReviewChar(BYTE WaitForIt):
  668.      *
  669.      *    Get the next character present at the console read port.
  670.      */
  671.  
  672. STATIC UBYTE __regargs
  673. GetReviewChar(BYTE WaitForIt)
  674. {
  675.     UBYTE Char;
  676.  
  677.     if(!WaitForIt)
  678.     {
  679.         if(!CheckIO(ReviewReadRequest))
  680.             return(0);
  681.     }
  682.  
  683.     WaitIO(ReviewReadRequest);
  684.  
  685.     Char = ReviewChar;
  686.  
  687.     ReviewReadRequest -> io_Command    = CMD_READ;
  688.     ReviewReadRequest -> io_Data    = &ReviewChar;
  689.     ReviewReadRequest -> io_Length    = 1;
  690.  
  691.     SetSignal(0,SIG_REVIEWPORT);
  692.  
  693.     SendIO(ReviewReadRequest);
  694.  
  695.     return(Char);
  696. }
  697.  
  698.     /* MarkReviewLine(STRPTR Buffer,LONG Line,LONG Column,LONG Len):
  699.      *
  700.      *    Similar to PrintReviewLine(), but also allows to mark a
  701.      *    certain word on the line.
  702.      */
  703.  
  704. STATIC VOID __regargs
  705. MarkReviewLine(STRPTR Buffer,LONG Line,LONG Column,LONG Len)
  706. {
  707.     WORD Length = Buffer[-1];
  708.  
  709.     if(Length > ReviewColumns)
  710.         Length = ReviewColumns;
  711.  
  712.     ReviewWrites("\33[%ldH",Line);
  713.  
  714.     if(Length <= Column)
  715.     {
  716.         ReviewWriteRequest -> io_Command    = CMD_WRITE;
  717.         ReviewWriteRequest -> io_Data        = Buffer;
  718.         ReviewWriteRequest -> io_Length        = Length;
  719.  
  720.         DoIO(ReviewWriteRequest);
  721.  
  722.         ReviewWrites("\33[0K");
  723.     }
  724.     else
  725.     {
  726.         ReviewWriteRequest -> io_Command    = CMD_WRITE;
  727.         ReviewWriteRequest -> io_Data        = Buffer;
  728.         ReviewWriteRequest -> io_Length        = Column;
  729.  
  730.         DoIO(ReviewWriteRequest);
  731.  
  732.         ReviewWrites("\33[7;3%ldm",ReviewPen);
  733.  
  734.         ReviewWriteRequest -> io_Command    = CMD_WRITE;
  735.         ReviewWriteRequest -> io_Data        = &Buffer[Column];
  736.         ReviewWriteRequest -> io_Length        = Len;
  737.  
  738.         DoIO(ReviewWriteRequest);
  739.  
  740.         ReviewWrites("\33[0;3%ldm",ReviewPen);
  741.  
  742.         if(Column + Len < Length)
  743.         {
  744.             ReviewWriteRequest -> io_Command    = CMD_WRITE;
  745.             ReviewWriteRequest -> io_Data        = &Buffer[Column + Len];
  746.             ReviewWriteRequest -> io_Length        = Length - (Column + Len);
  747.  
  748.             DoIO(ReviewWriteRequest);
  749.         }
  750.  
  751.         ReviewWrites("\33[0K");
  752.     }
  753. }
  754.  
  755.     /* ReviewMarkArea(LONG Top,LONG Column,LONG Line,LONG Len,BYTE FullRefresh):
  756.      *
  757.      *    Mark a word on the current display.
  758.      */
  759.  
  760. STATIC VOID __regargs
  761. ReviewMarkArea(LONG Top,LONG Column,LONG Line,LONG Len,BYTE FullRefresh)
  762. {
  763.     STATIC LONG LastMarked = -1;
  764.  
  765.     LONG i,Last,LineIndex = 0;
  766.  
  767.     ReviewGlobalLines = Lines;
  768.  
  769.     ObtainSemaphore(BufferSemaphore);
  770.  
  771.     if((Last = Top + ReviewLines + 1) >= Lines)
  772.         Last = Lines;
  773.  
  774.     if(FullRefresh)
  775.     {
  776.         if(BufferLines)
  777.         {
  778.             for(i = Top ; i < Last ; i++)
  779.             {
  780.                 if(i != Line)
  781.                     PrintReviewLine(BufferLines[i],++LineIndex);
  782.                 else
  783.                     MarkReviewLine(BufferLines[i],++LineIndex,Column,Len);
  784.             }
  785.         }
  786.  
  787.         if(LineIndex <= ReviewLines)
  788.             ReviewWrites("\33[0J");
  789.     }
  790.     else
  791.     {
  792.         if(BufferLines)
  793.         {
  794.             for(i = Top ; i < Last ; i++)
  795.             {
  796.                 LineIndex++;
  797.  
  798.                 if(i == LastMarked)
  799.                     PrintReviewLine(BufferLines[i],LineIndex);
  800.  
  801.                 if(i == Line)
  802.                     MarkReviewLine(BufferLines[i],LineIndex,Column,Len);
  803.             }
  804.         }
  805.     }
  806.  
  807.     LastMarked = Line;
  808.  
  809.     ReleaseSemaphore(BufferSemaphore);
  810. }
  811.  
  812.     /* ReviewSearch(struct SearchInfo *SearchInfo):
  813.      *
  814.      *    Search for a certain word in the text buffer.
  815.      */
  816.  
  817. STATIC VOID __regargs
  818. ReviewSearch(struct SearchInfo *SearchInfo,STRPTR SearchBuffer)
  819. {
  820.     LT_LockWindow(ReviewWindow);
  821.  
  822.     if(Lines)
  823.     {
  824.         LONG LineNumber;
  825.  
  826.         ObtainSemaphore(BufferSemaphore);
  827.  
  828.         LineNumber = SearchTextBuffer(SearchInfo);
  829.  
  830.         ReleaseSemaphore(BufferSemaphore);
  831.  
  832.         if(LineNumber == -1)
  833.         {
  834.             RefreshReview(ReviewTop);
  835.  
  836.             MyEasyRequest(ReviewWindow,LocaleString(MSG_TERMBUFFER_DID_NOT_FIND_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),SearchBuffer);
  837.  
  838.             SearchInfo -> FoundY = -1;
  839.         }
  840.         else
  841.         {
  842.             if(LineNumber < ReviewTop || LineNumber > ReviewTop + ReviewLines)
  843.             {
  844.                 if(LineNumber + ReviewLines > Lines)
  845.                 {
  846.                     ReviewTop = Lines - ReviewLines;
  847.  
  848.                     if(ReviewTop < 0)
  849.                         ReviewTop = 0;
  850.                 }
  851.                 else
  852.                     ReviewTop = LineNumber;
  853.  
  854.                 ReviewUpdatePot();
  855.  
  856.                 ReviewMarkArea(ReviewTop,SearchInfo -> FoundX,LineNumber,SearchInfo -> PatternWidth,TRUE);
  857.             }
  858.             else
  859.                 ReviewMarkArea(ReviewTop,SearchInfo -> FoundX,LineNumber,SearchInfo -> PatternWidth,FALSE);
  860.         }
  861.     }
  862.     else
  863.         MyEasyRequest(ReviewWindow,LocaleString(MSG_GLOBAL_NOTHING_IN_THE_BUFFER_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  864.  
  865.     LT_UnlockWindow(ReviewWindow);
  866. }
  867.  
  868. STATIC VOID
  869. LocalDeleteReview(VOID)
  870. {
  871.     if(ReviewReadRequest)
  872.     {
  873.         if(ReviewReadRequest -> io_Device)
  874.         {
  875.             if(!CheckIO(ReviewReadRequest))
  876.                 AbortIO(ReviewReadRequest);
  877.  
  878.             WaitIO(ReviewReadRequest);
  879.         }
  880.  
  881.         FreeVecPooled(ReviewReadRequest);
  882.  
  883.         ReviewReadRequest = NULL;
  884.     }
  885.  
  886.     if(ReviewWriteRequest)
  887.     {
  888.         if(ReviewWriteRequest -> io_Device)
  889.             CloseDevice(ReviewWriteRequest);
  890.  
  891.         DeleteIORequest(ReviewWriteRequest);
  892.  
  893.         ReviewWriteRequest = NULL;
  894.     }
  895.  
  896.     if(ReviewWindow)
  897.     {
  898.         PutWindowInfo(WINDOW_REVIEW,ReviewWindow -> LeftEdge,ReviewWindow -> TopEdge,ReviewWindow -> Width,ReviewWindow -> Height);
  899.  
  900.         LT_DeleteWindowLock(ReviewWindow);
  901.  
  902.         ClearMenuStrip(ReviewWindow);
  903.  
  904.         CloseWindow(ReviewWindow);
  905.  
  906.         ReviewWindow = NULL;
  907.     }
  908.  
  909.     if(LocalFont)
  910.     {
  911.         CloseFont(LocalFont);
  912.  
  913.         LocalFont = NULL;
  914.     }
  915.  
  916.     if(ReviewMenuStrip)
  917.     {
  918.         FreeMenus(ReviewMenuStrip);
  919.  
  920.         ReviewMenuStrip = NULL;
  921.     }
  922.  
  923.     ReviewDeleteScroller();
  924.  
  925.     if(ReviewWritePort)
  926.     {
  927.         DeleteMsgPort(ReviewWritePort);
  928.  
  929.         ReviewWritePort = NULL;
  930.     }
  931.  
  932.     if(ReviewPort)
  933.     {
  934.         DeleteMsgPort(ReviewPort);
  935.  
  936.         ReviewPort = NULL;
  937.     }
  938.  
  939.     if(ReviewSignal != -1)
  940.     {
  941.         FreeSignal(ReviewSignal);
  942.  
  943.         ReviewSignal = -1;
  944.     }
  945.  
  946.     if(ReviewLineWidths)
  947.     {
  948.         FreeVecPooled(ReviewLineWidths);
  949.  
  950.         ReviewLineWidths = NULL;
  951.     }
  952.  
  953.     if(ReviewQueue)
  954.     {
  955.         DeleteMsgQueue(ReviewQueue);
  956.  
  957.         ReviewQueue = NULL;
  958.     }
  959. }
  960.  
  961. STATIC BOOLEAN
  962. LocalCreateReview(VOID)
  963. {
  964.     if(ReviewBox . Left == -1)
  965.     {
  966.         ReviewBox . Left    = 0;
  967.         ReviewBox . Top        = Window -> WScreen -> BarHeight + 1;
  968.         ReviewBox . Width    = Window -> WScreen -> Width;
  969.         ReviewBox . Height    = Window -> WScreen -> Height - (Window -> WScreen -> BarHeight + 1);
  970.     }
  971.  
  972.     if((ReviewSignal = AllocSignal(-1)) != -1)
  973.     {
  974.         if(ReviewQueue = CreateMsgQueue(NULL,0))
  975.         {
  976.             if(ReviewCreateScroller(Window -> WScreen))
  977.             {
  978.                 LocalizeMenu(ReviewMenu,MSG_TERMREVIEW_PROJECT_MEN);
  979.  
  980.                 if(ReviewMenuStrip = CreateMenus(ReviewMenu,TAG_DONE))
  981.                 {
  982.                     if(LayoutMenus(ReviewMenuStrip,VisualInfo,
  983.                         AmigaGlyph ? GTMN_AmigaKey :  TAG_IGNORE, AmigaGlyph,
  984.                         CheckGlyph ? GTMN_Checkmark : TAG_IGNORE, CheckGlyph,
  985.  
  986.                         GTMN_TextAttr,        &UserFont,
  987.                         GTMN_NewLookMenus,    TRUE,
  988.                     TAG_DONE))
  989.                     {
  990.                         LONG    Left    = 0,
  991.                             Top    = 0,
  992.                             Width    = 0,
  993.                             Height    = 0;
  994.  
  995.                         GetWindowInfo(WINDOW_REVIEW,&Left,&Top,&Width,&Height,NULL,Window -> WScreen -> WBorTop + Window -> WScreen -> WBorBottom + 1 + Window -> WScreen -> Font -> ta_YSize + 10 * CurrentFont -> tf_YSize);
  996.  
  997.                         if(ReviewWindow = OpenWindowTags(NULL,
  998.                             WA_Left,        Left,
  999.                             WA_Top,            Top,
  1000.                             WA_Width,        Width,
  1001.                             WA_Height,        Height,
  1002.                             WA_MinWidth,        Window -> WScreen -> WBorLeft + RightBorderWidth + 15 * CurrentFont -> tf_XSize,
  1003.                             WA_MinHeight,        Window -> WScreen -> WBorTop + Window -> WScreen -> WBorBottom + 1 + Window -> WScreen -> Font -> ta_YSize + 2 * CurrentFont -> tf_YSize,
  1004.                             WA_MaxWidth,        Window -> WScreen -> Width,
  1005.                             WA_MaxHeight,        Window -> WScreen -> Height,
  1006.                             WA_DragBar,        TRUE,
  1007.                             WA_CloseGadget,        TRUE,
  1008.                             WA_DepthGadget,        TRUE,
  1009.                             WA_SizeGadget,        TRUE,
  1010.                             WA_SizeBRight,        TRUE,
  1011.                             WA_MenuHelp,        TRUE,
  1012.                             WA_IDCMP,        IDCMP_IDCMPUPDATE | IDCMP_GADGETDOWN | IDCMP_SIZEVERIFY | IDCMP_MOUSEMOVE | IDCMP_MENUPICK | IDCMP_MENUHELP,
  1013.                             WA_Title,        LocaleString(MSG_TERMREVIEW_REVIEWBUFFER_TXT),
  1014.                             WA_CustomScreen,    Window -> WScreen,
  1015.                             WA_SimpleRefresh,    TRUE,
  1016.                             WA_RMBTrap,        TRUE,
  1017.                             WA_Activate,        TRUE,
  1018.                             WA_NewLookMenus,    TRUE,
  1019.                             WA_Zoom,        &ReviewBox,
  1020.                             WA_Gadgets,        Scroller,
  1021.  
  1022.                             AmigaGlyph ? WA_AmigaKey  : TAG_IGNORE, AmigaGlyph,
  1023.                             CheckGlyph ? WA_Checkmark : TAG_IGNORE, CheckGlyph,
  1024.                         TAG_DONE))
  1025.                         {
  1026.                             ReviewMaxLines = (ReviewWindow -> WScreen -> Height - (ReviewWindow -> BorderTop + ReviewWindow -> BorderBottom)) / CurrentFont -> tf_YSize;
  1027.  
  1028.                             if(ReviewLineWidths = (UBYTE *)AllocVecPooled(ReviewMaxLines,MEMF_ANY | MEMF_CLEAR))
  1029.                             {
  1030.                                 SetMenuStrip(ReviewWindow,ReviewMenuStrip);
  1031.  
  1032.                                 memcpy(&LocalTextFont,&TextAttr,sizeof(struct TTextAttr));
  1033.  
  1034.                                 LocalTextFont . tta_Name    = LocalTextFontName;
  1035.                                 LocalTextFont . tta_YSize    = Config -> TerminalConfig -> TextFontHeight;
  1036.  
  1037.                                 strcpy(LocalTextFontName,Config -> TerminalConfig -> TextFontName);
  1038.  
  1039.                                 if(!Config -> CaptureConfig -> ConvertChars && Config -> TerminalConfig -> FontMode != FONT_STANDARD)
  1040.                                 {
  1041.                                     strcpy(LocalTextFontName,Config -> TerminalConfig -> IBMFontName);
  1042.  
  1043.                                     LocalTextFont . tta_YSize = Config -> TerminalConfig -> IBMFontHeight;
  1044.                                 }
  1045.  
  1046.                                 if(LocalFont = OpenDiskFont(&LocalTextFont))
  1047.                                     SetFont(ReviewWindow -> RPort,LocalFont);
  1048.  
  1049.                                 if(ReviewWritePort = CreateMsgPort())
  1050.                                 {
  1051.                                     if(ReviewPort = CreateMsgPort())
  1052.                                     {
  1053.                                         if(ReviewWriteRequest = CreateIORequest(ReviewPort,sizeof(struct IOStdReq)))
  1054.                                         {
  1055.                                             if(ReviewReadRequest = (struct IOStdReq *)AllocVecPooled(sizeof(struct IOStdReq),MEMF_ANY | MEMF_CLEAR))
  1056.                                             {
  1057.                                                 ReviewWriteRequest -> io_Data = ReviewWindow;
  1058.  
  1059.                                                 if(!OpenDevice("console.device",CONU_SNIPMAP,ReviewWriteRequest,CONFLAG_NODRAW_ON_NEWSIZE))
  1060.                                                 {
  1061.                                                     CopyMem(ReviewWriteRequest,ReviewReadRequest,sizeof(struct IOStdReq));
  1062.  
  1063.                                                     ReviewReadRequest -> io_Message . mn_ReplyPort = ReviewPort;
  1064.  
  1065.                                                     switch(Config -> ScreenConfig -> ColourMode)
  1066.                                                     {
  1067.                                                         case COLOUR_AMIGA:
  1068.                                                         case COLOUR_MONO:
  1069.  
  1070.                                                             ReviewPen = 1;
  1071.                                                             break;
  1072.  
  1073.                                                         case COLOUR_EIGHT:
  1074.                                                         case COLOUR_SIXTEEN:
  1075.  
  1076.                                                             ReviewPen = 7;
  1077.                                                             break;
  1078.                                                     }
  1079.  
  1080.                                                     ReviewPen = GetPenIndex(ReviewPen) & 7;
  1081.  
  1082.                                                     if(Screen)
  1083.                                                         ReviewWrites("\33[0 p\33[11;12\173\33[3%ldm",ReviewPen);
  1084.                                                     else
  1085.                                                         ReviewWrites("\33[0 p\33[11;12\173");
  1086.  
  1087.                                                     ObtainSemaphore(BufferSemaphore);
  1088.  
  1089.                                                     if(ReviewTop == -1 || !Config -> CaptureConfig -> RememberBufferWindow)
  1090.                                                     {
  1091.                                                         switch(Config -> CaptureConfig -> OpenBufferWindow)
  1092.                                                         {
  1093.                                                             case BUFFER_TOP:
  1094.  
  1095.                                                                 ReviewTop = 0;
  1096.                                                                 break;
  1097.  
  1098.                                                             case BUFFER_END:
  1099.  
  1100.                                                                 if((ReviewTop = Lines - ReviewLines) < 0)
  1101.                                                                     ReviewTop = 0;
  1102.  
  1103.                                                                 break;
  1104.  
  1105.                                                             default:
  1106.  
  1107.                                                                 ReviewTop = 0;
  1108.                                                                 break;
  1109.                                                         }
  1110.                                                     }
  1111.  
  1112.                                                     if(ReviewTop > Lines - ReviewLines)
  1113.                                                     {
  1114.                                                         if((ReviewTop = Lines - ReviewLines) < 0)
  1115.                                                             ReviewTop = 0;
  1116.                                                     }
  1117.  
  1118.                                                     ReviewGlobalLines = Lines;
  1119.  
  1120.                                                     ReleaseSemaphore(BufferSemaphore);
  1121.  
  1122.                                                     ReviewQuery();
  1123.  
  1124.                                                     RefreshReview(ReviewTop);
  1125.  
  1126.                                                     ReviewUpdatePot();
  1127.  
  1128.                                                     ReviewReadRequest -> io_Command    = CMD_READ;
  1129.                                                     ReviewReadRequest -> io_Data    = &ReviewChar;
  1130.                                                     ReviewReadRequest -> io_Length    = 1;
  1131.  
  1132.                                                     SendIO(ReviewReadRequest);
  1133.  
  1134.                                                     ReviewWindow -> Flags &= ~WFLG_RMBTRAP;
  1135.  
  1136.                                                     return(TRUE);
  1137.                                                 }
  1138.                                             }
  1139.                                         }
  1140.                                     }
  1141.                                 }
  1142.                             }
  1143.                         }
  1144.                     }
  1145.                 }
  1146.             }
  1147.         }
  1148.     }
  1149.  
  1150.     LocalDeleteReview();
  1151.  
  1152.     return(FALSE);
  1153. }
  1154.  
  1155.     /* LocalUpdateReview():
  1156.      *
  1157.      *    Update the contents of the review buffer window.
  1158.      */
  1159.  
  1160. STATIC VOID __regargs
  1161. LocalUpdateReview(BYTE Force)
  1162. {
  1163.     if(Force)
  1164.     {
  1165.         if(Lines)
  1166.         {
  1167.             if(ReviewTop > 0)
  1168.             {
  1169.                 SetGadgetAttrs(Scroller,ReviewWindow,NULL,
  1170.                     PGA_Top,--ReviewTop,
  1171.                 TAG_DONE);
  1172.             }
  1173.             else
  1174.                 MoveUp();
  1175.         }
  1176.     }
  1177.     else
  1178.     {
  1179.         if(Lines >= ReviewGlobalLines && ReviewGlobalLines <= ReviewLines)
  1180.             RefreshReview(ReviewTop);
  1181.     }
  1182.  
  1183.     ReviewGlobalLines = Lines;
  1184.  
  1185.     if(!Lines)
  1186.     {
  1187.         SetGadgetAttrs(Scroller,ReviewWindow,NULL,
  1188.             PGA_Top,    ReviewTop = 0,
  1189.             PGA_Visible,    1,
  1190.             PGA_Total,    1,
  1191.         TAG_DONE);
  1192.  
  1193.         ReviewWrites("\f\33[3%ldm",ReviewPen);
  1194.     }
  1195.     else
  1196.         ReviewUpdatePot();
  1197. }
  1198.  
  1199.     /* LocalMoveReview(BYTE Mode):
  1200.      *
  1201.      *    Move the currently visible review area.
  1202.      */
  1203.  
  1204. STATIC VOID __regargs
  1205. LocalMoveReview(BYTE Mode)
  1206. {
  1207.     LONG NewTop;
  1208.  
  1209.     switch(Mode)
  1210.     {
  1211.         case REVIEW_MOVE_TOP:
  1212.  
  1213.             if(ReviewTop)
  1214.             {
  1215.                 ScrollReview(0);
  1216.  
  1217.                 ReviewUpdatePot();
  1218.             }
  1219.  
  1220.             break;
  1221.  
  1222.         case REVIEW_MOVE_BOTTOM:
  1223.  
  1224.             NewTop = Lines - ReviewLines;
  1225.  
  1226.             if(NewTop < 0)
  1227.                 NewTop = 0;
  1228.  
  1229.             if(ReviewTop != NewTop)
  1230.             {
  1231.                 ScrollReview(NewTop);
  1232.  
  1233.                 ReviewUpdatePot();
  1234.             }
  1235.  
  1236.             break;
  1237.  
  1238.         case REVIEW_MOVE_UP:
  1239.  
  1240.             ReviewUp(ReviewLines);
  1241.             break;
  1242.  
  1243.         case REVIEW_MOVE_DOWN:
  1244.  
  1245.             ReviewDown(ReviewLines);
  1246.             break;
  1247.     }
  1248. }
  1249.  
  1250. STATIC VOID __stdargs
  1251. ReviewDestructor(struct MsgItem *Item)
  1252. {
  1253.     Signal(ReviewProcess,1L << ReviewSignal);
  1254. }
  1255.  
  1256. STATIC VOID __regargs
  1257. ReviewSerWrite(APTR Data,LONG Size)
  1258. {
  1259.     struct DataMsg Msg;
  1260.  
  1261.     InitMsgItem(&Msg,ReviewDestructor);
  1262.  
  1263.     Msg . Type = DATAMSGTYPE_WRITE;
  1264.     Msg . Data = Data;
  1265.     Msg . Size = Size;
  1266.  
  1267.     Forbid();
  1268.  
  1269.     ClrSignal(1L << ReviewSignal);
  1270.  
  1271.     PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  1272.  
  1273.     Wait(1L << ReviewSignal);
  1274.  
  1275.     Permit();
  1276. }
  1277.  
  1278. STATIC VOID __saveds
  1279. ReviewProcessEntry(VOID)
  1280. {
  1281.     struct Process *Father = ThisProcess;
  1282.  
  1283.     if(LocalCreateReview())
  1284.     {
  1285.         UBYTE             SearchBuffer[256];
  1286.         struct Hook         HistoryHook;
  1287.         ULONG             Signals;
  1288.         BOOLEAN             Done        = FALSE;
  1289.         struct SearchInfo    *SearchInfo    = NULL;
  1290.         struct SearchContext    *Context    = NULL;
  1291.  
  1292.         HistoryHook . h_Data = &ReviewBufferHistory;
  1293.  
  1294.         Forbid();
  1295.  
  1296.         ReviewProcess = (struct Process *)SysBase -> ThisTask;
  1297.  
  1298.         Signal(ThisProcess,SIG_HANDSHAKE);
  1299.  
  1300.         Permit();
  1301.  
  1302.         do
  1303.         {
  1304.             Signals = Wait(SIG_KILL | SIG_REVIEWPORT | SIG_REVIEWWINDOW | ReviewQueue -> SigMask);
  1305.  
  1306.             if(Signals & SIG_KILL)
  1307.                 break;
  1308.  
  1309.             if(Signals & SIG_REVIEWPORT)
  1310.             {
  1311.                 UBYTE Char;
  1312.  
  1313.                     /* Control sequence available? */
  1314.  
  1315.                 if((Char = GetReviewChar(FALSE)) == CSI)
  1316.                 {
  1317.                     UBYTE    InputBuffer[257];
  1318.                     WORD    Count = 0;
  1319.  
  1320.                         /* Try to read the entire sequence. */
  1321.  
  1322.                     while(Char = GetReviewChar(FALSE))
  1323.                     {
  1324.                         InputBuffer[Count++] = Char;
  1325.  
  1326.                         if(Char != ' ' && Char != ';' && (Char < '0' || Char > '9'))
  1327.                             break;
  1328.                     }
  1329.  
  1330.                         /* Provide termination. */
  1331.  
  1332.                     InputBuffer[Count] = 0;
  1333.  
  1334.                         /* Raw event? */
  1335.  
  1336.                     if(!strcmp(InputBuffer,"?~"))
  1337.                         GuideDisplay(CONTEXT_TEXTBUFFER);
  1338.  
  1339.                     if(!strcmp(InputBuffer,"A"))
  1340.                         ReviewUp(1);
  1341.  
  1342.                     if(!strcmp(InputBuffer,"B"))
  1343.                         ReviewDown(1);
  1344.  
  1345.                     if(!strcmp(InputBuffer,"T"))
  1346.                         ReviewUp(ReviewLines);
  1347.  
  1348.                     if(!strcmp(InputBuffer,"S"))
  1349.                         ReviewDown(ReviewLines);
  1350.  
  1351.                     if(!memcmp(InputBuffer,"11;",3))
  1352.                     {
  1353.                         Done = TRUE;
  1354.  
  1355.                         if(!(SetSignal(0,SIG_KILL) & SIG_KILL))
  1356.                             Father = NULL;
  1357.                     }
  1358.  
  1359.                     if(!memcmp(InputBuffer,"12;",3))
  1360.                     {
  1361.                         if(ReviewQuery())
  1362.                             RefreshReview(ReviewTop);
  1363.                     }
  1364.  
  1365.                     if(!strcmp(InputBuffer,"0 v"))
  1366.                     {
  1367.                         struct DataMsg Msg;
  1368.  
  1369.                         InitMsgItem(&Msg,ReviewDestructor);
  1370.  
  1371.                         Msg . Type = DATAMSGTYPE_WRITECLIP;
  1372.                         Msg . Size = Config -> ClipConfig -> ClipboardUnit;
  1373.  
  1374.                         Forbid();
  1375.  
  1376.                         ClrSignal(1L << ReviewSignal);
  1377.  
  1378.                         PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  1379.  
  1380.                         Wait(1L << ReviewSignal);
  1381.  
  1382.                         Permit();
  1383.                     }
  1384.                 }
  1385.                 else
  1386.                 {
  1387.                     if(Char)
  1388.                     {
  1389.                         if(Config -> SerialConfig -> StripBit8)
  1390.                             Char &= 0x7F;
  1391.  
  1392.                         if(Status == STATUS_HOLDING)
  1393.                         {
  1394.                             if(Char == XOF)
  1395.                             {
  1396.                                 ReviewSerWrite(&Char,1);
  1397.  
  1398.                                 Status = STATUS_READY;
  1399.                             }
  1400.                         }
  1401.                         else
  1402.                         {
  1403.                                 /* Convert chars
  1404.                                  * as approriate.
  1405.                                  */
  1406.  
  1407.                             if(Char == '\n')
  1408.                             {
  1409.                                 switch(Config -> TerminalConfig -> SendLF)
  1410.                                 {
  1411.                                     case EOL_LF:
  1412.  
  1413.                                         goto SendIt;
  1414.  
  1415.                                     case EOL_LFCR:
  1416.  
  1417.                                         ReviewSerWrite("\n\r",2);
  1418.                                         break;
  1419.  
  1420.                                     case EOL_CRLF:
  1421.  
  1422.                                         ReviewSerWrite("\r\n",2);
  1423.                                         break;
  1424.  
  1425.                                     case EOL_CR:
  1426.  
  1427.                                         ReviewSerWrite("\r",1);
  1428.                                         break;
  1429.                                 }
  1430.                             }
  1431.  
  1432.                             if(Char == '\r')
  1433.                             {
  1434.                                 switch(Config -> TerminalConfig -> SendCR)
  1435.                                 {
  1436.                                     case EOL_CR:
  1437.  
  1438.                                         goto SendIt;
  1439.  
  1440.                                     case EOL_LFCR:
  1441.  
  1442.                                         ReviewSerWrite("\n\r",2);
  1443.                                         break;
  1444.  
  1445.                                     case EOL_CRLF:
  1446.  
  1447.                                         ReviewSerWrite("\r\n",2);
  1448.                                         break;
  1449.  
  1450.                                     case EOL_LF:
  1451.  
  1452.                                         ReviewSerWrite("\n",1);
  1453.                                         break;
  1454.                                 }
  1455.                             }
  1456.  
  1457.                                 /* Stop in/output. */
  1458.  
  1459.                             if(Char == XON)
  1460.                             {
  1461.                                 if(Config -> SerialConfig -> PassThrough)
  1462.                                     ReviewSerWrite(&Char,1);
  1463.  
  1464.                                 if(Config -> SerialConfig -> xONxOFF)
  1465.                                     Status = STATUS_HOLDING;
  1466.                             }
  1467.  
  1468.                                 /* Restart in/output. */
  1469.  
  1470.                             if(Char == XOF)
  1471.                             {
  1472.                                 if(Config -> SerialConfig -> PassThrough)
  1473.                                     ReviewSerWrite(&Char,1);
  1474.  
  1475.                                 if(Status == STATUS_HOLDING)
  1476.                                     Status = STATUS_READY;
  1477.                             }
  1478.  
  1479.                                 /* Convert special
  1480.                                  * Amiga characters into
  1481.                                  * alien IBM dialect.
  1482.                                  */
  1483.  
  1484. SendIt:                            if(Config -> TerminalConfig -> FontMode == FONT_IBM)
  1485.                             {
  1486.                                 if(IBMConversion[Char])
  1487.                                     ReviewSerWrite(&IBMConversion[Char],1);
  1488.                                 else
  1489.                                     ReviewSerWrite(&Char,1);
  1490.                             }
  1491.                             else
  1492.                                 ReviewSerWrite(&Char,1);
  1493.                         }
  1494.                     }
  1495.                 }
  1496.             }
  1497.  
  1498.             if(Signals & SIG_REVIEWWINDOW)
  1499.             {
  1500.                 struct IntuiMessage    *Message;
  1501.                 struct MenuItem        *MenuItem;
  1502.                 struct TagItem        *TagList;
  1503.                 ULONG             MsgClass;
  1504.                 UWORD             MsgCode,
  1505.                              MsgQualifier;
  1506.  
  1507.                 while(Message = (struct IntuiMessage *)GetMsg(ReviewWindow -> UserPort))
  1508.                 {
  1509.                     if(Context && Context -> SearchWindow == Message -> IDCMPWindow)
  1510.                     {
  1511.                         MsgClass = NULL;
  1512.  
  1513.                         if(HandleSearchMessage(Context,&Message))
  1514.                         {
  1515.                             BOOLEAN Ok = Context -> Ok;
  1516.  
  1517.                             DeleteSearchContext(Context);
  1518.  
  1519.                             Context = NULL;
  1520.  
  1521.                             if(Ok)
  1522.                             {
  1523.                                 if(SearchInfo)
  1524.                                     DeleteSearchInfo(SearchInfo);
  1525.  
  1526.                                 if(SearchInfo = CreateSearchInfo(SearchBuffer,SearchForward,IgnoreCase,WholeWords))
  1527.                                     ReviewSearch(SearchInfo,SearchBuffer);
  1528.                             }
  1529.                             else
  1530.                             {
  1531.                                 if(SearchInfo)
  1532.                                 {
  1533.                                     DeleteSearchInfo(SearchInfo);
  1534.  
  1535.                                     SearchInfo = NULL;
  1536.                                 }
  1537.                             }
  1538.                         }
  1539.                     }
  1540.                     else
  1541.                     {
  1542.                         MsgClass    = Message -> Class;
  1543.                         MsgCode        = Message -> Code;
  1544.                         MsgQualifier    = Message -> Qualifier;
  1545.                         TagList        = (struct TagItem *)Message -> IAddress;
  1546.  
  1547.                         ReplyMsg((struct Message *)Message);
  1548.                     }
  1549.  
  1550.                     switch(MsgClass)
  1551.                     {
  1552.                         case IDCMP_MENUHELP:
  1553.  
  1554.                             GuideDisplay(CONTEXT_BUFFER_MENU);
  1555.                             break;
  1556.  
  1557.                         case IDCMP_IDCMPUPDATE:
  1558.  
  1559.                             switch(GetTagData(GA_ID,0,TagList))
  1560.                             {
  1561.                                 case GAD_UP:    ReviewUp(1);
  1562.                                         break;
  1563.  
  1564.                                 case GAD_DOWN:    ReviewDown(1);
  1565.                                         break;
  1566.                             }
  1567.  
  1568.                             break;
  1569.  
  1570.                         case IDCMP_GADGETDOWN:
  1571.                         case IDCMP_MOUSEMOVE:
  1572.  
  1573.                             if(ReviewGlobalLines > ReviewLines)
  1574.                             {
  1575.                                 LONG NewTop;
  1576.  
  1577.                                 if(GetAttr(PGA_Top,Scroller,(ULONG *)&NewTop))
  1578.                                     ScrollReview(NewTop);
  1579.                             }
  1580.  
  1581.                             break;
  1582.  
  1583.                         case IDCMP_MENUPICK:
  1584.  
  1585.                             while(MsgCode != MENUNULL)
  1586.                             {
  1587.                                 MenuItem = ItemAddress(ReviewMenuStrip,MsgCode);
  1588.  
  1589.                                 switch((ULONG)GTMENUITEM_USERDATA(MenuItem))
  1590.                                 {
  1591.                                     case MEN_SEARCH:
  1592.  
  1593.                                         if(Context)
  1594.                                             LT_ShowWindow(Context -> SearchHandle,TRUE);
  1595.                                         else
  1596.                                             Context = CreateSearchContext(ReviewWindow,SearchBuffer,&HistoryHook,&SearchForward,&IgnoreCase,&WholeWords);
  1597.  
  1598.                                         break;
  1599.  
  1600.                                     case MEN_REPEAT:
  1601.  
  1602.                                         if(Context)
  1603.                                             LT_ShowWindow(Context -> SearchHandle,TRUE);
  1604.                                         else
  1605.                                         {
  1606.                                             if(SearchInfo)
  1607.                                                 ReviewSearch(SearchInfo,SearchBuffer);
  1608.                                             else
  1609.                                                 Context = CreateSearchContext(ReviewWindow,SearchBuffer,&HistoryHook,&SearchForward,&IgnoreCase,&WholeWords);
  1610.                                         }
  1611.  
  1612.                                         break;
  1613.  
  1614.                                     case MEN_QUITBUF:
  1615.  
  1616.                                         Done = TRUE;
  1617.  
  1618.                                         if(!(SetSignal(0,SIG_KILL) & SIG_KILL))
  1619.                                             Father = NULL;
  1620.  
  1621.                                         break;
  1622.  
  1623.                                     case MEN_CLEARBUF:
  1624.  
  1625.                                         if(Lines)
  1626.                                         {
  1627.                                             if((MsgQualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)) || !Config -> MiscConfig -> ProtectiveMode)
  1628.                                                 FreeBuffer();
  1629.                                             else
  1630.                                             {
  1631.                                                 if(MyEasyRequest(ReviewWindow,LocaleString(MSG_TERMBUFFER_BUFFER_STILL_HOLDS_LINES_TXT),LocaleString(MSG_GLOBAL_YES_NO_TXT),Lines))
  1632.                                                     FreeBuffer();
  1633.                                             }
  1634.                                         }
  1635.  
  1636.                                         break;
  1637.                                 }
  1638.  
  1639.                                 MsgCode = MenuItem -> NextSelect;
  1640.                             }
  1641.  
  1642.                             break;
  1643.                     }
  1644.                 }
  1645.             }
  1646.  
  1647.             if(Signals & ReviewQueue -> SigMask)
  1648.             {
  1649.                 struct DataMsg *Msg;
  1650.  
  1651.                 while(Msg = (struct DataMsg *)GetMsgItem(ReviewQueue))
  1652.                 {
  1653.                     switch(Msg -> Type)
  1654.                     {
  1655.                         case DATAMSGTYPE_UPDATEREVIEW:
  1656.  
  1657.                             LocalUpdateReview(Msg -> Size);
  1658.                             break;
  1659.  
  1660.                         case DATAMSGTYPE_MOVEREVIEW:
  1661.  
  1662.                             LocalMoveReview(Msg -> Size);
  1663.                             break;
  1664.                     }
  1665.  
  1666.                     DeleteMsgItem(Msg);
  1667.                 }
  1668.             }
  1669.         }
  1670.         while(!Done);
  1671.  
  1672.         if(Context)
  1673.             DeleteSearchContext(Context);
  1674.  
  1675.         if(SearchInfo)
  1676.             DeleteSearchInfo(SearchInfo);
  1677.  
  1678.         LocalDeleteReview();
  1679.     }
  1680.  
  1681.     Forbid();
  1682.  
  1683.     ReviewProcess = NULL;
  1684.  
  1685.     if(Father)
  1686.         Signal(Father,SIG_HANDSHAKE);
  1687.     else
  1688.         CheckItem(MEN_REVIEW_WINDOW,FALSE);
  1689. }
  1690.  
  1691. STATIC VOID __stdargs
  1692. ReviewClientDestructor(struct DataMsg *Item)
  1693. {
  1694.     Signal((struct Task *)Item -> Client,Item -> Mask);
  1695. }
  1696.  
  1697. VOID __regargs
  1698. UpdateReview(BYTE Force)
  1699. {
  1700.     if(ReviewQueue)
  1701.     {
  1702.         if(SysBase -> ThisTask != (struct Task *)ReviewProcess)
  1703.         {
  1704.             LONG Bit;
  1705.  
  1706.             if((Bit = AllocSignal(-1)) != -1)
  1707.             {
  1708.                 struct DataMsg Msg;
  1709.  
  1710.                 InitMsgItem(&Msg,ReviewClientDestructor);
  1711.  
  1712.                 Msg . Type    = DATAMSGTYPE_UPDATEREVIEW;
  1713.                 Msg . Size    = Force;
  1714.                 Msg . Client    = SysBase -> ThisTask;
  1715.                 Msg . Mask    = 1L << Bit;
  1716.  
  1717.                 Forbid();
  1718.  
  1719.                 if(ReviewProcess)
  1720.                 {
  1721.                     ClrSignal(Msg . Mask);
  1722.  
  1723.                     PutMsgItem(ReviewQueue,(struct MsgItem *)&Msg);
  1724.  
  1725.                     Wait(Msg . Mask);
  1726.                 }
  1727.  
  1728.                 Permit();
  1729.  
  1730.                 FreeSignal(Bit);
  1731.             }
  1732.         }
  1733.         else
  1734.             LocalUpdateReview(Force);
  1735.     }
  1736. }
  1737.  
  1738. VOID __regargs
  1739. MoveReview(BYTE Mode)
  1740. {
  1741.     if(ReviewQueue)
  1742.     {
  1743.         if(SysBase -> ThisTask != (struct Task *)ReviewProcess)
  1744.         {
  1745.             LONG Bit;
  1746.  
  1747.             if((Bit = AllocSignal(-1)) != -1)
  1748.             {
  1749.                 struct DataMsg Msg;
  1750.  
  1751.                 InitMsgItem(&Msg,ReviewClientDestructor);
  1752.  
  1753.                 Msg . Type    = DATAMSGTYPE_MOVEREVIEW;
  1754.                 Msg . Size    = Mode;
  1755.                 Msg . Client    = SysBase -> ThisTask;
  1756.                 Msg . Mask    = 1L << Bit;
  1757.  
  1758.                 Forbid();
  1759.  
  1760.                 if(ReviewProcess)
  1761.                 {
  1762.                     ClrSignal(Msg . Mask);
  1763.  
  1764.                     PutMsgItem(ReviewQueue,(struct MsgItem *)&Msg);
  1765.  
  1766.                     Wait(Msg . Mask);
  1767.                 }
  1768.  
  1769.                 Permit();
  1770.  
  1771.                 FreeSignal(Bit);
  1772.             }
  1773.         }
  1774.         else
  1775.             LocalMoveReview(Mode);
  1776.     }
  1777. }
  1778.  
  1779. VOID
  1780. DeleteReview()
  1781. {
  1782.     CheckItem(MEN_REVIEW_WINDOW,FALSE);
  1783.  
  1784.     Forbid();
  1785.  
  1786.     if(ReviewProcess)
  1787.     {
  1788.         ClrSignal(SIG_HANDSHAKE);
  1789.  
  1790.         Signal(ReviewProcess,SIG_KILL);
  1791.  
  1792.         Wait(SIG_HANDSHAKE);
  1793.     }
  1794.  
  1795.     Permit();
  1796. }
  1797.  
  1798. BYTE
  1799. CreateReview()
  1800. {
  1801.     if(ReviewProcess)
  1802.         return(TRUE);
  1803.     else
  1804.     {
  1805.         BYTE Result = FALSE;
  1806.  
  1807.         Forbid();
  1808.  
  1809.         if(CreateNewProcTags(
  1810.             NP_Entry,    ReviewProcessEntry,
  1811.             NP_Name,    "term Review Process",
  1812.             NP_Priority,    SysBase -> ThisTask -> tc_Node . ln_Pri,
  1813.             NP_StackSize,    4000,
  1814.             NP_WindowPtr,    -1,
  1815.         TAG_END))
  1816.         {
  1817.             ClrSignal(SIG_HANDSHAKE);
  1818.  
  1819.             Wait(SIG_HANDSHAKE);
  1820.  
  1821.             if(ReviewProcess)
  1822.             {
  1823.                 CheckItem(MEN_REVIEW_WINDOW,TRUE);
  1824.  
  1825.                 Result = TRUE;
  1826.             }
  1827.         }
  1828.  
  1829.         Permit();
  1830.  
  1831.         return(Result);
  1832.     }
  1833. }
  1834.