src/demo/share/jfc/J2Ddemo/java2d/Surface.java

/*
 *
 * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package java2d;


import static java.awt.RenderingHints.KEY_ANTIALIASING;
import static java.awt.RenderingHints.KEY_RENDERING;
import static java.awt.RenderingHints.VALUE_ANTIALIAS_OFF;
import static java.awt.RenderingHints.VALUE_ANTIALIAS_ON;
import static java.awt.RenderingHints.VALUE_RENDER_QUALITY;
import static java.awt.RenderingHints.VALUE_RENDER_SPEED;
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Paint;
import java.awt.Toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferUShort;
import java.awt.image.DirectColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JPanel;
import javax.swing.RepaintManager;


/**
 * Surface is the base class for the 2d rendering demos.  Demos must
 * implement the render() method. Subclasses for Surface are
 * AnimatingSurface, ControlsSurface and AnimatingControlsSurface.
 */
@SuppressWarnings("serial")
public abstract class Surface extends JPanel implements Printable {

    public Object AntiAlias = VALUE_ANTIALIAS_ON;
    public Object Rendering = VALUE_RENDER_SPEED;
    public AlphaComposite composite;
    public Paint texture;
    public String perfStr;            // PerformanceMonitor
    public BufferedImage bimg;
    public int imageType;
    public String name;
    public boolean clearSurface = true;
    // Demos using animated gif's that implement ImageObserver set dontThread.
    public boolean dontThread;
    public AnimatingSurface animating;
    protected long sleepAmount = 50;
    private long orig, start, frame;
    private Toolkit toolkit;
    private boolean perfMonitor, outputPerf;
    private int biw, bih;
    private boolean clearOnce;
    private boolean toBeInitialized = true;

    public Surface() {
        setDoubleBuffered(this instanceof AnimatingSurface);
        toolkit = getToolkit();
        name = this.getClass().getSimpleName();
        setImageType(0);

        // To launch an individual demo with the performance str output  :
        //    java -Dj2ddemo.perf= -cp J2Ddemo.jar demos.Clipping.ClipAnim
        try {
            if (System.getProperty("j2ddemo.perf") != null) {
                perfMonitor = outputPerf = true;
            }
        } catch (Exception ex) {
        }
        if (this instanceof AnimatingSurface) {
            animating = (AnimatingSurface) this;
        }
    }

    protected Image getImage(String name) {
        return DemoImages.getImage(name, this);
    }

    protected Font getFont(String name) {
        return DemoFonts.getFont(name);
    }

    public int getImageType() {
        return imageType;
    }

    public final void setImageType(int imgType) {
        if (imgType == 0) {
            imageType = 1;
        } else {
            imageType = imgType;
        }
        bimg = null;
    }

    public void setAntiAlias(boolean aa) {
        AntiAlias = aa ? VALUE_ANTIALIAS_ON : VALUE_ANTIALIAS_OFF;
    }

    public void setRendering(boolean rd) {
        Rendering = rd ? VALUE_RENDER_QUALITY : VALUE_RENDER_SPEED;
    }

    public void setTexture(Object obj) {
        if (obj instanceof GradientPaint) {
            texture = new GradientPaint(0, 0, Color.white,
                    getSize().width * 2, 0, Color.green);
        } else {
            texture = (Paint) obj;
        }
    }

