import java.awt.*;
import java.awt.image.*;
import java.applet.Applet;

class MyCanvas extends Canvas implements Runnable {

    final String AppInfo = "Moving Sprites by Hiroyuki Murata";
    final String imagefile = "8ken_bw.gif";
    final int N=8, SpWidth=32;
    final Font fontFix = new Font("TimesRoman",Font.ITALIC,20);
    final Font fontApp = new Font("TimesRoman",Font.ITALIC,36);
    final int colors[] = {
        0xff0000,
        0x00ff00,
        0x0000ff,
        0xffff00,
        0x00ffff,
        0xff00ff,
        0xff8000,
        0x00ff80,
        0x8000ff
    };

    Applet app;
    Frame frame;

    Thread thread;
    MediaTracker tracker;
    Image sprite[] = new Image[N];
    Motion mv[] = new Motion[N];
    int offsetB;    // x-offset of Front,Background
    int size_w,size_h;

    Image    iA;
    Graphics gA;
    Toolkit  tk;
    boolean
        calledByUpdate, // (set in update())
        loadedB,        // loaded on backbround
        loadedF,        // loaded on front
        loadedAll,      // loaded on all sprites & background
        loadingDisplayed,  // "loading..." displayed
        sleepEnable     // long sleep enable
    ;

    //---------------------------------------------------------------------
    MyCanvas(int size_w, int size_h, Applet app, Frame frame) {
        this.size_w = size_w;
        this.size_h = size_h;
        this.app = app;
        this.frame = frame;
        frame.setCursor(Frame.HAND_CURSOR);

        setBackground(Color.black);
    }

    //---------------------------------------------------------------------
    public Dimension preferredSize() {
        return new Dimension(size_w,size_h);
    }

    //---------------------------------------------------------------------
    public void init() {
        loadedB = loadedF = loadedAll =
        calledByUpdate = loadingDisplayed = false;
        sleepEnable = false;

        tracker = new MediaTracker(this);

        offsetB = size_w;

        tk = getToolkit();
        iA = createImage(offsetB+size_w,size_h);
        gA = iA.getGraphics();
        gA.setColor(Color.pink);
        gA.fillRect(offsetB,0,size_w,size_h);
        gA.setColor(Color.cyan);
        gA.fillRect(0,0,size_w,size_h);

        Image allsprite = app.getImage(app.getDocumentBase(), imagefile);
        ImageProducer imgSrc = allsprite.getSource();

        for (int i=0; i<N; i++) {
            ImageFilter CrpFlt = new CropImageFilter(i*SpWidth,0, SpWidth,32);
            ImageProducer CrpSrc = new FilteredImageSource(imgSrc,CrpFlt);
            MyFilter MyFlt = new MyFilter(colors[i]);
            ImageProducer imgPrd = new FilteredImageSource(CrpSrc,MyFlt);
            sprite[i] = createImage(imgPrd);
            tracker.addImage(sprite[i], 0);
            mv[i] = new Motion(32,32,size_w,size_h);
        }

        setFont(fontApp);
    }

    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() {
        try {
            tracker.waitForAll();
        } catch (InterruptedException e) {
            return;
        }

        Thread me = Thread.currentThread();

        if (!loadedB) {
            if (thread==me) {
                repaint();
            }
            createBackground();
            loadedB = true;
        }

        me.setPriority(Thread.MIN_PRIORITY);

        while (thread==me) {
            int interval = sleepEnable ? 50 : 10;
            try {
                Thread.sleep(interval);
            } catch (InterruptedException e) {
                break;
            }
            repaint();
        }
    }

