Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.app.project.documents.layout.fframes;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.RenderingHints;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.awt.image.ImagingOpException;

import java.io.File;

import javax.swing.ImageIcon;

import com.sun.jimi.core.Jimi;

import org.apache.batik.bridge.BridgeContext;

import org.apache.batik.bridge.DocumentLoader;

import org.apache.batik.bridge.GVTBuilder;

import org.apache.batik.bridge.UserAgentAdapter;

import org.apache.batik.bridge.ViewBox;

import org.apache.batik.gvt.GraphicsNode;

import org.apache.batik.gvt.renderer.StaticRenderer;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.svg.SVGDocument;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * FFrame para introducir una imagen en el Layout o para dibujar sobre el

 * graphics un SVG.

 * 

 * @author Vicente Caballero Navarro

 */

public class FFramePicture extends FFrame {

    public static final String PERSISTENCE_DEFINITION_NAME = "FFramePicture";

    private static final String PATH_FIELD = "path";

    private static final String QUALITY_FIELD = "quality";

    private static final String VIEWING_FIELD = "viewing";

    protected static RenderingHints defaultRenderingHints;

    static {

        defaultRenderingHints = new RenderingHints(null);

        defaultRenderingHints.put(RenderingHints.KEY_ANTIALIASING,

            RenderingHints.VALUE_ANTIALIAS_ON);

        defaultRenderingHints.put(RenderingHints.KEY_INTERPOLATION,

            RenderingHints.VALUE_INTERPOLATION_BILINEAR);

    }

    private static final int PRESENTACION = 0;

    private static final int ACTIVO = 1;

    private BufferedImage m_image = null;

    private int m_quality = PRESENTACION;

    private int m_viewing = ACTIVO;

    private String m_path = null;

    private boolean isSVG = false;

    private StaticRenderer renderer = new StaticRenderer();

    private Element elt;

    private GVTBuilder gvtBuilder = new GVTBuilder();

    private GraphicsNode gvtRoot = null;

    private BridgeContext ctx;

    /**

     * Creates a new FFramePicture object.

     */

    public FFramePicture() {

    }

    /**

     * M?todo que dibuja sobre el graphics que se le pasa como par?metro, seg?n

     * la transformada afin que se debe de aplicar y el rect?ngulo que se debe

     * de dibujar.

     * 

     * @param g

     *            Graphics

     * @param at

     *            Transformada afin.

     * @param rv

     *            rect?ngulo sobre el que hacer un clip.

     * @param imgBase

     *            Imagen para acelerar el dibujado.

     */

    public void draw(Graphics2D g, AffineTransform at, Rectangle2D rv,

        BufferedImage imgBase) {

        Rectangle2D.Double r = getBoundingBox(at);

        g.rotate(Math.toRadians(getRotation()), r.x + (r.width / 2), r.y

            + (r.height / 2));

        double x = r.getMinX();

        double y = r.getMinY();

        double w = r.getWidth();

        double h = r.getHeight();

        if (intersects(rv, r) || w != 0 || h != 0) {

            if ((m_image == null) && !isSVG) { // Que no hay una imagen.

                drawEmpty(g);

            } else {

                if ((rv == null) || (getQuality() == PRESENTACION)) {

                    if (!isSVG) {

                        double scalex = w / m_image.getWidth(null);

                        double scaley = h / m_image.getHeight(null);

                        try {

                            AffineTransform xform =

                                AffineTransform

                                    .getScaleInstance(scalex, scaley);

                            AffineTransform xpos =

                                AffineTransform.getTranslateInstance(x, y);

                            xpos.concatenate(xform);

                            g.drawRenderedImage(m_image, xpos);

                        } catch (ImagingOpException e) {

                            NotificationManager.addError(

                                "Dibujando FFramePicture", e);

                        }

                    } else

                        if (isSVG) {

                            try {

                                if (r != null) {

                                    drawSVG(g, r, rv);

                                }

                            } catch (OutOfMemoryError e) {

                                NotificationManager.addError(

                                    "Dibujando SVG FFramePicture", e);

                            } catch (IllegalArgumentException e) {

                                NotificationManager.addError(

                                    "Dibujando SVG FFramePicture", e);

                            }

                        }

                    System.gc();

                } else {

                    drawDraft(g);

                }

            }

        }

        g.rotate(Math.toRadians(-getRotation()), r.x + (r.width / 2), r.y

            + (r.height / 2));

    }

