home *** CD-ROM | disk | FTP | other *** search
/ Carousel Volume 2 #1 / carousel.iso / mactosh / fonts / fontshow.sit / Windows.Pas < prev    next >
Pascal/Delphi Source File  |  1988-09-14  |  24KB  |  465 lines
  1. UNIT Windows(2);
  2. (* This unit contains the window handling routines for the FontShow program *)
  3. (* Version 1.0 by Richard Clark, September 1988 *)
  4. (* Version 1.1, September 13, 1988.  Added the CreateFontPict routine so that the Menus unit   *)
  5. (*         doesn't have to scrounge up the WindowPict when the user chooses Copy.  Apparently, *)
  6. (*         the system modifies the WindowPict's boundaries before drawing it, and this causes  *)
  7. (*         great problems if you try to paste this into the clipboard.                         *)
  8. (*                                                                                             *)
  9. (*         Also changed the DisposHandle() calls to get rid of the WindowPic to KillPicture()  *)
  10.  
  11. {$U-}
  12. {$D+}
  13.  
  14. INTERFACE  
  15.   {$U globals}
  16.   USES
  17.     MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf,
  18.     Globals;
  19.  
  20.   CONST
  21.           wFont  = 128;                                   (* Resource ID of the Font display window *)
  22.           wAbout = 129;                                   (* Resource ID of the ╥About╙ window *)
  23.  
  24.   FUNCTION  CreateFontPict(fNum, fSize: INTEGER): PicHandle; 
  25.   (* Added in 1.1: Create a font grid picture with the given font and font size *)
  26.   
  27.   PROCEDURE OpenAWindow;                            (* Create a new Font Display window *)
  28.   PROCEDURE AttachWindowPict(whichWindow : WindowPeek); (* Connect a font grid to a font window *)
  29.   PROCEDURE CloseAWindow (whichWindow : WindowPtr); (* Close the specified window *)
  30.   PROCEDURE CloseAllWindows;                        (* Close all visible windows, allowing each *)
  31.                                                     (* window to be updated just before closure *)
  32.  
  33.   PROCEDURE DoAbout;                                (* Open the ╥About╙ window *)
  34.   PROCEDURE UpdateAboutWindow;                      (* Cause the memory statistic in the ╥About╙ *)
  35.                                                     (* window to be updated. *)
  36.  
  37.   PROCEDURE UpdateWindow (whichWindow : WindowPtr); (* Redraw the given window *)
  38.   PROCEDURE ActivateWindow (whichWindow : WindowPeek; (* Set the global font information if it's a Font window *)
  39.                                                        makeActive : Boolean);  
  40. IMPLEMENTATION
  41.  
  42.   CONST
  43.           pAbout = 128;                                    (* Resource ID of the ╥About╙ picture *)
  44.  
  45.   VAR
  46.           MemSizeRect   : Rect;                            (* The bounding box for the memory size number *)
  47.                                                      (* in the about window *)
  48.           MemSizeLeft,                                     (* The starting coordinates of the memory size *)
  49.     MemSizeBottom : INTEGER;                         (* message in the about window *)
  50.  
  51.  
  52.   PROCEDURE OpenAWindow;
  53.   (* This procedure creates a new font display window.  The new window is located 16 pixels down  *)
  54.         (* and to the right of the frontmost Font window.  A QuickDraw picture containing the displayed *)
  55.   (* font grid is attached so that the window will be updated automatically by the system.        *)
  56.  
  57.   VAR
  58.              myWindow   : WindowPeek;                         (* Our new window *)
  59.              done       : Boolean;                            (* Flag used when searching for the frontmost *)
  60.                                                      (* font window *)
  61.              currWindow : WindowPeek;                         (* The window being examined (to determine if it is *)
  62.                                                      (* a font window *)
  63.              top, left  : INTEGER;                            (* The upper, left coordinates of this window *)
  64.  
  65.   BEGIN
  66.     (* Get the new window using the storage pre-allocated in the main loop *)
  67.           myWindow := WindowPeek(GetNewWindow(wFont, WindowReserve, WindowPtr(-1)));
  68.           WindowReserve := NIL;                            (* We've used this block, so get another *)
  69.     myWindow^.refCon := wFont;                       (* Mark this as being a font display window *)
  70.  
  71.     (* Find the frontmost font window and position this window 16 pixels left and down from it *)
  72.           currWindow := WindowPeek(FrontWindow);
  73.           REPEAT
  74.                done := false;
  75.                IF (currWindow <> NIL) THEN
  76.                   BEGIN
  77.                        IF (currWindow^.windowKind < 0) OR (currWindow^.refCon <> wFont) THEN
  78.         (* This is a desk accessory, or not a font window, so skip it *)
  79.                             currWindow := currWindow^.nextWindow
  80.                        ELSE                                         (* It's a font window *)
  81.                           BEGIN                                        (* Calculate the new coordinates and exit the loop *)
  82.                                top  := 16 - currWindow^.port.portBits.bounds.top;
  83.                                left := 16 - currWindow^.port.portBits.bounds.left;
  84.                                done := TRUE;
  85.                           END;
  86.                   END
  87.           ELSE                                             (* No more windows are left, so no Font window *)
  88.                   BEGIN                                          (* was found.  Place this window in the upper  *)
  89.                        top  := 40;                                  (* left corner of the screen, and exit the loop *)
  90.                        left := 20;
  91.                        done := TRUE;
  92.                END;
  93.           UNTIL done;
  94.  
  95.           MoveWindow(WindowPtr(myWindow), left, top, true);(* Set the window's new position *)
  96.           ShowWindow(WindowPtr(myWindow));                 (* Open it so our ╥Attach Picture╙ procedure *)
  97.                                                      (* has something to work with. *)
  98.           AttachWindowPict(myWindow);                      (* Connect a picture of the font grid to this window *)
  99.   END; (* OpenAWindow *)
  100.  
  101.  
  102.   PROCEDURE CalcPictBounds(VAR PictBounds: Rect);
  103.   (* Calculate the boundaries of our Font Grid.  We do this before drawing the picture so the *)
  104.   (* window's picture can be sized appropriately.  (This isn't normally a problem when drawing*)
  105.   (* the window, as we could use an extremely large rectangle when creating picture and only  *)
  106.   (* the top, left part would appear in the window.  But, having too large of a rectangle     *)
  107.   (* would cause a problem if the user Copies this picture to the Clipboard.)                 *)
  108.   (*                                                                                          *)
  109.   (* This routine assumes that a Font window has been selected (using SetPort) and will take  *)
  110.   (* its font and size information from the current GrafPort.                                 *)
  111.   CONST
  112.     Margin = 4;                                      (* Start the picture at (4,4) *)
  113.     
  114.         VAR
  115.              topMargin,                                        (* How much space should we allocate for *)
  116.     leftMargin   : INTEGER;                           (* the labels on the side of the grid? *)
  117.              cellSize,
  118.     gridSize     : INTEGER;
  119.  
  120.      BEGIN
  121.           cellSize := thePort^.txSize + 4;                  (* How large is each square? *)
  122.           gridSize := cellSize * 16;                        (* The grid is 16 squares on a side *)
  123.           topMargin := Margin + 3 * thePort^.txSize + 1;    (* Calculate the depth of the top label area *)
  124.           leftMargin := Margin + StringWidth('$0X') + 1;    (* Calculate the width of the side label area *)
  125.     SetRect(PictBounds, 0, 0,                         (* Set the picture's bounds, with a few (4) *)
  126.             leftMargin+gridSize+Margin,               (* extra pixels on the sides. *)
  127.             topMargin+gridSize+Margin);
  128.   END; (* CalcPictBounds *)
  129.  
  130.  
  131.   
  132.   PROCEDURE DrawFontGrid(fNum, fSize: INTEGER);
  133.   (* Draw a font grid in the current window using its current font and font size.  *)
  134.   CONST
  135.     Margin = 4;
  136.  
  137.      VAR
  138.              topMargin,                                        (* This first part is a duplicate of the *)
  139.     leftMargin      : INTEGER;                        (* procedure above. *)
  140.              rowCount,
  141.     colCount        : INTEGER;
  142.              rowEnd,
  143.     colEnd          : INTEGER;
  144.              rowV,
  145.     colH            : INTEGER;
  146.              cellSize,
  147.     gridSize        : INTEGER;
  148.              hexString       : STRING[16];
  149.     oldFont,
  150.     oldSize         : INTEGER;
  151.     
  152.   BEGIN
  153.           hexString := '0123456789ABCDEF';                  (* 0..15 in Hexadecimal *)
  154.  
  155.           oldFont := thePort^.txFont;
  156.     oldSize := thePort^.txSize;
  157.     
  158.     TextFont(fNum);
  159.     TextSize(fSize);
  160.     
  161.     cellSize := fSize + 4;                            (* Calculate the spacing and placement of *)
  162.           gridSize := cellSize * 16;                        (* the grid lines *)
  163.           topMargin := Margin + 3 * fSize + 1;
  164.           leftMargin := Margin + StringWidth('$0X') + 1;
  165.  
  166.           rowEnd := LeftMargin + gridSize;                  (* Set up to draw the Row lines *)
  167.           rowV := TopMargin;
  168.           FOR rowCount := 0 TO 15 DO                        (* Draw the horizontal lines *)
  169.              BEGIN
  170.                   MoveTo(rowEnd, rowV);                           (* Draw one line *)
  171.                   LineTo(Margin, rowV);
  172.                   Move(0, cellSize - 1);                          (* Drop down to the next row *)
  173.                   DrawChar('$');                                  (* Add the label for this row *)
  174.                   DrawChar(hexString[rowCount + 1]);
  175.                   DrawChar('X');
  176.                   rowV := rowV + cellSize;                        (* Set up for the next row *)
  177.              END;
  178.   
  179.           MoveTo(rowEnd, rowV);                             (* Draw a final line to close off the grid *)
  180.           LineTo(Margin, rowV);
  181.  
  182.           colEnd := topMargin + gridSize;                   (* Set up to draw the column lines *)
  183.           colH := leftMargin;
  184.   
  185.           FOR colCount := 0 TO 15 DO                        (* Draw each vertical line *)
  186.              BEGIN
  187.                   MoveTo(colH, colEnd);                           (* Draw the line *)
  188.                   LineTo(colH, Margin);
  189.                   colH := colH + cellSize;
  190.                                                       (* Draw one label at the top *)
  191.                   MoveTo(colH - cellSize + 3, Margin + fSize);
  192.                   DrawChar('$');            
  193.                   MoveTo(colH - cellSize + 3, Margin + 2 * fSize);
  194.                   DrawChar('X');
  195.                   MoveTo(colH - cellSize + 3, Margin + 3 * fSize);
  196.                   DrawChar(hexString[colCount + 1]);
  197.  
  198.                   rowV := TopMargin + cellSize - 2;
  199.                   FOR rowCount := 0 TO 15 DO                      (* Draw the characters inside of the grid *)
  200.                      BEGIN
  201.                           MoveTo(colH - cellSize + 2, rowV);
  202.                           DrawChar(chr(rowCount * 16 + colCount));
  203.                           rowV := rowV + cellSize;
  204.                      END;
  205.              END;
  206.  
  207.           MoveTo(colH, colEnd);                             (* Draw one final line to complete the grid *)
  208.           LineTo(colH, Margin);
  209.      END; (* DrawFontGrid *)
  210.  
  211.  
  212.   FUNCTION CreateFontPict;
  213.   VAR
  214.              picBounds   : Rect;                               (* The bounds of the font grid *)
  215.              myPic       : PicHandle;                          (* The new picture we are creating *)
  216.  
  217.   BEGIN
  218.                 CalcPictBounds(picBounds);                        (* Get the boundaries of our new picture *)
  219.                 myPic := OpenPicture(picBounds);                  (* and begin recording the drawing commands *)
  220.                 IF (myPic <> nil) THEN
  221.     BEGIN
  222.       DrawFontGrid(fNum, fSize);                      (* Draw the font grid into our picture *)
  223.                                                       (* (nothing will appear on the screen) *)
  224.                 ClosePicture;                                     (* Complete the picture's definition, *)
  225.     END;
  226.     CreateFontPict := myPic;
  227.   END; (* CreateFontPict *)
  228.   
  229.  
  230.      PROCEDURE AttachWindowPict;
  231.   (* Given a font window, attach a picture to it containing a new font grid.  (We use this method *)
  232.   (* so that QuickDraw will update the window for us.)                                            *)
  233.         VAR
  234.              oldPort     : GrafPtr;                            (* The currently selected GrafPort *)
  235.              wName,                                            (* The new name of this window (eg. ╥Geneva 12╙) *)
  236.     scratch     : Str255;                             (* String used in building the window name *)
  237.  
  238.   BEGIN
  239.           IF (whichWindow <> NIL) THEN                      (* Make sure we have a window *)
  240.                IF (whichWindow^.refCon = wFont) THEN           (* And make sure it's a font window *)
  241.                   BEGIN
  242.                        GetPort(oldPort);                             (* Preserve the current port *)
  243.                        SetPort(WindowPtr(whichWindow));              (* And set the port to our target window *)
  244.                        TextFace([]);                                 (* Set the text face to plain, and the *)
  245.                        TextSize(currSize);                           (* Font and Size to those indicated in the *)
  246.                        TextFont(currFont);                           (* Font and Size menus *)
  247.                        TextMode(srcOr);                              (* Set up the pen mode to overlay any lines *)
  248.  
  249.                        IF (whichWindow^.windowPic <> NIL) THEN       (* If we already have a picture attached to *)
  250.                           BEGIN                                         (* this window, then get rid of it *)
  251.                                KillPicture(whichWindow^.windowPic);
  252.                                whichWindow^.windowPic := NIL;
  253.                           END;
  254.  
  255.                        whichWindow^.windowPic := CreateFontPict(whichWindow^.port.txFont, 
  256.                                                  whichWindow^.port.txSize);
  257.                                                       (* and attach the picture to this window *)
  258.  
  259.                                                       (* Assemble the window's title, ex: "Geneva 12" *)
  260.                        GetFontName(currFont, wName);                 (* Get the current font's name *)
  261.                        Insert(' ', wName, length(wName) + 1);        (* Append a space (this is safer than CONCAT) *)
  262.                        NumToString(currSize, scratch);               (* Convert the font's size into a string *)
  263.                        Insert(scratch, wName, length(wName) + 1);    (* Append it to the title string *)
  264.                        SetWTitle(WindowPtr(whichWindow), wName);     (* And change the window's title (this redraws *)
  265.                                                       (* the window's bounds *)
  266.                        InvalRect(whichWindow^.port.portRect);        (* Mark the contents of this window as having been changed *)
  267.                        EraseRect(whichWindow^.port.portRect);        (* And erase the old picture *)
  268.  
  269.                        SetPort(oldPort);                             (* Restore the saved GrafPort *)
  270.                   END;
  271.   END; (* AttachWindowPict *)
  272.  
  273.  
  274.   PROCEDURE ForceUpdate;
  275.   (* This procedure is used by CloseAllWindows to activate and update a window just after it has *)
  276.   (* been uncovered.                                                                             *)
  277.   VAR
  278.     theEvent: EventRecord;
  279.    
  280.   BEGIN
  281.     IF (GetNextEvent(activMask, theEvent)) THEN        (* The window has been activated *)
  282.       ;                                                (* Throw away the event! *)
  283.     IF (GetNextEvent(updateMask, theEvent)) THEN       (* If FALSE, then the window is self-updating *)
  284.                                                        (* by virtue of having an attached picture *)
  285.       UpdateWindow(WindowPtr(theEvent.message));       (* If TRUE, we will need to draw the window *)
  286.   END; (* ForceUpdate *)
  287.  
  288.  
  289.   PROCEDURE CloseAWindow;
  290.   (* Given a window, look at its type and perform the actions necesary to close it and dispose *)
  291.   (* of any private storage.                                                                   *)
  292.         VAR
  293.              currWindow : WindowPeek;                           (* Used to access the window's kind and RefCon *)
  294.              aboutPict  : Handle;                               (* Used to purge the "About" picture from memory *)
  295.  
  296.   BEGIN
  297.           currWindow := WindowPeek(whichWindow);             (* Convert our WindowPtr into a WindowPeek *)
  298.  
  299.           IF (currWindow^.windowKind < 0) THEN                                          (* This is a desk accessory *)
  300.                CloseDeskAcc(currWindow^.windowKind)
  301.           ELSE IF (currWindow^.refCon = wAbout) THEN         (* This is the "About" window *)
  302.           BEGIN
  303.                   DisposeWindow(whichWindow);                      (* Close the window and release its storage *)
  304.                   AboutWindow := NIL;                              (* Mark it as being closed *)
  305.       IF (WindowReserve <> NIL) THEN                   (* Let our Pre-Allocation routine reclaim the memory *)
  306.       BEGIN                                            (* (instead of leaving a hole below the current WindowReserve) *)
  307.         DisposPtr(WindowReserve);
  308.         WindowReserve := NIL;    
  309.       END;                          
  310.                   aboutPict := GetResource('PICT', pAbout);        (* Get the "About" picture, then purge it from memory *)
  311.                   ReleaseResource(aboutPict);
  312.           END 
  313.     ELSE IF (currWindow^.refCon = wFont) THEN          (* This is one of the font display windows *)
  314.              BEGIN                                                                              
  315.                   IF (currWindow^.windowPic <> NIL) THEN           (* Get rid of the window's picture *)
  316.                        KillPicture(currWindow^.windowPic);
  317.                DisposeWindow(whichWindow);                      (* Close the window and release its storage *)
  318.       IF (WindowReserve <> NIL) THEN                   (* Let our Pre-Allocation routine reclaim the memory *)
  319.       BEGIN
  320.         DisposPtr(WindowReserve);
  321.         WindowReserve := NIL;    
  322.       END;                          
  323.              END;
  324.   END; (* CloseAWindow *)
  325.  
  326.  
  327.      PROCEDURE CloseAllWindows;
  328.   (* This procedure goes through all of the windows from front to back and closes each one.  It *)
  329.   (* then gives the newly uncovered window a chance to get updated *)
  330.         VAR
  331.             inFront : WindowPtr;
  332.  
  333.      BEGIN
  334.           REPEAT
  335.                inFront := FrontWindow;
  336.                IF (inFront <> NIL) THEN
  337.       BEGIN
  338.                     CloseAWindow(inFront);                        (* Close the frontmost window *)                   
  339.         ForceUpdate;                                  (* Now that the second window is exposed, update it *)
  340.       END;
  341.           UNTIL (inFront = NIL);
  342.   END; (* CloseAllWindows *)
  343.  
  344.  
  345.   PROCEDURE DoAbout;
  346.   (* Open our "About" window and calculate the location of the "Available Memory" prompt string *)
  347.      (* at the bottom of the window.                                                               *)
  348.      VAR
  349.              aboutPict       : PicHandle;
  350.              promptWidth,                                       (* The width of the "Available Memory" string *)
  351.     numWidth,                                          (* The width of the following integer *)
  352.     combinedWidth   : INTEGER;
  353.              promptString    : StringHandle;
  354.  
  355.     BEGIN
  356.          IF (AboutWindow = NIL) THEN
  357.             BEGIN
  358.                  AboutWindow := GetNewWindow(wAbout, WindowReserve, WindowPtr(-1)); (* Create the new window *)
  359.                  WindowReserve := NIL;                              (* Ask for a replacement pre-allocation *)
  360.                  SetPort(AboutWindow);                              (* Set the font to Chicago, 12 point *)
  361.                  TextFace([]);
  362.                  TextFont(0);  
  363.                  TextSize(12);
  364.                  aboutPict := PicHandle(GetResource('PICT', pAbout)); (* Pull the picture into memory so we can get its size *)
  365.      promptString := GetString(128);                                (* get the prompt that reads "Available memory:" *)
  366.                  (* Put the baseline of our memory size message 16 pixels below the picture *)
  367.      MemSizeBottom := aboutPict^^.picFrame.bottom + 16;
  368.      
  369.                  HLock(Handle(promptString));                       (* Lock the handle (so it doesn't move) *)
  370.                  promptWidth := StringWidth(promptString^^);        (* and calculate the display width of the string *)
  371.                  HUnlock(Handle(promptString));
  372.  
  373.                  numWidth := 10 * CharWidth('0');                   (* Assume that our free memory count will never be *)
  374.                                                         (* longer than 10 digits *)
  375.                  combinedWidth := promptWidth + numWidth;
  376.  
  377.      (* Calculate the starting coordinates of the prompt string (the whole thing should be centered *)
  378.      (* in the dialog window *)
  379.                  MemSizeLeft := ((AboutWindow^.portRect.right - AboutWindow^.portRect.left)
  380.                      - combinedWidth) DIV 2;
  381.                      
  382.      (* Set up a rectangle which encloses just the displayed number.  When the number changes, we *)
  383.      (* can invalidate this rectangle to force the About window to be redrawn.                    *)
  384.                  SetRect(MemSizeRect, MemSizeLeft + promptWidth,
  385.                           MemSizeBottom - 12,
  386.                           MemSizeLeft + combinedWidth,
  387.                           MemSizeBottom);
  388.     END
  389.   ELSE                                                  (* If the window already exists, then bring *)
  390.     SelectWindow(AboutWindow);                          (* it to the front *)
  391.   END; (* DoAbout *)
  392.  
  393.  
  394.   PROCEDURE UpdateAboutWindow;
  395.   (* This procedure forces the system to redraw the memory size info in the "About" window *)
  396.         VAR
  397.              oldPort : GrafPtr;
  398.  
  399.   BEGIN
  400.     IF (AboutWindow <> NIL) THEN
  401.              BEGIN
  402.                   GetPort(oldPort);                                   (* Save the current port *)                                
  403.                   SetPort(AboutWindow);                               (* Switch to the About window *)
  404.                   InvalRect(MemSizeRect);                             (* Invalidate the memory size area *)
  405.                   SetPort(oldPort);                                   (* Switch back to the old port *)
  406.              END;
  407.      END; (* UpdateAboutWindow *)
  408.  
  409.  
  410.   PROCEDURE DrawAboutWindow;
  411.   (* This procedure is used to update the "About" window.  Since we have both a picture and some    *)
  412.   (* text to draw in the window (and the text is subject to change), we can't just attach a picture *)
  413.   (* to the window.                                                                                 *)
  414.         VAR
  415.              aboutPict       : PicHandle;                          (* The main picture *)
  416.              promptString    : StringHandle;                       (* The "Available Memory" prompt *)
  417.              memSizeString   : Str255;                             (* Our free memory number converted into a string *)
  418.  
  419.   BEGIN
  420.           aboutPict := PicHandle(GetResource('PICT', pAbout));  (* Load the picture into memory, and draw it *)
  421.           DrawPicture(aboutPict, aboutPict^^.picFrame);
  422.           MoveTo(MemSizeLeft, MemSizeBottom);                   (* Now, get ready to draw the memory information *)
  423.           promptString := GetString(128);
  424.           HLock(Handle(promptString));                          (* Lock the string, as DrawString might cause Handles to be moved *)
  425.           DrawString(promptString^^);
  426.           HUnlock(Handle(promptString));                        (* unlock it to prevent memory fragmentation *)
  427.           NumToString(CurrFreeMem, memSizeString);              (* Now convert our free memory figure into a string *)
  428.           DrawString(memSizeString);                            (* and draw it at the current pen position *)
  429.                                                           (* (right after the prompt) *)
  430.   END; (* DrawAboutWindow *)
  431.  
  432.  
  433.   PROCEDURE UpdateWindow; 
  434.      (* This only gets called if the window doesn't have a picture attached to it and we need to *)
  435.   (* redraw the window's contents *)
  436.      VAR
  437.              currWindow : WindowPeek;
  438.  
  439.   BEGIN
  440.        BeginUpdate(whichWindow);                             (* Set the visRgn to this window's update region *)
  441.           SetPort(whichWindow);                                 (* Switch to our destination window *)
  442.           EraseRect(whichWindow^.portRect);                     (* Erase any old information that may be there *)
  443.              currWindow := WindowPeek(whichWindow);
  444.           IF (currWindow^.refCon = wAbout) THEN                 (* Dispatch to the appropriate drawing routine *)
  445.                DrawAboutWindow
  446.           ELSE
  447.                DrawFontGrid(whichWindow^.txFont, whichWindow^.txSize);
  448.           EndUpdate(whichWindow);                               (* And remove this update region from the one maintained *)
  449.                                                           (* by the Event Manager *)
  450.      END; (* UpdateWindow *)
  451.  
  452.  
  453.      PROCEDURE ActivateWindow;
  454.   (* This procedure sets the internal Font and Size indiocators to reflect the settings of the *)
  455.   (* frontmost window.  Since this unit can't access the Menus unit, we'll have to adjust the  *)
  456.   (* menus from within the main loop.                                                          *)
  457.      BEGIN
  458.           IF (MakeActive) AND (whichWindow^.refCon = wFont) THEN  
  459.              BEGIN                                                 (* A Font window just came to the front *)
  460.                   currFont := whichWindow^.port.txFont;
  461.                   currSize := whichWindow^.port.txSize;
  462.              END;
  463.      END; (* ActivateWindow *)
  464.  
  465. END.