/* Pinger: a count-down ('kitchen') timer.                            */
/* ------------------------------------------------------------------ */
/* This is a sample stand-alone Java application with frame, menus,   */
/* and a custom component that shows how to use images and graphics.  */
/* This version needs Java 1.1 (or later) to run.                     */
/*                                                                    */
/* When the timer ends, an audio clip is played.  You'll only hear    */
/* this if:                                                           */
/*   -- you have a sound card or equivalent installed and working.    */
/*   -- you have speakers, headphone, etc. attached to the sound      */
/*      card, in range of your hearing, and switched on if need be.   */
/*   -- the file Pinger.au is available (this can be any sound clip   */
/*      in .au format, 0.5 seconds or less; a default is supplied).   */
/* You can specify the name of an alternative soundclip file when the */
/* pinger is started.  For example:  java Pinger myclip.au            */
/* ------------------------------------------------------------------ */
/* For the latest version, go to http://www2.hursley.ibm.com/netrexx  */
/* ------------------------------------------------------------------ */
/* Mike Cowlishaw -- April 1996 - October 1997                        */

options binary                     -- optional, for speed
import sun.audio.                  -- for sound clip player

/* ------------------------------------------------------------------ */
/* Pinger -- a stand-alone application for the Java Virtual Machine   */
/* ------------------------------------------------------------------ */
class Pinger extends Frame-
             adapter implements WindowListener, ActionListener

 properties constant
   defaultclip='Pinger.au'    -- default soundclip file

 properties private
   -- active dialogs --
   aboutdialog=Dialog
   helpdialog =Dialog

   -- menu selection objects --
   menuhelp=MenuItem("Help")
   menuabout=MenuItem("About")

 /* The 'main' method is called when this class is started as an application */
 /* The optional argument is the name of the sound clip file to use */
 method main(s=String[]) static
   Pinger("Pinger", Rexx(s))                 -- make a Pinger, with title

 /* The constructor/initializer for Pinger */
 method Pinger(title, soundclip)
   super(title)                              -- pass title to Frame
   addWindowListener(this)                   -- we want window events

   -- setup the logical structure of the frame
   createmenus                               -- set up menubar
   setLayout(BorderLayout())                 -- we must have a layout
   timer=PingerComponent()                   -- make new timer
   add("Center", timer)                      -- add new timer image
   this.pack                                 -- recalculate the frame

   -- position centre-screen
   sizex=200; sizey=175
   screen=Toolkit.getDefaultToolkit.getScreenSize
   setBounds((screen.width-sizex)%2,(screen.height-sizey)%2, sizex, sizey)

   this.show                                 -- make us visible
   timer.prime(soundclip)                    -- prime the audio system
   return                                    -- JVM will wait for threads to end

 /* Create menus and menu bar */
 method createmenus
   bar=MenuBar()                             -- create a MenuBar
   -- Help drop-down menu --
   help=Menu("Help")                         -- create a Menu
   help.add(menuhelp)
   -- help.addSeparator                      -- [how to add a separator]
   help.add(menuabout)
   bar.add(help)                             -- add the menu to the MenuBar
   setMenuBar(bar)                           -- add the menubar to the Frame
   -- say we want the MenuItem events to come to us
   menuhelp.addActionListener(this)
   menuabout.addActionListener(this)

 /* Method for handling Button and MenuItem events */
 method actionPerformed(a=ActionEvent)
   source=a.getSource                        -- the sender object
   if source<=MenuItem then                  -- .. from a MenuItem
     select label menuitems
       when source=menuhelp  then do
         if helpdialog=null then
           helpdialog=PingerDialog(this, PingerDialog.HELP)
         helpdialog.show
         end
       when source=menuabout then do
         -- aboutdialog varies, so we always construct a new one
         aboutdialog=PingerDialog(this, PingerDialog.ABOUT)
         aboutdialog.show
         end
       end menuitems

  /* windowClosing -- called when the window is closed.
     We need to handle this to end the program. */
  method windowClosing(e=WindowEvent)
    exit

