|
<!--StartFragment-->******************************************************************************
// Lake.java: Applet
//
// (c) David Griffiths, 1997
// This source code may not be reproduced without the express permission of the
// author.
//******************************************************************************
import java.applet.*;
import java.net.URL;
import java.net.MalformedURLException;
import java.awt.*;
//==============================================================================
// Main Class for applet Lake
//
//==============================================================================
public class Lake extends Applet implements Runnable
{
// THREAD SUPPORT:
// m_Lake is the Thread object for the applet
//--------------------------------------------------------------------------
Thread m_Lake = null;
// ANIMATION SUPPORT:
// m_Graphics used for storing the applet's Graphics context
// m_WaveGraphics used for storing the animation's Graphics context
// m_Image the original image
// m_WaveImage the image containing the wave animations
// m_nCurrImage the index of the next image to be displayed
// m_ImgWidth width of each image
// m_ImgHeight height of each image
// m_OvlWidth width of each overlay
// m_OvlHeight height of each overlay
// m_fAllLoaded indicates whether all images have been loaded
// m_tAnimate indicates that OK to do animation (changed by mouse
// click)
// NUM_FRAMES number of NUM_FRAMES used in the animation
//--------------------------------------------------------------------------
private Graphics m_Graphics, m_WaveGraphics;
private Image m_Image, m_Overlay, m_WaveImage;
private int m_nCurrImage;
private int m_nImgWidth = 0;
private int m_nImgHeight = 0;
private int m_nOvlWidth = 0;
private int m_nOvlHeight = 0;
private boolean m_fAllLoaded = false, m_tAnimate = true;
private final int NUM_FRAMES = 12;
// PARAMETER SUPPORT:
// Parameters allow an HTML author to pass information to the applet;
// the HTML author specifies them using the <PARAM> tag within the <APPLET>
// tag. The following variables are used to store the values of the
// parameters.
//--------------------------------------------------------------------------
// Members for applet parameters
// <type> <MemberVar> = <Default Value>
//--------------------------------------------------------------------------
private String m_ImageName = "";
private String m_OverlayName = "";
private URL m_HRef;
private String m_Frame = "_self";
// Parameter names. To change a name of a parameter, you need only make
// a single change. Simply modify the value of the parameter string below.
//--------------------------------------------------------------------------
private final String PARAM_image = "image";
private final String PARAM_overlay = "overlay";
private final String PARAM_href = "href";
private final String PARAM_target = "target";
// Lake Class Constructor
//--------------------------------------------------------------------------
public Lake()
{
// TODO: Add constructor code here
}
// APPLET INFO SUPPORT:
// The getAppletInfo() method returns a string describing the applet's
// author, copyright date, or miscellaneous information.
//--------------------------------------------------------------------------
public String getAppletInfo()
{
return "Name: Lake v3.0 " +
"Author: David Griffiths " +
"Created with Microsoft Visual J++ Version 1.0";
}
// PARAMETER SUPPORT
// The getParameterInfo() method returns an array of strings describing
// the parameters understood by this applet.
//
// Lake Parameter Information:
// { "Name", "Type", "Description" },
//--------------------------------------------------------------------------
public String[][] getParameterInfo()
{
String[][] info =
{
{ PARAM_image, "String", "JPG or GIF file to reflect" },
{ PARAM_overlay, "String", "JPG or GIF file to use as overlay" },
{ PARAM_href, "URL", "URL to link to" },
{ PARAM_target, "String", "Target frame" },
};
return info;
}
// The init() method is called by the AWT when an applet is first loaded or
// reloaded. Override this method to perform whatever initialization your
// applet needs, such as initializing data structures, loading images or
// fonts, creating frame windows, setting the layout manager, or adding UI
// components.
//--------------------------------------------------------------------------
public void init()
{
// PARAMETER SUPPORT
// The following code retrieves the value of each parameter
// specified with the <PARAM> tag and stores it in a member
// variable.
//----------------------------------------------------------------------
String param;
// image: JPG of GIF file to reflect
//----------------------------------------------------------------------
param = getParameter(PARAM_image);
if (param != null)
m_ImageName = param;
// overlay: JPG of GIF file to use as overlay
//----------------------------------------------------------------------
param = getParameter(PARAM_overlay);
if (param != null)
m_OverlayName = param;
// href: URL to link to
//----------------------------------------------------------------------
param = getParameter(PARAM_href);
if (param != null)
try
{
m_HRef = new URL(getDocumentBase(), param);
}
catch (MalformedURLException e)
{
getAppletContext().showStatus("Bad URL: " + param);
return;
}
// target: Target frame
//----------------------------------------------------------------------
param = getParameter(PARAM_target);
if (param != null)
m_Frame = param;
}
// Place additional applet clean up code here. destroy() is called when
// when you applet is terminating and being unloaded.
//-------------------------------------------------------------------------
public void destroy()
{
// TODO: Place applet cleanup code here
}
// ANIMATION SUPPORT:
// Draws the next image, if all images are currently loaded
//--------------------------------------------------------------------------
private void displayImage(Graphics g)
{
if (!m_fAllLoaded)
return;
// Draw frame of rippled lower half
//----------------------------------------------------------------------
if (m_WaveImage != null) {
g.drawImage (m_WaveImage, (-m_nCurrImage * m_nImgWidth), m_nImgHeight, this);
g.drawImage (m_WaveImage, ((NUM_FRAMES-m_nCurrImage) * m_nImgWidth),
m_nImgHeight, this);
}
// Draw the original in the tophalf.
//----------------------------------------------------------------------
g.drawImage (m_Image, 0, -1, this);
}
// Lake Paint Handler
//--------------------------------------------------------------------------
public void paint(Graphics g)
{
// ANIMATION SUPPORT:
// The following code displays a status message until all the
// images are loaded. Then it calls displayImage to display the current
// image.
//----------------------------------------------------------------------
if (m_fAllLoaded)
displayImage(g);
else
g.drawString("Loading images...", 10, 20);
// TODO: Place additional applet Paint code here
}
// The start() method is called when the page containing the applet
// first appears on the screen. The AppletWizard's initial implementation
// of this method starts execution of the applet's thread.
//--------------------------------------------------------------------------
public void start()
{
if (m_Lake == null)
{
m_Lake = new Thread(this);
m_Lake.start();
}
}
// The stop() method is called when the page containing the applet is
// no longer on the screen. The AppletWizard's initial implementation of
// this method stops execution of the applet's thread.
//--------------------------------------------------------------------------
public void stop()
{
if (m_Lake != null)
{
m_Lake.stop();
m_Lake = null;
}
}
// THREAD SUPPORT
// The run() method is called when the applet's thread is started. If
// your applet performs any ongoing activities without waiting for user
// input, the code for implementing that behavior typically goes here. For
// example, for an applet that performs animation, the run() method controls
// the display of images.
//--------------------------------------------------------------------------
public void run()
{
m_nCurrImage = 0;
// If re-entering the page, then the images have already been loaded.
// m_fAllLoaded == TRUE.
//----------------------------------------------------------------------
if (!m_fAllLoaded)
{
repaint();
m_Graphics = getGraphics();
// Now load up the image to be used in the animation. Rather than do
// this asynchronously with imageUpdate (which is a pain in the bum to
// use) we'll do it synchronously with a MediaTracker. This hangs
// around until the image is loaded. Using the waitForAll method, just
// in case we ever add other images to the applet.
//------------------------------------------------------------------
MediaTracker tracker = new MediaTracker(this);
String strImage;
m_Image = getImage(getDocumentBase(), m_ImageName);
if (!"".equals(m_OverlayName))
m_Overlay = getImage(getDocumentBase(), m_OverlayName);
tracker.addImage(m_Image, 0);
if (!"".equals(m_OverlayName))
tracker.addImage(m_Overlay, 1);
// Wait until all images are fully loaded
//------------------------------------------------------------------
try
{
tracker.waitForAll();
m_fAllLoaded = !tracker.isErrorAny();
}
catch (InterruptedException e) {}
if (!m_fAllLoaded)
{
stop();
m_Graphics.drawString("Error loading images!", 10, 40);
return;
}
// Can now set width and height straight away because the
// MediaTracker object has ensured this information is now available.
//--------------------------------------------------------------
m_nImgWidth = m_Image.getWidth(this);
m_nImgHeight = m_Image.getHeight(this);
if (!"".equals(m_OverlayName)) {
m_nOvlWidth = m_Overlay.getWidth(this);
m_nOvlHeight = m_Overlay.getHeight(this);
}
// Now create the animation of the rippling waves.
//--------------------------------------------------------------
createAnimation();
}
repaint();
while (true)
{
try
// Draw next image in animation
//--------------------------------------------------------------
if (m_tAnimate)
{
displayImage(m_Graphics);
if (++m_nCurrImage == NUM_FRAMES)
m_nCurrImage = 0;
Thread.sleep(50);
}
else
Thread.sleep(500);
catch (InterruptedException e)
stop();
}
}
// MOUSE SUPPORT:
// Clicking on the applet starts/stops it.
// Doesn't call 'stop()' directly because otherwise an InterruptedException
// is thrown. ..
//--------------------------------------------------------------------------
public boolean mouseUp(Event event, int i, int j)
{
boolean flag = super.mouseUp(event, i, j);
if (m_HRef == null)
m_tAnimate = !m_tAnimate; // Toggle m_tAnimate to start/stop animation.
else
{
showStatus("" + m_HRef);
getAppletContext().showDocument(m_HRef, m_Frame);
}
return true;
}
// ANIMATION
// Create the animation within a single background image. We use a single
// image rather than the default multiple images because it's quicker.
//---------------------------------------------------------------------------
public void createAnimation ()
{
// Create inverted image of original loaded image.
// We create a background image (backImg) 1 pixel higher
// than the original because we'll need an extra line of
// pixels to play with when we flip the image upside down.
//--------------------------------------------------------
Image backImg = createImage (m_nImgWidth, m_nImgHeight + 1);
Graphics backG = backImg.getGraphics();
// Copy the original image (m_Image) onto the background
// version.
//--------------------------------------------------------
backG.drawImage (m_Image, 0, 1, this);
// Now flip the image upside down.
//--------------------------------------------------------
for (int i = 0; i < (m_nImgHeight >> 1); i++)
{
backG.copyArea (0, i, m_nImgWidth, 1, 0, m_nImgHeight - i);
backG.copyArea (0, m_nImgHeight - 1 - i, m_nImgWidth, 1,
0, -m_nImgHeight + 1 + (i << 1));
backG.copyArea (0, m_nImgHeight, m_nImgWidth, 1, 0, -1 - i);
}
// Now create the large (NUM_FRAMES + 1 times the width) image
// that will store dithered copies of the inverted original.
//--------------------------------------------------------
m_WaveImage = createImage ((NUM_FRAMES + 1) * m_nImgWidth, m_nImgHeight);
m_WaveGraphics = m_WaveImage.getGraphics();
m_WaveGraphics.drawImage (backImg, NUM_FRAMES * m_nImgWidth, 0, this);
// Now create dithered copies (sine displacement up or down) of the
// inverted original.
//--------------------------------------------------------
for (int phase = 0; phase < NUM_FRAMES; phase++)
makeWaves (m_WaveGraphics, phase);
// Now, if there is an overlay image, draw the top half of it
// over the frame. (The bottom half of the overlay will be drawn over
// the rippled image)
//------------------------------------------------------------
backG.drawImage (m_Image, 0, 1, this);
if (!"".equals(m_OverlayName))
backG.drawImage (m_Overlay,
(m_nImgWidth - m_nOvlWidth) >> 1,
m_nImgHeight - (m_nOvlHeight >> 1), this);
m_Image = backImg;
}
// ANIMATION
// Take the initial (unwaved) image from the left-hand-side of the graphics
// and make NUM_FRAMES copies of it - the pixels rows of each one dithered
// up or down depending upon the dispy sine function.
//---------------------------------------------------------------------------
public void makeWaves (Graphics g, int phase)
{
double p1;
int dispx, dispy;
// Convert the phase into radians (by splitting 2*PI into
// NUM_FRAMES segments).
//--------------------------------------------------------
p1 = 2 * Math.PI * (double)phase / (double)NUM_FRAMES;
// dispx defines how far across the image has to be copied
// from the original LHS frame.
//--------------------------------------------------------
dispx = (NUM_FRAMES - phase) * m_nImgWidth;
// Now process each horizontal line of pixels. Copy across
// from original frame on the left-had-side and displacing
// up or down WRT the dispy sine function.
//--------------------------------------------------------
for (int i = 0; i < m_nImgHeight; i++)
{
// dispy defines the vertical sine displacement. It
// attenuates higher up the image, for perspective.
//--------------------------------------------------------
dispy = (int)((m_nImgHeight/14) * ((double) i + 28.0)
* Math.sin ((double)((m_nImgHeight/14)*(m_nImgHeight - i))
/(double)(i + 1)
+ p1)
/ (double) m_nImgHeight);
// If no line dithers here then copy original.
//--------------------------------------------------------
if (i < -dispy)
g.copyArea (NUM_FRAMES * m_nImgWidth, i, m_nImgWidth, 1,
-dispx, 0);
else
// Else copy dithered line.
//--------------------------------------------------------
g.copyArea (NUM_FRAMES * m_nImgWidth, i + dispy,
m_nImgWidth, 1, -dispx, -dispy);
}
// Now, if there is an overlay image, draw the bottom half of it
// over the frame. (The top half of the overlay will be drawn over
// the original image)
//------------------------------------------------------------
if (!"".equals(m_OverlayName))
g.drawImage (m_Overlay,
(phase * m_nImgWidth) + ((m_nImgWidth - m_nOvlWidth) >> 1),
-m_nOvlHeight >> 1, this);
}
}
| |
