Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.symbols;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Paint;

import java.awt.Rectangle;

import java.awt.TexturePaint;

import java.awt.geom.AffineTransform;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import javax.print.attribute.PrintRequestAttributeSet;

import org.apache.log4j.Logger;

import org.gvsig.symbology.fmap.styles.BackgroundFileStyle;

import org.gvsig.symbology.fmap.styles.ImageStyle;

import org.gvsig.symbology.fmap.styles.SVGStyle;

import org.gvsig.symbology.fmap.styles.SimpleMarkerFillPropertiesStyle;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.iver.cit.gvsig.fmap.Messages;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.core.FPolygon2D;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.GeneralPathX;

import com.iver.cit.gvsig.fmap.core.SymbologyFactory;

import com.iver.cit.gvsig.fmap.core.styles.IMarkerFillPropertiesStyle;

import com.iver.cit.gvsig.fmap.core.symbols.AbstractFillSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.ILineSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.ISymbol;

import com.iver.cit.gvsig.fmap.core.symbols.SymbolDrawingException;

import com.iver.utiles.StringUtilities;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.swing.threads.Cancellable;

/**

 * PictureFillSymbol allows to use an image file suported by gvSIG as a padding

 * for the polygons.This image can be modified using methods to scale or rotate it.

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 */

public class PictureFillSymbol extends AbstractFillSymbol {

        private double angle = 0;

        private double xScale = 1;

        private double yScale = 1;

        private IMarkerFillPropertiesStyle markerFillProperties = new SimpleMarkerFillPropertiesStyle();

        private String imagePath;

        private BackgroundFileStyle bgImage;

        public void draw(Graphics2D g, AffineTransform affineTransform, FShape shp, Cancellable cancel) {

                Color fillColor = getFillColor();

                if (fillColor != null) {

                        g.setColor(getFillColor());

                        g.fill(shp);

                }

                g.setClip(shp);

                if (xScale<=0 &&  yScale<=0)

                        return;

                BackgroundFileStyle bg =  bgImage ;

                final double imageWidth  = bg.getBounds().getWidth()  * xScale;

                final double imageHeight = bg.getBounds().getWidth() * yScale;

                if (imageWidth==0 || imageHeight==0) return;

                Rectangle rProv = new Rectangle();

                rProv.setFrame(0, 0, imageWidth, imageHeight);

                Paint resulPatternFill = null;

                Graphics2D gAux;// = img.createGraphics();

                double xSeparation = markerFillProperties.getXSeparation(); 

                double ySeparation = markerFillProperties.getYSeparation(); 

                double xOffset = markerFillProperties.getXOffset();

                double yOffset = markerFillProperties.getYOffset();

                rProv.setRect(0, 0,

                                rProv.getWidth() + xSeparation,

                                rProv.getHeight() + ySeparation);

                BufferedImage bi = new BufferedImage(rProv.width, rProv.height, BufferedImage.TYPE_INT_ARGB);

                gAux = bi.createGraphics();

                AffineTransform tx = AffineTransform.getScaleInstance(xScale, yScale);

                tx.translate(xSeparation*0.5, ySeparation*0.5);

                tx.rotate(angle, rProv.getWidth(), rProv.getHeight());

                gAux.setTransform(tx);

                bg.drawInsideRectangle(gAux, rProv);

                resulPatternFill = new TexturePaint(bi,rProv);

                g.translate(xOffset, yOffset);

                g.setPaint(resulPatternFill);

                g.fill(shp);

                g.translate(-xOffset, -yOffset);

                g.setClip(null);

                if (getOutline()!=null) {

                        getOutline().draw(g, affineTransform, shp, cancel);

                }

        }

        /**

         * Defines the file from where the picture to fill the polygon is taken.

         * @param imageFile

         * @throws IOException

         */

        public void setImage(File imageFile) throws IOException{

                if(imageFile!=null && imageFile.exists()) {

                        imagePath = imageFile.getAbsolutePath();

                        bgImage= (imageFile.getAbsolutePath().toLowerCase().endsWith(".svg")) ?

                                        new SVGStyle() :

                                        new ImageStyle();

                        bgImage.setSource(imageFile.toURL());

                }

        }

        public void drawInsideRectangle(Graphics2D g,

                        AffineTransform scaleInstance, Rectangle r) throws SymbolDrawingException {

                draw(g, null, new FPolygon2D(new GeneralPathX(r)), null);

        }

        public ISymbol getSymbolForSelection() {

                // TODO Auto-generated method stub

                throw new Error("Not yet implemented!");

        }

        public int getSymbolType() {

                return FShape.POLYGON;

        }

