home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / BEEHIVE / UTILITYS / WINDOM2.ARC / WINDOWS.MOD < prev   
Text File  |  1990-07-21  |  20KB  |  747 lines
  1. (* **********  Window Management System   ********** *)
  2. (* **********  Version 1.1   2/10/87      ********** *)
  3. (* **********  Written by : Bob Catiller  ********** *)
  4. (*                                                             *)
  5. (*(C)Copyright 1987 Bob Catiller all commercial rights reserved*)
  6. (*                                                             *)
  7. (* ********** constant and variable declarations ********** *)
  8.  
  9. IMPLEMENTATION MODULE Windows;
  10.  
  11.   FROM SYSTEM
  12.     IMPORT ADDRESS, ADR, FILL, MOVE, TSIZE;
  13.   FROM STORAGE
  14.     IMPORT ALLOCATE, DEALLOCATE;
  15.   FROM Strings
  16.     IMPORT Length;
  17.   FROM Terminal
  18.     IMPORT GotoXY,
  19.     WriteChar, WriteString, Highlight, Normal;
  20.   FROM TermAtt
  21.     IMPORT  GraphicOn, GraphicOff,
  22.     GraphicChar, RevVideo, NormVideo;
  23.  
  24.   CONST
  25.     wxa = 1; (*min col*)
  26.     wya = 1; (*min row*)
  27.     wyz = 23; (*max row*)
  28.     wlz = 1840; (*max length*)
  29.  
  30.   VAR
  31.     wzr: INTEGER;
  32.  
  33.   TYPE
  34.     wpt = POINTER TO wcb;
  35.     wcb = RECORD (*window control block*)
  36.             wbt, (*window border type*)
  37.             wx, (*window col*)
  38.             wy, (*window row*)
  39.             ww, (*window width*)
  40.             wh: INTEGER;
  41.             (*window height*)
  42.             wxo, (*window origin col*)
  43.             wyo, (*window origin row*)
  44.             wl: INTEGER;(*window length*)
  45.             wb: BOOLEAN;(*window border flag*)
  46.             wc, (*window cols*)
  47.             wr, (*window rows*)
  48.             wrh: INTEGER; (*window row highlighted*)
  49.             wrp: ARRAY [wya..wyz] OF INTEGER;
  50.             (*window row positions*)
  51.             wbc: ARRAY [1..8] OF CHAR;
  52.             wch: ARRAY [0..wlz-1] OF CHAR;
  53.             (*window contents*)
  54.           END;
  55.     wino = ARRAY [0..9] OF wpt;
  56.  
  57.     (* for use by window management services *)
  58.     (* Pointer array used to allocate, deallocate, and access windows *)
  59.     (* 10 windows maximum are allowed, numbered 0 thru 9 *)
  60.     VAR
  61.       wno: wino;
  62.  
  63.   (* ********** internal functions and procedures ********** *)
  64.  
  65.   (* **********  wiBord1  ********* *)
  66.   (* set up border parameters  in window record *)
  67.  
  68. (* Graphics characters for Wyse 50 terminal *)
  69.   (* 0  line upper left & right corner *)
  70.   (* 1  line lower left corner *)
  71.   (* 2  line upper left corner *)
  72.   (* 3  line upper right corner *)
  73.   (* 4  line upper & lower left corner *)
  74.   (* 5  line lower right corner *)
  75.   (* 6  line vertical *)
  76.   (* 7  block dense *)
  77.   (* 8  line vertical & horizontal *)
  78.   (* 9  line upper & lower right corner *)
  79.   (* :  line horizontal *)
  80.   (* ;  block medium *)
  81.   (* <  line double horizontal *)
  82.   (* =  line lower left & right corner *)
  83.   (* >  line double vertical *)
  84.   (* ?  block light *)
  85. (* The ASCII characters listed above will be *)
  86. (* stored in the window as border characters. *)
  87. (* They will be automatically be displayed as *)
  88. (* graphic characters by the wiShow routine. *)
  89.  
  90.   VAR
  91.     i: INTEGER;
  92.     c: CARDINAL;
  93.  
  94.   PROCEDURE wiBord1(no: INTEGER);
  95.   BEGIN
  96.     WITH wno[no]^ DO
  97.  
  98. (* The following CASE statement will load the border *)
  99. (* graphic character string in the wbc array of the *)
  100. (* window record. You may create your own border types *)
  101. (* by adding lines to the case statement. The meaning *)
  102. (* of the characters in the string is as follows: *)
  103. (*     Character 1 = left border character *)
  104. (*    Character 2 = right border character *)
  105. (*    Character 3 = top border character *)
  106. (*    Character 4 = bottom border character *)
  107. (*    Character 5 = top left corner character *)
  108. (*    Character 6 = top right corner character *)
  109. (*    Character 7 = bottom left corner character *)
  110. (*    Character 8 = bottom right corner character *)
  111.  
  112.       c := CARD(wbt);(* window border type *)
  113.       CASE c OF
  114.         | 1 : wbc := '77777777'(* type 1 = dense blocks *)
  115.         | 2 : wbc := ';;;;;;;;'(* type 2 = medium blocks *)
  116.         | 3 : wbc := '????????'(* type 3 = light blocks *)
  117.         | 4 : wbc := '>><<2315'(* type 4 = double line *)
  118.         | 5 : wbc := '66::2315'(* type 5 = single line *)
  119.         | 6 : wbc := '88888888'(* type 6 = cross hatch *)
  120.         | 7 : wbc := '94=02315'(* type 7 = hatch out *)
  121.         | 8 : wbc := '490=2315'(* type 8 = hatch in *)
  122.         | 9 : wbc := '>><<;;;;'(* type 9 = mixed line *)
  123.         | 10 : wbc := ';;;;2315'(* type 10 = mixed block *)
  124.       ELSE
  125.         wbt := 0
  126.       END;(* CASE *)
  127.       IF wbt <> 0 THEN
  128.         wb := TRUE;
  129.         wc := ww-4;
  130.         wr := wh-2;
  131.         FOR i := wya TO wyz DO
  132.           wrp[i] := ((i*ww)+2)
  133.         END;(* FOR *)
  134.       ELSE
  135.         wb := FALSE;
  136.         wc := ww;
  137.         wr := wh;
  138.         FOR i := wya TO wyz DO
  139.           wrp[i] := ((i-1)*wc);
  140.         END;(* FOR *)
  141.       END;(* IF *)
  142.     END;(* WITH *)
  143.   END wiBord1;
  144.  
  145.   (* **********  wiBord2  ********* *)
  146.   (* insert border characters into window *)
  147.  
  148.   PROCEDURE wiBord2(no: INTEGER);
  149.  
  150.     VAR
  151.       i: INTEGER;
  152.  
  153.   BEGIN
  154.     WITH wno[no]^ DO
  155.       IF (wb) THEN
  156.         FOR i := 0 TO wh-1 DO
  157.           (* Fill left border. *)
  158.           wch[(i)*ww] := wbc[1];
  159.           (* Fill right border. *)
  160.           wch[(((i)*ww)+ww)-1] := wbc[2];
  161.         END;
  162.         FOR i := 0 TO ww-1 DO
  163.           (* Fill top border. *)
  164.           wch[i] := wbc[3];
  165.           (* Fill bottom border. *)
  166.           wch[(wl-ww+i)] := wbc[4];
  167.         END;
  168.         (* Fill top left corner *)
  169.         wch[0] := wbc[5];
  170.         (* Fill top right corner *)
  171.         wch[ww-1] := wbc[6];
  172.         (* Fill bottom left corner *)
  173.         wch[wl-ww] := wbc[7];
  174.         (* Fill bottom right corner *)
  175.         wch[wl-1] := wbc[8];
  176.  
  177.       END;
  178.     END;
  179.   END wiBord2;
  180.  
  181.   (* **********  wiOut  ********** *)
  182.   (* store string to window at current window position *)
  183.   (* optionally, write string to screen at current screen position *)
  184.  
  185.   PROCEDURE wiOut(no: INTEGER; st: wst; out: BOOLEAN);
  186.  
  187.   VAR
  188.       i, x, y: INTEGER;
  189.   BEGIN
  190.     wiStatus := FALSE;
  191.     wiEoln := FALSE;
  192.     wiEow := FALSE;
  193.     IF (wno[no] <> NIL) THEN
  194.       WITH wno[no]^ DO
  195.         IF (wy > wr) THEN
  196.           wiInsln(no, wy);
  197.           IF (out) THEN
  198.             wiShow(no)
  199.           END;
  200.         END;
  201.         i := 0;
  202.         WHILE (i < INTEGER(Length(st))) AND (wx <= wc) DO
  203.           wch[(wrp[wy]+wx)-1] := st[i];
  204.           IF (out) THEN
  205.             x := INTEGER((wxo+wx)+1);
  206.             y := INTEGER(wyo+wy);
  207.             IF ( NOT wb) THEN
  208.               x := x-2;
  209.               y := y-1;
  210.             END;
  211.             IF ((x >= wxa) OR (x <= wxz))
  212.              AND ((y >= wya) OR (y <= wyz)) THEN
  213.               GotoXY(x, y);
  214.               WriteChar(st[i]);
  215.             END;
  216.           END;
  217.           wx := wx+1;
  218.           i := i+1;
  219.         END;
  220.         IF (wx > wc) THEN
  221.           wx := 1;
  222.           wy := wy+1;
  223.           wiEoln := TRUE;
  224.           IF (wy > wr) THEN
  225.             wiEow := TRUE
  226.           END;
  227.         END;
  228.         wiStatus := TRUE;
  229.       END;
  230.     END;
  231.   END wiOut;
  232.  
  233.   (* *********  wiOutln  ********** *)
  234.   (* store string to window at current window position *) 
  235.   (* optionally, write string to screen at current screen position *)
  236.  
  237.   PROCEDURE wiOutln(no: INTEGER; st: wst; out: BOOLEAN);
  238.  
  239.   VAR
  240.     temp1, temp2: INTEGER;
  241.  
  242.   BEGIN
  243.     wiOut(no, st, out);(* display text *)
  244.     IF (wiStatus) THEN
  245.       WITH wno[no]^ DO
  246.         IF (wx > 1) THEN
  247.           FILL(ADR(wch[(wrp[wy]+wx)-1]), CARD(wc-wx), ' ');
  248.           IF (out) THEN
  249.         temp1 := (wxo+wx)-1;
  250.         temp2 := (wyo+wx)-1;
  251.             IF ((temp1 >= wxa) OR (temp1 <= wxz))
  252.              AND ((temp2 >= wya) OR (temp2 <= wyz)) THEN
  253.               wiClreol(no);
  254.             END;
  255.           END;
  256.           wx := 1;
  257.           wy := (wy)+1;
  258.           wiEoln := TRUE;
  259.           IF (wy > wr) THEN
  260.             wiEow := TRUE
  261.           END;
  262.         END;
  263.       END;
  264.     END;
  265.   END wiOutln;
  266.  
  267. (* ********** wiOutGt ************ *)
  268.   (* Outputs text string as graphic characters *)
  269.   PROCEDURE wiOutGt(st: wst);
  270.  
  271.   BEGIN
  272. (* initiate graphics mode *)
  273.     GraphicOn();
  274. (* The following string of characters will be *)
  275. (* displayed as graphic characters. *)
  276.     WriteString(st);
  277. (* return to normal display mode. *)
  278.     GraphicOff();
  279.   END wiOutGt;
  280.  
  281.   (* **********  wiSher  ********* *)
  282.   (* show/erase window from screen *)
  283.  
  284.   PROCEDURE wiSher(no: INTEGER; show: BOOLEAN);
  285.  
  286.     VAR
  287.  
  288.       h, i, j, k, x, y: INTEGER;
  289.       st: wst;
  290.       temp5: ADDRESS;
  291.  
  292.   BEGIN
  293.     wiStatus := FALSE;
  294.     IF (wno[no] <> NIL) THEN
  295.       WITH wno[no]^ DO
  296.         j := (wxo+ww)-1;
  297.         IF (j <= wxz) THEN
  298.           j := INTEGER(ww)
  299.         ELSE
  300.           j := ww-(j-wxz)
  301.         END;(* IF *)
  302.         IF (wxo >= 1) THEN
  303.           k := 1;
  304.           x := wxo;
  305.         ELSE
  306.           j := (wxo+ww)-1;
  307.           k := (ww-j)+1;
  308.           x := 1;
  309.         END;(* IF *)
  310.         IF (j > 0) THEN
  311.           FILL(ADR(st[0]), CARD(j), CHR(0));
  312.             FOR i := 1 TO wh DO
  313.               y := (wyo+i)-1;
  314.               IF ((x >= wxa) OR (x <= wxz))
  315.                AND ((y >= wya) OR (y <=wyz)) THEN
  316.                 GotoXY(x, y);
  317.                 IF (NOT show) THEN
  318.                   FILL(ADR(st[0]), CARD(j), ' ');
  319.                   WriteString(st);
  320.                 ELSE
  321.                   temp5 := ADR(wch[((i-1)*ww)+k-1]);
  322.                   MOVE(temp5, ADR(st[0]), CARD(j));
  323.                   IF (wb) THEN
  324.                     IF (i=1) OR (i=wh) THEN
  325.                       (* Display graphics for top & bottom borders *)
  326.                       wiOutGt(st);
  327.                     ELSE
  328.                       GraphicChar(st[0]);(* left border *)
  329.                       IF ((wrh+1) = i) AND (wrh <> 0) THEN
  330.                         RevVideo();
  331.                       ELSE
  332.                         NormVideo();
  333.                       END;(* IF *)
  334.                       FOR h:= 2 TO (ww-3) DO
  335.                         WriteChar(st[h]);(* text *)
  336.                       END;(* FOR *)
  337.                       NormVideo();
  338.                       GraphicChar(st[ww-1]);(* right border *)
  339.                     END;(* IF *)
  340.                   ELSE
  341.                     IF ((wrh+1) = i) AND (wrh <> 0) THEN
  342.                       Highlight;
  343.                     END;(* IF *)
  344.                     WriteString(st);
  345.                     IF ((wrh+1) = i) AND (wrh <> 0) THEN
  346.                       Normal;
  347.                     END;(* IF *)
  348.                   END;(* IF *)
  349.                 END;(* IF *)
  350.               END;(* IF *)
  351.             END;(* FOR *)
  352.         END;(* IF *)
  353.         wiStatus := TRUE;
  354.       END;(* WITH *)
  355.     END;(* IF *)
  356.   END wiSher;
  357.  
  358. (* ***** End of internal functions & procedures ***** *)
  359.  
  360.   (* **********  Window Management Services  ********** *)
  361.  
  362.   (* *********  wiDelln  ********** *)
  363.   (* delete line from window *)
  364.  
  365.   PROCEDURE wiDelln(no, y: INTEGER);
  366.  
  367.     VAR
  368.       i: INTEGER;
  369.   BEGIN
  370.     wiStatus := FALSE;
  371.     IF (wno[no] <> NIL) THEN
  372.       WITH wno[no]^ DO
  373.         IF  NOT ((y >= 1) OR (y <= wr)) THEN
  374.           wiStatus := FALSE
  375.         ELSE
  376.           (* Move all lines below deleted line up one line. *)
  377.           FOR i := y TO wr-1 DO
  378.             MOVE(ADR(wch[wrp[i+1]]),
  379.              ADR(wch[wrp[i]]),
  380.               CARD(wc))
  381.           END;
  382.           (* Fill bottom line with blanks. *)
  383.           FILL(ADR(wch[wrp[wr]]), CARD(wc), ' ');
  384.           wx := 1;
  385.           wy := y;
  386.           wiStatus := TRUE;
  387.         END;
  388.       END;
  389.     END; 
  390.   END wiDelln;
  391.  
  392.   (* **********  wiInsln  ********** *)
  393.   (* insert line into window *)
  394.  
  395.   PROCEDURE wiInsln(no, y: INTEGER);
  396.  
  397.     VAR
  398.       i: INTEGER;
  399.   BEGIN
  400.     wiStatus := FALSE;
  401.     IF (wno[no] <> NIL) THEN
  402.       WITH wno[no]^ DO
  403.         IF  NOT ((y >= 1) OR (y <= wr)) THEN
  404.           IF (y < 1) THEN
  405.             wiStatus := FALSE
  406.           ELSE
  407.             wiDelln(no, 1);
  408.             wy := wr;
  409.           END
  410.         ELSE
  411.           FOR i := wr TO y BY -1 DO
  412.             MOVE(ADR(wch[wrp[i-1]]),
  413.               ADR(wch[wrp[i]]),
  414.                CARD(wc))
  415.           END;
  416.           FILL(ADR(wch[wrp[y]]), CARD(wc), ' ');
  417.           wy := y;
  418.           wx := 1;
  419.           wiStatus := TRUE;
  420.         END;
  421.       END;
  422.     END;
  423.   END wiInsln;
  424.  
  425.   (* **********  wiClreol  ********** *)
  426.   (* clear from current window position to end of line *)
  427.  
  428.   PROCEDURE wiClreol(no: INTEGER);
  429.   BEGIN
  430.     wiStatus := FALSE;
  431.     IF (wno[no] <> NIL) THEN
  432.       WITH wno[no]^ DO
  433.         IF ((wy >= 1) OR (wy <= wr))
  434.          AND ((wx >= 1) OR (wx <= wc)) THEN
  435.           FILL(ADR(wch[(wrp[wy]+wx)-1]), CARD(wc-wx), ' ');
  436.           wiStatus := TRUE;
  437.         END;
  438.       END;
  439.     END;
  440.   END wiClreol;
  441.  
  442.   (* **********  wiClear  ********* *)
  443.   (* blank window contents *)
  444.  
  445.   PROCEDURE wiClear(no: INTEGER);
  446.   BEGIN 
  447.     wiStatus := FALSE;
  448.     IF (wno[no] <> NIL) THEN
  449.       WITH wno[no]^ DO
  450.         (* Blank entire window. *)
  451.         FILL(ADR(wch[0]), CARD(wl), ' ');
  452.         wch[wl] := CHR(0);
  453.         wx := 1;
  454.         wy := 1;
  455.         (* Restore border. *)
  456.         wiBord2(no);
  457.       END;
  458.       wiStatus := TRUE;
  459.     END;
  460.   END wiClear;
  461.  
  462.   (* *********  wiHome  ********** *)
  463.   (* set window position to beginning of first line *)
  464.  
  465.   PROCEDURE wiHome(no: INTEGER);
  466.   BEGIN
  467.     wiStatus := FALSE;
  468.     IF (wno[no] <> NIL) THEN
  469.       WITH wno[no]^ DO
  470.         (* Set origin to row 1, column 1. *)
  471.         wx := 1;
  472.         wy := 1;
  473.       END;
  474.       wiStatus := TRUE;
  475.     END;
  476.   END wiHome;
  477.  
  478.   (* *********  wiBorder ********** *)
  479.   (* set/reset window border type *)
  480.   (* overlay *)
  481.  
  482.   PROCEDURE wiBorder(no, bt: INTEGER);
  483.   BEGIN
  484.     wiStatus := FALSE;
  485.     IF (wno[no] <> NIL) THEN
  486.       WITH wno[no]^ DO
  487.         wbt := bt;(* set new border type *)
  488.         wiBord1(no);(* set up border parameters *)
  489.         IF (wb) THEN
  490.           wiBord2(no);(* insert new border in window *)
  491.           wiStatus := TRUE;
  492.         END;
  493.       END;
  494.     END;
  495.   END wiBorder;
  496.  
  497.   (* *********  wiOpen  ********** *)
  498.   (* open window - allocate dynamic memory for window control block *)
  499.   (* overlay *)
  500.  
  501.   PROCEDURE wiOpen(no, x, y, w, h, bt: INTEGER);
  502.  
  503.     VAR
  504.       i, l: INTEGER;
  505.   BEGIN
  506.     wiStatus := FALSE;
  507.     IF ((w >= wxa) OR (w <= wxz))
  508.      AND ((h >= wya) OR (h <= wyz))
  509.       AND  NOT (wno[no] <> NIL) THEN
  510.       l := w*h;
  511.       ALLOCATE(wno[no], ((INTEGER(TSIZE(wcb))-wlz)+l+1));
  512.       WITH wno[no]^ DO
  513.     wbt := bt;
  514.     wx := 1;
  515.         wy := 1;
  516.         wxo := x;
  517.         wyo := y;
  518.         ww := w;
  519.         wh := h;
  520.         wl := l;
  521.         wrh := 0;
  522.         wiBord1(no);(* set up border parameters *)
  523.       END;
  524.       wiClear(no);
  525.     END;
  526.   END wiOpen;
  527.  
  528.   (* **********  wiClose  ********** *)
  529.   (* close window - release dynamic memory *)
  530.   (* overlay *)
  531.  
  532.   PROCEDURE wiClose(no: INTEGER);
  533.   BEGIN
  534.     wiStatus := FALSE;
  535.     IF (wno[no] <> NIL) THEN
  536.       DEALLOCATE(wno[no],(((TSIZE(wcb))-wlz)+CARD(wno[no]^.wl)));
  537.       wiStatus := TRUE;
  538.     END;
  539.   END wiClose;
  540.  
  541.   (* **********  wiGetpos  ********** *)
  542.   (* get window position *)
  543.   (* overlay *)
  544.  
  545.   PROCEDURE wiGetpos(no: INTEGER;
  546.                      VAR x, y: INTEGER);
  547.   BEGIN
  548.     wiStatus := FALSE;
  549.     IF (wno[no] <> NIL) THEN
  550.       WITH wno[no]^ DO
  551.         x := INTEGER(wx);
  552.         y := INTEGER(wy);
  553.       END;(* WITH *)
  554.       wiStatus := TRUE;
  555.     END;(* IF *)
  556.   END wiGetpos;
  557.  
  558.   (* *********  wiGetorg  ********** *)
  559.   (* get window screen origin *)
  560.   (* overlay *)
  561.  
  562.   PROCEDURE wiGetorg(no: INTEGER;
  563.                      VAR x, y: INTEGER);
  564.   BEGIN
  565.     wiStatus := FALSE;
  566.     IF (wno[no] <> NIL) THEN
  567.       WITH wno[no]^ DO
  568.         x := wxo;
  569.         y := wyo;
  570.       END;(* WITH *)
  571.       wiStatus := TRUE;
  572.     END;(* IF *)
  573.   END wiGetorg; (*wiGetorg*)
  574.  
  575.   (* **********  wiSetpos  ********** *)
  576.   (* set window position *)
  577.  
  578.   PROCEDURE wiSetpos(no, x, y: INTEGER); 
  579.   BEGIN 
  580.     wiStatus := FALSE; 
  581.     IF (wno[no] <> NIL) THEN
  582.       WITH wno[no]^ DO
  583.         IF ((x >= 1) OR (x <= wc)) AND ((y >=1) OR (y <= wr)) THEN
  584.           wx := x;
  585.           wy := y;
  586.           wiStatus := TRUE;
  587.         ELSE
  588.           wiStatus := FALSE
  589.         END;
  590.       END;
  591.     END;
  592.   END wiSetpos;
  593.  
  594.   (* **********  wiSetorg  ********** *)
  595.   (* set window screen origin *)
  596.  
  597.   PROCEDURE wiSetorg(no, x, y: INTEGER);
  598.   BEGIN
  599.     wiStatus := FALSE;
  600.     IF (wno[no] <> NIL) THEN
  601.       WITH wno[no]^ DO
  602.         wxo := x;
  603.         wyo := y;
  604.       END;
  605.       wiStatus := TRUE;
  606.     END;
  607.   END wiSetorg;
  608.  
  609.   (* **********  wiPut  ********* *)
  610.   (* store string in window *)
  611.  
  612.   PROCEDURE wiPut(no: INTEGER;
  613.                   st: wst);
  614.   BEGIN
  615.     wiOut(no, st, FALSE);
  616.   END wiPut;
  617.  
  618.   (* *********  wiPutln  ********* *)
  619.   (* store string in window *)
  620.  
  621.   PROCEDURE wiPutln(no: INTEGER;
  622.                     st: wst);
  623.   BEGIN
  624.     wiOutln(no, st, FALSE);
  625.   END wiPutln;
  626.  
  627.   (* *********  wiWrite  ********* *)
  628.   (* write string to screen thru window *)
  629.  
  630.   PROCEDURE wiWrite(no: INTEGER;
  631.                     st: wst);
  632.   BEGIN
  633.     wiOut(no, st, TRUE);
  634.   END wiWrite;
  635.  
  636.   (* *********  wiWriteln  ********** *)
  637.   (* write string to screen thru window *)
  638.  
  639.   PROCEDURE wiWriteln(no: INTEGER;
  640.                       st: wst);
  641.   BEGIN
  642.     wiOutln(no, st, TRUE);
  643.   END wiWriteln;
  644.  
  645.   (* **********  wiShow  ********* *)
  646.   (* display window to screen *)
  647.  
  648.   PROCEDURE wiShow(no: INTEGER);
  649.   BEGIN
  650.     wiSher(no, TRUE);
  651.   END wiShow;
  652.  
  653.   (* *********  wiErase  ********** *)
  654.   (* blank window region on screen *)
  655.  
  656.   PROCEDURE wiErase(no: INTEGER);
  657.   BEGIN
  658.     wiSher(no, FALSE);
  659.   END wiErase;
  660.  
  661. (* ********** wiHlup ************ *)
  662.   (* Rotates highlighting to next line up. *)
  663.   (* Moves to bottom line if at top line. *)
  664.  
  665.   PROCEDURE wiHlup(no: INTEGER);
  666.  
  667.   BEGIN
  668.     wiStatus := FALSE;
  669.     IF (wno[no] <> NIL) THEN
  670.       WITH wno[no]^ DO
  671.         IF wrh <> 0 THEN
  672.           IF wrh = 1 THEN
  673.             wrh := wr;
  674.           ELSE
  675.             wrh := wrh-1;
  676.           END;(* IF *)
  677.           wiShow(no);
  678.         END;(* IF *)
  679.       END;(* DO *)
  680.     END;(* IF *)
  681.   END wiHlup;
  682.  
  683. (* ********** wiHldown ************ *)
  684.   (* Rotates highlighting to next line down. *)
  685.   (* Moves to top line if at bottom line. *)
  686.   PROCEDURE wiHldown(no: INTEGER);
  687.  
  688.   BEGIN
  689.     wiStatus := FALSE;
  690.     IF (wno[no] <> NIL) THEN
  691.       WITH wno[no]^ DO
  692.         IF wrh <> 0 THEN
  693.           IF wrh = wr THEN
  694.             wrh := 1;
  695.           ELSE
  696.             wrh := wrh+1;
  697.           END;(* IF *)
  698.           wiShow(no);
  699.         END;(* IF *)
  700.       END;(* DO *)
  701.     END;(* IF *)
  702.   END wiHldown;
  703.  
  704. (* ********** wiSethl ************ *)
  705.   (* Selects row to be highlighted in window *)
  706.   (* 0 selects no highlighting *)
  707.  
  708.   PROCEDURE wiSethl(no, rh: INTEGER);
  709.  
  710.   BEGIN
  711.     wiStatus := FALSE;
  712.     IF (wno[no] <> NIL) THEN
  713.       WITH wno[no]^ DO
  714.         IF (rh > wr) OR (rh < 0) THEN
  715.           wrh := 0;
  716.         ELSE
  717.           wrh := rh;
  718.         END;(* IF *)
  719.       END;(* DO *)
  720.       wiShow(no);
  721.       wiStatus := TRUE;
  722.     END;(* IF *)
  723.   END wiSethl;
  724.  
  725. (* ********** wiGethl ************ *)
  726.   (* Gets row number of currently highlighted *)
  727.   (* row. Returns 0 if no highlighting. *)
  728.  
  729.   PROCEDURE wiGethl(no: INTEGER);
  730.  
  731.   VAR
  732.     rh: INTEGER;
  733.  
  734.   BEGIN
  735.     wiStatus := FALSE;
  736.     IF (wno[no] <> NIL) THEN
  737.       WITH wno[no]^ DO
  738.           y := wrh;
  739.       END;(* DO *)
  740.       wiStatus := TRUE;
  741.     END;(* IF *)
  742.   END wiGethl;
  743.  
  744.  
  745. (* **********  End of Window Management Services  ********* *)
  746. END Windows.
  747.