    void createBackground() {
        int pw=128, ph=128;
        int pix[] = new int[pw * ph];
        int index = 0;

        for (int y=0; y<ph; y++) {
            int gre = y * 256 / ph;
            for (int x=0; x<pw; x++) {
                int red = x * 256 / pw;
                int blu = 255 - ((red+gre)/2);
                pix[index++] = (255<<24) | (red<<16) | (gre<<8) | blu;
            }
        }

        Image img = createImage(new MemoryImageSource(
            pw,ph, ColorModel.getRGBdefault(), pix, 0,pw
        ));

        for (int y=0; y<size_h; y+=ph) {
            for (int x=0; x<size_w; x+=pw) {
                gA.drawImage(img,offsetB+x,y,this);
                tk.sync();
            }
        }

        gA.setColor(Color.black);
        gA.setFont(fontFix);
        FontMetrics metricsFix = getFontMetrics(fontFix);
        int xFix = offsetB+size_w - metricsFix.stringWidth(AppInfo) - 10;
        int yFix =         size_h - metricsFix.getDescent()         - 3;
        gA.drawString(AppInfo,xFix,yFix);
        tk.sync();

        // draw border
        gA.setColor(Color.white);
        bgLine(       0,        0,        20,        20);
        bgLine(       0, size_h-1,        20, size_h-21);
        bgLine(size_w-1,        0, size_w-21,        20);
        bgLine(size_w-1, size_h-1, size_w-21, size_h-21);
    }
    void bgLine(int x0, int y0, int x1, int y1) {
        gA.drawLine(offsetB+x0,y0, offsetB+x0,y1);
        gA.drawLine(offsetB+x0,y0, offsetB+x1,y0);
        tk.sync();
    }

    //---------------------------------------------------------------------
    public void update(Graphics g) {
        calledByUpdate = true;
        paint(g);
    }

    public void paint(Graphics g) {
        g.clipRect(0,0,size_w,size_h);

        if (tracker.isErrorAny()) {
            g.setColor(Color.red);
            g.drawString("Error!",40,120);
            return;
        }

        if (calledByUpdate) {
            paintF();
            paintO(g);
            calledByUpdate = false;
        } else {
            System.out.println("canvas: paint() without update()");
            paintO(g);
        }
    }

    synchronized void paintF() {
        if (loadedAll) {
            for (int i=0; i<N; i++) {
                mv[i].step();
                gA.copyArea(
                    offsetB+mv[i].x0, mv[i].y0,
                    mv[i].fw, mv[i].fh,
                    -size_w, 0
                );
            }
        } else {
            gA.copyArea(
                offsetB, 0,
                size_w, size_h,
                -size_w, 0
            );
        }

        for (int i=0; i<N; i++) {
            if (loadedAll) {
                gA.drawImage(sprite[i], mv[i].x1, mv[i].y1, this);
                loadedF = true;
                mv[i].catchup();
            } else if (tracker.checkAll() && loadedB) {
                loadedAll = true;
            }
        }
    }

    void paintO(Graphics g) {
        if (calledByUpdate && loadedF && !loadingDisplayed) {
            for (int i=0; i<N; i++) {
                Graphics gcO =  g.create(
                    mv[i].minX, mv[i].minY, mv[i].maxW, mv[i].maxH
                );
                gcO.drawImage(iA, -mv[i].minX, -mv[i].minY, this);
                gcO.dispose();
            }
        } else {
            loadingDisplayed = false;
            g.drawImage(iA, 0, 0, this);
        }
        if (!loadedF) {
            g.drawString("loading...",40,80);
            loadingDisplayed = true;
        }
    }

    Color rndcol() {
        return new Color(
            (int)(Math.random()*256.0),
            (int)(Math.random()*256.0),
            (int)(Math.random()*256.0)
        );
    }

    //---------------------------------------------------------------------
    void goFast() {
        sleepEnable = false;
        frame.setCursor(Frame.HAND_CURSOR);
    }
    void goSlow() {
        sleepEnable = true;
        frame.setCursor(Frame.CROSSHAIR_CURSOR);
    }

    //---------------------------------------------------------------------
    public synchronized boolean mouseDown(Event evt, int x, int y) {
        for (int i=0; i<N; i++) {
            if (mv[i].checkHit(x,y)) {
                mv[i].setxy(x,y,true);
            } else {
                mv[i].hold = false;
            }
        }
        return true;
    }
    public synchronized boolean mouseDrag(Event evt, int x, int y) {
        for (int i=0; i<N; i++) {
            if (mv[i].hold && mv[i].checkHit(x,y)) {
                mv[i].setxy(x,y,false);
            } else {
                mv[i].hold = false;
            }
        }
        return true;
    }
}
//System.out.println("canvas00"); //DEBUG
/*************************************************************************/