        public XMLEntity getXMLEntity() {

                XMLEntity xml = new XMLEntity();

                xml.putProperty("desc", getDescription());

                xml.putProperty("className", getClassName());

                xml.putProperty("isShapeVisible", isShapeVisible());

                xml.putProperty("referenceSystem", getReferenceSystem());

                xml.putProperty("unit", getUnit());

                xml.putProperty("angle", angle);

                xml.putProperty("scaleX", xScale);

                xml.putProperty("scaleY", yScale);

                xml.putProperty("imagePath", imagePath);

                if (getFillColor()!=null)

                        xml.putProperty("fillColor", StringUtilities.color2String(getFillColor()));

                xml.putProperty("hasFill", hasFill());

                XMLEntity fillPropertiesXML = markerFillProperties.getXMLEntity();

                fillPropertiesXML.putProperty("id", "fillProperties");

                xml.addChild(fillPropertiesXML);

                if (getOutline()!=null) {

                        XMLEntity outlineXML = getOutline().getXMLEntity();

                        outlineXML.putProperty("id", "outline symbol");

                        xml.addChild(outlineXML);

                }

                xml.putProperty("hasOutline", hasOutline());

                return xml;

        }

        public void setXMLEntity(XMLEntity xml) {

                try {

                        File f = new File(xml.getStringProperty("imagePath"));

                        setImage(f);

                        setDescription(xml.getStringProperty("desc"));

                        setIsShapeVisible(xml.getBooleanProperty("isShapeVisible"));

                        setAngle(xml.getDoubleProperty("angle"));

                        setXScale(xml.getDoubleProperty("scaleX"));

                        setYScale(xml.getDoubleProperty("scaleY"));

                        if (xml.contains("fillColor"))

                                setFillColor(StringUtilities.string2Color(

                                                xml.getStringProperty("fillColor")));

                        markerFillProperties = (IMarkerFillPropertiesStyle) SymbologyFactory.

                        createStyleFromXML(

                                        xml.firstChild("id", "fillProperties"), "fill properties");

                        try {

                                setImage(new File(imagePath));

                        } catch (IOException e) {

                                e.printStackTrace();

                        }

                        if (xml.contains("hasFill"))

                                setHasFill(xml.getBooleanProperty("hasFill"));

                        XMLEntity outlineXML = xml.firstChild("id", "outline symbol");

                        if (outlineXML != null) {

                                setOutline((ILineSymbol) SymbologyFactory.createSymbolFromXML(outlineXML, "outline"));

                        }

                        if (xml.contains("unit")) { // remove this line when done

                        // measure unit (for outline)

                        setUnit(xml.getIntProperty("unit"));

                        // reference system (for outline)

                        setReferenceSystem(xml.getIntProperty("referenceSystem"));

                        }

                        if (xml.contains("hasOutline"))

                                setHasOutline(xml.getBooleanProperty("hasOutline"));

                }catch (IOException e) {

                        Logger.getLogger(this.getClass()).error(Messages.getString("failed_to_read_image_file"), e);

                }

        }

        public String getClassName() {

                return getClass().getName();

        }

        public void print(Graphics2D g, AffineTransform at, FShape shape,

                        PrintRequestAttributeSet properties) throws ReadDriverException {

                // TODO Auto-generated method stub

                throw new Error("Not yet implemented!");

        }

        /**

         * Returns the IMarkerFillProperties that allows this class to treat the picture as

         * a marker in order to scale it, rotate it and so on.

         * @return markerFillProperties,IMarkerFillPropertiesStyle

         */

        public IMarkerFillPropertiesStyle getMarkerFillProperties() {

                return markerFillProperties;

        }

        /**

         * Sets the MarkerFillProperties in order to allow the user to modify the picture as

         * a marker (it is possible to scale it, rotate it and so on)

         * @param prop

         */

        public void setMarkerFillProperties(IMarkerFillPropertiesStyle prop) {

                this.markerFillProperties = prop;

        }

        /**

         * Defines the angle for the rotation of the image when it is added to create the

         * padding

         *

         * @return angle

         */

        public double getAngle() {

                return angle;

        }

        /**

         * Sets the angle for the rotation of the image when it is added to create the padding

         * @param angle

         */

        public void setAngle(double angle) {

                this.angle = angle;

        }

        /**

         * Defines the scale for the x axis of the image when it is added to create the

         * padding

         * @return xScale

         */

        public double getXScale() {

                return xScale;

        }

        /**

         * Returns the scale for the x axis of the image when it is added to create the

         * padding

         * @param xScale

         */

        public void setXScale(double xScale) {

                this.xScale = xScale;

        }

        /**

         * Defines the scale for the y axis of the image when it is added to create the

         * padding

         * @return yScale

         */

        public double getYScale() {

                return yScale;

        }

        /**

         * Returns the scale for the y axis of the image when it is added to create the

         * padding

         * @param yScale

         */

        public void setYScale(double yScale) {

                this.yScale = yScale;

        }

        /**

         * Returns the path of the image that is used to create the padding to fill the

         * polygon

         * @return imagePath

         */

        public String getImagePath() {

                return imagePath;

        }

        @Override

        public double toCartographicSize(ViewPort viewPort, double dpi, FShape shp) {

                return super.toCartographicSize(viewPort, dpi, shp);

                // this symbol cannot apply any cartographic transfomation to its filling

        }

}