Learn Java Now/Learn_Java_Now_Microsoft_1996.iso/JavaNow/Code/Chap16/Animation/Animation.java

Java Source | 1996-07-29 | 11.6 KB | 331 lines

//******************************************************************************
// Animation.java:    Applet
//
//******************************************************************************
import java.applet.*;
import java.awt.*;

//==============================================================================
// Main Class for applet Animation
//
//==============================================================================
public class Animation extends Applet implements Runnable
{
    // THREAD SUPPORT:
    //        m_Animation    is the Thread object for the applet
    //--------------------------------------------------------------------------
    Thread     m_Animation = null;

    // ANIMATION SUPPORT:
    //        m_Graphics        used for storing the applet's Graphics context
    //        m_Images[]        the array of Image objects for the animation
    //        m_nCurrImage    the index of the next image to be displayed
    //        m_ImgWidth        width of each image
    //        m_ImgHeight        height of each image
    //        m_fAllLoaded    indicates whether all images have been loaded
    //        m_numImages         number of images used in the animation
    //--------------------------------------------------------------------------
    private Graphics m_Graphics;
    private Image     m_Images[];
    private int      m_nCurrImage;
    private int      m_nImgWidth  = 0;
    private int      m_nImgHeight = 0;
    private boolean  m_fAllLoaded = false;
    // private final int m_numImages = 18;

    private int    m_nSleepTime;  // sleep time based on m_fps

    // 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 int m_fps = 10;
    private String m_imageFile = "";
    private int m_numImages = 22;

    // 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_fps = "fps";
    private final String PARAM_imageFile = "imageFile";
    private final String PARAM_numImages = "numImages";

    // Animation Class Constructor
    //--------------------------------------------------------------------------
    public Animation()
    {
        // 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: Animation\r\n" +
               "Author: Stephen R. Davis\r\n" +
               "Created for Learn Java Now (c)";
    }

    // PARAMETER SUPPORT
    //        The getParameterInfo() method returns an array of strings describing
    // the parameters understood by this applet.
    //
    // Animation Parameter Information:
    //  { "Name", "Type", "Description" },
    //--------------------------------------------------------------------------
    public String[][] getParameterInfo()
    {
        String[][] info =
        {
            { PARAM_fps, "int", "Frame rate" },
            { PARAM_imageFile, "String", "Name of the image seq" },
            { PARAM_numImages, "int", "Number of images" },
        };
        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;

        // fps: Frame rate
        //----------------------------------------------------------------------
        param = getParameter(PARAM_fps);
        if (param != null)
            m_fps = Integer.parseInt(param);

        // imageFile: Name of the image seq
        //----------------------------------------------------------------------
        param = getParameter(PARAM_imageFile);
        if (param != null)
            m_imageFile = param;

        // numImages: Number of images
        //----------------------------------------------------------------------
        param = getParameter(PARAM_numImages);
        if (param != null)
            m_numImages = Integer.parseInt(param);

        // If you use a ResourceWizard-generated "control creator" class to
        // arrange controls in your applet, you may want to call its
        // CreateControls() method from within this method. Remove the following
        // call to resize() before adding the call to CreateControls();
        // CreateControls() does its own resizing.
        //----------------------------------------------------------------------
        resize(320, 240);

        // Calculate the sleep time based on fps
        if (m_fps != 0)
        {
            m_nSleepTime = 1000 / m_fps;
        }
    }

    // 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 Image in center of applet
        //----------------------------------------------------------------------
        g.drawImage(m_Images[m_nCurrImage],
                   (size().width - m_nImgWidth)   / 2,
                   (size().height - m_nImgHeight) / 2, null);
        // display the frame number (this is optional)
        g.setColor(Color.white);
        g.drawString("Image #" + m_nCurrImage, 10,40);
    }

    // Animation 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)
        {
            Rectangle r = g.getClipRect();

            g.clearRect(r.x, r.y, r.width, r.height);
            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_Animation == null)
        {
            m_Animation = new Thread(this);
            m_Animation.start();
        }
        // TODO: Place additional applet start code here
    }

    //        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_Animation != null)
        {
            m_Animation.stop();
            m_Animation = null;
        }

        // TODO: Place additional applet stop code here
    }

    // 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();
            m_Images   = new Image[m_numImages];

            // Load in all the images
            //------------------------------------------------------------------
            MediaTracker tracker = new MediaTracker(this);
            String strImage;

            // For each image in the animation, this method first constructs a
            // string containing the path to the image file; then it begins
            // loading the image into the m_Images array.  Note that the call to
            // getImage will return before the image is completely loaded.
            //------------------------------------------------------------------
            for (int i = 1; i <= m_numImages; i++)
            {
                // Build path to next image
                //--------------------------------------------------------------
                // the AppletWizard code uses a hard-coded filename;
                // replace with a parameter from the HTML file
                strImage = // "images/img00"
                           m_imageFile       // initialized in init()
                           + ((i < 10) ? "0" : "")
                           + i
                           + ".gif";
                m_Images[i-1] = getImage(getDocumentBase(), strImage);

                tracker.addImage(m_Images[i-1], 0);
            }

            // Wait until all images are fully loaded
            //------------------------------------------------------------------
            try
            {
                tracker.waitForAll();
                m_fAllLoaded = !tracker.isErrorAny();
            }
            catch (InterruptedException e)
            {
                // TODO: Place exception-handling code here in case an
                //       InterruptedException is thrown by Thread.sleep(),
                //         meaning that another thread has interrupted this one
            }

            if (!m_fAllLoaded)
            {
                stop();
                m_Graphics.drawString("Error loading images!", 10, 40);
                return;
            }


            // Assuming all images are same width and height.
            //--------------------------------------------------------------
            m_nImgWidth  = m_Images[0].getWidth(this);
            m_nImgHeight = m_Images[0].getHeight(this);
        }
        repaint();

        // get the audio clip that goes with the animation above
        String sSoundClip = new String(m_imageFile + ".au");
        AudioClip ac = getAudioClip(getCodeBase(), sSoundClip);

        // now play it in a loop
        ac.loop();

        while (true)
        {
            try
            {
                // Draw next image in animation
                //--------------------------------------------------------------
                displayImage(m_Graphics);
                m_nCurrImage++;
                if (m_nCurrImage == m_numImages)
                    m_nCurrImage = 0;

                // replace with a value based on the fps parameter:
                Thread.sleep(m_nSleepTime);
            }
            catch (InterruptedException e)
            {
                // TODO: Place exception-handling code here in case an
                //       InterruptedException is thrown by Thread.sleep(),
                //         meaning that another thread has interrupted this one
                stop();
            }
        }
    }



    // TODO: Place additional applet code here

}