/* ------------------------------------------------------------------ */
/* PingerTime -- an object that holds a time, initially 00:00         */
/* ------------------------------------------------------------------ */
/* As an object, it can be protected for safe multiple-thread access. */
class PingerTime
  properties public           -- we're just a data receptacle
  mm=0                        -- minutes
  ss=0                        -- seconds

/* ------------------------------------------------------------------ */
/* PingerComponent -- a custom Pinger component                       */
/* ------------------------------------------------------------------ */
class PingerComponent extends Canvas-   -- Canvas is a drawing area
   adapter implements MouseListener, MouseMotionListener

 properties constant
   minmm=0; maxmm=99               -- bounds
   minss=0; maxss=59               -- ..

 properties private
   -- Timing properties
   current=PingerTime()            -- current time [minutes and seconds]
   timer  =PingerTimer             -- main timer, null unless started
   spinner=PingerSpinner           -- spin-button, non-null if spinning

   -- Sound stuff
   bleeper=PingerBleeper           -- a bleeper object

   -- Drawing and layout properties
   shadow=Image                    -- shadow image
   width=0; height=0               -- current picture dimensions
   draw=Graphics                   -- 'context' where we can draw
   background=Color.yellow         -- guess what

   badsize =boolean 1              -- too small
   resizing=boolean 0              -- we are preparing new shadow
   spinbutw=0                      -- spin button width
   spinbuth=10                     -- spin button height [fixed]
   controlw=0                      -- control button width
   controlh=24                     -- control button height [fixed]
   gap=5                           -- margin [fixed]
   timerect  =Rectangle            -- where time will go
   timefont  ="TimesRoman"         -- font face for time
   timepoints=0                    -- pointsize for time
   timeweight=Font.BOLD            -- weight for time
   timecol   =Color.black          -- color for time
   timedi    =boolean              -- time needs redraw
   buttons   =6                    -- number of buttons
   but=Rectangle[buttons]          -- button rectangles
                                   -- 0/1 are Ups; 2/3 are Downs
                                   -- 4/5 are reset/start
   bcol=Color[buttons]             -- button colors
   btext=String[buttons]           -- button labels
   ben=boolean[buttons]            -- button enabled
   bup=boolean[buttons]            -- button up
   bdi=boolean[buttons]            -- button dirty (needs redraw)
   over=-1                         -- button we are over [-1 is none]

 /* Construct the component */
 method PingerComponent
   super()
   addMouseListener(this)          -- we want mouse events ..
   addMouseMotionListener(this)    -- .. and mouse movements

 /* update  -- called in reponse to repaint() */
 -- We update our off-screen image here, to avoid embarrassment to the
 -- AWT caused by asynchronous calls to paint()
 method update(g=Graphics)
   -- redraw areas that have changed since last repaint.  We draw into
   -- an off-screen image, later copied to the screen in a single call.
   loop i=0 to 5                      -- redraw dirty buttons
     if bdi[i] then do
       drawbutton(i)
       bdi[i]=0
       end
     end i
   if timedi then do
     drawtime(timerect)               -- redraw the time
     timedi=0
     end
   paint(g)

 /* paint  -- called when the window needs to be resized or redrawn */
 method paint(g=Graphics)
   if resizing then return         -- ignore paints while recalculating
   if shadow=null | width<>getSize.width | height<>getSize.height then do
     resizing=1
     newsize
     return
     end
   g.drawImage(shadow, 0, 0, this) -- copy to screen

 /* newsize -- here when a new size detected */
 method newsize
   width=getSize.width; height=getSize.height

   -- The very first time that we get here, there won't be an existing
   -- Image, so we have to create it.  It cannot be set up in advance,
   -- as there's no physical context earlier.
   shadow=createImage(width, height)         -- need new image
   draw=shadow.getGraphics                   -- for graphics
   if height<gap*6+spinbuth*2+controlh*3/2 | width<50
    then do label toosmall
     badsize=1
     text="Window too small"
     draw.setColor(Color.white)              -- warner
     draw.fillRect(0, 0, width-1, height-1)
     draw.setFont(Font("Helvetica", Font.PLAIN, 10))
     fm=draw.getFontMetrics                  -- find out about font
     w=fm.stringWidth(text)                  -- actual width
     x=(width-w)%2                           -- offset
     y=(height-fm.getHeight)%2               -- raw offset
     y=y+fm.getAscent+fm.getLeading          -- adjust for whitespace
     draw.setColor(Color.black)
     draw.drawString(text, x, y)
     end toosmall
    else do label bigenough
     badsize=0
     draw.setColor(background)             -- ok
     draw.fillRect(0, 0, width-1, height-1)
     spinbutw=(width-gap-gap)*4%9          -- button sizes
     controlw=(width-gap*3)%2

     -- Calculate button positions
     but[0]=Rectangle(gap,                gap, spinbutw, spinbuth)
     but[1]=Rectangle(width-gap-spinbutw, gap, spinbutw, spinbuth)
     lowspins=height-gap*3-1-controlh-spinbuth
     but[2]=Rectangle(gap,                lowspins, spinbutw, spinbuth)
     but[3]=Rectangle(width-gap-spinbutw, lowspins, spinbutw, spinbuth)
     lowconts=height-gap-controlh
     but[4]=Rectangle(gap,                lowconts, controlw, controlh)
     but[5]=Rectangle(width-gap-controlw, lowconts, controlw, controlh)

     -- Calculate time position and pointsize
     timerect=Rectangle(gap, gap*2+spinbuth,-
       width-gap*2, height-controlh-spinbuth*2-gap*6-1)
     -- use 24 point for measuring, as an exact font almost certainly there
     draw.setFont(Font(timefont, timeweight, 24)) -- measure font
     fm=draw.getFontMetrics                       -- get metrics
     x0=fm.stringWidth('0')
     xc=fm.stringWidth(':')
     y0=fm.getAscent
     xpoints=timerect.width*24/(x0*4+xc*3)
     ypoints=timerect.height*24/y0
     if xpoints<ypoints then timepoints=int xpoints
                        else timepoints=int ypoints

     -- Draw separator
     draw.setColor(Color.lightGray)
     sepy=lowspins+gap+spinbuth+1
     draw.drawLine(0, sepy, width-1, sepy)
     end bigenough

   -- Set default state for buttons --
   loop i=0 to buttons-1
     select
       when i<4 then do
         btext[i]="";      bcol[i]=Color.orange.darker
         end
       when i=4 then do
         btext[i]="Reset"; bcol[i]=Color.cyan.darker
         end
       when i=5 then do
         btext[i]="Start"; bcol[i]=Color.cyan.darker
         end
       end
     bup[i]=1; ben[i]=1; bdi[i]=1
     end

   -- Update the time and buttons
   resizing=0                           -- OK to use shadow, now
   newtime                              -- this will refresh the display

 /* Draw the time */
 method drawtime(where=Rectangle)
   if badsize then return
   draw.setColor(background)
   draw.fillRect(where.x, where.y, where.width-1, where.height-1)
   draw.setFont(Font(timefont, timeweight, timepoints ))
   fm=draw.getFontMetrics               -- find out about font
   y=(where.height-fm.getHeight)%2      -- raw offset
   y=y+fm.getAscent+fm.getLeading       -- adjust for whitespace

   do protect current                   -- snapshot
     mmtext=String current.mm
     sstext=String current.ss
     end
   if sstext.length=1 then sstext='0'sstext
   ctext=':'
   draw.setColor(timecol)
   -- centre the colon
   cw=fm.stringWidth(ctext)
   cx=(where.width-cw)%2
   draw.drawString(ctext,  where.x+cx, where.y+y)
   -- right-align minutes
   mw=fm.stringWidth(mmtext)
   mx=spinbutw-mw   -- shouldn't really use spinbutw
   draw.drawString(mmtext, where.x+mx, where.y+y)
   -- left-align seconds
   -- sw=fm.stringWidth(sstext)
   sx=where.width-spinbutw
   draw.drawString(sstext, where.x+sx, where.y+y)

 /* Draw a button, up or down, filling with colour */
 method drawbutton(b=int)
   if badsize then return
   text=btext[b]; where=but[b]
   if ben[b] then do                    -- enabled
     col=bcol[b]; up=bup[b]
     if over=b then col=col.brighter    -- highlight if active
     end
    else do                             -- not enabled
     col=Color.gray; up=1
     end
   draw.setColor(col)
   draw.fillRect(where.x, where.y, where.width-1, where.height-1)
   draw.setColor(Color.gray)
   -- remember, draw3DRect in JDK 1.0 draws too large
   draw.draw3DRect(where.x, where.y, where.width-1, where.height-1, up)
   draw.draw3DRect(where.x+1, where.y+1, where.width-3, where.height-3, up)
   draw.setColor(Color.gray.darker)
   draw.drawLine(where.x, where.y, where.x+1, where.y+1) -- add definition
   if text.length=0 then return
   -- have some text to add
   draw.setFont(Font("Helvetica", Font.PLAIN, 15))   -- choose font
   fm=draw.getFontMetrics               -- find out about font
   w=fm.stringWidth(text)               -- actual width
   x=(where.width-w)%2                  -- offset
   if x<0 then return                   -- won't fit
   y=(where.height-fm.getHeight)%2      -- raw offset
   y=y+fm.getAscent+fm.getLeading       -- adjust for whitespace
   if y<0 then return                   -- won't fit
   draw.setColor(Color.black)
   draw.drawString(text, where.x+x, where.y+y)

 /* Returns number of button we are over, or -1 if none */
 method hit(m=MouseEvent) returns int
   if badsize | m=null then return -1   -- no buttons or no event
   x=m.getX; y=m.getY
   loop b=0 to buttons-1
     if x>=but[b].x
      then if x<but[b].x+but[b].width
      then if y>=but[b].y
      then if y<but[b].y+but[b].height then return b
     end b
   return -1

 /* The mouse is moving over our image */
 method mouseMoved(m=MouseEvent)
   new=hit(m)
   if new=over then return                   -- no change
   /* change of button (or move off button) */
   if spinner<>null then do; spinner.halt; spinner=null; end
   old=over; over=new
   -- indicate button state change
   if old >=0 then do; bup[old]=1;  bdi[old]=1;  end
   if over>=0 then do; bup[over]=1; bdi[over]=1; end
   this.repaint

 /* Drag is treated just like Move (redraws button if leaves button) */
 method mouseDragged(m=MouseEvent)
   mouseMoved(m)

 /* mouseReleased redraws the button, if we're over one */
 method mouseReleased(m=MouseEvent)
   if spinner<>null then do; spinner.halt; spinner=null; end
   new=hit(m)
   if new=-1 then return                -- not over a button
   over=new
   bup[over]=1; bdi[over]=1
   this.repaint

 /* mousePressed takes an action then redraws the button, if we're over one */
 method mousePressed(m=MouseEvent)
   new=hit(m)
   if new=-1 then return                -- not over a button
   over=new
   bup[over]=0; bdi[over]=1
   if spinner<>null then do; spinner.halt; spinner=null; end  -- just in case

   -- [from here, all paths should initiate a repaint eventually]
   if \ben[over] then this.repaint      -- not enabled, just repaint
    else select label action            -- enabled, so take action
     when over=0 then spinner=PingerSpinner(this, 1, +1)
     when over=1 then spinner=PingerSpinner(this, 0, +1)
     when over=2 then spinner=PingerSpinner(this, 1, -1)
     when over=3 then spinner=PingerSpinner(this, 0, -1)
     when over=4 then do  -- reset
       if timer<>null then stoptimer               -- stop the timer
       do protect current
         current.mm=0; current.ss=0                -- back to zero
         -- [or could simply make a new PingerTime object]
         end
       newtime
       end
     when over=5 then do
       if timer<>null then stoptimer               -- Stop or Beep state
                      else timer=PingerTimer(this) -- Start state
       settextStart
       this.repaint
       end
     end action

 /* mouseEntered and mouseExited call our mouseMoved to ensure known state */
 method mouseEntered(m=MouseEvent); mouseMoved(m)
 method mouseExited(m=MouseEvent);  mouseMoved(m)

 /* Increase or decrease minutes and seconds numbers
    Arg1 is increment (+1 or -1)
    returns 1 if result is 00:00
  */
 method bumpmm(inc=int) returns boolean
   do protect current
     current.mm=current.mm+inc
     if current.mm>maxmm then current.mm=maxmm
      else if current.mm<minmm then current.mm=minmm
     end
   return newtime

 method bumpss(inc=int) returns boolean
   do protect current
     current.ss=current.ss+inc
     if current.ss>maxss then /* carry */ do
       current.ss=minss
       current.mm=current.mm+1
       if current.mm>maxmm then do; current.mm=maxmm; current.ss=maxss; end
       end
     if current.ss<minss then /* borrow */ do
       current.ss=maxss
       current.mm=current.mm-1
       if current.mm<minmm then do; current.mm=minmm; current.ss=minss; end
       end
     end
   return newtime

 /* we have a new time -- update buttons, etc.
    returns 1 if the current time is 00:00 */
 method newtime returns boolean
   -- set buttons enablement and state
   ben[0]=1; ben[1]=1
   do protect current
     if current.mm=maxmm then do
       ben[0]=0
       if current.ss=maxss then ben[1]=0
       end
     atzero=current.mm=0 & current.ss=0
     end
   ben[2]=\atzero;               ben[3]=ben[2]
   ben[4]=\atzero | timer<>null; ben[5]=ben[4]
   settextStart
   loop i=0 to 5; bdi[i]=1; end         -- redraw all buttons
   timedi=1                             -- redraw the time
   this.repaint                         -- update display
   return atzero

 /* set the text for button 5 */
 method settextStart
  do protect current
    atzero=current.mm=0 & current.ss=0  -- take safe snapshot
    end
  if atzero then do
    if timer=null then btext[5]="Time?"
                  else btext[5]="Beep!"
    end
   else /* nonzero */ do
    if timer=null then btext[5]="Start"
                  else btext[5]="Stop"
    end
  bdi[5]=1                              -- button needs redraw

 /* prime -- called to initialize the sound system */
 method prime(filename)
   if filename='' then filename=Pinger.defaultclip
   bleeper=PingerBleeper(filename) -- make the bleeper object

 /* ping -- sound the bleeper once */
 method ping
   bleeper.bleep

 /* stoptimer -- called when the timer is to be stopped */
 method stoptimer
   -- closing: stop the timer last, because we may have been called from it
   savetimer=timer; timer=null
   newtime                              -- update display
   if savetimer<>null then do; savetimer.halt; savetimer=null; end
   return

