home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 September / Simtel20_Sept92.cdr / msdos / modem / wxtermsr.arc / WXTMWIND.INC < prev    next >
Text File  |  1988-02-12  |  9KB  |  306 lines
  1. {$U-,C-,R-,K-}
  2. { A set of routines for text window manipulation
  3.   By Bela Lubkin
  4.   Borland International Technical Support
  5.   1/10/85
  6.   2/20/85 Bug fix: DisposeWindow left a bunch of junk on the heap, causing
  7.     uncontrolled growth!
  8.   (For PC-DOS Turbo Pascal version 2 or greater)
  9. }
  10. TYPE
  11.   XTCoord=1..80;   { X Text coordinate }
  12.   YTCoord=1..25;   { Y Text coordinate }
  13.   XTCoord0=0..80;  { X Text coordinate + 0 for nothing }
  14.   YTCoord0=0..25;  { Y Text coordinate + 0 for nothing }
  15.   WindowRec=RECORD
  16.               XSize: XTCoord;
  17.               YSize: YTCoord;
  18.               XPosn: XTCoord;
  19.               YPosn: YTCoord;
  20.               Contents: ARRAY [0..1999] OF INTEGER;
  21.             END;
  22.   WindowPtr=^WindowRec;
  23.  
  24. VAR
  25.   WindowXLo: XTCoord;
  26.   WindowYLo: YTCoord;
  27.   WindowXHi: XTCoord;
  28.   WindowYHi: YTCoord;
  29.   ScreenBase: INTEGER;
  30.  
  31. PROCEDURE TurboWindow(XL: XTCoord; YL: YTCoord; XH: XTCoord; YH: YTCoord);
  32. { This procedure provides an entry to Turbo's built in Window procedure }
  33.   BEGIN
  34.     Window(XL,YL,XH,YH);
  35.   END;
  36.  
  37. PROCEDURE Window(XL: XTCoord; YL: YTCoord; XH: XTCoord; YH: YTCoord);
  38. { This procedure replaces Turbo's built in Window procedure.  It calls the
  39.   original Window procedure, and also keeps track of the window boundaries. }
  40.  
  41.   BEGIN
  42.     TurboWindow(XL,YL,XH,YH);
  43.     WindowXLo:=XL;
  44.     WindowYLo:=YL;
  45.     WindowXHi:=XH;
  46.     WindowYHi:=YH;
  47.   END;
  48.  
  49. FUNCTION SaveWindow(XLow: XTCoord; YLow: YTCoord;
  50.                     XHigh: XTCoord; YHigh:YTCoord): WindowPtr;
  51. { Allocate a WindowRec of the precise size needed to save the window, then
  52.   fill it with the text that is in the window XLow..XHigh, YLow..YHigh.
  53.   Return a pointer to this WindowRec. }
  54.  
  55.   VAR
  56.     SW: WindowPtr;
  57.     I: INTEGER;
  58.     XS: XTCoord;
  59.     YS: YTCoord;
  60.  
  61.   BEGIN
  62.     XS:=XHigh-XLow+1;
  63.     YS:=YHigh-YLow+1;
  64.     GetMem(SW,2*XS*YS + 4);
  65.     { Allocate 2 bytes for each screen position, + 4 for size and position }
  66.     WITH SW^ DO
  67.      BEGIN
  68.       XSize:=XS;
  69.       YSize:=YS;
  70.       XPosn:=XLow;
  71.       YPosn:=YLow;
  72.       FOR I:=0 TO YSize-1 DO
  73.         Move(Mem[ScreenBase:((YPosn+I-1)*80+XPosn-1) ShL 1],
  74.              Contents[I*XSize],XSize ShL 1);
  75.       { For each line of the window,
  76.           Move XSize*2 bytes (1 for char, 1 for attribute) into the Contents
  77.                array.  Leave no holes in the array. }
  78.      END;
  79.     SaveWindow:=SW;
  80.   END;
  81.  
  82. FUNCTION SaveCurrentWindow: WindowPtr;
  83.   BEGIN
  84.     SaveCurrentWindow:=SaveWindow(WindowXLo,WindowYLo,WindowXHi,WindowYHi);
  85.   END;
  86.  
  87. PROCEDURE RestoreWindow(WP: WindowPtr; XPos: XTCoord0; YPos: YTCoord0);
  88. { Given a pointer to a WindowRec, restore the contents of the window.  If
  89.   XPos or YPos is 0, use the XPosn or YPosn that the window was originally
  90.   saved with.  If either is nonzero, use it.  Thus a window can be restored
  91.   exactly with  RestoreWindow(wp,0,0);  or its upper left corner can be
  92.   placed at (2,3) with  RestoreWindow(wp,2,3); }
  93.  
  94.   VAR
  95.     I: INTEGER;
  96.  
  97.   BEGIN
  98.     WITH WP^ DO
  99.      BEGIN
  100.       IF XPos=0 THEN XPos:=XPosn;
  101.       IF YPos=0 THEN YPos:=YPosn;
  102.       FOR I:=0 TO YSize-1 DO
  103.         Move(Contents[I*XSize],
  104.              Mem[ScreenBase:2*((YPos+I-1)*80+XPos-1)],XSize*2);
  105.       { For each line of the window,
  106.           Move XSize*2 bytes (1 for char, 1 for attribute) from the Contents
  107.                array onto the screen. }
  108.      END;
  109.   END;
  110.  
  111. PROCEDURE DisposeWindow(VAR WP: WindowPtr);
  112. { Dispose of a WindowPtr.  The built in procedure Dispose cannot be used,
  113.   because it will deallocate SizeOf(WindowRec) bytes, even though less may
  114.   have been allocated. }
  115.  
  116.   BEGIN
  117.     WITH WP^ DO FreeMem(WP,2*XSize*YSize+4);
  118.     WP:=NIL;
  119.   END;
  120.  
  121. PROCEDURE DRestoreWindow(VAR WP: WindowPtr; XPos: XTCoord0; YPos: YTCoord0);
  122. { Restore the contents of a window, then dispose of the saved image }
  123.  
  124.   BEGIN
  125.     RestoreWindow(WP, XPos, YPos);
  126.     DisposeWindow(WP);
  127.   END;
  128.  
  129. PROCEDURE DRestoreCurrentWindow(VAR WP: WindowPtr;
  130.                                 XPos: XTCoord0; YPos: YTCoord0);
  131. { Restore the contents of a window, set the current window to fit the restored
  132.   window, and dispose of the saved image.  A similar procedure
  133.   RestoreCurrentWindow could be written by changing DRestoreWindow to
  134.   RestoreWindow in the last line of the procedure, but I have assumed that
  135.   when you select a window area, you are going to modify it, and not want the
  136.   old image }
  137.  
  138.   BEGIN
  139.     WITH WP^ DO
  140.      BEGIN
  141.       IF XPos=0 THEN XPos:=XPosn;
  142.       IF YPos=0 THEN YPos:=YPosn;
  143.       Window(XPos,YPos,XPos+XSize-1,YPos+YSize-1);
  144.      END;
  145.     DRestoreWindow(WP, XPos, YPos);
  146.   END;
  147.  
  148. {****** My interface - S. Murphy ******}
  149.  
  150. TYPE
  151.     WindowParms = RECORD
  152.         col1, col2,
  153.         row1, row2 : INTEGER;          {corner co-ordinates}
  154.         frame : 0..2;                  {border type}
  155.         CursorX, CursorY : INTEGER;          {cursor position}
  156.     END;
  157.  
  158.     WindowDescriptor = ^WindowParms;
  159. VAR
  160.    StatWin, TermWin,
  161.    CurrentWin, border    : WindowDescriptor;
  162.    TempWin               : WindowPtr;
  163.    StackedPage           : WindowPtr;
  164.  
  165. PROCEDURE UsePermWindow(VAR w : WindowDescriptor);
  166. BEGIN
  167.      WITH CurrentWin^ DO
  168.      BEGIN
  169.           CursorX := WhereX;
  170.           CursorY := WhereY
  171.      END;
  172.      CurrentWin := w;
  173.      WITH w^ DO
  174.      BEGIN
  175.           Window(col1,row1,col2,row2);
  176.           GotoXY(CursorX, CursorY)
  177.      END
  178. END;
  179.  
  180. PROCEDURE Status(slot :INTEGER; msg : bigstring);
  181. VAR
  182.    i : INTEGER;
  183. BEGIN
  184.      UsePermWindow(StatWin);
  185.      GotoXY(20*slot+1,1);
  186.      IF slot < 3 THEN
  187.          WRITE('                    ')
  188.      ELSE
  189.          WRITE('                   ');
  190.      GotoXY(20*slot+1,1);
  191.      WRITE(msg);
  192.      UsePermWindow(TermWin)
  193. END;
  194.  
  195.  
  196. PROCEDURE InitWindow(VAR w : WindowDescriptor;
  197.                          x1, y1, x2, y2 : INTEGER);
  198. BEGIN
  199.      NEW(w);
  200.      WITH w^ DO
  201.      BEGIN
  202.           col1 := x1;
  203.           col2 := x2;
  204.           row1 := y1;
  205.           row2 := y2;
  206.           CursorX := 1;
  207.           CursorY :=1
  208.      END
  209. END;
  210.  
  211. PROCEDURE DrawBox(col1, row1, col2, row2, frame : INTEGER);
  212. TYPE
  213.     cvec6 = ARRAY[1..6] OF CHAR;
  214.     cptr = ^cvec6;
  215. CONST
  216.      V1 = #179;   UR1 = #191;   UL1 = #218;
  217.      V2 = #186;   UR2 = #187;   UL2 = #201;
  218.      H1 = #196;   LR1 = #217;   LL1 = #192;
  219.      H2 = #205;   LR2 = #188;   LL2 = #200;
  220.  
  221.      SFRAME : cvec6 = (UL1,H1,UR1,V1,LL1,LR1);
  222.      DFRAME : cvec6 = (UL2,H2,UR2,V2,LL2,LR2);
  223.  
  224. VAR
  225.    framedef : cptr;
  226.    i,j : INTEGER;
  227. BEGIN
  228.      IF frame <> 0 THEN
  229.      BEGIN
  230.           CASE frame OF
  231.              1 : framedef := Ptr(Seg(SFRAME),Ofs(SFRAME));
  232.              2 : framedef := Ptr(Seg(DFRAME),Ofs(DFRAME))
  233.           END;
  234.           GotoXY(col1, row1);
  235.           WRITE(framedef^[1]);
  236.           FOR i := col1 + 1 TO col2 - 1 DO
  237.               WRITE(framedef^[2]);
  238.           WRITE(framedef^[3]);
  239.           FOR i := row1 + 1 TO row2 - 1 DO
  240.           BEGIN
  241.                 GotoXY(col1, i);
  242.                 WRITE(framedef^[4]);
  243.                 GotoXY(col2, i);
  244.                 WRITE(framedef^[4])
  245.           END;
  246.           GotoXY(col1, row2);
  247.           WRITE(framedef^[5]);
  248.           FOR i := col1 + 1 TO col2 - 1 DO
  249.               WRITE(framedef^[2]);
  250.           WRITE(framedef^[6])
  251.     END
  252. END;
  253.  
  254. PROCEDURE OpenTemp(x1,y1,x2,y2,border : INTEGER);
  255. BEGIN
  256.      WITH CurrentWin^ DO
  257.      BEGIN
  258.        CursorX := WhereX;
  259.        CursorY := WhereY;
  260.        TempWin := SaveWindow(col1,row1,col2,row2)
  261.      END;
  262.      DrawBox(x1,y1,x2,y2,border);
  263.      TurboWindow(x1+1, y1+3, x2-1, y2+1);
  264.      ClrScr;
  265.      GotoXY(1,1)
  266. END;
  267.  
  268. PROCEDURE CloseTemp;
  269. BEGIN
  270.      DRestoreWindow(TempWin,0,0);
  271.      WITH CurrentWin^ DO
  272.      BEGIN
  273.         TurboWindow(col1,row1,col2,row2);
  274.         GotoXY(CursorX,CursorY)
  275.      END
  276. END;
  277.  
  278. PROCEDURE PushPage;
  279. CONST
  280.      MEMNEEDED = 3696; {memory overhead to store a page}
  281. VAR
  282.    c : CHAR;
  283. BEGIN
  284.      IF MEMAVAIL >= MEMNEEDED THEN
  285.      BEGIN
  286.           OpenTemp(20,5,75,10,2);
  287.           WRITE('Save this screen? (Y/N; default N) ');
  288.           READLN(c);
  289.           CloseTemp;
  290.           IF c IN  ['Y','y'] THEN
  291.                StackedPage := SaveWindow(1,3,80,25)
  292.      END
  293.      ELSE BEGIN
  294.           OpenTemp(30,5,70,10,2);
  295.           WRITELN('Out of Memory: Can''t save page.');
  296.           WRITE('Type <cr> to continue.');
  297.           READLN
  298.      END
  299. END;
  300.  
  301. PROCEDURE PopPage;
  302. BEGIN
  303.      IF StackedPage <> NIL THEN
  304.           DRestoreWindow(StackedPage,0,0)
  305. END;
  306.