Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

 * 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.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.impl;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol_v2;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolDrawingException;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.AbstractSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.CartographicSupportToolkit;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.style.IMask;

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;

import org.gvsig.tools.util.Callable;

/**

 * Abstract class that any MARKER SYMBOL should extend.

 *

 * @author gvSIG team

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractMarkerSymbol extends AbstractSymbol implements IMarkerSymbol_v2 {

    public static final String MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME = "MarkerSymbol";

    private static final String FIELD_COLOR = "color";

    private static final String FIELD_ROTATION = "rotation";

    private static final String FIELD_OFFSET = "offset";

    private static final String FIELD_SIZE = "size";

    private static final String FIELD_MASK = "mask";

    private static final String FIELD_LINETOOFFSETCOLOR = "lineToOffsetColor";

    private static final String FIELD_DRAWLINETOOFFSET = "drawLineToOffset";

    private static final String FIELD_SIZE_EXPRESSION = "sizeExpression";

    private static final String FIELD_OFFSETX_EXPRESSION = "offsetXExpression";

    private static final String FIELD_OFFSETY_EXPRESSION = "offsetYExpression";

    private static final String FIELD_ROTATION_EXPRESSION = "rotationExpression";

    private static final String FIELD_LINETOOFFSETCOLOR_EXPRESSION = "lineToOffsetColorExpression";

    private static final GeometryManager GEOMETRY_MANAGER = GeometryLocator.getGeometryManager();

    private Color color;

    private double rotation;

    private Point2D offset = new Point2D.Double();

    private double size = 4d;

    private IMask mask;

    private Color lineToOffsetColor;

    private boolean drawLineToOffset;

    private String sizeExpression;

    private String offsetXExpression;

    private String offsetYExpression;

    private String rotationExpression;

    private String lineToOffsetColorExpression;

    private transient org.gvsig.fmap.geom.primitive.Point point;

    private transient ViewPort viewPort;

    private transient double dpi;

    public AbstractMarkerSymbol() {

        super();

        color = MapContextLocator.getSymbolManager()

                .getSymbolPreferences()

                .getDefaultSymbolFillColor();

        this.lineToOffsetColor = Color.BLACK;

        try {

            this.point = GEOMETRY_MANAGER.createPoint(0, 0, SUBTYPES.GEOM2D);

        } catch (CreateGeometryException ex) {

        }

    }

    protected org.gvsig.fmap.geom.primitive.Point getPoint(double x, double y) {

        this.point.setX(x);

        this.point.setY(y);

        return this.point;

    }

    @Override

    public final int getSymbolType() {

        return Geometry.TYPES.POINT;

    }

    @Override

    public double getRotation() {

        return rotation;

    }

    @Override

    public void setRotation(double r) {

        this.rotation = r;

    }

    @Override

    public Point2D getOffset() {

        if (offset == null) {

            offset = new Point();

        }

        return offset;

    }

    @Override

    public void setOffset(Point2D offset) {

        this.offset = offset;

    }

    private FeatureSymbolTable symbolTable = null;

    protected SymbolTable getSymbolTable(Feature f) {

        if( symbolTable==null ) {

            this.symbolTable = DALLocator.getManager().createFeatureSymbolTable();

            this.symbolTable.addSymbolTable(ExpressionUtils.createSymbolTable());

        }

        symbolTable.setFeature(f);

        return symbolTable;

    }

    @Override

    public Color getLineToOffsetColor() {

        return this.lineToOffsetColor;

    }

    @Override

    public void setLineToOffsetColor(Color color) {

        this.lineToOffsetColor = color;

    }

    @Override

    public boolean isDrawLineToOffset() {

        return this.drawLineToOffset;

    }

    @Override

    public void setDrawLineToOffset(boolean drawLineToOffset) {

        this.drawLineToOffset = drawLineToOffset;

    }

    @Override

    public String getOffsetXExpression() {

        return offsetXExpression;

    }

    @Override

    public void setOffsetXExpression(String offsetXExpression) {

        this.offsetXExpression = StringUtils.trimToNull(offsetXExpression);

    }

    @Override

    public String getOffsetYExpression() {

        return offsetYExpression;

    }

    @Override

    public void setOffsetYExpression(String offsetYExpression) {

        this.offsetYExpression = StringUtils.trimToNull(offsetYExpression);

    }

    @Override

    public String getRotationExpression() {

        return rotationExpression;

    }

    @Override

    public void setRotationExpression(String rotationExpression) {

        this.rotationExpression = StringUtils.trimToNull(rotationExpression);

    }

    @Override

    public String getSizeExpression() {

        return sizeExpression;

    }

    @Override

    public void setSizeExpression(String sizeExpression) {

        this.sizeExpression = StringUtils.trimToNull(sizeExpression);

    }

    @Override

    public String getLineToOffsetColorExpression() {

        return this.lineToOffsetColorExpression;

    }

    @Override

    public void setLineToOffsetColorExpression(String lineToOffsetColorExpression) {

        this.lineToOffsetColorExpression = StringUtils.trimToNull(lineToOffsetColorExpression);

    }

    @Override

    public Point2D getEfectiveOffset(Feature f) {

        if( f == null ) {

            f = this.getFeature();

        }

        Point2D p;

        if( f==null || StringUtils.isBlank(this.offsetXExpression) || StringUtils.isBlank(this.offsetYExpression) ) {

            p = this.getOffset();

            p = new Point2D.Double(

                    toCartographicUnits(p.getX()), 

                    toCartographicUnits(p.getY())

            );

        } else {

            double offsetX = toCartographicUnits(ExpressionUtils.parseDouble(

                    this.getSymbolTable(f), 

                    offsetXExpression, 

                    (int) this.getOffset().getX()

            ));

            double offsetY = toCartographicUnits(ExpressionUtils.parseDouble(

                    this.getSymbolTable(f), 

                    offsetYExpression, 

                    (int) this.getOffset().getY()

            ));

            p = new Point2D.Double(offsetX, offsetY);

        }

        return p;

    }

    @Override

    public double getEfectiveRotationInDegres(Feature f) {

        // Por defecto vedra en grados.

        if( f == null ) {

            f = this.getFeature();

        }

        if( f==null || StringUtils.isBlank(this.rotationExpression) ) {

            return this.getRotation();

        }

        double r = ExpressionUtils.parseDouble(

                this.getSymbolTable(f), 

                rotationExpression, 

                this.getRotation()

        );

        return r;

    }

    @Override

    public double getEfectiveRotationInRadians(Feature f) {

        // Pillamos el valor por defecto que es en grados y lo transformamos a radianes.

        double r = this.getEfectiveRotationInDegres(f);

        if( r == 0 ) {

            return 0;

        }

        r = Math.toRadians(r);

        return r;

    }

    @Override

    public Color getEfectiveLineToOffsetColor(Feature f) {

        if( f == null ) {

            f = this.getFeature();

        }

        if( f==null || StringUtils.isBlank(this.lineToOffsetColorExpression) ) {

            return this.getLineToOffsetColor();

        }

        Color theColor = ExpressionUtils.parseColor(

                this.getSymbolTable(f), 

                this.lineToOffsetColorExpression, 

                this.getLineToOffsetColor()

        );

        return theColor;

    }

    @Override

    public double getEfectiveSize(Feature f) {

        if( f == null ) {

            f = this.getFeature();

        }

        if( f==null || StringUtils.isBlank(this.sizeExpression) ) {

            return this.getSize();

        }

        double sz = ExpressionUtils.parseDouble(

                this.getSymbolTable(f), 

                this.sizeExpression, 

                -1

        );

        if(sz<0){

            return this.getSize();

        }

        return toCartographicUnits(sz);

    }

    @Override

    public boolean isSuitableFor(Geometry geom) {

        return geom.getType() == Geometry.TYPES.POINT;

    }

    @Override

    public int getOnePointRgb() {

        return color.getRGB();

    }

    @Override

    public double getSize() {

        return size;

    }

    @Override

    public void setSize(double size) {

        this.size = size;

    }

    @Override

    public Color getColor() {

        return color;

    }

    @Override

    public void setColor(Color color) {

        this.color = color;

    }

    @Override

    public void setAlpha(int outlineAlpha) {

        Color theColor = getColor();

        setColor(new Color(theColor.getRed(), theColor.getGreen(), theColor.getBlue(),

                outlineAlpha));

    }

    @Override

    public void getPixExtentPlus(Geometry geom, float[] distances, ViewPort viewPort, int dpi) {

        float cs = (float) getCartographicSize(viewPort, dpi, geom);

        distances[0] = cs;

        distances[1] = cs;

    }

    @Override

    public void print(Graphics2D g, AffineTransform at, Geometry geom, PrintAttributes properties) {

        double originalSize = getEfectiveSize(getFeature());

        double theSize = originalSize;

        // scale it to size

        int pq = properties.getPrintQuality();

        switch (pq) {

            case PrintAttributes.PRINT_QUALITY_NORMAL:

                theSize *= (double) 300 / 72;

                break;

            case PrintAttributes.PRINT_QUALITY_HIGH:

                theSize *= (double) 600 / 72;

                break;

            case PrintAttributes.PRINT_QUALITY_DRAFT:

                // size *= 72/72; // (which is the same than doing nothing)

                break;

            default:

                break;

        }

//                setSize(theSize);

        draw(g, at, geom, getFeature(), null);

//                setSize(originalSize);

    }

    @Override

    public final IMask getMask() {

        return mask;

    }

    @Override

    public void drawInsideRectangle(Graphics2D g, AffineTransform scaleInstance, Rectangle r, PrintAttributes properties) throws SymbolDrawingException {

        try {

            if (properties == null) {

                draw(

                        g, 

                        scaleInstance, 

                        this.getPoint(r.getCenterX(), r.getCenterY()),

//                        GEOMETRY_MANAGER.createPoint(r.getCenterX(), r.getCenterY(), SUBTYPES.GEOM2D), 

                        this.getFeature(), 

                        null

                );

            } else {

                double originalSize = getEfectiveSize(getFeature());

                double theSize = originalSize;

                int pq = properties.getPrintQuality();

                switch (pq) {

                    case PrintAttributes.PRINT_QUALITY_NORMAL:

                        theSize *= (double) 300 / 72;

                        break;

                    case PrintAttributes.PRINT_QUALITY_HIGH:

                        theSize *= (double) 600 / 72;

                        break;

                    case PrintAttributes.PRINT_QUALITY_DRAFT:

                        // d *= 72/72; // (which is the same than doing nothing)

                        break;

                    default:

                        break;

                }

                setSize(theSize);

                print(

                        g, 

                        scaleInstance, 

                        this.getPoint(r.getCenterX(), r.getCenterY()),

//                        GEOMETRY_MANAGER.createPoint(r.getCenterX(), r.getCenterY(), SUBTYPES.GEOM2D), 

                        properties

                );

                setSize(originalSize);

            }

        } catch (Exception e) {

            SymbolDrawingException sde = new SymbolDrawingException(TYPES.POINT);

            sde.initCause(e);

            throw sde;

        }

    }

    @Override

    public final void setMask(IMask mask) {

        this.mask = mask;

    }

    @Override

    public void setCartographicSize(double cartographicSize, Geometry geom) {

        setSize(cartographicSize);

    }

    @Override

    public double toCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

        this.viewPort = viewPort;

        this.dpi  = dpi;

        double oldSize = getSize();

        setCartographicSize(getCartographicSize(

                viewPort,

                dpi,

                geom),

                geom);

        return oldSize;

    }

    @Override

    public double getCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

        return CartographicSupportToolkit.

                getCartographicLength(this,

                        getSize(),

                        viewPort,

                        dpi);

    }

    private double toCartographicUnits(double value){

        if(viewPort == null){

            return value;

        }

        return CartographicSupportToolkit.

                getCartographicLength(this,

                        value,

                        viewPort,

                        dpi);

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        AbstractMarkerSymbol copy = (AbstractMarkerSymbol) super.clone();

        // Clone the offset

        if (offset != null) {

            copy.offset = (Point2D) offset.clone();

        }

        // clone the mask

        if (mask != null) {

            copy.mask = (IMask) mask.clone();

        }

        return copy;

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        // Set parent symbol properties

        super.loadFromState(state);

        // Set own properties

        setColor((Color) state.get(FIELD_COLOR));

        setMask((IMask) state.get(FIELD_MASK));

        setOffset((Point2D) state.get(FIELD_OFFSET));

        setRotation(state.getDouble(FIELD_ROTATION));

        setSize(state.getDouble(FIELD_SIZE));

        setDrawLineToOffset(state.getBoolean(FIELD_DRAWLINETOOFFSET, false));

        setLineToOffsetColor((Color) state.get(FIELD_LINETOOFFSETCOLOR));

        setSizeExpression(state.getString(FIELD_SIZE_EXPRESSION));

        setOffsetXExpression(state.getString(FIELD_OFFSETX_EXPRESSION));

        setOffsetYExpression(state.getString(FIELD_OFFSETY_EXPRESSION));

        setRotationExpression(state.getString(FIELD_ROTATION_EXPRESSION));

        setLineToOffsetColorExpression(state.getString(FIELD_LINETOOFFSETCOLOR_EXPRESSION));

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent symbol properties

        super.saveToState(state);

        // Save own properties

        state.set(FIELD_COLOR, getColor());

        state.set(FIELD_MASK, getMask());

        state.set(FIELD_OFFSET, getOffset());

        state.set(FIELD_ROTATION, getRotation());

        state.set(FIELD_SIZE, getSize());

        state.set(FIELD_LINETOOFFSETCOLOR, getLineToOffsetColor());

        state.set(FIELD_DRAWLINETOOFFSET, isDrawLineToOffset());

        state.set(FIELD_OFFSETX_EXPRESSION, getOffsetXExpression());

        state.set(FIELD_OFFSETY_EXPRESSION, getOffsetYExpression());

        state.set(FIELD_SIZE_EXPRESSION, getSizeExpression());

        state.set(FIELD_ROTATION_EXPRESSION, getRotationExpression());

        state.set(FIELD_LINETOOFFSETCOLOR_EXPRESSION, getLineToOffsetColorExpression());

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

                DynStruct definition = manager.addDefinition(

                        AbstractMarkerSymbol.class,

                        MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME,

                        MARKER_SYMBOL_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

                        null,

                        null

                );

                // Extend the Symbol base definition

                definition.extend(manager.getDefinition(SYMBOL_PERSISTENCE_DEFINITION_NAME));

                // Color

                definition.addDynFieldObject(FIELD_COLOR).setMandatory(false).setClassOfValue(Color.class);

                // Mask

                definition.addDynFieldObject(FIELD_MASK).setMandatory(false).setClassOfValue(IMask.class);

                // Offset

                definition.addDynFieldObject(FIELD_OFFSET).setMandatory(false).setClassOfValue(Point2D.class);

                // Rotation

                definition.addDynFieldDouble(FIELD_ROTATION).setMandatory(false);

                // Size

                definition.addDynFieldDouble(FIELD_SIZE).setMandatory(false);

                definition.addDynFieldBoolean(FIELD_DRAWLINETOOFFSET).setMandatory(false);

                definition.addDynFieldObject(FIELD_LINETOOFFSETCOLOR).setClassOfValue(Color.class).setMandatory(false);

                definition.addDynFieldString(FIELD_OFFSETX_EXPRESSION).setMandatory(false);

                definition.addDynFieldString(FIELD_OFFSETY_EXPRESSION).setMandatory(false);

                definition.addDynFieldString(FIELD_LINETOOFFSETCOLOR_EXPRESSION).setMandatory(false);

                definition.addDynFieldString(FIELD_ROTATION_EXPRESSION).setMandatory(false);

                definition.addDynFieldString(FIELD_SIZE_EXPRESSION).setMandatory(false);

            }

            return true;

        }

    }

}