/* ------------------------------------------------------------------ */
/* PingerSpinner  -- a class for the spinner Thread                   */
/* ------------------------------------------------------------------ */
class PingerSpinner extends Thread
  count=0                     -- ticks
  owner=PingerComponent       -- who we work for
  mins=boolean                -- 1 if a minutes spinner
  inc=int                     -- up or down
  spin=boolean 1              -- spin allowed

  properties constant
  slow=400                    -- initial delay time [ms]
  fast=30                     -- fastest delay time [ms]
  over=6                      -- how many ticks to accelerate over

  /* Construct with
     Arg1 is parent object
     Arg2 is 1=minute, 0=seconds
     Arg3 is increment (+1 or -1)
  */
  method PingerSpinner(newowner=PingerComponent, newmins=boolean, newinc=int)
    owner=newowner; mins=newmins; inc=newinc
    this.start

  /* This runs so long as the button is held down (after which halt is
     set), bumping either minutes or seconds, at intervals */
  method run
    loop until \spin                    -- always bump once
      if mins then owner.bumpmm(inc)
              else owner.bumpss(inc)
      count=count+1
      if count<=over then wait=fast+(over+1-count)*(slow-fast)%over
       else wait=fast
      sleep(wait)
    catch InterruptedException
      return
    end

  /* This method is called to request that the spin stop.  We use this
     pending request, as a direct call to stop could leave the call to
     owner unfinished. */
  method halt
    spin=0

