bouncingtextcanvas.java

J2ME MIDP_Example_Applications

// Copyright 2002 Nokia Corporation.
//
// THIS SOURCE CODE IS PROVIDED 'AS IS', WITH NO WARRANTIES WHATSOEVER,
// EXPRESS OR IMPLIED, INCLUDING ANY WARRANTY OF MERCHANTABILITY, FITNESS
// FOR ANY PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE
// OR TRADE PRACTICE, RELATING TO THE SOURCE CODE OR ANY WARRANTY OTHERWISE
// ARISING OUT OF ANY PROPOSAL, SPECIFICATION, OR SAMPLE AND WITH NO
// OBLIGATION OF NOKIA TO PROVIDE THE LICENSEE WITH ANY MAINTENANCE OR
// SUPPORT. FURTHERMORE, NOKIA MAKES NO WARRANTY THAT EXERCISE OF THE
// RIGHTS GRANTED HEREUNDER DOES NOT INFRINGE OR MAY NOT CAUSE INFRINGEMENT
// OF ANY PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OWNED OR CONTROLLED
// BY THIRD PARTIES
//
// Furthermore, information provided in this source code is preliminary,
// and may be changed substantially prior to final release. Nokia Corporation
// retains the right to make changes to this source code at
// any time, without notice. This source code is provided for informational
// purposes only.
//
// Nokia and Nokia Connecting People are registered trademarks of Nokia
// Corporation.
// Java and all Java-based marks are trademarks or registered trademarks of
// Sun Microsystems, Inc.
// Other product and company names mentioned herein may be trademarks or
// trade names of their respective owners.
//
// A non-exclusive, non-transferable, worldwide, limited license is hereby
// granted to the Licensee to download, print, reproduce and modify the
// source code. The licensee has the right to market, sell, distribute and
// make available the source code in original or modified form only when
// incorporated into the programs developed by the Licensee. No other
// license, express or implied, by estoppel or otherwise, to any other
// intellectual property rights is granted herein.


package example.hello;

import java.util.Random;
import javax.microedition.lcdui.*;


