水面的倒影源程序

核心提示：<!--StartFragment-->**// Lake.java: Applet (c) David Griffiths, 1997// This source code may not be rePRodUCed without the eXPress permission of the // aut

　　<!--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);

}

}