/* ------------------------------------------------------------------ */
/* PingerTimer  -- a main pinger timer Thread                         */
/* ------------------------------------------------------------------ */
/* This thread must update the pinger in real time, so it keeps       */
/* an eye on 'wall-clock' time so the timer cannot drift.  Any delays */
/* will be corrected as soon as the thread gets control.              */
/*                                                                    */
/* When done, it notifies its owner with calls to the 'ping' method,  */
/* for each bleep, and then to the 'stoptimer' method.                */

class PingerTimer extends Thread
  owner=PingerComponent            -- who we work for
  started=System.currentTimeMillis -- timestamp of when we were born
  down=boolean 1                   -- count down while 1

  /* Construct with
     Arg1 is parent object
  */
  method PingerTimer(newowner=PingerComponent)
    owner=newowner
    this.setPriority(Thread.MAX_PRIORITY)         -- time matters, here
    this.start                                    -- off we go

  /* This runs until stopped, or we reach 0 */
  method run
    loop millisecs=started+1000 by 1000           -- when next tick
      -- calculate how long to next second
      wait=millisecs-System.currentTimeMillis
      if wait<=0 then iterate                     -- badly behind
      sleep(wait)
      if \down then leave                         -- halt request
      if owner.bumpss(-1) then leave              -- decrement and quit if 0
    catch InterruptedException
      return
    end

    if down then loop for 3
      -- reach here iff countdown not halted
      owner.ping
      sleep(600)
    catch InterruptedException
      nop
    end

    owner.stoptimer                               -- definitely done

  /* This method is called to request that the count stop.  We use this
     pending request, as a direct call to stop could leave the bumpss
     call to owner unfinished. */
  method halt
    down=0