class BouncingTextCanvas
    extends Canvas
    implements CommandListener, Runnable
{
    private static final int MILLIS_PER_TICK = 200; // msec

    private final BouncingTextMIDlet midlet; // parent MIDlet
    private final Display display;           // parent MIDlet's Display
    private final Command exitCommand;       // display 'Exit' command
    private final Command reverseCommand;    // display 'Reverse' command
    private final BouncingText text;         // text string to print

    private int bgRGB;                       // background color
    private int textRGB;                     // text color
    private volatile Thread animationThread = null; // animation thread


    BouncingTextCanvas(BouncingTextMIDlet midlet, Display display,
                       String string)
    {
        this.midlet  = midlet;
        this.display = display;

        // Setup the command handling
        setCommandListener(this);
        reverseCommand = new Command("Rev", Command.SCREEN, 1);
        exitCommand = new Command("Exit", Command.EXIT, 1);
        addCommand(exitCommand);
        addCommand(reverseCommand);


        // Initialize the bouncing text message
        //
        // Create a new 'bouncing text' string whose color is 'textRGB'.
        // Its initial position is at x=0 and
        // y="middle of the canvas". the canvas width and height
        // are also used by a BouncingText object, as it manages
        // its own position update within the canvas displayable area
        // {x,y} = {0,0} to {w,h}.

        int ch = getHeight(); // canvas height
        int cw = getWidth();  // canvas width
        initColors();         // Choose fg and background colors ...
                              // ... based on display capabilities.
        text = new BouncingText(string, textRGB, 0, ch/2, cw, ch);
    }


    synchronized void startAnimation()
    {
        animationThread = new Thread(this);
        animationThread.start();
    }


    synchronized void stopAnimation()
    {
        animationThread = null;
    }


    // While this thread has not been stopped, it will perform a
    // tick() action approximately every 'millis_per_tick' milliseconds
    // (as close to that period as possible).
    public void run()
    {
        Thread currentThread = Thread.currentThread();

        try
        {
            // This ends when animationThread is set to null, or when
            // it is subsequently set to a new Thread.  Either way, the
            // current thread should terminate.
            while (currentThread == animationThread)
            {
                long startTime = System.currentTimeMillis();
                if (isShown())
                {
                    // If the canvas is not visible, it may be hidden
                    // by a system screen (for example, a display screen for
                    // an incoming phone call, etc.). We don't move the
                    // bouncing text, nor repaint the canvas unless we are
                    // visible (e.g. an obscuring system screen goes away).
                    tick();

                    repaint(0, 0, getWidth(), getHeight());
                    serviceRepaints();
                }
                long elapsedTime = System.currentTimeMillis() - startTime;
                if (elapsedTime < MILLIS_PER_TICK)
                {
                    synchronized(this)
                    {
                        wait(MILLIS_PER_TICK - elapsedTime);
                    }
                }
                else
                {
                    currentThread.yield();
                }
            }
        }
        catch(InterruptedException e)
        {
        }
    }


    //Draw the background and the bouncing text string
    public void paint(Graphics g)
    {
        g.setColor(bgRGB);
        g.fillRect(0, 0, getWidth(), getHeight());
        text.draw(g);
    }


    // Handle the UI commands
    public void commandAction(Command c, Displayable d)
    {
        if (c == exitCommand)
        {
            stopAnimation();
            midlet.exitRequested();
        }
        else if (c == reverseCommand)
        {
            text.reverse();
        }
    }


    // What to do each run() tick
    private synchronized void tick()
    {
        text.updatePosition();
    }


    // Choose a random background color on color displays,
    // use a white background color on black-and-white displays
    private void initColors()
    {
        int white = 0xffffff;
        int black = 0x000000;
        if (display.isColor())
        {
            Random random = new Random();
            textRGB = random.nextInt() & 0xffffff;
            bgRGB = white - textRGB; // constrasting background color
        }
        else
        {
            textRGB = black;
            bgRGB = white;
        }
    }


    class BouncingText
    {
        private final int w;          // The canvas width
        private final int h;          // The canvas height
        private final int textRGB;    // Color for the string
        private final Random random;  // For generating random numbers

        private String string;        // The string to print
        private int x;                // The x anchor for the string
        private int y;                // The y anchor for the string
        private int strWidth = 0;     // The pixel width of the string
        private int strHeight = 0;    // The pixel height of the string
        private int xdir = 1;         // 1 or -1 : bounce direction
        private int ydir = 1;         // 1 or -1 : bounce direction


        BouncingText(String string, int textRGB,
                     int x, int y, int w, int h)
        {
            this.string = string;
            this.x = x;
            this.y = y;
            this.w = w;
            this.h = h;
            this.textRGB = textRGB;
            random = new Random();
        }


        // Randomly change the position of the string, the string
        // must be completely drawable within the canvas
        private void updatePosition()
        {
            // Choose a random { vx, vy } velocity.
            int vx = random.nextInt() & 0x07;  // 0-7 pixels
            int vy = random.nextInt() & 0x07;  // 0-7 pixels


            // Note: The methods maxAnchorX() and maxAnchorY()
            //       determine the upper left hand {x, y} coordinates
            //       of the string so that the string can be drawn
            //       within the canvas height and width.
            if ((xdir == 1) && ((x + vx) >= maxAnchorX()))
            {
                xdir = -xdir;  // change direction at right edge
            }
            else if ((xdir == -1) && ((x - vx) < 0))
            {
                xdir = -xdir;  // change direction at left edge
            }
            int xnew = x + (vx * xdir) ;
            if ((xnew >= 0) && (x < maxAnchorX()))
            {
                x = xnew;
            }

            if ((ydir == 1) && ((y + vy) >= maxAnchorY()))
            {
                ydir = -ydir;  // change direction at bottom edge
            }
            else if ((ydir == -1) && ((y - vy) < 0))
            {
                ydir = -ydir;  // change direction at top edge
            }
            int ynew = y + (vy * ydir) ;
            if ((ynew >= 0) && (y < maxAnchorY()))
            {
                y = ynew;
            }
        }


        // Draw the text string at the appropriate position
        private void draw(Graphics g)
        {
             // If the strHeight is still 0, then initialize the
             // strHeight and strWidth variables used in maxAnchorX()
             // and maxAnchorY(). This assumes that the font represents
             // strings as at least 1 pixel high.
             if (! (strHeight > 0))
             {
                 Font f = g.getFont();
                 strHeight = f.getHeight();
                 strWidth = f.stringWidth(string);
             }

             // draw the string
             g.setColor(textRGB);
             g.drawString(string, x, y, Graphics.TOP|Graphics.LEFT);
        }


        private int maxAnchorX()
        {
            return w - strWidth;
        }


        private int maxAnchorY()
        {
            return h - strHeight;
        }


        // Reverse the BouncingText string
        private void reverse()
        {
            // Note: another approach is to store two copies of
            //       the string, one forwards and one reversed

            char[] carray = string.toCharArray();
            for (int old = string.length()-1, nu=0;
                 old >=0;
                 old--, nu++)
            {
               carray[nu] = string.charAt(old);
            }
            string = new String(carray);
        }
    }
}