lake.java

实现图片水波效果

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   lake.java

import java.applet.Applet;
import java.applet.AppletContext;
import java.awt.*;
import java.awt.image.ImageObserver;
import java.io.PrintStream;
import java.net.MalformedURLException;
import java.net.URL;

public class lake extends Applet
    implements Runnable
{

    private int boatHeight;
    private boolean keepRunning;
    private transient Thread thrLake;
    private static final String PARAM_IMAGE = "image";
    private static final String PARAM_OVERLAY = "overlay";
    private static final String PARAM_TARGET = "target";
    private static final String PARAM_HREF = "hRef";
    private static final String PARAM_ROCKING = "rocking";
    private static final String PARAM_UNDERWATER = "underwater";
    private static final String PARAM_SPEED = "speed";
    private static final String PARAM_HORIZON = "horizon";
    private Image image;
    private Image overlay;
    private MediaTracker overlayTracker;
    private String target;
    private URL hRef;
    private boolean rocking;
    private boolean underwater;
    private int speed;
    private int horizon;
    private int numFrames;
    private transient Graphics gMain;
    private transient Graphics gWave;
    private transient Image imgWave;
    private transient int currImage;
    private transient int widthImage;
    private transient int heightImage;
    private transient int widthOverlay;
    private transient int heightOverlay;
    private transient boolean allLoaded;
    private transient boolean isAnimating;
    private transient int boatPhase;
    private transient int boatPhaseTotal;

    public void start()
    {
        keepRunning = true;
        if(thrLake == null)
        {
            thrLake = new Thread(this);
            thrLake.start();
        }
    }

    public void stop()
    {
        keepRunning = false;
    }

    public void run()
    {
        currImage = 0;
        while(keepRunning) 
            try
            {
                while(!isAnimating) 
                    Thread.sleep(500L);
                if(++currImage == numFrames)
                    currImage = 0;
                if(++boatPhase == boatPhaseTotal)
                    boatPhase = 0;
                displayImage();
                repaint();
                Thread.sleep(30L);
            }
            catch(InterruptedException _ex)
            {
                stop();
            }
    }

    public String getAppletInfo()
    {
        return "Name: lake Version 4.0\r\nAuthor: David Griffiths\r\nis an applet class which takes in an \r\nimage and reflects it in a virtual lake.\r\nLast compiled: 10th October 1999 at 13:17:27  \r\nFor more information about this and other applets\r\ngo to http://www.spigots.com/spigots.htm\r\nCreated with Sun JDK 1.1";
    }

    public Image getImage()
    {
        return image;
    }

    public void setImage(Image image1)
    {
        image = image1;
        widthImage = image.getWidth(this);
        heightImage = image.getHeight(this);
        allLoaded = true;
        createAnimation();
    }

    public void setImageValue(String s)
    {
        setImage(getImage(getDocumentBase(), s));
    }

    public boolean imageUpdate(Image image1, int i, int j, int k, int l, int i1)
    {
        boolean flag = super.imageUpdate(image1, i, j, k, l, i1);
        if(image1 == image)
        {
            int j1 = heightImage;
            if((i & 0x30) != 0)
            {
                widthImage = l;
                heightImage = i1;
            } else
            {
                widthImage = size().width;
                heightImage = (10 * size().height) / 18;
            }
            if(j1 != heightImage)
                createAnimation();
        }
        return flag;
    }

    public Image getOverlay()
    {
        return overlay;
    }

    public void setOverlay(Image image1)
    {
        overlay = image1;
        overlayTracker = new MediaTracker(this);
        overlayTracker.addImage(image1, 0);
    }

    public void setOverlayValue(String s)
    {
        setOverlay(getImage(getDocumentBase(), s));
    }

    private boolean overlayReady()
    {
        if(overlayTracker != null)
            return overlayTracker.statusID(0, true) == 8;
        else
            return false;
    }

    public String getTarget()
    {
        return target;
    }

    public void setTarget(String s)
    {
        target = s;
    }

    public void setTargetValue(String s)
    {
        setTarget(s);
    }

    public URL getHRef()
    {
        return hRef;
    }

    public void setHRef(URL url)
    {
        hRef = url;
    }

    public void setHRefValue(String s)
    {
        setHRef(createURL(s));
    }

    private URL createURL(String s)
    {
        URL url = null;
        if(s != null)
            try
            {
                url = new URL(getDocumentBase(), s);
            }
            catch(MalformedURLException _ex)
            {
                error("Bad URL: " + s);
                url = null;
            }
        return url;
    }

    public boolean isRocking()
    {
        return rocking;
    }

    public void setRocking(boolean flag)
    {
        rocking = flag;
    }

    public void setRockingValue(String s)
    {
        setRocking(s.toUpperCase().equals("TRUE"));
    }

    public void toggleRocking()
    {
        setRocking(!isRocking());
    }

    public boolean isUnderwater()
    {
        return underwater;
    }

    public void setUnderwater(boolean flag)
    {
        underwater = flag;
    }

    public void setUnderwaterValue(String s)
    {
        setUnderwater(s.toUpperCase().equals("TRUE"));
    }

    public void toggleUnderwater()
    {
        setUnderwater(!isUnderwater());
    }

    public int getSpeed()
    {
        return speed;
    }

    public void setSpeed(int i)
    {
        if(i > 100)
            i = 100;
        else
        if(i < 1)
            i = 1;
        speed = i;
        numFrames = 600 / i;
    }

    public void setSpeedValue(String s)
    {
        setSpeed(Integer.parseInt(s));
    }

    public int getHorizon()
    {
        return horizon;
    }

    public void setHorizon(int i)
    {
        if(i > -2)
            horizon = i;
    }

    public void setHorizonValue(String s)
    {
        setHorizon(Integer.parseInt(s));
    }

    public String[][] getParameterInfo()
    {
        String as[][] = {
            {
                "image", "Image", "JPG or GIF file to reflect"
            }, {
                "overlay", "Image", "JPG or GIF file to use as an overlay"
            }, {
                "target", "String", "Target frame"
            }, {
                "hRef", "URL", "URL to link to"
            }, {
                "rocking", "boolean", "TRUE if boat rocking"
            }, {
                "underwater", "boolean", "TRUE if viewer underwater"
            }, {
                "speed", "int", "The animation speed: 1-100"
            }, {
                "horizon", "int", "The horizon level: 0-height of image"
            }
        };
        return as;
    }

    private void loadParams()
    {
        String s = getParameter("horizon");
        if(s != null)
            setHorizonValue(s);
        s = getParameter("image");
        if(s != null)
            setImageValue(s);
        s = getParameter("overlay");
        if(s != null)
            setOverlayValue(s);
        s = getParameter("target");
        s = getParameter("hRef");
        if(s != null)
            setHRefValue(s);
        else
            setHRefValue("http://www.spigots.com/lake.htm");
        s = getParameter("rocking");
        if(s != null)
            setRockingValue(s);
        s = getParameter("underwater");
        if(s != null)
            setUnderwaterValue(s);
        s = getParameter("speed");
        if(s != null)
            setSpeedValue(s);
    }

    public boolean mouseUp(Event event, int i, int j)
    {
        if(hRef != null)
        {
            error(String.valueOf(hRef));
            getAppletContext().showDocument(hRef, target);
        }
        return true;
    }

    public void init()
    {
        repaint();
        System.out.println(getAppletInfo());
        loadParams();
        allLoaded = true;
    }

    public Dimension getPreferredSize()
    {
        return new Dimension(widthImage, (int)((double)heightImage * 1.8D));
    }

    private void error(String s)
    {
        getAppletContext().showStatus(s);
    }

    public void update(Graphics g)
    {
        paint(g);
    }

    public void paint(Graphics g)
    {
        if(imgWave != null)
            g.drawImage(imgWave, 0, boatHeight, this);
    }

    private void displayImage()
    {
        if(isRocking())
            boatHeight = (int)(((double)heightImage * Math.sin((6.2831853071795862D * (double)boatPhase) / (double)boatPhaseTotal)) / 8D) - heightImage / 8;
        else
            boatHeight = 0;
        if(imgWave != null)
        {
            if(isUnderwater())
            {
                if(horizon >= 0)
                {
                    gWave.drawImage(image, 0, 0, this);
                    makeWavesInverseHorizon(gWave, currImage);
                } else
                {
                    gWave.drawImage(image, 0, size().height - heightImage, this);
                    makeWavesInverse(gWave, currImage);
                }
                boatHeight = -boatHeight;
            } else
            {
                gWave.drawImage(image, 0, 0, this);
                if(horizon >= 0)
                    makeWavesHorizon(gWave, currImage);
                else
                    makeWaves(gWave, currImage);
            }
            if(overlay != null && overlayReady())
                gWave.drawImage(overlay, widthImage - overlay.getWidth(this) >> 1, (heightImage - (overlay.getHeight(this) >> 1)) + boatHeight, this);
        }
    }

    private void createAnimation()
    {
        if(widthImage > 0 && heightImage > 0)
            synchronized(this)
            {
                if(horizon >= 0)
                    imgWave = createImage(2 * widthImage, 2 * heightImage);
                else
                    imgWave = createImage(widthImage, 2 * heightImage);
                gWave = imgWave.getGraphics();
                if(horizon >= 0)
                    gWave.drawImage(image, widthImage, 0, this);
            }
        repaint();
    }

    private void makeWaves(Graphics g, int i)
    {
        double d = (6.2831853071795862D * (double)i) / (double)numFrames;
        for(int j = 0; j < heightImage; j++)
        {
            int k = (int)(((double)(heightImage / 14) * ((double)j + 28D) * Math.sin((double)((heightImage / 14) * (heightImage - j)) / (double)(j + 1) + d)) / (double)heightImage);
            if(j - heightImage > k)
                g.copyArea(0, heightImage - j, widthImage, 1, 0, j << 1);
            else
                g.copyArea(0, (heightImage - j) + k, widthImage, 1, 0, (j << 1) - k);
        }

    }

    private void makeWavesHorizon(Graphics g, int i)
    {
        double d = (6.2831853071795862D * (double)i) / (double)numFrames;
        for(int j = horizon; j < heightImage; j++)
        {
            int k = (int)(((double)(heightImage / 14) * ((double)(j - horizon) + 28D) * Math.sin((double)((heightImage / 14) * ((heightImage - j) + horizon)) / (double)((j - horizon) + 1) + d)) / (double)heightImage);
            if(j + k >= heightImage)
                g.copyArea(widthImage, j, widthImage, 1, -widthImage, 0);
            else
                g.copyArea(widthImage, j + k, widthImage, 1, -widthImage, -k);
        }

    }

    private void makeWavesInverse(Graphics g, int i)
    {
        double d = (6.2831853071795862D * (double)i) / (double)numFrames;
        int j = size().height;
        for(int k = 0; k < heightImage; k++)
        {
            int l = (int)(((double)(heightImage / 14) * ((double)k + 28D) * Math.sin((double)((heightImage / 14) * (heightImage - k)) / (double)(k + 1) + d)) / (double)heightImage);
            if(k - heightImage > l)
                g.copyArea(0, (j - heightImage) + k, widthImage, 1, 0, -(k << 1));
            else
                g.copyArea(0, ((j - heightImage) + k) - l, widthImage, 1, 0, l - (k << 1));
        }

    }

    private void makeWavesInverseHorizon(Graphics g, int i)
    {
        double d = (6.2831853071795862D * (double)i) / (double)numFrames;
        size();
        for(int j = horizon; j < heightImage; j++)
        {
            int k = (int)(((double)(heightImage / 14) * ((double)(j - horizon) + 28D) * Math.sin((double)((heightImage / 14) * ((heightImage - j) + horizon)) / (double)((j - horizon) + 1) + d)) / (double)heightImage);
            if(j + k >= heightImage)
                g.copyArea(widthImage, heightImage - j, widthImage, 1, -widthImage, 0);
            else
                g.copyArea(widthImage, (heightImage - j) + k, widthImage, 1, -widthImage, -k);
        }

    }

    public lake()
    {
        keepRunning = true;
        target = "_self";
        rocking = false;
        underwater = false;
        speed = 50;
        horizon = -1;
        numFrames = 12;
        allLoaded = false;
        isAnimating = true;
        boatPhaseTotal = 50;
    }
}