/* ------------------------------------------------------------------ */
/* PingerBleeper -- the sound maker                                   */
/* ------------------------------------------------------------------ */
class PingerBleeper
  soundfile=File                   -- File of The Sound
  okfile=boolean 0                 -- 1 if the file is good
  input=InputStream                -- .. as a stream
  audio=AudioStream                -- .. as audio

  /* Constructor.
     Arg1 is beep file (.au) to play
  */
  method PingerBleeper(filename)
    -- first ensure that the file exists
    soundfile=File(filename)
    if \soundfile.exists | \soundfile.isFile then do
      say 'The audio file "'filename'" could not be found'
      return
      end
    okfile=1                       -- file is plausible

    -- now prime the audio subsystem by sending it a 0 byte.  This loads
    -- the audio software so the final bleeps will be prompt (starting
    -- up the audio subsystem can take seconds on some platforms).
    do
      input=ByteArrayInputStream([byte 0])
      -- next lines prime the audio subsystem, by trying to play an
      -- invalid stream
      audio=AudioStream(input)
      AudioPlayer.player.start(audio)
    catch IOException
      -- we expect to get here
    end

  /* bleep once */
  method bleep
    if \okfile then return         -- no good file to play
    do
      -- set the input stream each time ('rewind')
      input=FileInputStream(soundfile)
      audio=AudioStream(input)
    catch IOException
      say "Could not play file '"soundfile"'"
      okfile=0                     -- don't even try next time
    end
    AudioPlayer.player.start(audio)

