// "Counter2.java" Java Counter2 Ver1.10 1999,Feb,06
// copyright: Hiroyuki Murata <faichan@kt.rim.or.jp>

import java.applet.Applet;
import java.awt.*;
import java.io.*;
import java.net.URL;

public class Counter2 extends Applet implements Runnable {

    int
        digit,   // Counter Digit
        digMarX, // X Digit Margin
        digMarY, // Y Digit Margin
        numSizX, // X Numeric Size
        numSizY  // Y Numeric Size
    ;
    static final int
        appMarX = 4, // X Applet Margin
        appMarY = 4  // Y Applet Margin
    ;
    Color
        bgColor, // background color
        f0Color, // frame color (dark)
        f1Color  // frame color (light)
    ;

    MediaTracker tracker;
    Thread thread = null;
    boolean inited = false;
    int numStepX;
    int offsetX;
    int imgStepX, imgOsX, imgOsY;
    Image iorigin, iroll, ioff;
    Graphics groll, goff;

    Graphics[] gsub;
    Motionc2[] mv;

    //-----------------------------------------------------------
    public void init() {

        inited = false;

        String strCount_ = getParameter("count");
        if (strCount_ == null)
            strCount_ = getParamStr("name", "0");

        String imagefile = getParamStr("image", "jnum.jpg");

        digit    = getParamInt("digit",      4);
        digMarX  = getParamInt("digmarx",    0);
        digMarY  = getParamInt("digmary",    2);
        bgColor = getParamCol("bgcolor", 0);
        f0Color = getParamCol("f0color", 0x808080);
        f1Color = getParamCol("f1color", 0xe0e0e0);
        numSizX  = getParamInt("numsizx",   40);
        numSizY  = getParamInt("numsizy",   40);
        imgStepX = getParamInt("imgstepx",  numSizX);
        imgOsX   = getParamInt("imgosx", 0);
        imgOsY   = getParamInt("imgosy", 0);

        gsub = new Graphics[digit];
        mv = new Motionc2[digit];

        for (int i=0; i<digit; i++) {
            int j = i - (digit - strCount_.length());
            int intCount = (j<0) ?
                0 : Character.digit(strCount_.charAt(j),10);
            mv[i] = new Motionc2(intCount);
            // /*Debug*/ System.out.println("intCount="+intCount);
        }

        tracker = new MediaTracker(this);
        iorigin = getImage(getCodeBase(), imagefile);
        tracker.addImage(iorigin, 0);
    }

