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

public class Tomei extends Applet {
    MyCanvas canvas = new MyCanvas();
    Control control = new Control(canvas);

    public void init() {
        canvas.setMySize(size().width, size().height * 3 / 5);
        setLayout(new BorderLayout());
        add("North", canvas);
        add("Center", control);
        canvas.init();
    }
    public void start() {
        canvas.start();
    }
    public void stop() {
        canvas.stop();
    }
}

/*************************************************************************/
class MyCanvas extends Canvas implements Runnable {
    Image imageBG,imagep,imageOff, // for Background, pointer & Double-Buffer
          imageBefore,imageAfter, // for RGBImageFilter
          imageMemBug,imageMemNoBug; // for MemoryImageSource
    Graphics gBefore,gOff;
    String str = "Transparency";
    int wid,hei,strX,strY;
    Thread thread;
    boolean filterOn;

    public Dimension preferredSize() {
        return new Dimension(wid,hei);
    }
    void setMySize(int width, int height) {
        wid = width;
        hei = height;
    }

    void init() {
        setBackground(Color.white);

        imageOff = createImage(wid, hei);
        gOff = imageOff.getGraphics();

        imageBG = createImage(wid*2, hei);
        Graphics g = imageBG.getGraphics();
        Color col[] = {Color.red, Color.green, Color.blue};
        int i = 0;
        for (int x=0; x < wid*2; x+=5) {
            g.setColor(col[i]);
            g.fillRect(x   , 0, 5, hei);
            i = (i + 1) % 3;
        }

        imageBefore = createImage(wid, hei);
        gBefore = imageBefore.getGraphics();
        gBefore.setColor(Color.black);
        gBefore.setFont(new Font("TimesRoman", Font.ITALIC|Font.BOLD, 50));
        strX = wid - 1;
        strY = hei / 2;

        int[] pixBug = new int[wid * hei];
        i = 0;
        int alpha;
        for (int y=0; y<hei; y++) {
            int gre = y * 256 / hei;
            for (int x=0; x<wid; x++) {
                int red = x * 256 / wid;
                int blu = 255 - ((red+gre)/2);
                int xm = x - wid/2;
                int ym = y - hei/2;
                int rr = xm*xm + ym*ym;
                if      (rr > 2000) alpha = 0xff000000;
                else if (rr > 1000) alpha = 0x80000000;
                else if (rr >  500) alpha = 0x40000000;
                else                alpha = 0;
                pixBug[i++] = alpha | (red<<16) | (gre<<8) | blu;
            }
        }
        ColorModel colormodel = ColorModel.getRGBdefault();
        imageMemBug = createImage(
            new MemoryImageSource(wid,hei, colormodel, pixBug, 0,wid)
        );

        int[] pixNoBug = new int[pixBug.length];
        for (i=0; i<pixBug.length; i++)
            pixNoBug[i] = pixBug[i];
        pixNoBug[0] &= 0x00ffffff;
        imageMemNoBug = createImage(
            new MemoryImageSource(wid,hei, colormodel, pixNoBug, 0,wid)
        );

        imagep = imageBefore;
    }

    void start() {
        if (thread == null) {
            thread = new Thread(this);
            thread.start();
        }
    }
    void stop() {
        if (thread != null) {
            thread.stop();
            thread = null;
        }
    }

    public void run() {
        Thread me = Thread.currentThread();
        while (thread == me) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                return;
            }
            repaint();
        }
    }

    public void update(Graphics g) {
        prepaint();
        paint(g);
    }
    synchronized void prepaint() {
        gBefore.clearRect(0, 0, wid, hei);
        gBefore.drawString(str, strX-wid, strY);
        gBefore.drawString(str, strX,     strY);
        strX--;
        if (strX < 0) strX += wid;

        gOff.drawImage(imageBG, strX-wid, 0, this);
        gOff.drawImage(imagep, 0, 0, this);
    }
    public void paint(Graphics g) {
        g.drawImage(imageOff, 0, 0, this);
    }

    //------------------------------------------------------
    void evOrigin() {
        imagep = imageBefore;
    }
    void evBug() {
        evXBug(true);
    }
    void evNoBug() {
        evXBug(false);
    }
    private void evXBug(boolean bug) {
        RGBImageFilter myfilter;
        ImageProducer prodImage = imageBefore.getSource();

        if (bug)    myfilter = new BugFilter();
        else        myfilter = new NoBugFilter();
        ImageProducer prodMyFilter
         = new FilteredImageSource(prodImage, myfilter);

        if (imageAfter != null)
            imageAfter.flush();
        imageAfter = createImage(prodMyFilter);
        imagep = imageAfter;
    }
    void evMemBug() {
        imagep = imageMemBug;
    }
    void evMemNoBug() {
        imagep = imageMemNoBug;
    }
}

/*************************************************************************/
class Control extends Panel {
    MyCanvas canvas;
    CheckboxGroup cg = new CheckboxGroup();

    Control(MyCanvas canvas) {
        this.canvas = canvas;
        setBackground(Color.cyan);

        setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10));
        add(new Checkbox("BeforeFilter", cg, true));
        add(new Checkbox("Filter:Bug", cg, false));
        add(new Checkbox("Filter:NoBug", cg, false));
        add(new Checkbox("Memory:Bug", cg, false));
        add(new Checkbox("Memory:NoBug", cg, false));
    }

    public boolean action(Event ev, Object arg) {
        if (ev.target instanceof Checkbox) {
            String label = cg.getCurrent().getLabel();
            if ("BeforeFilter".equals(label)) {
                canvas.evOrigin();
            } else if ("Filter:Bug".equals(label)) {
                canvas.evBug();
            } else if ("Filter:NoBug".equals(label)) {
                canvas.evNoBug();
            } else if ("Memory:Bug".equals(label)) {
                canvas.evMemBug();
            } else /*if ("Memory:NoBug".equals(label))*/ {
                canvas.evMemNoBug();
            }
            return true;
        }
        return false;
    }
}

/*************************************************************************/
class BugFilter extends RGBImageFilter {

    public BugFilter() {
        canFilterIndexColorModel = true;
    }

    public int filterRGB(int x, int y, int rgb){
        int intensity = ((rgb & 0x00ff0000) >> 16)
            + ((rgb & 0x0000ff00) >> 8) + (rgb & 0x000000ff);
        int ret = rgb;
        if (intensity < 0x180)
            ret &= 0x00ffffff;
        return ret;
    }
}
/*-----------------------------------------------------------------------*/
class NoBugFilter extends RGBImageFilter {

    public NoBugFilter() {
        canFilterIndexColorModel = false; // must be "false"
    }

    public int filterRGB(int x, int y, int rgb){
        int intensity = ((rgb & 0x00ff0000) >> 16)
            + ((rgb & 0x0000ff00) >> 8) + (rgb & 0x000000ff);
        int ret = rgb;
        if (intensity < 0x180)
            ret &= 0x00ffffff;
        if (x==0 && y==0) ret &= 0x00ffffff; // avoid Bug
        return ret;
    }
}