    public void setComposite(boolean cp) {
        composite = cp
                ? AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f)
                : null;
    }

    public void setMonitor(boolean pm) {
        perfMonitor = pm;
    }

    public void setSleepAmount(long amount) {
        sleepAmount = amount;
    }

    public long getSleepAmount() {
        return sleepAmount;
    }

    public BufferedImage createBufferedImage(Graphics2D g2,
            int w,
            int h,
            int imgType) {
        BufferedImage bi = null;
        if (imgType == 0) {
            bi = g2.getDeviceConfiguration().
                    createCompatibleImage(w, h);
        } else if (imgType > 0 && imgType < 14) {
            bi = new BufferedImage(w, h, imgType);
        } else if (imgType == 14) {
            bi = createBinaryImage(w, h, 2);
        } else if (imgType == 15) {
            bi = createBinaryImage(w, h, 4);
        } else if (imgType == 16) {
            bi = createSGISurface(w, h, 32);
        } else if (imgType == 17) {
            bi = createSGISurface(w, h, 16);
        }
        return bi;
    }
    // Lookup tables for BYTE_BINARY 1, 2 and 4 bits.
    private static final byte[] lut1Arr = new byte[] { 0, (byte) 255 };
    private static final byte[] lut2Arr = new byte[] { 0, (byte) 85, (byte) 170, (byte) 255 };
    private static final byte[] lut4Arr = new byte[] { 0, (byte) 17, (byte) 34, (byte) 51,
        (byte) 68, (byte) 85, (byte) 102, (byte) 119,
        (byte) 136, (byte) 153, (byte) 170, (byte) 187,
        (byte) 204, (byte) 221, (byte) 238, (byte) 255 };

    private BufferedImage createBinaryImage(int w, int h, int pixelBits) {
        int bytesPerRow = w * pixelBits / 8;
        if (w * pixelBits % 8 != 0) {
            bytesPerRow++;
        }
        byte[] imageData = new byte[h * bytesPerRow];
        IndexColorModel cm = null;
        switch (pixelBits) {
            case 1:
                cm = new IndexColorModel(pixelBits, lut1Arr.length,
                        lut1Arr, lut1Arr, lut1Arr);
                break;
            case 2:
                cm = new IndexColorModel(pixelBits, lut2Arr.length,
                        lut2Arr, lut2Arr, lut2Arr);
                break;
            case 4:
                cm = new IndexColorModel(pixelBits, lut4Arr.length,
                        lut4Arr, lut4Arr, lut4Arr);
                break;
            default:
                Logger.getLogger(Surface.class.getName()).log(Level.SEVERE,
                        null, new Exception("Invalid # of bit per pixel"));
        }

        DataBuffer db = new DataBufferByte(imageData, imageData.length);
        WritableRaster r = Raster.createPackedRaster(db, w, h, pixelBits, null);
        return new BufferedImage(cm, r, false, null);
    }

    private BufferedImage createSGISurface(int w, int h, int pixelBits) {
        int rMask32 = 0xFF000000;
        int rMask16 = 0xF800;
        int gMask32 = 0x00FF0000;
        int gMask16 = 0x07C0;
        int bMask32 = 0x0000FF00;
        int bMask16 = 0x003E;

        DirectColorModel dcm = null;
        DataBuffer db = null;
        WritableRaster wr = null;
        switch (pixelBits) {
            case 16:
                short[] imageDataUShort = new short[w * h];
                dcm = new DirectColorModel(16, rMask16, gMask16, bMask16);
                db = new DataBufferUShort(imageDataUShort,
                        imageDataUShort.length);
                wr = Raster.createPackedRaster(db, w, h, w,
                        new int[] { rMask16, gMask16, bMask16 },
                        null);
                break;
            case 32:
                int[] imageDataInt = new int[w * h];
                dcm = new DirectColorModel(32, rMask32, gMask32, bMask32);
                db = new DataBufferInt(imageDataInt, imageDataInt.length);
                wr = Raster.createPackedRaster(db, w, h, w,
                        new int[] { rMask32, gMask32, bMask32 },
                        null);
                break;
            default:
                Logger.getLogger(Surface.class.getName()).log(Level.SEVERE,
                        null, new Exception("Invalid # of bit per pixel"));
        }

        return new BufferedImage(dcm, wr, false, null);
    }

    public Graphics2D createGraphics2D(int width,
            int height,
            BufferedImage bi,
            Graphics g) {

        Graphics2D g2 = null;

        if (bi != null) {
            g2 = bi.createGraphics();
        } else {
            g2 = (Graphics2D) g;
        }

        g2.setBackground(getBackground());
        g2.setRenderingHint(KEY_ANTIALIASING, AntiAlias);
        g2.setRenderingHint(KEY_RENDERING, Rendering);

        if (clearSurface || clearOnce) {
            g2.clearRect(0, 0, width, height);
            clearOnce = false;
        }

        if (texture != null) {
            // set composite to opaque for texture fills
            g2.setComposite(AlphaComposite.SrcOver);
            g2.setPaint(texture);
            g2.fillRect(0, 0, width, height);
        }

        if (composite != null) {
            g2.setComposite(composite);
        }

        return g2;
    }

    // ...demos that extend Surface must implement this routine...
    public abstract void render(int w, int h, Graphics2D g2);

    /**
     * It's possible to turn off double-buffering for just the repaint
     * calls invoked directly on the non double buffered component.
     * This can be done by overriding paintImmediately() (which is called
     * as a result of repaint) and getting the current RepaintManager and
     * turning off double buffering in the RepaintManager before calling
     * super.paintImmediately(g).
     */
    @Override
    public void paintImmediately(int x, int y, int w, int h) {
        RepaintManager repaintManager = null;
        boolean save = true;
        if (!isDoubleBuffered()) {
            repaintManager = RepaintManager.currentManager(this);
            save = repaintManager.isDoubleBufferingEnabled();
            repaintManager.setDoubleBufferingEnabled(false);
        }
        super.paintImmediately(x, y, w, h);

        if (repaintManager != null) {
            repaintManager.setDoubleBufferingEnabled(save);
        }
    }

    @Override
    public void paint(Graphics g) {

        super.paint(g);

        Dimension d = getSize();

        if (biw != d.width || bih != d.height) {
            toBeInitialized = true;
            biw = d.width;
            bih = d.height;
        }

        if (imageType == 1) {
            bimg = null;
        } else if (bimg == null || toBeInitialized) {
            bimg = createBufferedImage((Graphics2D) g,
                    d.width, d.height, imageType - 2);
            clearOnce = true;
        }

        if (toBeInitialized) {
            if (animating != null) {
                animating.reset(d.width, d.height);
            }
            toBeInitialized = false;
            startClock();
        }

        if (animating != null && animating.running()) {
            animating.step(d.width, d.height);
        }
        Graphics2D g2 = createGraphics2D(d.width, d.height, bimg, g);
        render(d.width, d.height, g2);
        g2.dispose();

        if (bimg != null) {
            g.drawImage(bimg, 0, 0, null);
            toolkit.sync();
        }

        if (perfMonitor) {
            LogPerformance();
        }
    }

    @Override
    public int print(Graphics g, PageFormat pf, int pi) throws PrinterException {
        if (pi >= 1) {
            return Printable.NO_SUCH_PAGE;
        }

        Graphics2D g2d = (Graphics2D) g;
        g2d.translate(pf.getImageableX(), pf.getImageableY());
        g2d.translate(pf.getImageableWidth() / 2,
                pf.getImageableHeight() / 2);

        Dimension d = getSize();

        double scale = Math.min(pf.getImageableWidth() / d.width,
                pf.getImageableHeight() / d.height);
        if (scale < 1.0) {
            g2d.scale(scale, scale);
        }

        g2d.translate(-d.width / 2.0, -d.height / 2.0);

        if (bimg == null) {
            Graphics2D g2 = createGraphics2D(d.width, d.height, null, g2d);
            render(d.width, d.height, g2);
            g2.dispose();
        } else {
            g2d.drawImage(bimg, 0, 0, this);
        }

        return Printable.PAGE_EXISTS;
    }

    public void startClock() {
        orig = System.currentTimeMillis();
        start = orig;
        frame = 0;
    }
    private static final int REPORTFRAMES = 30;

    private void LogPerformance() {
        if ((frame % REPORTFRAMES) == 0) {
            long end = System.currentTimeMillis();
            long rel = (end - start);
            if (frame == 0) {
                perfStr = name + " " + rel + " ms";
                if (animating == null || !animating.running()) {
                    frame = -1;
                }
            } else {
                String s1 = Float.toString((REPORTFRAMES / (rel / 1000.0f)));
                s1 = (s1.length() < 4) ? s1.substring(0, s1.length()) : s1.
                        substring(0, 4);
                perfStr = name + " " + s1 + " fps";
            }
            if (outputPerf) {
                System.out.println(perfStr);
            }
            start = end;
        }
        ++frame;
    }

    // System.out graphics state information.
    public void verbose(GlobalControls controls) {
        String str = "  " + name + " ";
        if (animating != null && animating.running()) {
            str = str.concat(" Running");
        } else if (this instanceof AnimatingSurface) {
            str = str.concat(" Stopped");
        }

        if (controls != null) {
            str = str.concat(" " + controls.screenCombo.getSelectedItem());
        }

        str.concat((AntiAlias == VALUE_ANTIALIAS_ON) ? " ANTIALIAS_ON "
                : " ANTIALIAS_OFF ");
        str.concat((Rendering == VALUE_RENDER_QUALITY) ? "RENDER_QUALITY "
                : "RENDER_SPEED ");

        if (texture != null) {
            str = str.concat("Texture ");
        }

        if (composite != null) {
            str = str.concat("Composite=" + composite.getAlpha() + " ");
        }

        Runtime r = Runtime.getRuntime();
        r.gc();
        float freeMemory = r.freeMemory();
        float totalMemory = r.totalMemory();
        str = str.concat(((totalMemory - freeMemory) / 1024) + "K used");
        System.out.println(str);
    }

    public static void createDemoFrame(Surface surface) {
        final DemoPanel dp = new DemoPanel(surface, new DemoInstVarsAccessorImplBase());
        Frame f = new Frame("J2D Demo - " + surface.name);
        f.addWindowListener(new WindowAdapter() {

            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }

            @Override
            public void windowDeiconified(WindowEvent e) {
                dp.start();
            }

            @Override
            public void windowIconified(WindowEvent e) {
                dp.stop();
            }
        });
        f.add("Center", dp);
        f.pack();
        f.setSize(new Dimension(500, 300));
        f.setVisible(true);
        if (surface.animating != null) {
            surface.animating.start();
        }
    }
}