home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d8xx / d832 / term.lha / Term / term-3.1-Source.lha / termMarker.c < prev    next >
C/C++ Source or Header  |  1993-02-12  |  15KB  |  687 lines
  1. /*
  2. **    termMarker.c
  3. **
  4. **    Text block marker routines
  5. **
  6. **    Copyright © 1990-1993 by Olaf `Olsen' Barthel & MXM
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* BM_Draw():
  13.      *
  14.      *    Redraw or remove marked regions.
  15.      */
  16.  
  17. VOID
  18. BM_Draw(struct BlockMarker *Marker,VOID (*Select)(struct BlockMarker *Marker,LONG Left,LONG Top,LONG Width,LONG Height))
  19. {
  20.         /* Is the first line the same as the last line? If so,
  21.          * continue and mark only single characters. Else,
  22.          * determine first line and column to mark and last
  23.          * line and last column.
  24.          */
  25.  
  26.     if(Marker -> FirstLine != Marker -> LastLine)
  27.     {
  28.         LONG    First    = Marker -> FirstLine - Marker -> Top,
  29.             Last    = Marker -> LastLine  - Marker -> Top,
  30.             Lines;
  31.  
  32.             /* Is the first line visible? If so, mark it. */
  33.  
  34.         if(First >= 0)
  35.             (*Select)(Marker,Marker -> FirstColumn,First,Marker -> Width - Marker -> FirstColumn,1);
  36.         else
  37.         {
  38.             (*Select)(Marker,0,0,Marker -> Width,1);
  39.  
  40.             First = 0;
  41.         }
  42.  
  43.             /* Is the last line visible? If so, mark it. */
  44.  
  45.         if(Last >= 0 && Last < Marker -> Height)
  46.             (*Select)(Marker,0,Last,Marker -> LastColumn,1);
  47.         else
  48.             Last = Marker -> Height;
  49.  
  50.             /* Determine the number of lines the selection spans. */
  51.  
  52.         if((Lines = Last - First - 1) > 0)
  53.             (*Select)(Marker,0,First + 1,Marker -> Width,Lines);
  54.     }
  55.     else
  56.     {
  57.             /* Is the first column different from the last column? */
  58.  
  59.         if(Marker -> FirstColumn != Marker -> LastColumn)
  60.         {
  61.                 /* Is the line visible? If so, mark it. */
  62.  
  63.             if(Marker -> Top <= Marker -> LastLine && Marker -> LastLine < Marker -> Top + Marker -> Height)
  64.                 (*Select)(Marker,Marker -> FirstColumn,Marker -> FirstLine - Marker -> Top,Marker -> LastColumn - Marker -> FirstColumn,1);
  65.         }
  66.     }
  67. }
  68.  
  69.     /* BM_ClearMark(struct BlockMarker *Marker):
  70.      *
  71.      *    Free block marker memory.
  72.      */
  73.  
  74. VOID
  75. BM_ClearMark(struct BlockMarker *Marker)
  76. {
  77.     BM_Draw(Marker,Marker -> Unselect);
  78.  
  79.     FreeVec(Marker);
  80. }
  81.  
  82.     /* BM_SetMark():
  83.      *
  84.      *    Create block marker structure.
  85.      */
  86.  
  87. struct BlockMarker *
  88. BM_SetMark(APTR Object,VPTR Select,VPTR Unselect,LONG Width,LONG Height,LONG LeftEdge,LONG TopEdge,LONG Top,LONG Lines,LONG X,LONG Y,WORD TextFontWidth,WORD TextFontHeight)
  89. {
  90.     if(Height && Lines)
  91.     {
  92.         struct BlockMarker *Marker;
  93.  
  94.             /* Allocate marker buffer. */
  95.  
  96.         if(Marker = (struct BlockMarker *)AllocVec(sizeof(struct BlockMarker),MEMF_ANY | MEMF_CLEAR))
  97.         {
  98.                 /* Fill in the object or canvas, usually a RastPort. */
  99.  
  100.             Marker -> Object    = Object;
  101.  
  102.                 /* Fill in the canvas left and top edge. */
  103.  
  104.             Marker -> LeftEdge    = LeftEdge;
  105.             Marker -> TopEdge    = TopEdge;
  106.  
  107.                 /* Fill in the select and unselect routines. */
  108.  
  109.             Marker -> Select    = Select;
  110.             Marker -> Unselect    = Unselect;
  111.  
  112.                 /* Fill in current display window top and number of
  113.                  * lines in the buffer.
  114.                  */
  115.  
  116.             Marker -> Top        = Top;
  117.             Marker -> Lines        = Lines;
  118.  
  119.                 /* Fill in width and height of the display window. */
  120.  
  121.             Marker -> Width        = Width;
  122.             Marker -> Height    = Height;
  123.  
  124.                 /* Fill in the marker anchor point. */
  125.  
  126.             Marker -> FirstColumn    = X;
  127.             Marker -> LastColumn    = X;
  128.             Marker -> FirstLine    = Y + Top;
  129.             Marker -> LastLine    = Y + Top;
  130.  
  131.                 /* Fill in current mouse position. */
  132.  
  133.             Marker -> LastX        = X;
  134.             Marker -> LastY        = Y;
  135.  
  136.             Marker -> OriginX    = X;
  137.             Marker -> OriginY    = Y + Top;
  138.  
  139.                 /* Remember text font dimensions. */
  140.  
  141.             Marker -> TextFontWidth    = TextFontWidth;
  142.             Marker -> TextFontHeight= TextFontHeight;
  143.  
  144.             Marker -> WriteMask    = ((struct RastPort *)Object) -> Mask;
  145.         }
  146.  
  147.             /* Return marker buffer. */
  148.  
  149.         return(Marker);
  150.     }
  151.     else
  152.         return(NULL);
  153. }
  154.  
  155.     /* BM_ExtendMark(struct BlockMarker *Marker,LONG X,LONG Y,LONG Delta):
  156.      *
  157.      *    Extend current block marker. This routine was
  158.      *    first written by me, but Martin Berndt rewrote it
  159.      *    after we both realised that it would not work
  160.      *    properly.
  161.      */
  162.  
  163. VOID
  164. BM_ExtendMark(struct BlockMarker *Marker,LONG X,LONG Y,LONG Delta)
  165. {
  166.     if(Marker -> LastX != X || Marker -> LastY != Y)
  167.     {
  168.         LONG    OldCharPos,NewCharPos,
  169.             CharStart,CharEnd,
  170.             CharOrigin,
  171.             OriginY,
  172.             Lines;
  173.         BYTE    Crossed;
  174.  
  175.             OriginY = Marker -> OriginY - Marker -> Top;
  176.  
  177.  
  178.             /* Deal with illegal X position. */
  179.  
  180.         if(X < 0)
  181.             X = 0;
  182.  
  183.         if(X > Marker -> Width)
  184.             X = Marker -> Width;
  185.  
  186.             /* Deal with illegal Y position. */
  187.  
  188.         if(Y < 0)
  189.             Y = 0;
  190.  
  191.         if(Y >= Marker -> Height)
  192.             Y = Marker -> Height - 1;
  193.  
  194.         if(Y + Marker -> Top >= Marker -> Lines)
  195.             Y = Marker -> Lines - Marker -> Top - 1;
  196.  
  197.             /* Is the Y position larger than the last line? If so,
  198.              * truncate it.
  199.              */
  200.  
  201.         if(Y > Marker -> Lines - Marker -> Top)
  202.             Y -= Marker -> Lines - Marker -> Top;
  203.  
  204.             /* Select the text. */
  205.  
  206.         OldCharPos    = (Marker -> LastY + Marker -> Top) * Marker -> Width + Marker -> LastX;
  207.         NewCharPos    = (Y + Marker -> Top) * Marker -> Width + X;
  208.  
  209.         CharStart    = Marker -> FirstLine * Marker -> Width + Marker -> FirstColumn;
  210.         CharEnd        = Marker -> LastLine * Marker -> Width + Marker -> LastColumn;
  211.  
  212.         CharOrigin    = Marker -> OriginY * Marker -> Width + Marker -> OriginX;
  213.  
  214.         Crossed        = (OldCharPos < CharOrigin) ^ (NewCharPos < CharOrigin);
  215.  
  216.         if(NewCharPos > OldCharPos)
  217.         {
  218.             if(Delta && Y < OriginY)
  219.                 (*Marker -> Select)(Marker,0,Y,Marker -> Width,1);
  220.  
  221.             if(Crossed)
  222.             {
  223.                 if((Lines = OriginY - Marker -> LastY - 1) >= 0)
  224.                 {
  225.                     (*Marker -> Unselect)(Marker,Marker -> LastX,Marker -> LastY,Marker -> Width - Marker -> LastX,1);
  226.  
  227.                     if(Lines > 0)
  228.                         (*Marker -> Unselect)(Marker,0,Marker -> LastY + 1,Marker -> Width,Lines);
  229.  
  230.                     if(Marker -> OriginX)
  231.                         (*Marker -> Unselect)(Marker,0,OriginY,Marker -> OriginX,1);
  232.                 }
  233.                 else
  234.                 {
  235.                     if(Delta)
  236.                         (*Marker -> Unselect)(Marker,0,OriginY,Marker -> LastX,1);
  237.                     else
  238.                         (*Marker -> Unselect)(Marker,Marker -> LastX,OriginY,Marker -> OriginX - Marker -> LastX,1);
  239.                 }
  240.  
  241.                 Marker -> FirstColumn    = Marker -> OriginX;
  242.                 Marker -> FirstLine     = Marker -> OriginY;
  243.  
  244.                 Marker -> LastX        = Marker -> OriginX;
  245.                 Marker -> LastY        = OriginY;
  246.             }
  247.             else
  248.             {
  249.                 if(OldCharPos < CharOrigin)
  250.                 {
  251.                     if((Lines = Y - Marker -> LastY - 1) >= 0)
  252.                     {
  253.                         (*Marker -> Unselect)(Marker,Marker -> LastX,Marker -> LastY,Marker -> Width - Marker -> LastX,1);
  254.  
  255.                         if(Lines > 0)
  256.                             (*Marker -> Unselect)(Marker,0,Marker -> LastY + 1,Marker -> Width,Lines);
  257.  
  258.                         (*Marker -> Unselect)(Marker,0,Y,X,1);
  259.                     }
  260.                     else
  261.                     {
  262.                         if(Delta)
  263.                             (*Marker -> Unselect)(Marker,0,Y,X,1);
  264.                         else
  265.                             (*Marker -> Unselect)(Marker,Marker -> LastX,Y,X - Marker -> LastX,1);
  266.                     }
  267.  
  268.                     Marker -> FirstColumn    = X;
  269.                     Marker -> FirstLine    = Y + Marker -> Top;
  270.                 }
  271.             }
  272.  
  273.             if(NewCharPos > CharEnd)
  274.             {
  275.                 if((Lines = Y - Marker -> LastY - 1) >= 0)
  276.                 {
  277.                     (*Marker -> Select)(Marker,Marker -> LastX,Marker -> LastY,Marker -> Width - Marker -> LastX,1);
  278.  
  279.                     if(Lines > 0)
  280.                         (*Marker -> Select)(Marker,0,Marker -> LastY + 1,Marker -> Width,Lines);
  281.  
  282.                     (*Marker -> Select)(Marker,0,Y,X,1);
  283.                 }
  284.                 else
  285.                 {
  286.                     if(Delta)
  287.                         (*Marker -> Select)(Marker,0,Y,X,1);
  288.                     else
  289.                         (*Marker -> Select)(Marker,Marker -> LastX,Y,X - Marker -> LastX,1);
  290.                 }
  291.  
  292.                 Marker -> LastColumn    = X;
  293.                 Marker -> LastLine    = Y + Marker -> Top;
  294.             }
  295.         }
  296.         else
  297.         {
  298.             if(Delta && Y > OriginY)
  299.                 (*Marker -> Select)(Marker,0,Y,Marker -> Width,1);
  300.  
  301.             if(Crossed)
  302.             {
  303.                 if((Lines = Marker -> LastY - OriginY - 1) >= 0)
  304.                 {
  305.                     (*Marker -> Unselect)(Marker,0,Marker -> LastY,Marker -> LastX,1);
  306.  
  307.                     if(Lines > 0)
  308.                         (*Marker -> Unselect)(Marker,0,OriginY + 1,Marker -> Width,Lines);
  309.  
  310.                     (*Marker -> Unselect)(Marker,Marker -> OriginX,OriginY,Marker -> Width - Marker -> OriginX,1);
  311.                 }
  312.                 else
  313.                 {
  314.                     if(Delta)
  315.                         (*Marker -> Unselect)(Marker,Marker -> LastX,OriginY,Marker -> Width - Marker -> LastX,1);
  316.                     else
  317.                         (*Marker -> Unselect)(Marker,Marker -> OriginX,OriginY,Marker -> LastX - Marker -> OriginX,1);
  318.                 }
  319.  
  320.                 Marker -> LastColumn    = Marker -> OriginX;
  321.                 Marker -> LastLine    = Marker -> OriginY;
  322.  
  323.                 Marker -> LastX        = Marker -> OriginX;
  324.                 Marker -> LastY        = OriginY;
  325.             }
  326.             else
  327.             {
  328.                 if(OldCharPos > CharOrigin)
  329.                 {
  330.                     if((Lines = Marker -> LastY - Y - 1) >= 0)
  331.                     {
  332.                         if(Marker -> LastX)
  333.                             (*Marker -> Unselect)(Marker,0,Marker -> LastY,Marker -> LastX,1);
  334.  
  335.                         if(Lines > 0)
  336.                             (*Marker -> Unselect)(Marker,0,Y + 1,Marker -> Width,Lines);
  337.  
  338.                         (*Marker -> Unselect)(Marker,X,Y,Marker -> Width - X,1);
  339.                     }
  340.                     else
  341.                     {
  342.                         if(Delta)
  343.                             (*Marker -> Unselect)(Marker,X,Y,Marker -> Width - X,1);
  344.                         else
  345.                             (*Marker -> Unselect)(Marker,X,Y,Marker -> LastX - X,1);
  346.                     }
  347.  
  348.                     Marker -> LastColumn    = X;
  349.                     Marker -> LastLine    = Y + Marker -> Top;
  350.                 }
  351.             }
  352.  
  353.             if(NewCharPos < CharStart)
  354.             {
  355.                 if((Lines = Marker -> LastY - Y - 1) >= 0)
  356.                 {
  357.                     if(Marker -> LastX)
  358.                         (*Marker -> Select)(Marker,0,Marker -> LastY,Marker -> LastX,1);
  359.  
  360.                     if(Lines > 0)
  361.                         (*Marker -> Select)(Marker,0,Y + 1,Marker -> Width,Lines);
  362.  
  363.                     (*Marker -> Select)(Marker,X,Y,Marker -> Width - X,1);
  364.                 }
  365.                 else
  366.                 {
  367.                     if(Delta)
  368.                         (*Marker -> Select)(Marker,X,Y,Marker -> Width - X,1);
  369.                     else
  370.                         (*Marker -> Select)(Marker,X,Y,Marker -> LastX - X,1);
  371.                 }
  372.  
  373.                 Marker -> FirstColumn    = X;
  374.                 Marker -> FirstLine    = Y + Marker -> Top;
  375.             }
  376.         }
  377.  
  378.         Marker -> LastX = X;
  379.         Marker -> LastY = Y;
  380.     }
  381. }
  382.  
  383.  
  384.     /* ToggleSelect(struct BlockMarker *Marker,LONG Left,LONG Top,LONG Width,LONG Height):
  385.      *
  386.      *    Toggle selection subroutine.
  387.      */
  388.  
  389. VOID
  390. ToggleSelect(struct BlockMarker *Marker,LONG Left,LONG Top,LONG Width,LONG Height)
  391. {
  392.     if(Width && Height)
  393.         ClipBlit(Marker -> Object,0,0,Marker -> Object,Marker -> LeftEdge + Left * Marker -> TextFontWidth,Marker -> TopEdge + Top * Marker -> TextFontHeight,Width * Marker -> TextFontWidth,Height * Marker -> TextFontHeight,0x50);
  394. }
  395.  
  396.     /* WriteTrimmedString(struct IFFHandle *Handle,STRPTR String,LONG Len):
  397.      *
  398.      *    Write a string to the clipboard, sans trailing spaces.
  399.      */
  400.  
  401. VOID __regargs
  402. WriteTrimmedString(struct IFFHandle *Handle,STRPTR String,LONG Len)
  403. {
  404.     while(Len > 0)
  405.     {
  406.         if(String[Len - 1] != ' ')
  407.             break;
  408.         else
  409.             Len--;
  410.     }
  411.  
  412.     if(Len)
  413.         WriteChunkBytes(Handle,String,Len);
  414. }
  415.  
  416.     /* TrimLength(STRPTR String,LONG Len):
  417.      *
  418.      *    Determine the length of a string, sans trailing spaces.
  419.      */
  420.  
  421. LONG __regargs
  422. TrimLength(STRPTR String,LONG Len)
  423. {
  424.     while(Len > 0)
  425.     {
  426.         if(String[Len - 1] != ' ')
  427.             break;
  428.         else
  429.             Len--;
  430.     }
  431.  
  432.     return(Len);
  433. }
  434.  
  435.     /* ClipPage(struct BlockMarker *Marker):
  436.      *
  437.      *    Send the entire marked page to the clipboard.
  438.      */
  439.  
  440. STATIC VOID __inline
  441. ClipPage(struct BlockMarker *Marker)
  442. {
  443.     struct IFFHandle *Handle;
  444.  
  445.     if(Handle = AllocIFF())
  446.     {
  447.         if(Handle -> iff_Stream = (ULONG)OpenClipboard(Config -> ClipConfig -> ClipboardUnit))
  448.         {
  449.             InitIFFasClip(Handle);
  450.  
  451.             if(!OpenIFF(Handle,IFFF_WRITE))
  452.             {
  453.                 if(!PushChunk(Handle,ID_FTXT,ID_FORM,IFFSIZE_UNKNOWN))
  454.                 {
  455.                     if(!PushChunk(Handle,0,ID_CHRS,IFFSIZE_UNKNOWN))
  456.                     {
  457.                         LONG    Lines = Marker -> LastLine - Marker -> FirstLine - 1,
  458.                             i;
  459.  
  460.                         WriteTrimmedString(Handle,&Raster[RasterWidth * Marker -> FirstLine + Marker -> FirstColumn],Marker -> Width - Marker -> FirstColumn);
  461.                         WriteChunkBytes(Handle,"\n",1);
  462.  
  463.                         if(Lines > 0)
  464.                         {
  465.                             STRPTR Line = &Raster[(Marker -> FirstLine + 1) * RasterWidth];
  466.  
  467.                             for(i = 0 ; i < Lines ; i++)
  468.                             {
  469.                                 WriteTrimmedString(Handle,Line,Marker -> Width);
  470.                                 WriteChunkBytes(Handle,"\n",1);
  471.  
  472.                                 Line += RasterWidth;
  473.                             }
  474.                         }
  475.  
  476.                         WriteTrimmedString(Handle,&Raster[RasterWidth * Marker -> LastLine],Marker -> LastColumn);
  477.                         WriteChunkBytes(Handle,"\n",1);
  478.  
  479.                         PopChunk(Handle);
  480.                     }
  481.  
  482.                     PopChunk(Handle);
  483.                 }
  484.  
  485.                 CloseIFF(Handle);
  486.             }
  487.  
  488.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  489.         }
  490.  
  491.         FreeIFF(Handle);
  492.     }
  493. }
  494.  
  495.     /* MarkWord(LONG MouseX,LONG MouseY):
  496.      *
  497.      *    Mark a single word on the main screen (double-click).
  498.      */
  499.  
  500. VOID
  501. MarkWord(LONG MouseX,LONG MouseY)
  502. {
  503.     LONG FirstX,FirstY;
  504.  
  505.     FirstX = MouseX / TextFontWidth;
  506.     FirstY = MouseY / TextFontHeight;
  507.  
  508.     if(FirstX > LastColumn)
  509.         FirstX = LastColumn;
  510.  
  511.     if(FirstY > LastLine)
  512.         FirstY = LastLine;
  513.  
  514.     ObtainSemaphore(RasterSemaphore);
  515.  
  516.     if(Raster[FirstY * RasterWidth + FirstX] != ' ' && Raster[FirstY * RasterWidth + FirstX])
  517.     {
  518.         STRPTR    Line = &Raster[FirstY * RasterWidth];
  519.         LONG    LastX;
  520.  
  521.         LastX = FirstX;
  522.  
  523.         while(FirstX > 0 && Line[FirstX - 1] != ' ')
  524.             FirstX--;
  525.  
  526.         while(LastX < LastColumn && Line[LastX + 1] != ' ')
  527.             LastX++;
  528.  
  529.         if(WindowMarker = BM_SetMark(Window -> RPort,ToggleSelect,ToggleSelect,LastColumn + 1,LastLine + 1,WindowLeft,WindowTop,0,LastLine + 1,FirstX,FirstY,TextFontWidth,TextFontHeight))
  530.         {
  531.             ClearCursor();
  532.  
  533.             SetWrMsk(RPort,DepthMask);
  534.  
  535.             Marking = TRUE;
  536.  
  537.             ReportMouse(TRUE,Window);
  538.  
  539.             BM_ExtendMark(WindowMarker,LastX + 1,FirstY,0);
  540.         }
  541.     }
  542.  
  543.     ReleaseSemaphore(RasterSemaphore);
  544. }
  545.  
  546.     /* SetMarker(LONG MouseX,LONG MouseY):
  547.      *
  548.      *    Anchor a marker to the current mouse position.
  549.      */
  550.  
  551. VOID
  552. SetMarker(LONG MouseX,LONG MouseY)
  553. {
  554.     LONG FirstX,FirstY;
  555.  
  556.     FirstX = MouseX / TextFontWidth;
  557.     FirstY = MouseY / TextFontHeight;
  558.  
  559.     if(FirstX > LastColumn)
  560.         FirstX = LastColumn;
  561.  
  562.     if(FirstY > LastLine)
  563.         FirstY = LastLine;
  564.  
  565.     if(WindowMarker = BM_SetMark(Window -> RPort,ToggleSelect,ToggleSelect,LastColumn + 1,LastLine + 1,WindowLeft,WindowTop,0,LastLine + 1,FirstX,FirstY,TextFontWidth,TextFontHeight))
  566.     {
  567.         ClearCursor();
  568.  
  569.         SetWrMsk(RPort,DepthMask);
  570.  
  571.         Marking = TRUE;
  572.  
  573.         ReportMouse(TRUE,Window);
  574.     }
  575. }
  576.  
  577.     /* MoveMarker(LONG MouseX,LONG MouseY):
  578.      *
  579.      *    Move the marker with the mouse.
  580.      */
  581.  
  582. VOID
  583. MoveMarker(LONG MouseX,LONG MouseY)
  584. {
  585.     if(WindowMarker)
  586.         BM_ExtendMark(WindowMarker,(MouseX + TextFontWidth - 1) / TextFontWidth,MouseY / TextFontHeight,0);
  587. }
  588.  
  589.     /* DropMarker():
  590.      *
  591.      *    Drop the window marker, restore the window contents.
  592.      */
  593.  
  594. VOID
  595. DropMarker()
  596. {
  597.     if(WindowMarker)
  598.     {
  599.         struct RastPort    *RPort    = WindowMarker -> Object;
  600.         UBYTE         Mask    = WindowMarker -> WriteMask;
  601.  
  602.         BM_ClearMark(WindowMarker);
  603.  
  604.         SetWrMsk(RPort,Mask);
  605.  
  606.         DrawCursor();
  607.  
  608.         ReportMouse(FALSE,Window);
  609.  
  610.         WindowMarker = NULL;
  611.  
  612.         Marking = FALSE;
  613.     }
  614. }
  615.  
  616.     /* FreeMarker():
  617.      *
  618.      *    Free the main window marker.
  619.      */
  620.  
  621. VOID
  622. FreeMarker()
  623. {
  624.     if(WindowMarker)
  625.     {
  626.         struct RastPort    *RPort    = WindowMarker -> Object;
  627.         UBYTE         Mask    = WindowMarker -> WriteMask;
  628.  
  629.         FreeVec(WindowMarker);
  630.  
  631.         WindowMarker = NULL;
  632.  
  633.         SetWrMsk(RPort,Mask);
  634.  
  635.         ReportMouse(FALSE,Window);
  636.  
  637.         Marking = FALSE;
  638.     }
  639. }
  640.  
  641.     /* ClipMarker():
  642.      *
  643.      *    Transfer the marked area to the clipboard.
  644.      */
  645.  
  646. VOID
  647. ClipMarker()
  648. {
  649.     if(WindowMarker)
  650.     {
  651.         ObtainSemaphore(RasterSemaphore);
  652.  
  653.         SetWait(Window);
  654.  
  655.         if(WindowMarker -> FirstColumn == WindowMarker -> Width)
  656.         {
  657.             WindowMarker -> FirstLine++;
  658.  
  659.             WindowMarker -> FirstColumn = 0;
  660.         }
  661.  
  662.         if(WindowMarker -> LastColumn == 0)
  663.         {
  664.             WindowMarker -> LastLine--;
  665.  
  666.             WindowMarker -> LastColumn = WindowMarker -> Width;
  667.         }
  668.  
  669.         if(WindowMarker -> FirstLine <= WindowMarker -> LastLine)
  670.         {
  671.             if(WindowMarker -> FirstLine != WindowMarker -> LastLine || WindowMarker -> FirstColumn != WindowMarker -> LastColumn)
  672.             {
  673.                 if(WindowMarker -> FirstLine == WindowMarker -> LastLine)
  674.                     SaveClip(&Raster[RasterWidth * WindowMarker -> FirstLine + WindowMarker -> FirstColumn],WindowMarker -> LastColumn - WindowMarker -> FirstColumn);
  675.                 else
  676.                     ClipPage(WindowMarker);
  677.             }
  678.         }
  679.  
  680.         ClrWait(Window);
  681.  
  682.         ReleaseSemaphore(RasterSemaphore);
  683.  
  684.         DropMarker();
  685.     }
  686. }
  687.