// Copyright (c) 2003-2004, FreeHEP
package org.freehep.graphics2d;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.print.PrinterGraphics;

import javax.swing.JPanel;

/**
 * This class extends JPanel by adding double buffering. This is intended to be
 * used in situations in which redrawing the contents of the panel is expensive.
 * 
 * @author Mark Donszelmann
 * @version $Id: BufferedPanel.java 8584 2006-08-10 23:06:37Z duns $
 */
public class BufferedPanel extends JPanel implements java.io.Serializable {

    private VectorGraphics offScreenGraphics;

    private Image offScreenImage;

    private Dimension oldDimension = new Dimension();

    private Dimension dim = new Dimension();

    // FREEHEP-503 Disabled, since in Linux this made the blitting very
    // slow.     
    // private Rectangle clip = new Rectangle();

    private boolean printing = false;

    private boolean exporting = false;

    private boolean repaint = false;

    public BufferedPanel() {
        this(true);
    }

    /**
     * Creates a new BufferedPanel with a width and height set to zero.
     * 
     * @param opaque transparent panel
     */
    public BufferedPanel(boolean opaque) {

        // First turn off the Swing double buffering.
        super(false);

        // Make this either opaque or transparent.
        setOpaque(opaque);
    }

    /**
     * Triggers a full "user" repaint. If the "system" wants to repaint it will
     * call the paint(Graphics) method directly, rather than scheduling a
     * paint(Graphics) through a repaint().
     */
    public void repaint() {
        super.repaint();
        repaint = true;
    }

    /**
     * Triggers a full repaint, since the component is not valid anymore (size
     * change, iconized, ...)
     */
    public void invalidate() {
        super.invalidate();
        repaint = true;
    }

    /**
     * Returns if true if paintComponent(VectorGraphics) should be called (was
     * triggered by a repaint() or invalidate(), and resets the trigger.
     */
    private synchronized boolean shouldRepaint() {
        boolean result = repaint;
        repaint = false;
        return result;
    }

    /**
     * Paint this panel by calling paintComponent(VectorGraphics) if necessary
     * and flushing the buffered image to the screen. This method also handles
     * printing and exporting separately.
     * 
     * @param g Graphics object
     */
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        // do not paint if params are null
        if ((g == null) || (offScreenImage == null))
            return;

        // decide where we are painting
        if (g instanceof PrinterGraphics)
            printing = true;
        if (g instanceof VectorGraphics)
            exporting = true;

        if (!isDisplaying()) {
            paintComponent(VectorGraphics.create(g));
            return;
        }

        if (shouldRepaint()) {
            paintComponent(offScreenGraphics);
        }

        // copy buffer to screen
        //long t0 = System.currentTimeMillis();
        
        /*
         * FREEHEP-503 Disabled, since in Linux this made the blitting very
         * slow.
         * 
         * Despite what the API documentation says, getClipBounds()
         * returns the current dirty region. This can then be used to speedup
         * the drawing of the BufferedPanel.
         */ 
         
        // clip = g.getClipBounds(clip);
        // Make sure the clip is not larger than the bounds. 
        // clip = clip.intersection(getBounds());
        // BufferedImage bufferedImage = (BufferedImage)offScreenImage;
        // BufferedImage subimage = bufferedImage.getSubimage(clip.x,clip.y,
        // clip.width,clip.height); boolean done =
        // g.drawImage(subimage,clip.x,clip.y,this);


        /* boolean done = */ g.drawImage(offScreenImage, 0, 0, this);
        // System.err.println("CopyImage "+done+" took:
        // "+(System.currentTimeMillis()-t0)+" ms.");
    }

    /**
     * Returns a pointer to the graphics (VectorGraphics) context of the buffer.
     * The user is NOT allowed to call dispose() on this graphics object.
     * <P>
     * NOTE: this method used to be called getGraphics, however, since the JVM
     * paint thread may call getGraphics from paintImmediately and fails to work
     * with our VectorGraphics context (the gc is not longer attached to the
     * image), we decided to rename the method.
     */
    public Graphics getBufferedGraphics() {
        return offScreenGraphics;
    }

    /**
     * Allows for custom graphics to be painted. Subclasses should implement
     * real drawing here. They can ask isPrinting(), isExporting() or
     * isDisplaying() to see where the output goes. If painting is done to a
     * display it is done to a buffer which is kept and copied afterwards.
     * 
     * Note that the parameter here is of class VectorGraphics rather than
     * Graphics.
     */
    public void paintComponent(VectorGraphics vg) {
    }

    /**
     * Resize and move a component.
     */
    public void setBounds(int x, int y, int w, int h) {
        // Make sure that the parent's method is called first;
        // otherwise, the resize never happens and new images are NOT
        // made.
        super.setBounds(x, y, w, h);

        // FREEHEP-503 Disabled, since in Linux this made the blitting very
        // slow.     
//        clip = new Rectangle(x, y, w, h);

        // Make the backing image.
        makeImage();
    }

    /**
     * Returns true if the drawing is made for a PrinterGraphics context.
     */
    public boolean isPrinting() {
        return printing;
    }

    /**
     * Returns true if the drawing is made for a VectorGraphics context.
     */
    public boolean isExporting() {
        return exporting;
    }

    /**
     * Returns true if the drawing is made for a PixelGraphics context, the
     * display. True if not Printing and not Exporting.
     */
    public boolean isDisplaying() {
        return ((!isExporting()) && (!isPrinting()));
    }

    /**
     * Make the buffered image for this panel. Check to see if the size has
     * changed before doing anything.
     */
    private void makeImage() {

        // Get the full size of the panel.
        dim = getSize(dim);

        // Check that the current size is positive and that the new
        // dimension is not equal to the old one.
        if (dim.width > 0 && dim.height > 0) {
            if (!oldDimension.equals(dim)) {

                // allocate an Image, which from before JDK 1.4 was always in
                // System Memory,
                // and from JDK 1.4 is a Managed Buffered Image in System memory
                // or VRAM (Windows)
                // or a BufferedImage (getClass always returns BufferedImage)
                // Real BufferedImages resides in System Memory.
                // Volatile Images reside in VRAM (Windows), or XServer memory.
                // Drawing more than ~1000 line segments to system memory (BI)
                // and
                // doing a copy to the display is faster than drawing them
                // to video ram (VI) and using the fast VRAM->display copy.
                // For us, System Memory is the choice for both Windows and
                // XWindows,
                // since we draw more lines that copying.

                // However, it may be that the acceleration possible on VRAM my
                // up this
                // 1000 line limit.

                // The image created here is a Managed Buffered Image, which can
                // be moved
                // from System Memory and copied to VRAM...
                // Use the flag -Dsun.java2d.ddoffscreen=false to keep the image
                // in
                // system memory, or -Dsun.java2d.ddforcevram=true to keep the
                // image
                // in VRAM. Using none, seems to affect performance in picking
                // mode.

                // There is no programmatic (java) way of keeping the image in
                // system memory, not even if you create a BufferedImage
                // explicitly.
                if (isOpaque()) {
                    offScreenImage = super.createImage(dim.width, dim.height);
                } else {
                    offScreenImage = new BufferedImage(dim.width, dim.height,
                            BufferedImage.TYPE_INT_ARGB);
                }
                offScreenGraphics = VectorGraphics.create(offScreenImage
                        .getGraphics());

                // Reset the old size of this panel.
                oldDimension.setSize(dim);
            }
        } else {
            offScreenImage = null;
            offScreenGraphics = null;
        }
    }

}