    /**

     * Dibuja SVG sobre el Graphics que se pasa como par?metro.

     * 

     * @param g

     *            Graphics

     * @param rect

     *            rect?ngulo que ocupa.

     * @param rv

     *            Rect?ngulo que forma la parte visible del Layout.

     */

    private void drawSVG(Graphics2D g, Rectangle2D rect, Rectangle2D rv) {

        if ((rv == null) || rv.contains(rect)) {

            AffineTransform ataux = new AffineTransform();

            ataux.translate(rect.getX(), rect.getY());

            try {

                ataux.concatenate(ViewBox.getViewTransform(null, elt,

                    (float) rect.getWidth(), (float) rect.getHeight(), ctx));

                gvtRoot.setTransform(ataux);

            } catch (Exception e) {

                // TODO: handle exception

            }

        } else {

            AffineTransform ataux = new AffineTransform();

            ataux.translate(rect.getX(), rect.getY());

            ataux.concatenate(ViewBox.getViewTransform(null, elt,

                (float) rect.getWidth(), (float) rect.getHeight(), ctx));

            gvtRoot.setTransform(ataux);

        }

        RenderingHints renderingHints = defaultRenderingHints;

        g.setRenderingHints(renderingHints);

        if (gvtRoot != null) {

            gvtRoot.paint(g);

        }

    }

    /**

     * Rellena la calidad seg?n el entero que se pasa como par?metro.

     * 

     * @param q

     *            entero que representa el tipo de calidad elegido.

     */

    public void setQuality(int q) {

        m_quality = q;

    }

    /**

     * Devuelve la calidad que est? seleccionada.

     * 

     * @return entero que representa la calidad seleccionada.

     */

    public int getQuality() {

        return m_quality;

    }

    /**

     * Devuelve un entero que representa la forma en que se actualiza la vista.

     * 

     * @return forma que se actualiza la vista.

     */

    public int getViewing() {

        return m_viewing;

    }

    /**

     * Rellena la forma de actualizar la vista.

     * 

     * @param v

     *            entero que representa la forma de actualizar la vista.

     */

    public void setViewing(int v) {

        m_viewing = v;

    }

    /**

     * Rellena el nombre de la imagen.

     * 

     * @param path

     *            nombre de la imagen.

     */

    public void setPath(String path) {

        m_path = path;

    }

    /**

     * Devuelve la ruta del fichero.

     * 

     * @return String

     */

    public String getPath() {

        return m_path;

    }

    /**

     * Rellena la imagen.

     * 

     * @param image

     */

    public void setImage(BufferedImage image) {

        m_image = image;

    }

    /**

     * Devuelve la dimensi?n dela imagen.

     * 

     * @param file

     *            Nombre del fichero donde se encuentra la imagen.

     * 

     * @return DOCUMENT ME!

     */

    public Dimension getBound(String file) {

        Image img = load(file);

        if (isSVG) {

            return new Dimension(100, 100);

        }

        if (img == null) {

            return new Dimension((int) getBoundingBox(null).getWidth(),

                (int) getBoundingBox(null).getHeight());

        }

        return new Dimension(img.getWidth(null), img.getHeight(null));

    }

    /**

     * Carga el contnido del fichero.

     * 

     * @param file

     *            Nombre del fichero a cargar.

     * 

     * @return Imagen

     */

