PC Online 1997 May/PCO_5_97.ISO/FilesBBS/OS2/NETREXX.ARJ/NETREXX.ZIP/NetRexx/Pinger.nrx

Text File | 1997-02-15 | 25.8 KB | 659 lines

/* 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.  */
/*                                                                    */
/* When the timer expires, 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).   */
/* ------------------------------------------------------------------ */
/* Mike Cowlishaw -- April 1996, February 1997                        */

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

/* ------------------------------------------------------------------ */
/* Pinger -- a stand-alone application                                */
/* ------------------------------------------------------------------ */
class Pinger extends Frame         -- a Frame window object

 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 */
 method main(s=String[]) static
   Pinger("Pinger" Rexx(s))                  -- make a Pinger, with title

 /* The constructor/initializer for Pinger */
 method Pinger(s=String)
   super(s)                                  -- pass title to Frame

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

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

   this.show                                 -- and make us visible

 /* Create menus and menu bar */
 method createmenus
   menubar=MenuBar()

   -- Help menu --
   menu=Menu("Help")
   menu.add(menuhelp)
   -- menu.addSeparator                      -- [how to add a separator]
   menu.add(menuabout)
   menubar.add(menu)

   setMenuBar(menubar)

 /* Method for handling events */
 method handleEvent(e=Event) returns boolean
   if e.id=Event.ACTION_EVENT then           -- it's an action ..
    if e.target<=MenuItem then do            -- .. from a MenuItem
     select label menuitems
       when e.target=menuhelp  then do
         if helpdialog=null then
           helpdialog=PingerDialog(this, PingerDialog.HELP)
         helpdialog.show
         end
       when e.target=menuabout then do
         -- aboutdialog varies, so we always construct a new one
         aboutdialog=PingerDialog(this, PingerDialog.ABOUT)
         aboutdialog.show
         end
       end menuitems
     return 1                                -- we handled it
     end

   if e.id=Event.WINDOW_DESTROY then exit    -- exit on close
   return super.handleEvent(e)               -- otherwise take default action

/* ------------------------------------------------------------------ */
/* PingerTime -- an object that holds a time, initially 0:00          */
/* ------------------------------------------------------------------ */
class PingerTime
  properties public           -- we're just a data receptacle
  mm=0                        -- minutes
  ss=0                        -- seconds

/* ------------------------------------------------------------------ */
/* PingerComponent -- a custom Pinger component                       */
/* ------------------------------------------------------------------ */
/* Notes:                                                             */
/*  1. java.awt.Graphics draws some rectangles one pixel too large,   */
/*     so you'll see "width-1" and "height-1" in unexpected places.   */

class PingerComponent extends Canvas

 -- Timer functional properties
 current=PingerTime()              -- current time [minutes and seconds]

 properties private
 spinner=Thread                    -- spin-button Thread, non-null if spinning
 timer  =Thread                    -- main timer Thread, null unless started

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

 -- Drawing and layout properties
 properties private
 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
   nop                             -- nothing special to do here

 /* 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<>size.width | height<>size.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=size.width; height=size.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(e=Event, x=int, y=int) returns int
   if badsize | e=null then return -1        -- no buttons or no event
   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 mouseMove(e=Event, x=int, y=int) returns boolean
   new=hit(e, x, y)
   if new=over then return 0                 -- no change
   /* change of button (or move off button) */
   if spinner<>null then do; spinner.stop; 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
   return 1

 /* Drag is treated just like Move (redraws button if leaves button) */
 method mouseDrag(e=Event, x=int, y=int) returns boolean
   return mouseMove(e, x, y)

 /* mouseUp redraws the button, if we're over one */
 method mouseUp(e=Event, x=int, y=int) returns boolean
   if spinner<>null then do; spinner.stop; spinner=null; end
   new=hit(e, x, y)
   if new=-1 then return 0              -- not over a button
   over=new
   bup[over]=1; bdi[over]=1
   this.repaint
   return 1

 /* mouseDown takes an action then redraws the button, if we're over one */
 method mouseDown(e=Event, x=int, y=int) returns boolean
   new=hit(e, x, y)
   if new=-1 then return 0              -- not over a button
   over=new
   bup[over]=0; bdi[over]=1
   if spinner<>null then do; spinner.stop; 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 pinged(0)               -- 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 pinged(0)               -- Stop or Beep state
                      else timer=PingerTimer(this) -- Start state
       settextStart
       this.repaint
       end
     end action
   return 1

 /* Enter and exit call our mouseMove to ensure known state */
 method mouseEnter(e=Event, x=int, y=int) returns boolean
   return mouseMove(e, x, y)
 method mouseExit(e=Event, x=int, y=int) returns boolean
   return mouseMove(e, x, y)

 /* 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

 /* pinged -- called when the pinger has pinged, or timer is to be stopped
    Arg1 is 1 for first call, 0 when pinger is ending
    returns count of bleeps to make [if first]
 */
 method pinged(first=boolean) returns int
   if first then return 3
   -- 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.stop; savetimer=null; end
   return 0

/* ------------------------------------------------------------------ */
/* 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

  properties constant
  slow=400                    -- initial delay time [ms]
  fast=50                     -- fastest delay time [ms]
  over=5                      -- 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, bumping either
     minutes or seconds, at intervals */
  method run
    loop forever
      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

/* ------------------------------------------------------------------ */
/* 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 'pinged' method.*/

class PingerTimer extends Thread
  owner=PingerComponent            -- who we work for
  soundfile="Pinger.au"            -- The Sound
  sfile=FileInputStream            -- .. as a file
  audio=AudioStream                -- .. as audio
  started=System.currentTimeMillis -- timestamp of when we were born

  /* Construct with
     Arg1 is parent object
     Arg2 is beep file (.au) to play
  */
  method PingerTimer(newowner=PingerComponent)
    owner=newowner
    this.setPriority(Thread.MAX_PRIORITY)         -- time matters, here
    this.start                                    -- off we go
    do
      sfile=FileInputStream(soundfile)
      audio=AudioStream(sfile)
      -- next line primes the audio subsystem
      AudioPlayer.player.start(audio)
      AudioPlayer.player.stop(audio)
    catch IOException
      say "Could not play file '"soundfile"'"
    end

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

    -- reach here iff zero attained
    loop label bleeps for owner.pinged(1)
      sfile=FileInputStream(soundfile)
      audio=AudioStream(sfile)
      AudioPlayer.player.start(audio)
      sleep(600)
    catch IOException
      say "Could not play file '"soundfile"'"
    catch InterruptedException
      nop
    end bleeps

    owner.pinged(0)                               -- definitely done

/* ------------------------------------------------------------------ */
/* PingerDialog -- tell about us                                      */
/* ------------------------------------------------------------------ */
class PingerDialog extends Dialog
 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

   -- position centre-screen
   sizex=400; sizey=300            -- TV shape
   screen=Toolkit.getDefaultToolkit.getScreenSize
   this.addNotify                  -- ensure peer exists
   reshape((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<>size.width | height<>size.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=size.width; height=size.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, April 1996",   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

 method handleEvent(e=Event) returns boolean
   if e.id=Event.WINDOW_DESTROY then do      -- we are going away
     dispose()
     owner.requestFocus
     return 1; end                           -- we've handled it
   return super.handleEvent(e)               -- take default action