home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d534 / term.lha / Term / Source.LZH / ParseRoutines.c < prev    next >
C/C++ Source or Header  |  1991-07-17  |  25KB  |  1,646 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1990 by Olaf 'Olsen' Barthel & MXM
  4.  *
  5.  *    Name .....: ParseRoutines.c
  6.  *    Created ..: Monday 21-Jan-91 20:12
  7.  *    Revision .: 0
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    21-Jan-91       Olsen           Created this file!
  12.  *
  13.  * $Revision Header ********************************************************/
  14.  
  15. #include "TermGlobal.h"
  16.  
  17.  
  18.     /* Flag indicating whether the cursor has already been
  19.      * erased or not.
  20.      */
  21.  
  22. STATIC BYTE CursorEnabled = FALSE;
  23.  
  24.     /* Global string buffer and backup style. */
  25.  
  26. STATIC UBYTE GlobalBuffer[20],StyleType = FS_NORMAL;
  27.  
  28.     /* ClearCursor():
  29.      *
  30.      *    Clear the cursor image.
  31.      */
  32.  
  33. VOID
  34. ClearCursor()
  35. {
  36.     if(CursorEnabled)
  37.     {
  38.         if(Config . FontScale == SCALE_HALF)
  39.             ClipBlit(RPort,0,0,RPort,CursorX << 2,CursorY << 3,4,8,0x50);
  40.         else
  41.             ClipBlit(RPort,0,0,RPort,CursorX << 3,CursorY << 3,8,8,0x50);
  42.  
  43.         CursorEnabled = FALSE;
  44.     }
  45. }
  46.  
  47.     /* DrawCursor():
  48.      *
  49.      *    Explicitely (re-)draw the cursor image.
  50.      */
  51.  
  52. VOID
  53. DrawCursor()
  54. {
  55.     if(Config . FontScale == SCALE_HALF)
  56.         ClipBlit(RPort,0,0,RPort,CursorX << 2,CursorY << 3,4,8,0x50);
  57.     else
  58.         ClipBlit(RPort,0,0,RPort,CursorX << 3,CursorY << 3,8,8,0x50);
  59.  
  60.     CursorEnabled = TRUE;
  61. }
  62.  
  63.     /* ColourValue(UWORD Colour):
  64.      *
  65.      *    Calculate the value of a given colour (brightness).
  66.      */
  67.  
  68. STATIC SHORT
  69. ColourValue(UWORD Colour)
  70. {
  71.     BYTE    Red,Green,Blue;
  72.     SHORT    Sum;
  73.  
  74.     Red    = (Colour >> 8) & 0xF;
  75.     Green    = (Colour >> 4) & 0xF;
  76.     Blue    = (Colour     ) & 0xF;
  77.  
  78.     Sum = (Red + Green + Blue) / 3;
  79.  
  80.     return(Sum);
  81. }
  82.  
  83.     /* SetCursor():
  84.      *
  85.      *    Move the cursor to a given location.
  86.      */
  87.  
  88. VOID
  89. SetCursor()
  90. {
  91.     USHORT X,Y,Hit;
  92.  
  93.     Hit = UseRegion ? Bottom : LastLine;
  94.  
  95.     if(CursorY > Hit)
  96.         CursorY = Hit;
  97.  
  98.     X = CursorX * 8;
  99.     Y = CursorY * 8 + 6;
  100.  
  101.     Move(RPort,X,Y);
  102.  
  103.     if(!CursorEnabled)
  104.     {
  105.         if(Config . FontScale == SCALE_HALF)
  106.             ClipBlit(RPort,0,0,RPort,CursorX << 2,CursorY << 3,4,8,0x50);
  107.         else
  108.             ClipBlit(RPort,0,0,RPort,CursorX << 3,CursorY << 3,8,8,0x50);
  109.     }
  110.  
  111.     CursorEnabled = TRUE;
  112. }
  113.  
  114.     /* BackupRender():
  115.      *
  116.      *    Save current draw modes, pen and position or restore
  117.      *    the data.
  118.      */
  119.  
  120. VOID
  121. BackupRender()
  122. {
  123.     STATIC BYTE    Called = FALSE;
  124.     STATIC UBYTE    DrMd,FgPen,BgPen;
  125.     STATIC UWORD    CpX,CpY;
  126.     STATIC UBYTE    Style;
  127.  
  128.     if(!Called)
  129.     {
  130.         DrMd    = RPort -> DrawMode;
  131.         FgPen    = RPort -> FgPen;
  132.         BgPen    = RPort -> BgPen;
  133.  
  134.         CpX    = RPort -> cp_x;
  135.         CpY    = RPort -> cp_y;
  136.  
  137.         Style    = StyleType;
  138.  
  139.         Called    = TRUE;
  140.     }
  141.     else
  142.     {
  143.         if(RPort -> DrawMode != DrMd)
  144.             SetDrMd(RPort,DrMd);
  145.  
  146.         if(RPort -> FgPen != FgPen)
  147.             SetAPen(RPort,FgPen);
  148.  
  149.         if(RPort -> BgPen != BgPen)
  150.             SetBPen(RPort,BgPen);
  151.  
  152.         if(RPort -> cp_x != CpX || RPort -> cp_y != CpY)
  153.             Move(RPort,CpX,CpY);
  154.  
  155.         if(Style != StyleType)
  156.         {
  157.             SetSoftStyle(RPort,Style,0xFF);
  158.  
  159.             StyleType = Style;
  160.         }
  161.  
  162.         Called    = FALSE;
  163.     }
  164. }
  165.  
  166.     /* ShiftChar():
  167.      *
  168.      *    Simulate character insertion at the current cursor
  169.      *    position by shifting the whole line eight pixels
  170.      *    to the right.
  171.      */
  172.  
  173. VOID
  174. ShiftChar()
  175. {
  176.     BackupRender();
  177.  
  178.     SetBPen(RPort,0);
  179.  
  180.     ClearCursor();
  181.  
  182.     ScrollRaster(RPort,-8,0,CursorX * 8,CursorY * 8,(LastColumn + 1) * 8 - 1,(CursorY + 1) * 8 - 1);
  183.  
  184.     DrawCursor();
  185.  
  186.     BackupRender();
  187. }
  188.  
  189.     /* ScrollRegion(BYTE Direction):
  190.      *
  191.      *    Scroll the current scroll region up or down.
  192.      */
  193.  
  194. VOID
  195. ScrollRegion(BYTE Direction)
  196. {
  197.     RasterScrollRegion(Direction);
  198.  
  199.     BackupRender();
  200.  
  201.     SetBPen(RPort,0);
  202.  
  203.     ClearCursor();
  204.  
  205.     if(Config . JumpScroll)
  206.     {
  207.         if(UseRegion)
  208.             ScrollRaster(RPort,0,Direction,0,Top * 8,Window -> Width - 1,(Bottom + 1) * 8 - 1);
  209.         else
  210.             ScrollRaster(RPort,0,Direction,0,0,Window -> Width - 1,(LastLine + 1) * 8 - 1);
  211.     }
  212.     else
  213.     {
  214.         BYTE i,Diff = Direction / 4;
  215.  
  216.         if(UseRegion)
  217.         {
  218.             for(i = 0 ; i < 4 ; i++)
  219.             {
  220.                 WaitTOF();
  221.  
  222.                 ScrollRaster(RPort,0,Diff,0,Top * 8,Window -> Width - 1,(Bottom + 1) * 8 - 1);
  223.             }
  224.         }
  225.         else
  226.         {
  227.             for(i = 0 ; i < 4 ; i++)
  228.             {
  229.                 WaitTOF();
  230.  
  231.                 ScrollRaster(RPort,0,Diff,0,0,Window -> Width - 1,(LastLine + 1) * 8 - 1);
  232.             }
  233.         }
  234.     }
  235.  
  236.     DrawCursor();
  237.  
  238.     BackupRender();
  239. }
  240.  
  241.     /* LastChar(UBYTE *Buffer):
  242.      *
  243.      *    Return the last character in a string.
  244.      */
  245.  
  246. STATIC UBYTE
  247. LastChar(UBYTE *Buffer)
  248. {
  249.     SHORT Offset = 0;
  250.  
  251.     while(Buffer[Offset])
  252.         Offset++;
  253.  
  254.     return(Buffer[Offset - 1]);
  255. }
  256.  
  257.     /* ReadValue(UBYTE *Buffer,BYTE *Value):
  258.      *
  259.      *    Parse a buffer for numbers and return a pointer
  260.      *    to the next buffer element to contain additional
  261.      *    information.
  262.      */
  263.  
  264. STATIC UBYTE *
  265. ReadValue(UBYTE *Buffer,SHORT *Value)
  266. {
  267.     while((*Buffer < '0' || *Buffer > '9') && *Buffer)
  268.         Buffer++;
  269.  
  270.     if(*Buffer)
  271.     {
  272.         *Value = 0;
  273.  
  274.         while(*Buffer >= '0' && *Buffer <= '9')
  275.             *Value = (*Value * 10) + (*Buffer++ - '0');
  276.     }
  277.     else
  278.         *Value = -1;
  279.  
  280.     if(*Buffer == ';' || *Buffer == ' ')
  281.         return(&Buffer[1]);
  282.     else
  283.         return(NULL);
  284. }
  285.  
  286.     /* Ignore():
  287.      *
  288.      *    Do nothing, return immediately.
  289.      */
  290.  
  291. UBYTE *
  292. Ignore()
  293. {
  294.     return(NULL);
  295. }
  296.  
  297.     /* CursorScrollDown():
  298.      *
  299.      *    Move cursor down and scroll region if necessary.
  300.      */
  301.  
  302. UBYTE *
  303. CursorScrollDown()
  304. {
  305.     ClearCursor();
  306.  
  307.     if(UseRegion)
  308.     {
  309.         if(CursorY == Bottom)
  310.             ScrollRegion(8);
  311.         else
  312.         {
  313.             CursorY++;
  314.  
  315.             SetCursor();
  316.         }
  317.     }
  318.     else
  319.     {
  320.         if(CursorY == LastLine)
  321.             ScrollRegion(8);
  322.         else
  323.         {
  324.             CursorY++;
  325.  
  326.             SetCursor();
  327.         }
  328.     }
  329.  
  330.     return(NULL);
  331. }
  332.  
  333.     /* CursorScrollUp():
  334.      *
  335.      *    Move cursor up and scroll region if necessary.
  336.      */
  337.  
  338. UBYTE *
  339. CursorScrollUp()
  340. {
  341.     ClearCursor();
  342.  
  343.     if(UseRegion)
  344.     {
  345.         if(CursorY == Top)
  346.             ScrollRegion(-8);
  347.         else
  348.         {
  349.             CursorY--;
  350.  
  351.             SetCursor();
  352.         }
  353.     }
  354.     else
  355.     {
  356.         if(CursorY == 0)
  357.             ScrollRegion(-8);
  358.         else
  359.         {
  360.             CursorY--;
  361.  
  362.             SetCursor();
  363.         }
  364.     }
  365.  
  366.     return(NULL);
  367. }
  368.  
  369.     /* NextLine():
  370.      *
  371.      *    Do something like CR+LF.
  372.      */
  373.  
  374. UBYTE *
  375. NextLine()
  376. {
  377.     ClearCursor();
  378.  
  379.     CursorX = 0;
  380.  
  381.     if(UseRegion)
  382.     {
  383.         if(CursorY == Bottom)
  384.             ScrollRegion(8);
  385.         else
  386.         {
  387.             CursorY++;
  388.  
  389.             SetCursor();
  390.         }
  391.     }
  392.     else
  393.     {
  394.         if(CursorY == LastLine)
  395.             ScrollRegion(8);
  396.         else
  397.         {
  398.             CursorY++;
  399.  
  400.             SetCursor();
  401.         }
  402.     }
  403.  
  404.     return(NULL);
  405. }
  406.  
  407.     /* SaveCursor():
  408.      *
  409.      *    Save cursor position and rendering attributes.
  410.      */
  411.  
  412. UBYTE *
  413. SaveCursor()
  414. {
  415.     CursorBackup . Charset        = Charset;
  416.     CursorBackup . Attributes    = Attributes;
  417.     CursorBackup . UseRegion    = UseRegion;
  418.     CursorBackup . Top        = Top;
  419.     CursorBackup . Bottom        = Bottom;
  420.     CursorBackup . CursorX        = CursorX;
  421.     CursorBackup . CursorY        = CursorY;
  422.  
  423.     return(NULL);
  424. }
  425.  
  426.     /* FontStuff(UBYTE *Buffer):
  427.      *
  428.      *    Set the drawing font (standard characters/line).
  429.      */
  430.  
  431. UBYTE *
  432. FontStuff(UBYTE *Buffer)
  433. {
  434.     switch(LastChar(Buffer))
  435.     {
  436.         case 'A':
  437.         case 'B':    if(Config . Font == FONT_TOPAZ)
  438.                     SetFont(RPort,Topaz);
  439.                 else
  440.                 {
  441.                     if(IBM)
  442.                         SetFont(RPort,IBM);
  443.                 }
  444.  
  445.                 break;
  446.  
  447.         case '0':    if(GFX)
  448.                     SetFont(RPort,GFX);
  449.  
  450.                 break;
  451.  
  452.         default:    break;
  453.     }
  454.  
  455.     return(NULL);
  456. }
  457.  
  458.     /* LoadCursor():
  459.      *
  460.      *    Load cursor position and rendering attributes.
  461.      */
  462.  
  463. UBYTE *
  464. LoadCursor()
  465. {
  466.     LONG TextFlags = FS_NORMAL;
  467.  
  468.     ClearCursor();
  469.  
  470.     if(CursorBackup . Attributes & ATTR_UNDERLINE)
  471.         TextFlags |= FSF_UNDERLINED;
  472.  
  473.     if((CursorBackup . Attributes & ATTR_HIGHLIGHT) && Config . ColourMode != COLOUR_SIXTEEN)
  474.         TextFlags |= FSF_BOLD;
  475.  
  476.     if(CursorBackup . Attributes & ATTR_BLINK)
  477.     {
  478.         if(Config . Emulation == EMULATION_ANSIVT100)
  479.         {
  480.             switch(Config . ColourMode)
  481.             {
  482.                 case COLOUR_AMIGA:    if(CursorBackup . Attributes & ATTR_INVERSE)
  483.                                 BgPen = 3;
  484.                             else
  485.                                 FgPen = 3;
  486.  
  487.                             break;
  488.  
  489.                 case COLOUR_EIGHT:    if(CursorBackup . Attributes & ATTR_INVERSE)
  490.                                 BgPen |= 8;
  491.                             else
  492.                                 FgPen |= 8;
  493.  
  494.                             break;
  495.  
  496.                 case COLOUR_SIXTEEN:    break;
  497.             }
  498.         }
  499.     }
  500.  
  501.     if(StyleType != TextFlags)
  502.     {
  503.         SetSoftStyle(RPort,TextFlags,0xFF);
  504.  
  505.         StyleType = TextFlags;
  506.     }
  507.  
  508.     if(RPort -> FgPen != FgPen)
  509.         SetAPen(RPort,FgPen);
  510.  
  511.     if(RPort -> BgPen != BgPen)
  512.         SetBPen(RPort,BgPen);
  513.  
  514.     Attributes    = CursorBackup . Attributes;
  515.     UseRegion    = CursorBackup . UseRegion;
  516.     Top        = CursorBackup . Top;
  517.     Bottom        = CursorBackup . Bottom;
  518.     CursorX        = CursorBackup . CursorX;
  519.     CursorY        = CursorBackup . CursorY;
  520.  
  521.     SetCursor();
  522.  
  523.     return(NULL);
  524. }
  525.  
  526. UBYTE *
  527. ScaleFont(UBYTE *Buffer)
  528. {
  529.     ClearCursor();
  530.  
  531.     switch(LastChar(Buffer))
  532.     {
  533.         case '3':    if(Config . FontScale == SCALE_HALF)
  534.                 {
  535.                     CursorX >>= 1;
  536.                     SetCursor();
  537.  
  538.                     if(Config . EightyColumns)
  539.                         LastColumn = 79;
  540.                     else
  541.                         LastColumn = (Window -> Width >> 3) - 1;
  542.                 }
  543.  
  544.                 Config . FontScale = SCALE_TOP2X;
  545.  
  546.                 break;
  547.  
  548.         case '4':    if(Config . FontScale == SCALE_HALF)
  549.                 {
  550.                     CursorX >>= 1;
  551.                     SetCursor();
  552.  
  553.                     if(Config . EightyColumns)
  554.                         LastColumn = 79;
  555.                     else
  556.                         LastColumn = (Window -> Width >> 3) - 1;
  557.                 }
  558.  
  559.                 Config . FontScale = SCALE_BOT2X;
  560.  
  561.                 break;
  562.  
  563.         case '6':    if(Config . FontScale == SCALE_HALF)
  564.                 {
  565.                     CursorX >>= 1;
  566.                     SetCursor();
  567.  
  568.                     if(Config . EightyColumns)
  569.                         LastColumn = 79;
  570.                     else
  571.                         LastColumn = (Window -> Width >> 3) - 1;
  572.                 }
  573.  
  574.                 Config . FontScale = SCALE_2X;
  575.  
  576.                 break;
  577.  
  578.         default:    if(Config . FontScale == SCALE_HALF)
  579.                 {
  580.                     CursorX >>= 1;
  581.                     SetCursor();
  582.  
  583.                     if(Config . EightyColumns)
  584.                         LastColumn = 79;
  585.                     else
  586.                         LastColumn = (Window -> Width >> 3) - 1;
  587.                 }
  588.  
  589.                 Config . FontScale = SCALE_NORMAL;
  590.  
  591.                 break;
  592.     }
  593.  
  594.     return(NULL);
  595. }
  596.  
  597.     /* SetTab():
  598.      *
  599.      *    Set a tabulator stop at the current position.
  600.      */
  601.  
  602. UBYTE *
  603. SetTab()
  604. {
  605.     if(CursorX < 1024)
  606.         TabStops[CursorX] = TRUE;
  607.  
  608.     return(NULL);
  609. }
  610.  
  611.     /* RequestTerminal(UBYTE *Buffer):
  612.      *
  613.      *    Return the current terminal position.
  614.      */
  615.  
  616. UBYTE *
  617. RequestTerminal(UBYTE *Buffer)
  618. {
  619.     switch(Buffer[0])
  620.     {
  621.                 /* Make ourselves known as a VT200
  622.                  * terminal.
  623.                  */
  624.  
  625.         case '[':    if(Buffer[1] != '>')
  626.                     return("\033[?62;1;2;6;7;8;9c");
  627.                 else
  628.                     return("\033[>1;10;0c");
  629.  
  630.                 /* This is an old status request type,
  631.                  * we will return the standard `I am a
  632.                  * VT101' sequence.
  633.                  */
  634.  
  635.         case 'Z':    return("\033[?1;0c");
  636.  
  637.         default:    return(NULL);
  638.     }
  639. }
  640.  
  641.     /* Reset():
  642.      *
  643.      *    Reset terminal to initial state.
  644.      */
  645.  
  646. UBYTE *
  647. Reset()
  648. {
  649.     SHORT i;
  650.  
  651.     ClearCursor();
  652.  
  653.     memset(&TabStops[0],FALSE,1024);
  654.  
  655.     for(i = 9 ; i < 1024 ; i += 8)
  656.         TabStops[i] = TRUE;
  657.  
  658.     SetRast(RPort,0);
  659.  
  660.     RasterEraseScreen(2);
  661.  
  662.     switch(Config . ColourMode)
  663.     {
  664.         case COLOUR_EIGHT:    FgPen = 7;
  665.                     break;
  666.  
  667.         case COLOUR_SIXTEEN:    FgPen = 15;
  668.                     break;
  669.  
  670.         case COLOUR_AMIGA:
  671.         default:        FgPen = 1;
  672.                     break;
  673.     }
  674.  
  675.     BgPen = 0;
  676.  
  677.     if(RPort -> FgPen != FgPen)
  678.         SetAPen(RPort,FgPen);
  679.  
  680.     if(RPort -> BgPen != BgPen)
  681.         SetBPen(RPort,BgPen);
  682.  
  683.     if(StyleType != FS_NORMAL)
  684.     {
  685.         SetSoftStyle(RPort,FS_NORMAL,0xFF);
  686.  
  687.         StyleType = FS_NORMAL;
  688.     }
  689.  
  690.     if(Config . Font == FONT_TOPAZ)
  691.         SetFont(RPort,Topaz);
  692.     else
  693.     {
  694.         if(IBM)
  695.             SetFont(RPort,IBM);
  696.     }
  697.  
  698.     if(Config . EightyColumns)
  699.         LastColumn = 79;
  700.     else
  701.         LastColumn = (Window -> Width >> 3) - 1;
  702.  
  703.     UseRegion        = FALSE;
  704.     Config . AutoWrap    = TRUE;
  705.     Config . NewLine    = FALSE;
  706.     Config . InsertChar    = FALSE;
  707.     Config . CursorApp    = FALSE;
  708.     Config . NumApp        = FALSE;
  709.     Config . FontScale    = SCALE_NORMAL;
  710.     Config . JumpScroll    = TRUE;
  711.  
  712.     Attributes    = 0;
  713.     Top        = 0;
  714.     Bottom        = LastLine;
  715.     CursorX        = 0;
  716.     CursorY        = 0;
  717.  
  718.     CursorBackup . Charset        = Charset;
  719.     CursorBackup . Attributes    = Attributes;
  720.     CursorBackup . UseRegion    = UseRegion;
  721.     CursorBackup . Top        = Top;
  722.     CursorBackup . Bottom        = Bottom;
  723.     CursorBackup . CursorX        = CursorX;
  724.     CursorBackup . CursorY        = CursorY;
  725.  
  726.     SetCursor();
  727.  
  728.     return(NULL);
  729. }
  730.  
  731.     /* RequestInformation(UBYTE *Buffer):
  732.      *
  733.      *    Request miscellaneous information (state & cursor position).
  734.      */
  735.  
  736. UBYTE *
  737. RequestInformation(UBYTE *Buffer)
  738. {
  739.     SHORT Value;
  740.  
  741.     ReadValue(Buffer,&Value);
  742.  
  743.     switch(Value)
  744.     {
  745.                 /* Terminal status report, return code
  746.                  * for `no malfunction'.
  747.                  */
  748.  
  749.         case 5:        return("\033[0n");
  750.  
  751.                 /* The origin is placed at 0/0 and the first
  752.                  * cursor position is 1/1. We'll have to add
  753.                  * 1 to our internal positions since our
  754.                  * universe has been shifted one field to the
  755.                  * left top corner.
  756.                  */
  757.  
  758.         case 6:        SPrintf(GlobalBuffer,"\033[%ld;%ldR",CursorY + 1,CursorX + 1);
  759.                 return(GlobalBuffer);
  760.  
  761.                 /* A VT200 command: request printer status.
  762.                  * We will return `no printer connected'.
  763.                  */
  764.  
  765.         case 15:    return("\033[?13n");
  766.  
  767.                 /* VT200 command: request user defined
  768.                  * key status. We will return `user
  769.                  * defined keys are locked'.
  770.                  */
  771.  
  772.         case 25:    return("\033[?21n");
  773.  
  774.                 /* Another VT200 command: request
  775.                  * keyboard language. We will return
  776.                  * `keyboard language unknown' - does
  777.                  * anybody know when locale.library will
  778.                  * be released?
  779.                  */
  780.  
  781.         case 26:    return("\033[?27;0n");
  782.  
  783.         default:    return(NULL);
  784.     }
  785. }
  786.  
  787.     /* SetSomething(UBYTE *Buffer):
  788.      *
  789.      *    Set a terminal option.
  790.      */
  791.  
  792. UBYTE *
  793. SetSomething(UBYTE *Buffer)
  794. {
  795.     if(Buffer[1] == '?')
  796.     {
  797.         switch(Buffer[2])
  798.         {
  799.             case '1':    if(Buffer[3] == 'h')
  800.                         Config . CursorApp = TRUE;
  801.                     else
  802.                         Config . CursorApp = FALSE;
  803.  
  804.                     return(NULL);
  805.  
  806.             case '3':    if(Buffer[3] == 'h')
  807.                     {
  808.                         Config . FontScale = SCALE_HALF;
  809.  
  810.                         if(Config . EightyColumns)
  811.                             LastColumn = 131;
  812.                         else
  813.                             LastColumn = (Window -> Width >> 2) - 1;
  814.                     }
  815.                     else
  816.                     {
  817.                         if(Config . FontScale == SCALE_HALF)
  818.                         {
  819.                             ClearCursor();
  820.  
  821.                             CursorX >>= 1;
  822.  
  823.                             SetCursor();
  824.  
  825.                             if(Config . EightyColumns)
  826.                                 LastColumn = 79;
  827.                             else
  828.                                 LastColumn = (Window -> Width >> 3) - 1;
  829.  
  830.                             DrawCursor();
  831.                         }
  832.  
  833.                         Config . FontScale = SCALE_NORMAL;
  834.                     }
  835.  
  836.                     break;
  837.  
  838.             case '4':    if(Buffer[3] == 'h')
  839.                         Config . JumpScroll = FALSE;
  840.                     else
  841.                         Config . JumpScroll = TRUE;
  842.  
  843.                     break;
  844.  
  845.             case '6':    if(Buffer[3] == 'h')
  846.                         UseRegion = TRUE;
  847.                     else
  848.                         UseRegion = FALSE;
  849.  
  850.                     return(NULL);
  851.  
  852.             case '7':    if(Buffer[3] == 'h')
  853.                         Config . AutoWrap = TRUE;
  854.                     else
  855.                         Config . AutoWrap = FALSE;
  856.  
  857.                     return(NULL);
  858.  
  859.             case '9':    if(Buffer[3] == 'h')
  860.                     {
  861.                         if(!(Config . DisplayMode & LACE))
  862.                         {
  863.                             CopyMem(&Config,&PrivateConfig,sizeof(struct Configuration));
  864.  
  865.                             Config . DisplayMode |= LACE;
  866.  
  867.                             ResetDisplay = TRUE;
  868.                         }
  869.                     }
  870.                     else
  871.                     {
  872.                         if(Config . DisplayMode & LACE)
  873.                         {
  874.                             CopyMem(&Config,&PrivateConfig,sizeof(struct Configuration));
  875.  
  876.                             Config . DisplayMode &= ~LACE;
  877.  
  878.                             ResetDisplay = TRUE;
  879.                         }
  880.                     }
  881.  
  882.                     return(NULL);
  883.  
  884.             default:    return(NULL);
  885.         }
  886.     }
  887.     else
  888.     {
  889.         if(Buffer[1] == '2' && Buffer[2] == '0')
  890.         {
  891.             if(Buffer[3] == 'h')
  892.                 Config . NewLine = TRUE;
  893.             else
  894.                 Config . NewLine = FALSE;
  895.         }
  896.         else
  897.         {
  898.             if(Buffer[1] == '4')
  899.             {
  900.                 if(Buffer[2] == 'h')
  901.                     Config . InsertChar = TRUE;
  902.                 else
  903.                     Config . InsertChar = FALSE;
  904.             }
  905.         }
  906.     }
  907.  
  908.     return(NULL);
  909. }
  910.  
  911.     /* NumericAppMode(UBYTE *Buffer):
  912.      *
  913.      *    Set the numeric pad applications mode.
  914.      */
  915.  
  916. UBYTE *
  917. NumericAppMode(UBYTE *Buffer)
  918. {
  919.     if(*Buffer == '=')
  920.         Config . NumApp = TRUE;
  921.     else
  922.     {
  923.         if(*Buffer == '>')
  924.             Config . NumApp = FALSE;
  925.     }
  926.  
  927.     return(NULL);
  928. }
  929.  
  930.     /* MoveCursor(UBYTE *Buffer):
  931.      *
  932.      *    Move the cursor in some direction and stop at
  933.      *    top/bottom/margin if necessary.
  934.      */
  935.  
  936. UBYTE *
  937. MoveCursor(UBYTE *Buffer)
  938. {
  939.     SHORT Value;
  940.  
  941.     switch(LastChar(Buffer))
  942.     {
  943.         case 'A':    ReadValue(Buffer,&Value);
  944.  
  945.                 if(Value == -1)
  946.                     Value = 1;
  947.  
  948.                 ClearCursor();
  949.  
  950.                 if(UseRegion)
  951.                 {
  952.                     if(CursorY - Value > Top)
  953.                         CursorY -= Value;
  954.                     else
  955.                         CursorY = Top;
  956.                 }
  957.                 else
  958.                 {
  959.                     if(CursorY - Value > 0)
  960.                         CursorY -= Value;
  961.                     else
  962.                     {
  963.                         if(Config . CursorWrap)
  964.                         {
  965.                             SHORT i;
  966.  
  967.                             Value -= CursorY;
  968.  
  969.                             for(i = 0 ; i < Value ; i++)
  970.                                 ScrollRegion(-8);
  971.                         }
  972.  
  973.                         CursorY = 0;
  974.                     }
  975.                 }
  976.  
  977.                 break;
  978.  
  979.         case 'B':    ReadValue(Buffer,&Value);
  980.  
  981.                 if(Value == -1)
  982.                     Value = 1;
  983.  
  984.                 ClearCursor();
  985.  
  986.                 if(UseRegion)
  987.                 {
  988.                     if(CursorY + Value < Bottom)
  989.                         CursorY += Value;
  990.                     else
  991.                         CursorY = Bottom;
  992.                 }
  993.                 else
  994.                 {
  995.                     if(CursorY + Value < LastLine)
  996.                         CursorY += Value;
  997.                     else
  998.                     {
  999.                         if(Config . CursorWrap)
  1000.                         {
  1001.                             SHORT i;
  1002.  
  1003.                             Value = CursorY + Value - LastLine;
  1004.  
  1005.                             for(i = 0 ; i < Value ; i++)
  1006.                                 ScrollRegion(8);
  1007.                         }
  1008.  
  1009.                         CursorY = LastLine;
  1010.                     }
  1011.                 }
  1012.  
  1013.                 break;
  1014.  
  1015.         case 'C':    ReadValue(Buffer,&Value);
  1016.  
  1017.                 if(Value == -1)
  1018.                     Value = 1;
  1019.  
  1020.                 ClearCursor();
  1021.  
  1022.                 if(CursorX + Value < LastColumn)
  1023.                     CursorX += Value;
  1024.                 else
  1025.                 {
  1026.                     SHORT i;
  1027.  
  1028.                     Value = (CursorX + Value) - LastColumn;
  1029.  
  1030.                     CursorX = LastColumn;
  1031.  
  1032.                     if(Config . CursorWrap)
  1033.                     {
  1034.                         if(UseRegion)
  1035.                         {
  1036.                             for(i = 0 ; i < Value ; i++)
  1037.                             {
  1038.                                 if(CursorX == LastColumn)
  1039.                                 {
  1040.                                     if(CursorY == Bottom)
  1041.                                         ScrollRegion(8);
  1042.                                     else
  1043.                                         CursorY++;
  1044.  
  1045.                                     CursorX = 0;
  1046.                                 }
  1047.                                 else
  1048.                                     CursorX++;
  1049.                             }
  1050.                         }
  1051.                         else
  1052.                         {
  1053.                             for(i = 0 ; i < Value ; i++)
  1054.                             {
  1055.                                 if(CursorX == LastColumn)
  1056.                                 {
  1057.                                     if(CursorY == LastLine)
  1058.                                         ScrollRegion(8);
  1059.                                     else
  1060.                                         CursorY++;
  1061.  
  1062.                                     CursorX = 0;
  1063.                                 }
  1064.                                 else
  1065.                                     CursorX++;
  1066.                             }
  1067.                         }
  1068.                     }
  1069.                 }
  1070.  
  1071.                 break;
  1072.  
  1073.         case 'D':    ReadValue(Buffer,&Value);
  1074.  
  1075.                 if(Value == -1)
  1076.                     Value = 1;
  1077.  
  1078.                 ClearCursor();
  1079.  
  1080.                 if(CursorX - Value > 0)
  1081.                     CursorX -= Value;
  1082.                 else
  1083.                 {
  1084.                     Value -= CursorX;
  1085.  
  1086.                     CursorX = 0;
  1087.  
  1088.                     if(Config . CursorWrap)
  1089.                     {
  1090.                         SHORT i;
  1091.  
  1092.                         if(UseRegion)
  1093.                         {
  1094.                             for(i = 0 ; i < Value ; i++)
  1095.                             {
  1096.                                 if(CursorX == 0)
  1097.                                 {
  1098.                                     if(CursorY == Top)
  1099.                                         ScrollRegion(-8);
  1100.                                     else
  1101.                                         CursorY--;
  1102.  
  1103.                                     CursorX = LastColumn;
  1104.                                 }
  1105.                                 else
  1106.                                     CursorX--;
  1107.                             }
  1108.                         }
  1109.                         else
  1110.                         {
  1111.                             for(i = 0 ; i < Value ; i++)
  1112.                             {
  1113.                                 if(CursorX == 0)
  1114.                                 {
  1115.                                     if(CursorY == 0)
  1116.                                         ScrollRegion(-8);
  1117.                                     else
  1118.                                         CursorY--;
  1119.  
  1120.                                     CursorX = LastColumn;
  1121.                                 }
  1122.                                 else
  1123.                                     CursorX--;
  1124.                             }
  1125.                         }
  1126.                     }
  1127.                 }
  1128.  
  1129.                 break;
  1130.  
  1131.         default:    break;
  1132.     }
  1133.  
  1134.     SetCursor();
  1135.  
  1136.     return(NULL);
  1137. }
  1138.  
  1139.     /* EraseLine(UBYTE *Buffer):
  1140.      *
  1141.      *    Erase a line on the display.
  1142.      */
  1143.  
  1144. UBYTE *
  1145. EraseLine(UBYTE *Buffer)
  1146. {
  1147.     SHORT Value;
  1148.  
  1149.     ReadValue(Buffer,&Value);
  1150.  
  1151.     BackupRender();
  1152.  
  1153.     SetAPen(RPort,0);
  1154.  
  1155.     RasterEraseLine(Value);
  1156.  
  1157.     ClearCursor();
  1158.  
  1159.     switch(Value)
  1160.     {
  1161.         case 1:    RectFill(RPort,0,CursorY * 8,(CursorX + 1) * 8 - 1,(CursorY + 1) * 8 - 1);
  1162.             break;
  1163.  
  1164.         case 2:    RectFill(RPort,0,CursorY * 8,Window -> Width - 1,(CursorY + 1) * 8 - 1);
  1165.             break;
  1166.  
  1167.         default:RectFill(RPort,CursorX * 8,CursorY * 8,Window -> Width - 1,(CursorY + 1) * 8 - 1);
  1168.             break;
  1169.     }
  1170.  
  1171.     DrawCursor();
  1172.  
  1173.     BackupRender();
  1174.  
  1175.     return(NULL);
  1176. }
  1177.  
  1178.     /* EraseScreen(UBYTE *Buffer):
  1179.      *
  1180.      *    Erase parts of the screen.
  1181.      */
  1182.  
  1183. UBYTE *
  1184. EraseScreen(UBYTE *Buffer)
  1185. {
  1186.     SHORT Value;
  1187.  
  1188.     ClearCursor();
  1189.  
  1190.     ReadValue(Buffer,&Value);
  1191.  
  1192.     BackupRender();
  1193.  
  1194.     SetAPen(RPort,0);
  1195.  
  1196.     RasterEraseScreen(Value);
  1197.  
  1198.     switch(Value)
  1199.     {
  1200.         case 1:    RectFill(RPort,0,0,Window -> Width - 1,(CursorY + 1) * 8 - 1);
  1201.             break;
  1202.  
  1203.         case 2:    RectFill(RPort,0,0,Window -> Width - 1,(LastLine + 1) * 8 - 1);
  1204.             break;
  1205.  
  1206.         default:RectFill(RPort,0,CursorY * 8,Window -> Width - 1,(LastLine + 1) * 8 - 1);
  1207.             break;
  1208.     }
  1209.  
  1210.     DrawCursor();
  1211.  
  1212.     BackupRender();
  1213.  
  1214.     return(NULL);
  1215. }
  1216.  
  1217.     /* EraseCharacters(UBYTE *Buffer):
  1218.      *
  1219.      *    Erase a number of characters.
  1220.      */
  1221.  
  1222. UBYTE *
  1223. EraseCharacters(UBYTE *Buffer)
  1224. {
  1225.     SHORT Value;
  1226.  
  1227.     ReadValue(Buffer,&Value);
  1228.  
  1229.     BackupRender();
  1230.  
  1231.     SetBPen(RPort,0);
  1232.  
  1233.     if(Value == -1)
  1234.         Value = 1;
  1235.  
  1236.     if(Value > 0)
  1237.     {
  1238.         RasterEraseCharacters(Value);
  1239.  
  1240.         ClearCursor();
  1241.  
  1242.         ScrollRaster(RPort,8 * Value,0,CursorX * 8,CursorY * 8,Window -> Width - 1,(LastLine + 1) * 8 - 1);
  1243.  
  1244.         DrawCursor();
  1245.     }
  1246.  
  1247.     BackupRender();
  1248.  
  1249.     return(NULL);
  1250. }
  1251.  
  1252.     /* InsertLine(UBYTE *Buffer):
  1253.      *
  1254.      *    Insert a number of lines and scroll the rest of the
  1255.      *    display down.
  1256.      */
  1257.  
  1258. UBYTE *
  1259. InsertLine(UBYTE *Buffer)
  1260. {
  1261.     SHORT Value;
  1262.  
  1263.     ReadValue(Buffer,&Value);
  1264.  
  1265.     BackupRender();
  1266.  
  1267.     SetAPen(RPort,0);
  1268.  
  1269.     if(Value == -1)
  1270.         Value = 1;
  1271.  
  1272.     if(Value > 0)
  1273.     {
  1274.         RasterInsertLine(Value);
  1275.  
  1276.         ClearCursor();
  1277.  
  1278.         ScrollRaster(RPort,0,-8 * Value,0,CursorY * 8,Window -> Width - 1,(LastLine + 1) * 8 - 1);
  1279.  
  1280.         DrawCursor();
  1281.     }
  1282.  
  1283.     BackupRender();
  1284.  
  1285.     return(NULL);
  1286. }
  1287.  
  1288.     /* ClearLine(UBYTE *Buffer):
  1289.      *
  1290.      *    Clear a number of lines.
  1291.      */
  1292.  
  1293. UBYTE *
  1294. ClearLine(UBYTE *Buffer)
  1295. {
  1296.     SHORT Value;
  1297.  
  1298.     ReadValue(Buffer,&Value);
  1299.  
  1300.     BackupRender();
  1301.  
  1302.     SetAPen(RPort,0);
  1303.  
  1304.     if(Value == -1)
  1305.         Value = 1;
  1306.  
  1307.     if(Value > 0)
  1308.     {
  1309.         RasterClearLine(Value);
  1310.  
  1311.         ClearCursor();
  1312.  
  1313.         RectFill(RPort,0,CursorY * 8,Window -> Width - 1,(CursorY + Value + 1) * 8 - 1);
  1314.  
  1315.         DrawCursor();
  1316.     }
  1317.  
  1318.     BackupRender();
  1319.  
  1320.     return(NULL);
  1321. }
  1322.  
  1323.     /* SetTabs(UBYTE *Buffer):
  1324.      *
  1325.      *    Set the current tab stops.
  1326.      */
  1327.  
  1328. UBYTE *
  1329. SetTabs(UBYTE *Buffer)
  1330. {
  1331.     SHORT Value;
  1332.  
  1333.     ReadValue(Buffer,&Value);
  1334.  
  1335.     if(Value == -1)
  1336.         Value = 0;
  1337.  
  1338.     switch(Value)
  1339.     {
  1340.         case 0:    if(CursorX < 1024)
  1341.                 TabStops[CursorX] = FALSE;
  1342.  
  1343.             break;
  1344.  
  1345.         case 3:    memset(&TabStops[0],FALSE,1024);
  1346.  
  1347.             break;
  1348.  
  1349.         default:break;
  1350.     }
  1351.  
  1352.     return(NULL);
  1353. }
  1354.  
  1355.     /* SetPosition(UBYTE *Buffer):
  1356.      *
  1357.      *    Move the cursor to a given location on the display.
  1358.      */
  1359.  
  1360. UBYTE *
  1361. SetPosition(UBYTE *Buffer)
  1362. {
  1363.     SHORT Value;
  1364.  
  1365.     Buffer = ReadValue(Buffer,&Value);
  1366.  
  1367.     ClearCursor();
  1368.  
  1369.     if(Value == -1)
  1370.     {
  1371.         CursorX = 0;
  1372.  
  1373.         if(UseRegion)
  1374.             CursorY = Top;
  1375.         else
  1376.             CursorY = 0;
  1377.     }
  1378.     else
  1379.     {
  1380.         /* Our raster origin is 0/0 instead of 1/1. */
  1381.  
  1382.         if(UseRegion)
  1383.             CursorY = Top + Value - 1;
  1384.         else
  1385.             CursorY = Value - 1;
  1386.  
  1387.         if(Buffer)
  1388.         {
  1389.             ReadValue(Buffer,&Value);
  1390.  
  1391.             if(Value != -1)
  1392.                 CursorX = Value - 1;
  1393.             else
  1394.                 CursorX = 0;
  1395.         }
  1396.         else
  1397.             CursorX = 0;
  1398.     }
  1399.  
  1400.     SetCursor();
  1401.  
  1402.     return(NULL);
  1403. }
  1404.  
  1405.     /* SetAttributes(UBYTE *Buffer):
  1406.      *
  1407.      *    Set the current display rendering attributes.
  1408.      */
  1409.  
  1410. UBYTE *
  1411. SetAttributes(UBYTE *Buffer)
  1412. {
  1413.     LONG TextFlags = FS_NORMAL;
  1414.     SHORT Value;
  1415.  
  1416.     do
  1417.     {
  1418.         Buffer = ReadValue(Buffer,&Value);
  1419.  
  1420.         if(Value == -1)
  1421.             Value = 0;
  1422.  
  1423.         switch(Value)
  1424.         {
  1425.             case 0:    
  1426.                 if((Attributes & ATTR_HIGHLIGHT) && Config . ColourMode == COLOUR_SIXTEEN)
  1427.                 {
  1428.                     if(Attributes & ATTR_INVERSE)
  1429.                         BgPen &= ~8;
  1430.                     else
  1431.                         FgPen &= ~8;
  1432.                 }
  1433.  
  1434.                 if(Attributes & ATTR_BLINK)
  1435.                 {
  1436.                     switch(Config . ColourMode)
  1437.                     {
  1438.                         case COLOUR_AMIGA:
  1439.                         case COLOUR_MONO:    if(Attributes & ATTR_INVERSE)
  1440.                                         BgPen = 1;
  1441.                                     else
  1442.                                         FgPen = 1;
  1443.  
  1444.                                     break;
  1445.  
  1446.                         case COLOUR_EIGHT:    if(Attributes & ATTR_INVERSE)
  1447.                                         BgPen &= ~8;
  1448.                                     else
  1449.                                         FgPen &= ~8;
  1450.  
  1451.                                     break;
  1452.  
  1453.                         default:        break;
  1454.                     }
  1455.                 }
  1456.  
  1457.                 if(Attributes & ATTR_INVERSE)
  1458.                 {
  1459.                     BYTE Help;
  1460.  
  1461.                     Help    = FgPen;
  1462.                     FgPen    = BgPen;
  1463.                     BgPen    = Help;
  1464.                 }
  1465. /*
  1466.                 switch(Config . ColourMode)
  1467.                 {
  1468.                     case COLOUR_EIGHT:    FgPen = 7;
  1469.                                 break;
  1470.  
  1471.                     case COLOUR_SIXTEEN:    FgPen = 15;
  1472.                                 break;
  1473.  
  1474.                     case COLOUR_AMIGA:
  1475.                     default:        FgPen = 1;
  1476.                                 break;
  1477.                 }
  1478.  
  1479.                 BgPen = 0;*/
  1480.  
  1481.                 if(RPort -> FgPen != FgPen)
  1482.                     SetAPen(RPort,FgPen);
  1483.  
  1484.                 if(RPort -> BgPen != BgPen)
  1485.                     SetBPen(RPort,BgPen);
  1486.  
  1487.                 Attributes = 0;
  1488.  
  1489.                 break;
  1490.  
  1491.             case 1:    Attributes |= ATTR_HIGHLIGHT;
  1492.  
  1493.                 break;
  1494.  
  1495.             case 4:    Attributes |= ATTR_UNDERLINE;
  1496.  
  1497.                 break;
  1498.  
  1499.             case 5:    Attributes |= ATTR_BLINK;
  1500.  
  1501.                 break;
  1502.  
  1503.             case 7:    if(!(Attributes & ATTR_INVERSE))
  1504.                 {
  1505.                     BYTE Help;
  1506.  
  1507.                     Help    = FgPen;
  1508.                     FgPen    = BgPen;
  1509.                     BgPen    = Help;
  1510.                 }
  1511.  
  1512.                 Attributes |= ATTR_INVERSE;
  1513.  
  1514.                 break;
  1515.  
  1516.             default:if(Value >= 30)
  1517.                 {
  1518.                     if(Value <= 37)
  1519.                     {
  1520.                         if(Attributes & ATTR_INVERSE)
  1521.                             BgPen = Value - 30;
  1522.                         else
  1523.                             FgPen = Value - 30;
  1524.                     }
  1525.                     else
  1526.                     {
  1527.                         if(Value >= 40 && Value <= 47)
  1528.                         {
  1529.                             if(Attributes & ATTR_INVERSE)
  1530.                                 FgPen = Value - 40;
  1531.                             else
  1532.                                 BgPen = Value - 40;
  1533.                         }
  1534.                     }
  1535.                 }
  1536.  
  1537.                 break;
  1538.         }
  1539.     }
  1540.     while(Buffer);
  1541.  
  1542.     if(Attributes & ATTR_UNDERLINE)
  1543.         TextFlags |= FSF_UNDERLINED;
  1544.  
  1545.     if(Attributes & ATTR_HIGHLIGHT)
  1546.     {
  1547.         if(Config . ColourMode == COLOUR_SIXTEEN)
  1548.         {
  1549.             if(Attributes & ATTR_INVERSE)
  1550.                 BgPen |= 8;
  1551.             else
  1552.                 FgPen |= 8;
  1553.         }
  1554.         else
  1555.             TextFlags |= FSF_BOLD;
  1556.     }
  1557.  
  1558.     if(Attributes & ATTR_BLINK)
  1559.     {
  1560.         if(Config . Emulation == EMULATION_ANSIVT100)
  1561.         {
  1562.             switch(Config . ColourMode)
  1563.             {
  1564.                 case COLOUR_AMIGA:    if(Attributes & ATTR_INVERSE)
  1565.                                 BgPen = 3;
  1566.                             else
  1567.                                 FgPen = 3;
  1568.                             break;
  1569.  
  1570.                 case COLOUR_EIGHT:    if(Attributes & ATTR_INVERSE)
  1571.                                 BgPen |= 8;
  1572.                             else
  1573.                                 FgPen |= 8;
  1574.                             break;
  1575.  
  1576.                 case COLOUR_SIXTEEN:    break;
  1577.  
  1578.                 case COLOUR_MONO:    if(Attributes & ATTR_INVERSE)
  1579.                                 BgPen = 1;
  1580.                             else
  1581.                                 FgPen = 1;
  1582.                             break;
  1583.             }
  1584.         }
  1585.     }
  1586.  
  1587.     if(TextFlags != StyleType)
  1588.     {
  1589.         SetSoftStyle(RPort,TextFlags,0xFF);
  1590.  
  1591.         StyleType = TextFlags;
  1592.     }
  1593.  
  1594.     if(Config . ColourMode == COLOUR_MONO)
  1595.     {
  1596.         if(ColourValue(FgPen) < ColourValue(BgPen))
  1597.         {
  1598.             FgPen = 0;
  1599.             BgPen = 1;
  1600.         }
  1601.         else
  1602.         {
  1603.             FgPen = 1;
  1604.             BgPen = 0;
  1605.         }
  1606.     }
  1607.  
  1608.     if(FgPen != RPort -> FgPen)
  1609.         SetAPen(RPort,FgPen);
  1610.  
  1611.     if(BgPen != RPort -> BgPen)
  1612.         SetBPen(RPort,BgPen);
  1613.  
  1614.     return(NULL);
  1615. }
  1616.  
  1617.     /* SetRegion(UBYTE *Buffer):
  1618.      *
  1619.      *    Set the current scroll region top and bottom.
  1620.      */
  1621.  
  1622. UBYTE *
  1623. SetRegion(UBYTE *Buffer)
  1624. {
  1625.     SHORT Value;
  1626.  
  1627.     Buffer = ReadValue(Buffer,&Value);
  1628.  
  1629.     if(Value != -1)
  1630.     {
  1631.         Top = Value - 1;
  1632.  
  1633.         if(Buffer)
  1634.         {
  1635.             ReadValue(Buffer,&Value);
  1636.  
  1637.             if(Value != -1)
  1638.                 Bottom = Value - 1;
  1639.         }
  1640.  
  1641.         UseRegion = TRUE;
  1642.     }
  1643.  
  1644.     return(NULL);
  1645. }
  1646.