/* ------------------------------------------------------------------ */
/* PingerDialog -- tell about us                                      */
/* ------------------------------------------------------------------ */
class PingerDialog extends Dialog adapter implements WindowListener
 owner=Pinger                      -- who we work for
 form=int                          -- form of text

 -- Drawing and layout properties
 shadow=Image                      -- shadow image
 d=Graphics                        -- where we can draw
 width=0; height=0                 -- current picture dimensions

 properties constant
 HELP=0                            -- build Help text
 ABOUT=1                           -- build About text

 /* Construct a general dialog for Pinger */
 method PingerDialog(newowner=Pinger, newform=int)
   super(newowner, title(newform), 1)
   owner=newowner; form=newform
   addWindowListener(this)         -- we want window events

   -- position centre-screen
   sizex=400; sizey=300            -- TV shape
   screen=Toolkit.getDefaultToolkit.getScreenSize
   this.addNotify                  -- ensure peer exists
   setBounds((screen.width-sizex)%2,(screen.height-sizey)%2, sizex, sizey)
   setResizable(0)                 -- fixed size panel, please
   -- display (show) will be triggered by creator

 /* provide a title string, on demand */
 method title(titleform=int) static returns String
   if titleform=HELP  then return "Help for Pinger"
   return "About Pinger"

 /* update  -- overridden, because we set background */
 method update(g=Graphics); paint(g)

 /* paint  -- called when the window needs to be redrawn */
 method paint(g=Graphics)
   -- we do not need to protect the image, here, as there should be
   -- only one.  However, a race condition is possible, so we check for
   -- an uninitialized 'shadow'.
   if width<>getSize.width | height<>getSize.height then newsize
    else if shadow<>null then g.drawImage(shadow, 0, 0, this)

 /* newsize -- here when a new size detected; should be called once */
 method newsize
   /* make a new image to draw in, if needed */
   width=getSize.width; height=getSize.height
   shadow=this.createImage(width, height)         -- make image
   d=shadow.getGraphics                           -- context to draw
   d.setColor(Color.white)                        -- background
   d.fillRect(0, 0, width, height)                -- ..

   d.setFont(Font("TimesRoman", Font.PLAIN, 20))  -- measure font
   fm=d.getFontMetrics                            -- get metrics
   h=fm.getHeight+2                               -- +2 pels leading
   y=(height-h*5)%3                               -- offset

   -- Add some text, etc.  Any graphics allowed, here.
   if form=ABOUT then do
     secs=int Date().getTime//7000
     d.setColor(Color.getHSBColor(secs/6999, 1, 0.5))
     d.drawString("Simple 'Pinger' application",  20, y+h)
     d.drawString("For the NetRexx source, see:", 20, y+h*2)
     d.drawString("  http://www2.hursley.ibm.com/netrexx/", 20, y+h*3)
     d.drawString("Mike Cowlishaw, 1996-1997 ",   20, y+h*4)
     end
    else /* Help */ do
     d.setColor(Color.blue.darker)
     d.drawString("This is a 'kitchen timer' application",  20, y+h)
     d.drawString("Set the time using the unmarked buttons.", 20, y+h*2)
     d.drawString("Press 'Start' to start countdown.", 20, y+h*3)
     d.drawString("Press 'Reset' to zero timer.", 20, y+h*4)
     end
   d.setFont(Font("Helvetica", Font.PLAIN, 12))
   d.setColor(Color.black)
   d.drawString("Compiled with" version, 20, y+h*5)

   this.repaint

  /* windowClosing -- called when the window is closed.
     We need to handle this to end the program. */
  method windowClosing(e=WindowEvent)
    owner.requestFocus
    this.dispose()
    return

