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 java.awt.Color;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.geom.Point2D;

import org.apache.commons.lang3.StringUtils;

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.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.symbology.fmap.mapcontext.rendering.symbol.impl.AbstractSymbol;

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

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 rotationDegrees;

    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;

    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 this.getRotationInDegrees();

    }

    @Override

    public void setRotation(double r) {

        this.setRotationInDegrees(r);

    }

    public double getRotationInDegrees() {

        return rotationDegrees;

    }

    public void setRotationInDegrees(double r) {

        this.rotationDegrees = r;

        this.setRotationExpression(null);

    }

    public double getRotationInRadians() {

        return Math.toRadians(rotationDegrees);

    }

    public void setRotationInRadians(double r) {

        this.rotationDegrees = Math.toDegrees(r);

        this.setRotationExpression(null);

    }

    @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) {

        if (StringUtils.isBlank(this.rotationExpression)) {

            return this.getRotationInDegrees();

        }

        // Por defecto vedra en grados.

        if (f == null) {

            f = this.getFeature();

        }

        if (f == null) {

            return this.getRotationInDegrees();

        }

        double r = ExpressionUtils.parseDouble(

                this.getSymbolTable(f),

                rotationExpression,

                this.getRotationInDegrees()

        );

        return r;

    }

    @Override

    public double getEfectiveRotationInRadians(Feature f) {

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

        if (StringUtils.isBlank(this.rotationExpression)) {

            return this.getRotationInRadians();

        }

        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 (StringUtils.isBlank(this.sizeExpression)) {

            return this.getCartographicSize();

        }

        if (f == null) {

            f = this.getFeature();

        }

        if (f == null) {

            return this.getCartographicSize();

        }

        double sz = ExpressionUtils.parseDouble(

                this.getSymbolTable(f),

                this.sizeExpression,

                -1

        );

        if (sz < 0) {

            return this.getCartographicSize();

        }

        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;

        this.setSizeExpression(null);

    }

    @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) {

//        setCartographicContext(viewPort, dpi, geom);

//        float cs = (float) getCartographicSize();

//        distances[0] = cs;

//        distances[1] = cs;

//    }

    @Override

    public final IMask getMask() {

        return mask;

    }

    @Override

    public final void setMask(IMask mask) {

        this.mask = mask;

    }

    protected double getCartographicSize() {

        return toCartographicUnits(getSize());

    }

    @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;

        }

    }

    protected double getAdjustedSize(Rectangle r, double size) {

        if (r == null) {

            return size;

        }

        double min = Math.min(r.getHeight(), r.getWidth());

        if (size > min) {

            size = min;

        }

        return size;

    }

    protected Geometry getSampleGeometry(Rectangle r) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        try {

            return geomManager.createEnvelope(

                    r.x + 1,

                    r.y + 1,

                    r.x + r.width - 2,

                    r.y + r.height - 2,

                    Geometry.SUBTYPES.GEOM2D).getGeometry();

        } catch (Exception e) {

            throw new RuntimeException("Can't create smple geometry.", e);

        }

    }

}