Application: gvSIG desktop

package org.gvsig.svgsupport;

import java.awt.Graphics2D;

import java.awt.RenderingHints;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.net.URISyntaxException;

import java.net.URL;

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.dom.svg.SVGOMDocument;

import org.apache.batik.gvt.GraphicsNode;

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

import org.w3c.dom.Document;

import org.w3c.dom.Element;

public class DefaultSVGRenderer implements SVGRenderer {

    private final GVTBuilder gvtBuilder = new GVTBuilder();

    private final UserAgentAdapter userAgent;

    private final DocumentLoader loader;

    private final StaticRenderer renderer = new StaticRenderer();

    private GraphicsNode gvtRoot;

    private final BridgeContext ctx;

    private Element elt;

    private URL source;

    private static RenderingHints defaultRenderingHints = null;

    public DefaultSVGRenderer() {

        userAgent = new UserAgentAdapter();

        loader = new DocumentLoader(userAgent);

        ctx = new BridgeContext(userAgent, loader);

        renderer.setDoubleBuffered(true);

    }

    @Override

    public Rectangle2D getBounds() {

        Rectangle2D bounds = gvtRoot.getBounds();

        return bounds;

    }

    @Override

    public void drawInsideRectangle(Graphics2D g,

            Rectangle2D rect,

            boolean keepAspectRatio) {

        if (keepAspectRatio) {

            AffineTransform ataux = null;

            if (elt.hasAttribute("viewBox")) {

                try {

                    ataux

                            = ViewBox.getViewTransform(null,

                                    elt,

                                    (float) rect.getWidth(),

                                    (float) rect.getHeight(),

                                    ctx);

                } catch (NullPointerException e) {

                }

            }

            if( ataux == null ) {

                Rectangle2D bounds = gvtRoot.getBounds();

                ataux = getNoRotationTransform(

                    bounds,

                    new Rectangle2D.Double(

                        rect.getX(),

                        rect.getY(),

                        rect.getWidth(),

                        rect.getHeight()),

                    true

                );

            }

            RenderingHints renderingHints = new RenderingHints(null);

            renderingHints.putAll(getDefaultRenderingHints());

            g.setRenderingHints(renderingHints);

            gvtRoot.setTransform(ataux);

            gvtRoot.paint(g);

        } else {

            Rectangle2D bounds = gvtRoot.getBounds();

            AffineTransform ataux = getNoRotationTransform(

                bounds,

                new Rectangle2D.Double(

                    rect.getX(),

                    rect.getY(),

                    rect.getWidth(),

                    rect.getHeight()

                ),

                false

            );

            RenderingHints renderingHints = new RenderingHints(null);

            renderingHints.putAll(getDefaultRenderingHints());

            g.setRenderingHints(renderingHints);

            gvtRoot.setTransform(ataux);

            gvtRoot.paint(g);

        }

    }

    @Override

    public void setSource(URL url) throws IOException {

        source = url;

        Document svgDoc;

        try {

            svgDoc = loader.loadDocument(url.toURI().toString());

        } catch (URISyntaxException e) {

            throw new IOException(e);

        }

        gvtRoot = gvtBuilder.build(ctx, svgDoc);

        renderer.setTree(gvtRoot);

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

    }

    @Override

    public URL getSource() {

        return this.source;

    }

    private AffineTransform getNoRotationTransform(

            Rectangle2D from_rect,

            Rectangle2D to_rect,

            boolean keep_aspect) {

        double scalex = to_rect.getWidth() / from_rect.getWidth();

        double scaley = to_rect.getHeight() / from_rect.getHeight();

        if (keep_aspect) {

            // force min value for both

            scalex = Math.min(scalex, scaley);

            scaley = scalex;

        }

        double from_new_center_x = scalex * from_rect.getCenterX();

        double from_new_center_y = scaley * from_rect.getCenterY();

        double offx = to_rect.getCenterX() - from_new_center_x;

        double offy = to_rect.getCenterY() - from_new_center_y;

        AffineTransform resp

                = AffineTransform.getTranslateInstance(offx, offy);

        // this composition is equivalent to:

        // first scale, then move

        resp.concatenate(

                AffineTransform.getScaleInstance(scalex, scaley));

        return resp;

    }

    private RenderingHints getDefaultRenderingHints() {

        if (defaultRenderingHints == null) {

            defaultRenderingHints = new RenderingHints(null);

            defaultRenderingHints.put(RenderingHints.KEY_ANTIALIASING,

                    RenderingHints.VALUE_ANTIALIAS_ON);

            defaultRenderingHints.put(RenderingHints.KEY_INTERPOLATION,

                    RenderingHints.VALUE_INTERPOLATION_BILINEAR);

        }

        return defaultRenderingHints;

    }

    @Override

    public void setSource(File f) throws IOException {

        setSource(f.toURI().toURL());

    }

}