    public Image load(String file) {

        if (file == null) {

            return null;

        }

        ImageIcon tmpIcon = null;

        File f = new File(file);

        if (file == null || !f.exists()) {

            return null;

        }

        setPath(file);

        String iString = file.toLowerCase();

        if (iString.endsWith("jpg") || iString.endsWith("jpeg")

            || iString.endsWith("gif")) {

            tmpIcon = new ImageIcon(Jimi.getImage(file, Jimi.VIRTUAL_MEMORY)); // ((File)main.allImages.elementAt(x)).getAbsolutePath());

        } else

            if (iString.endsWith("png") || iString.endsWith("tif")

                || iString.endsWith("ico") || iString.endsWith("xpm")

                || iString.endsWith("bmp")) {

                tmpIcon =

                    new ImageIcon(Jimi.getImage(file, Jimi.VIRTUAL_MEMORY)); // new

                                                                             // ImageIcon(f.getPath());

            } else

                if (iString.endsWith("svg")) {

                    isSVG = true;

                    obtainStaticRenderer(new File(file));

                } else {

                    tmpIcon = new ImageIcon(file);

                }

        if (!isSVG && (tmpIcon != null)) {

            Image image = tmpIcon.getImage();

            if (image.getWidth(null) == -1 || image.getHeight(null) == -1) {

                NotificationManager.showMessageError(

                    PluginServices.getText(this, "unsupported_format"),

                    new Exception());

                return null;

            }

            BufferedImage bi =

                new BufferedImage(image.getWidth(null), image.getHeight(null),

                    BufferedImage.TYPE_INT_ARGB);

            Graphics2D biContext = bi.createGraphics();

            biContext.drawImage(image, 0, 0, null);

            setImage(bi);

            return image;

        }

        return null;

    }

    /**

     * Obtiene el renderer para svg a partir del svg.

     * 

     * @param file

     *            Nombre del fichero.

     */

    private void obtainStaticRenderer(File file) {

        try {

            UserAgentAdapter userAgent = new UserAgentAdapter();

            DocumentLoader loader = new DocumentLoader(userAgent);

            BridgeContext ctx = new BridgeContext(userAgent, loader);

            Document svgDoc = loader.loadDocument(file.toURI().toString());

            gvtRoot = gvtBuilder.build(ctx, svgDoc);

            renderer.setTree(gvtRoot);

            elt = ((SVGDocument) svgDoc).getRootElement();

            ctx = new BridgeContext(userAgent, loader);

        } catch (Exception ex) {

            ex.printStackTrace();

        }

    }

    /**

     * @see org.gvsig.app.project.documents.layout.fframes.IFFrame#getNameFFrame()

     */

    public String getNameFFrame() {

        return PluginServices.getText(this, "imagen") + num;

    }

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

    public void initialize() {

        // TODO Auto-generated method stub

    }

    public void cloneActions(IFFrame frame) {

        m_image = null;

    }

    public void print(Graphics2D g, AffineTransform at, Geometry geom,

        PrintAttributes properties) {

        draw(g, at, null, null);

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null) {

            DynStruct definition =

                manager.addDefinition(FFramePicture.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFramePicture persistence definition", null, null);

            definition.extend(manager

                .getDefinition(FFrame.PERSISTENCE_DEFINITION_NAME));

            definition.addDynFieldString(PATH_FIELD).setMandatory(true);

            definition.addDynFieldInt(QUALITY_FIELD).setMandatory(true);

            definition.addDynFieldInt(VIEWING_FIELD).setMandatory(true);

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        m_path = state.getString(PATH_FIELD);

        m_quality = state.getInt(QUALITY_FIELD);

        m_viewing = state.getInt(VIEWING_FIELD);

        load(m_path);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set(PATH_FIELD, m_path);

        state.set(QUALITY_FIELD, m_quality);

        state.set(VIEWING_FIELD, m_viewing);

    }

}