    //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    String getParamStr(String name, String defaultString) {
        String ret = getParameter(name);
        if (ret == null) {
            ret = defaultString;
        }
        return ret;
    }

    int getParamInt(String name, int defaultValue) {
        try {
            return new Integer(getParameter(name)).intValue();
        } catch (RuntimeException e) {
            return defaultValue;
        }
    }

    Color getParamCol(String name, int defaultCol) {
        try {
            return new Color(Integer.parseInt(getParameter(name), 16));
        } catch (RuntimeException e) {
            return new Color(defaultCol);
        }
    }

    //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    void init2() { // initializer after image load
        int iwid = size().width - appMarX * 2; // inset width
        numStepX = numSizX + digMarX * 2;
        int numAllX = numStepX * 13;
        offsetX = (iwid - numSizX) / 2 - numStepX;

        int ihei = size().height - appMarY * 2; // inset height
        int heiDig = ihei / digit; // height of a digit

        iroll = createImage(numAllX,heiDig);
        groll = iroll.getGraphics();
        ioff  = createImage(size().width, size().height);
        goff  = ioff.getGraphics();
        for (int i=0; i<digit; i++) {
            gsub[i] = goff.create(appMarX, appMarY+heiDig*i, iwid, heiDig);
        }

        groll.setColor(bgColor);
        groll.fillRect(0,0,numAllX,heiDig);
        for (int i=0; i<13; i++) {
            int j = (i+9) % 10;
            Graphics gtmp = groll.create(
                numStepX*i+digMarX, digMarY,
                numSizX, numSizY
            );
            gtmp.drawImage(
                iorigin,
                -imgStepX * j - imgOsX,
                -imgOsY,
                this
            );
        }

        goff.setColor(f0Color);
        goff.fillRect(0,0, size().width, size().height);
        getToolkit().sync();
        goff.setColor(bgColor);
        goff.fillRect(
            appMarX, appMarY,
            size().width-appMarX*2, size().height-appMarY*2
        );
        getToolkit().sync();
        goff.setColor(f1Color);
        goff.drawLine(0, 0,  size().width-1, 0);
        goff.drawLine(0, 1,  size().width-2, 1);
        goff.drawLine(4, size().height-4,  size().width-4, size().height-4);
        goff.drawLine(3, size().height-3,  size().width-3, size().height-3);
        goff.drawLine(0, 0,  0, size().height-1);
        goff.drawLine(1, 0,  1, size().height-2);
        goff.drawLine(size().width-4, 4,  size().width-4, size().height-4);
        goff.drawLine(size().width-3, 3,  size().width-3, size().height-3);
        getToolkit().sync();

        inited = true;
    }

    //-----------------------------------------------------------
    public void start() {
        if (thread == null) {
            thread = new Thread(this);
            thread.start();
        }
    }

    public void stop() {
        if (thread != null) {
            thread.stop();
            thread = null;
        }
    }

    public void run() {

        // /*Debug*/ System.out.println("run()");
        try {
            tracker.waitForAll();
        } catch (InterruptedException e) {
            return;
        }
        // /*Debug*/ System.out.println("exit waitForAll");

        if (!inited) init2();

        for (int i=0; i<digit; i++) {
            mv[i].start();
            mv[i].brake();
        }

        while (thread.isAlive()) {
            repaint();
            try {
                thread.sleep(50);
            } catch (InterruptedException e) {
                break;
            }
        }
    }

    //-----------------------------------------------------------
    public void update(Graphics g) {
        for (int i=0; i<digit; i++) {
            gsub[i].drawImage(
                iroll,
                (int)(-mv[i].go()*numStepX) + offsetX - 10,
                0,
                this
            );
        }
        paint(g);
    }

    public void paint(Graphics g) {
        if (inited) {
            g.drawImage(ioff,0,0,this);
        } else {
            g.setColor(Color.red);
            g.drawString("Loading",0,10);
        }
    }

    //-----------------------------------------------------------
    public boolean mouseDown(Event e, int x, int y) {
        if (Motionc2.isStillAll(mv)) {
            for (int i=0; i<digit; i++) {
                mv[i].start();
            }
        } else if (Motionc2.isFullAll(mv)) {
            for (int i=0; i<digit; i++) {
                mv[i].brake();
            }
        }
        return true;
    }
    //-----------------------------------------------------------
    int irand(int n) {
        return (int)(Math.random()*n);
    }
}
/*************************************************************************/
class Motionc2
{
    static final int MinRot = 1;    // minimum rotation for braking
    static final double
        fMinDist = (double)MinRot * 10.0,   // minimum distance for braking
        fInitSpeed = 0.3
    ;
    public boolean still,brake;
    double fN,fSpeed,subSpeed,fLastN;
        // fN: current position
        // fSpeed: current velocity
        // subSpeed: braking (negative) acceleration
        // fLastN: target position

    //-----------------------------------------------------------
    static boolean isFullAll(Motionc2[] mv) {
        boolean ret = true;
        for (int i=0; i<mv.length; i++) {
            ret &= !mv[i].still && !mv[i].brake;
        }
        return ret;
    }
    static boolean isStillAll(Motionc2[] mv) {
        boolean ret = true;
        for (int i=0; i<mv.length; i++) {
            ret &= mv[i].still;
        }
        return ret;
    }

    //-----------------------------------------------------------
    Motionc2(int n) {
        fLastN = (double)n;
        //fN = Math.random() * 10.0;
        fN = (fLastN-1)%10;
        brake = false;
        still = true;
    }

    public void start() {
        fSpeed = fInitSpeed + Math.random() * (fInitSpeed * 0.8);
        still = brake = false;
    }

    public void brake() {
        brake = true;
        double Dist = fLastN - fN;
        Dist += (Dist>=0) ? fMinDist : (fMinDist + 10.0);
        double BrkTime = Dist * 2.0 / fSpeed;   // braking time
        subSpeed = fSpeed / BrkTime;
    }

    public double go() {
        if (brake) {
            fSpeed -= subSpeed;
            if (fSpeed<=0.0) {
                fSpeed = 0.0;
                brake = false;
                still = true;
            }
        }
        if (!still) {
            fN += fSpeed;
            if (fN >= 10.0) {
                fN -= 10.0;
            }
        }
        return fN;
    }
}
/*************************************************************************/