home *** CD-ROM | disk | FTP | other *** search
/ Carousel / CAROUSEL.cdr / mactosh / lang / skel.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-03-13  |  25.6 KB  |  466 lines
  1. {%describe 'a Skeleton demo program'}
  2. {$X-}       {Turn automatic run-time stack expansion off - it's a Lisa concept.}
  3. {$R-}       {Turn off range checking; it can cause crashes.}
  4. PROGRAM Skel;
  5. {          By    Steve Maker
  6.                  Academic Computing
  7.                  Kiewit Computation Center
  8.                  Dartmouth College
  9.                  July 14, 1984
  10. Copyright notice:
  11.            SKEL may be copied and used by anyone, so long as that use
  12.            is not for commercial purposes.  Please send significant changes
  13.            back to me so that I may incorporate them into future versions.
  14. Why SKEL?
  15.            Skel is a skeleton demo program.  Its purpose is to illustrate
  16.            in a clear fashion, isolated from any particular application,
  17.            the basic code for handling a simple Macintosh user interface.
  18.            It strives to be correct as far as it goes, without many short-cuts
  19.            that would lead to trouble in larger applications.
  20.            I think of SKEL as a program that does nothing, but does it well.
  21. What does SKEL do?
  22.            It handles:
  23.                Events, carefully handling only those which are its
  24.                        business, and passing the others on to their
  25.                        respective handlers.
  26.                A Window, which is filled with Dark Gray, and can be
  27.                        activated or inactivated, updated, dragged
  28.                        and grown but NOT scrolled or closed.
  29.                Menus, including the Apple Menu.  An "About Skel" menu entry
  30.                        is provided.  A File menu offers Rattle and Frighten,
  31.                        which just invoke dialog boxes, and Quit.  Command
  32.                        key equivalents are supported.
  33.                The Desk Accessories, supported in the Apple menu,
  34.                        and correctly meshed with the other features.
  35.                        NOT supported are Undo, Cut, Copy, Paste and Clear
  36.                        (and keyboard equivalents) for desk accessories.
  37.                A Modal Dialog Box, used to communicate with the user.
  38.                Special icons for the application and its related files.
  39.                The Finder information (in the resource file).
  40.            In accordance with Macintosh guidelines, everything possible is
  41.            kept in the resource file: window description, menus,
  42.            dialog specification, and the "About Skel" and other strings.
  43.            In addition, the resource file handles the Bundle, File References,
  44.            and Icons that determine what Skel's icon looks like, and other
  45.            information for the Finder.
  46. How do I use SKEL?
  47.            Study it.  Modify it to test your knowledge.  Steal working
  48.            pieces of code for your own programs.  Beat on it.  Subject
  49.            it to cruel and unusual experiments.  Pay heed to its warnings.
  50. What do I study first in SKEL?
  51.            Initially you should ignore several sections of SKEL, and the calls
  52.            made to them.  I recommend X-ing them out in your listing.
  53.            The sections to ignore on the first round of study are:
  54.                Report: ignore the implementation
  55.                SetUpMemory: ignore all of it
  56.                DrawWindow: ignore the scroll bar and grow icon handling
  57.                ReSize: ignore all of it
  58.                DoCommand: ignore the Desk Accessory handling in the Apple Menu
  59.                MainEventLoop:
  60.                   MouseDown handling: ignore inSysWindow, inDrag, inGrow
  61.                   keyDown, autoKey handling: ignore this.
  62.            In the resource definition file, SKELR:
  63.                Finder information (offset by asterisks):
  64.                   ignore this whole section, icons and all.
  65. What should I read in Inside Macintosh?
  66.            You should read the following sections of Inside Macintosh,
  67.            in the order given.  At first, just lightly skim the sections
  68.            with parenthesized names.  Read the others in some depth.  Read
  69.            the starred (*) ones in great detail.  Eventually, you will have
  70.            read all sections thoroughly, and many many times, I promise you.
  71.            To start:
  72.              * Inside Macintosh: A Road Map
  73.               (User Interface Guidelines)
  74.                Structure of a Macintosh Application
  75.              * Putting Together a Macintosh Application
  76.            Then, (low-level sections are listed first):
  77.             *  Memory Mgr Intro
  78.               (Memory Mgr)
  79.             *  Resource Mgr (through "Using the Resource Mgr")
  80.             *  QuickDraw
  81.               (Desk Mgr)
  82.             *  Event Mgr (through "Event Mgr routines")
  83.                Window Mgr
  84.                Menu Mgr
  85.               (Dialog Mgr)
  86. How do I get SKEL to run?
  87.            The best way is to use the special EXEC file SKELX, and insert a
  88.            Macintosh diskette into your Lisa.  SKELX will write on it with
  89.            MacCom, and will set all info correctly so that the icon will appear.
  90.            You may also use Apple's EXEC file, or the Dartmouth exec files
  91.            T/EXEC or M/MACCOM.  The first two will not set the icon correctly,
  92.            while M/MACCOM will do that right, and also refrain from recompiling
  93.            or repeating other steps if they are unnecessary.
  94. What are the funny % describes for?
  95.            They are formatting commands for a Pascal formatter used at Dartmouth
  96.            on Lisa Pascal code, for producing a readable listing.
  97. What is the history of SKEL?
  98.       v1.0 July 14, 1984   sm: major revision of earlier version
  99.            Sept 30, 1984   sm: used \14 for apple symbol in res. file,
  100.                                bracketed OpenDeskAcc with Get and SetPort,
  101.            Oct 11, 1984   sm:  changed FREF, BNDL resources from HEXA
  102.                                   to readable,
  103.                                nested some routines in SKEL,
  104.                                added constants for FILE menu items,
  105.       v2.0 Nov 12, 1984   sm:  made resources pre-loaded and/or purgeable,
  106.                                turned off range-checking,
  107.                                documented no Resume proc passed to InitDialogs,
  108.                                added SetUpMemory:
  109.                                   calls MoreMasters, MaxApplZone,
  110.                                   sets the NIL address to -1,
  111.                                   lots of general memory doc.
  112.                                added a warning about passing doubly-
  113.                                   dereferenced handles,
  114.                                removed en/disabling of Rattle and Frighten items,
  115.       v2.1 Dec 4, 1984    sm:  added menu key handling,
  116.                                put Rattle and Frighten strings in res file,
  117.                                rewrote intro documentation
  118.       v2.2 Mar 6, 1985    sm:  converted to % describes,
  119.                                fixed SKELX for both 2.0 and 3.0 workshop,
  120.                                set the event mask
  121.  {%describe '(declarations)'}
  122.    USES {$U-}                            {Turn off Lisa libraries}
  123.       {$U Obj/MemTypes    } MemTypes,    {use type defs in MemTypes unit}
  124.       {$U Obj/QuickDraw   } QuickDraw,   {Search "Obj/Quickdraw" for  }
  125.       {$U Obj/OSIntf      } OSIntf,      {  the "QuickDraw" unit, etc.}
  126.       {$U Obj/ToolIntf    } ToolIntf,
  127.       {$U Obj/PackIntf    } PackIntf,    {these are not needed for SKEL,}
  128.       {$U Obj/Sane        } Sane,        {  but may be useful later.}
  129.       {$U Obj/Elems       } Elems,       {Assume normal SANE, not SANELIB}
  130.       {$U Obj/Graf3D      } Graf3D,
  131.       {$U Obj/MacPrint    } MacPrint;
  132.    CONST
  133.       lastMenu = 2;    { number of menus }
  134.       appleMenu = 1;   { menu ID for desk accessory menu }
  135.       fileMenu = 2;    { menu ID for File menu }
  136.       iRattle = 1;     {items in the File menu}
  137.       iFrighten = 2;
  138.       {--------}
  139.       iQuit = 4;
  140.     VAR
  141.       screenPort: GrafPtr;         {a port for the whole screen}
  142.       myWindow: WindowPtr;         {our one window}
  143.       wRecord: WindowRecord;       {storage for window record}
  144.       dragRect: Rect;              {rect to drag within}
  145.       growRect: Rect;              {bounds for the growth of the windows}
  146.       myMenus: ARRAY [1..lastMenu] OF MenuHandle;   {our menus}
  147.  {%describe 'Print a string in dialog box'}
  148.   {############################   Report   #################################}
  149.   {   We put up a dialog box, show the string, and wait for user to hit OK.}
  150.    PROCEDURE Report(reportstr: str255);
  151.       CONST RptBoxID = 257;   {ID of our report dialog in resource file}
  152.             rptText = 2;      {Item # of dialog's report text}
  153.       VAR
  154.          itemhit: INTEGER;    {which Item was clicked on (only OK avail)}
  155.          ReportPtr: DialogPtr;
  156.       BEGIN {Report}
  157.          {set text to display}
  158.          ParamText(reportStr, '', '', '');
  159.          ReportPtr := getNewDialog(RptBoxID, NIL, pointer(-1));    {get from Resource file;
  160.                                                                     NIL => use heap storage;
  161.                                                                     -1 => make dlg frontmost}
  162.          ModalDialog(NIL, itemHit);     {carry out dialog;
  163.                                          NIL => no FilterProc;
  164.                                          return item Hit when done}
  165.          DisposDialog(ReportPtr);        {release storage and remove dialog from screen}
  166.       END; {Report}
  167.  {%describe 'Once-only initialization for Skel'}
  168.   {############################   SetUp   #################################}
  169.   {   Initialize our program.  It seems best to handle:
  170.    Memory inits first, ToolBox inits second, then the program variables' inits.
  171.    Note that the order of inits is important; see "Using the Dialog Manager"
  172.    in the Dialog Mgr section.}
  173.   PROCEDURE SetUp;
  174.      CONST
  175.         WindowID = 260;       {Resource ID for my window}
  176.      VAR
  177.         screenRect: rect;     {size of screen; could be machine-dependent}
  178.  {%describe 'SetUps for handling memory'}
  179.   {############################   SetUpMemory   #################################}
  180.   {   This very important set of initializations can be left out of the first
  181.    versions of a program. We are making sure that memory is laid out as
  182.    we desire, with adequate protection against running out of memory, bad
  183.    handles, etc.}
  184. Procedure SetUpMemory;
  185.    CONST
  186.          maxStackSize = 8192;     {max size of stack; the heap gets the rest}
  187.    TYPE
  188.         loMemPtr = ^longint;      {a pointer to low memory locations}
  189.    VAR
  190.        nilPtr: loMemPtr;          {will have value NIL}
  191.        stackBasePtr: loMemPtr;    {points to current stack base}
  192.    BEGIN {SetUpMemory}
  193.         {If you define a GrowZone function to handle bad memory problems,
  194.          you should define it at the top level (not nested), and set it here.
  195.          We don't.}
  196.      (*  SetGrowZone(@MyGrowZone);
  197.      *)
  198.         {Place a longint -1 (an odd and therefore illegal address) in the
  199.          memory location that would be referenced by an accidentally-NIL
  200.          handle, so the error will be caught at handle-reference time (as
  201.          an Address error, ID=02) instead of later on.}
  202.         nilPtr := NIL;
  203.         nilPtr^ := -1;
  204.         {If you needed to use an Application heap limit other than the default
  205.          (which allows 8K for the stack), you'd set it here, possible using this
  206.          technique of explicitly specifying the maximum stack size and allocating
  207.          the rest to the heap.  Should be independent of memory size. }
  208.         stackBasePtr := loMemPtr($908);    {CurStackBase from Tlasm/sysequ.text}
  209.         SetApplLimit( pointer(stackBasePtr^ - maxStackSize) );
  210.         {Expand the application heap zone to its maximum size, without purging
  211.          any purgeable resources.  This saves memory compactions and heap expansions later.}
  212.         MaxApplZone;
  213.         {get plenty of master pointers now; if we let the Memory Manager allocate
  214.          them as needed, they'd form non-relocatable islands in the heap.}
  215.         MoreMasters;  MoreMasters;  MoreMasters;
  216.         {Here you might install bulwarks against running out of memory unexpectedly.
  217.          One such (cheesy) technique is to here allocate a large handle, call it
  218.          "CheeseBuf", which you can de-allocate in your GrowZone function, when
  219.          you must obtain more memory to avoid a crash.  While de-allocated,
  220.          the program could prevent the user from doing anything requiring memory,
  221.          and tell him he must discard windows or some such memory freeing action.
  222.          Each time he does so, the program can try to re-allocate CheeseBuf; if it
  223.          succeeds, the user can go on doing memory-eating operations.}
  224.    END; {SetUpMemory}
  225.  {%describe 'Once-only initialization for menus'}
  226.   {############################   SetUpMenus   #################################}
  227.   {   We read in all menus from the resource file, and install them,
  228.     and all desk accessories (drivers).}
  229.   PROCEDURE SetUpMenus;
  230.      VAR
  231.         i: INTEGER;
  232.      BEGIN {SetUpMenus}
  233.         for i := 1 to lastMenu do    {get all my menus in}
  234.            myMenus[i] := GetMenu(i); {use the fact that our menu ID's start at 1}
  235.         AddResMenu(myMenus[appleMenu], 'DRVR');    {pull in all desk accessories }
  236.         for i := 1 to lastMenu do
  237.            InsertMenu(myMenus[i], 0);          {insert menus; 0 => put at end}
  238.         DrawMenuBar;
  239.      END; {SetUpMenus }
  240.  {%describe '(body of SetUp)'}
  241.      BEGIN {SetUp}
  242.         {init memory layout and protection}
  243.         SetUpMemory;
  244.         {init QuickDraw, and everybody else}
  245.         InitGraf(@thePort);
  246.         InitFonts;
  247.         InitWindows;
  248.         InitMenus;
  249.         TEInit;
  250.         InitDialogs(NIL); {NIL => no Restart proc; see Dialog Mgr and System Error Handler}
  251.         InitCursor;
  252.         {Init the system event mask, in case the previous program left it in
  253.          a bad state.  If you set it non-standard here, FIX IT BEFORE EXITING,
  254.          because the Finder (1.1g) does NOT set it.}
  255.         SetEventMask(everyEvent - keyUpMask);     {standard setting}
  256.         {Get the port which is the whole screen, to use when deactivating our window.
  257.            This prevents the current grafPort pointer from ever dangling.}
  258.         GetWMgrPort(screenPort);   {get whole screen port that window mgr uses}
  259.         SetPort(screenPort);       {and start off with it}
  260.         {get window: use wRecord storage.  Port is set to that of the new window.
  261.             GetNewWindow posts an update event for the new window,
  262.             so it will be redrawn right away.}
  263.         myWindow := GetNewWindow(windowID, @wRecord, POINTER(-1));    {-1 => frontmost window}
  264.         {set up dragRect; we can drag the window within it}
  265.         screenRect := screenBits.bounds;          {don't assume screen size}
  266.         {set drag rect to avoid menu bar, and keep at least 4 pixels on screen}
  267.         SetRect(dragRect, 4, 24, screenRect.right-4, screenRect.bottom-4);
  268.         {set up GrowRect, for limits on window growing}
  269.         SetRect(growRect, 48, 14, screenRect.right-7, screenRect.bottom-7);
  270.         {pull in and set up our menus}
  271.         SetUpMenus;
  272.      END; {SetUp}
  273.  {%describe 'Redraw my window'}
  274.   {############################   DrawWindow   #################################}
  275.   {   We draw all the contents of our one window, myWindow.  Note that this must include
  276.    scroll bar areas and the grow icon; the Window Manager will NOT handle those for us.
  277.    Since there are no scroll bars, we must erase the region they would be in.  Echh.}
  278. PROCEDURE DrawWindow;
  279.    VAR aRect: rect; {rectangle to erase}
  280.    BEGIN {DrawWindow}
  281.       {first, fill the window with dark gray; this fills scroll bars, too}
  282.       FillRect(myWindow^.portRect, dkGray);
  283.       {second, erase the scroll bars and draw the grow icon}
  284.       {erase the horizontal scroll bar}
  285.       SetRect(aRect,          {cover the horizontal bar}
  286.               myWindow^.portRect.left,     myWindow^.portRect.bottom-15,
  287.               myWindow^.portRect.right-15, myWindow^.portRect.bottom);
  288.       FillRect(aRect, white);  {fill with white}
  289.       {erase the vertical scroll bar}
  290.       SetRect(aRect,          {cover the vertical bar}
  291.               myWindow^.portRect.right-15, myWindow^.portRect.top,
  292.               myWindow^.portRect.right,    myWindow^.portRect.bottom-15);
  293.       FillRect(aRect, white); {fill with white}
  294.       DrawGrowIcon(myWindow); {draw the size box in the corner of the window}
  295.     END; {DrawWindow}
  296.  {%describe 'Update the contents of the given window'}
  297.   {############################   UpdateWindow   #################################}
  298.   {   This is our response to receipt of an update event for myWindow.  Since the
  299.    window is likely to be inactive, the current grafPort will be elsewhere.  We must
  300.    change it for drawing, yet leave it as it was.}
  301.    PROCEDURE UpdateWindow(aWindow: WindowPtr);
  302.       VAR
  303.          savePort: GrafPtr;   {to save and restore the old port}
  304.       BEGIN {UpdateWindow}
  305.          BeginUpdate(aWindow); {reset ClipRgn etc to only redraw what's necessary.}
  306.          GetPort(savePort);    {don't trash the port; we might be updating an inactive window}
  307.          SetPort(aWindow);     {work in the specified window}
  308.          drawWindow;           {redraw contents of window}
  309.          SetPort(savePort);    {all nice and tidy as before}
  310.          EndUpdate(aWindow);
  311.       END; {UpdateWindow}
  312.   {%describe 'Change the size of the given window'}
  313.   {############################   ReSize   #################################}
  314.   {   Called on a mouse-down in the grow box, this allows the user to change
  315.    the size of the window.  We change the size, then
  316.    claim that the whole of the window contents is no longer validly drawn,
  317.    because we're too lazy to do so for just the scroll bar regions
  318.    that are actually subject to change.  See the Window Manager.}
  319. PROCEDURE ReSize(a_window : WindowPtr; downPt: Point);
  320.    VAR w, h : integer;           {new width and height of the sized window}
  321.        newSize : longint;       {the new size}
  322.    BEGIN {ReSize}
  323.        newSize := GrowWindow(a_window, downPt, growRect); {find new size}
  324.        w := LoWord(newSize); {find the width}
  325.        h := HiWord(newSize); {find the height}
  326.        SizeWindow(a_window, w, h, true); {change to the new window size}
  327.        {place whole window into update region to be sure it all gets updated.
  328.         This is more than is strictly necessary, but a lot easier than just
  329.         invalidating the regions that actually may have changed.}
  330.        InvalRect(a_window^.portRect);
  331.     END; {ReSize}
  332.  {%describe 'the main loop that handles events'}
  333.   {############################   MainEventLoop   #################################}
  334.   {   Brace yourself: here's where the action is.  Most Mac programs just wait for events
  335.    (as do we all), and then process them.  There are two sorts of events: those directly
  336.    initiated by the user, like key presses and mouse-downs, and those consequent events
  337.    posted by the Event Manager, like update and activate events.  The latter MUST be handled
  338.    correctly and carefully.  In particular, it's important for all events to make sure
  339.    that the event occurred in or for the window you expect -- it's possible to get events
  340.    which are not for one of our windows, despite GetNextEvent's return value.  Similarly,
  341.    be sure to check that the window it occured in is the active one, if it matters.
  342.       A common mistake in handling update and activate events is in finding out which window
  343.    they are for.  It is "WindowPtr(myEvent.message)" that gives this information,
  344.    NOT "whichWindow" (the WindowPtr returned by FindWindow).  The latter pointer merely tells
  345.    you what window the mouse was in at the time the event was posted -- completely irrelevant
  346.    for Update and Activate events.  Think it through carefully.}
  347.    PROCEDURE MainEventLoop;
  348.       VAR
  349.           myEvent: EventRecord;
  350.           whichWindow: WindowPtr;       {points to window of MouseDown}
  351.           windowCode: integer;          {what mouse was in when event posted}
  352.           userDone: boolean;            {true when user wants to exit program}
  353.  {%describe 'handle a command given through a menu selection'}
  354.   {############################   DoCommand   #################################}
  355.   {   We carry out the command indicated by mResult.
  356.    If it was Quit, we return true, else false.  Since the menu was highlighted by
  357.    MenuSelect, we must finish by unhighlighting it to indicate we're done.}
  358. FUNCTION DoCommand(mResult: LongInt): boolean;
  359.    CONST
  360.       AboutSkelId = 1;     {Resource ID of the string}
  361.       RattleID = 2;
  362.       FrightenID = 3;
  363.    VAR
  364.       refNum: integer;
  365.       theMenu, theItem: integer;
  366.       name: str255;
  367.       savePort: grafPtr;    {for saving current port in when opening a desk acc}
  368.       aStr: str255;         {a utility string}
  369.    BEGIN  {DoCommand}
  370.       DoCommand := false;            {assume Quit not selected}
  371.       theMenu := HiWord(mResult);    {get the menu selected}
  372.       theItem := LoWord(mResult);    {... and the item of that menu}
  373.       CASE theMenu OF
  374.          0: ;    {user made no selection; do nothing}
  375.          appleMenu:
  376.             begin
  377.             if theItem = 1
  378.               then begin;  {get string, and tell about Skel}
  379.                     {It's important not to pass Report a de-referenced handle;
  380.                      if Report were in another segment, loading it could
  381.                      caused a memory compaction; the de-referenced handle
  382.                      could become invalid.  Watch out for this and similar
  383.                      nasties everywhere in your program.
  384.                      See the Memory Manager and the Segment Loader.}
  385.                    aStr := GetString(AboutSkelId)^^;
  386.                    report(aStr);
  387.                    end
  388.               else begin   {run a desk accessory; make sure port is preserved}
  389.                    getPort(savePort);
  390.                    GetItem(myMenus[appleMenu], theItem, name);     {get name}
  391.                    refNum := OpenDeskAcc(name);          {run the desk accessory}
  392.                    setPort(savePort);
  393.                    end;
  394.             end;
  395.          fileMenu:
  396.             CASE theItem OF
  397.                iRattle: begin;                              {Rattle}
  398.                         aStr := GetString(RattleId)^^;
  399.                         report(aStr);
  400.                         end;
  401.                iFrighten: begin;                            {Frighten}
  402.                         aStr := GetString(FrightenId)^^;
  403.                         report(aStr);
  404.                         end;
  405.                iQuit:     DoCommand := true                 {Quit}
  406.             END; {fileMenu case}
  407.       END; {menu case }
  408.       HiliteMenu(0)        {turn off hilighting on the menu just used}
  409.    END; {DoCommand }
  410.  {%describe '(body of MainEventLoop)'}
  411.    BEGIN  {MainEventLoop}
  412.       FlushEvents(EveryEvent, 0);    {discard leftover events}
  413.       {get next event, and handle it appropriately, until user QUITs}
  414.       userDone := false;
  415.       REPEAT
  416.          systemTask;       {handle desk accessories}
  417.          if GetNextEvent(everyEvent, myEvent)  {get event; if for us...}
  418.            then begin
  419.                 case myEvent.what of           {handle each kind of event}
  420.                    mouseDown:
  421.                       begin
  422.                          {find out what window the mouse went down in, and where in it}
  423.                          windowCode := FindWindow(myEvent.where, whichWindow);
  424.                          case windowCode of     {handle mouse-down for each place}
  425.                             inSysWindow:          {handle the desk accessories}
  426.                                   SystemClick(myEvent, whichWindow);
  427.                             inMenuBar:  {handle the command}
  428.                                   userDone := DoCommand(MenuSelect(myEvent.where));
  429.                             inDrag:     {drag the window}
  430.                                   DragWindow(whichWindow, myEvent.where, dragRect);
  431.                             inContent:   {includes inGrow if window inactive. Activate window}
  432.                                   if whichWindow = myWindow  {moke sure it's for mine}
  433.                                     then if whichWindow <> FrontWindow
  434.                                            then SelectWindow(whichWindow);   {make it active}
  435.                             inGrow:  {window is already active; change its size}
  436.                                   if whichWindow = myWindow  {moke sure it's for mine}
  437.                                     then ReSize(myWindow, myEvent.where);
  438.                             inGoAway:   {we don't have a GoAway region}
  439.                          end; {case windowCode}
  440.                       end;  {mouseDown handling}
  441.                    keyDown, autoKey:   {if command key, pass the char to MenuKey}
  442.                       if BitAnd(myEvent.modifiers, cmdKey) <> 0
  443.                         then userDone := DoCommand(MenuKey(chr(BitAnd(myEvent.message, charCodeMask))));
  444.                    updateEvt: {if it's for our window, update it}
  445.                       if WindowPtr(myEvent.message) = myWindow
  446.                         then UpdateWindow(myWindow);             {redraw the window contents}
  447.                    activateEvt:      {if for our window, set port as nec.}
  448.                       if WindowPtr(myEvent.message) = myWindow       {my window}
  449.                         then begin
  450.                              DrawGrowIcon(myWindow);     {redraw grow icon to reflect new state}
  451.                              if odd(myEvent.modifiers)   {odd means an activate event}
  452.                                then SetPort(myWindow)    {activate evt: work in our own port}
  453.                                else SetPort(screenPort); {deactivate evt: our port is gone;
  454.                                                           keep port from dangling}
  455.                              end;
  456.                 end;  {case myEvent.what}
  457.                 end;  {THEN BEGIN for "it's our event"}
  458.       UNTIL userDone;
  459.    END; {MainEventLoop}
  460.  {%describe '(body of Skel)'}
  461.    BEGIN {Skel}
  462.       SetUp;
  463.       MainEventLoop;
  464.    END. {Skel}
  465.  
  466.