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.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.ExpressionBuilder;

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.marker.IMarkerSymbol;

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 {

    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_OFFSETX_EXPRESSION = "offsetXExpression";

    private static final String FIELD_OFFSETY_EXPRESSION = "offsetYExpression";

    private static final String FIELD_ROTATION_EXPRESSION = "rotationExpression";

    private static final String FIELD_DRAWLINETOOFFSET = "drawLineToOffsetExpression";

    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 boolean drawLineToOffset;

    private String offsetXExpression;

    private String offsetYExpression;

    private String rotationExpression;

    private String lineToOffsetColorExpression;

    public AbstractMarkerSymbol() {

        super();

        color = MapContextLocator.getSymbolManager()

                .getSymbolPreferences()

                .getDefaultSymbolFillColor();

    }

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

    private SymbolTable getSymbolTable(Feature f) {

        if( symbolTable==null ) {

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

        }

        symbolTable.setFeature(f);

        return symbolTable;

    }

    public String getOffsetXExpression() {

        return offsetXExpression;

    }

    public void setOffsetXExpression(String offsetXExpression) {

        this.offsetXExpression = StringUtils.trimToNull(offsetXExpression);

    }

    public String getOffsetYExpression() {

        return offsetYExpression;

    }

    public void setOffsetYExpression(String offsetYExpression) {

        this.offsetYExpression = StringUtils.trimToNull(offsetYExpression);

    }

    public String getRotationExpression() {

        return rotationExpression;

    }

    public void setRotationExpression(String rotationExpression) {

        this.rotationExpression = StringUtils.trimToNull(rotationExpression);

    }

    public Color getLineToOffsetColor() {

        return this.getLineToOffsetColor(null);

    }

    public Color getLineToOffsetColor(Feature f) {

        return ExpressionUtils.parseColor(this.getSymbolTable(f), this.lineToOffsetColorExpression, Color.BLACK);

    }

    public String getLineToOffsetColorExpression() {

        return this.lineToOffsetColorExpression;

    }

    public void setLineToOffsetColorExpression(String lineToOffsetColorExpression) {

        this.lineToOffsetColorExpression = StringUtils.trimToNull(lineToOffsetColorExpression);

    }

    public void setLineToOffsetColor(Color lineToOffsetColor) {

        ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

        this.lineToOffsetColorExpression = StringUtils.trimToNull(builder.color(color).toString());

    }

    public boolean isDrawLineToOffset() {

        return this.isDrawLineToOffset(null);

    }

    public boolean isDrawLineToOffset(Feature f) {

        return this.drawLineToOffset;

    }

    public void setDrawLineToOffset(boolean drawLineToOffset) {

        this.drawLineToOffset = drawLineToOffset;

    }

    public Point2D getEfectiveOffset(Feature f) {

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

            return this.getOffset();

        }

        int offsetX = ExpressionUtils.parseInt(this.getSymbolTable(f), offsetXExpression, (int) this.getOffset().getX());

        int offsetY = ExpressionUtils.parseInt(this.getSymbolTable(f), offsetYExpression, (int) this.getOffset().getY());

        Point p = new Point(offsetX, offsetY);

        return p;

    }

    public double getEfectiveRotation(Feature f) {

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

            return this.getRotation();

        }

        double r = ExpressionUtils.parseDouble(this.getSymbolTable(f), rotationExpression, this.getRotation());

        return r;

    }

    @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 = getSize();

        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, null, 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, GEOMETRY_MANAGER.createPoint(r.getCenterX(), r.getCenterY(), SUBTYPES.GEOM2D), null, null);

            } else {

                double originalSize = getSize();

                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, GEOMETRY_MANAGER.createPoint(r.getCenterX(), r.getCenterY(), SUBTYPES.GEOM2D), properties);

                setSize(originalSize);

            }

        } catch (CreateGeometryException e) {

            throw new SymbolDrawingException(TYPES.POINT);

        }

    }

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

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

    }

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

        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_OFFSETX_EXPRESSION, getOffsetXExpression());

        state.set(FIELD_OFFSETY_EXPRESSION, getOffsetYExpression());

        state.set(FIELD_ROTATION_EXPRESSION, getRotationExpression());

        state.set(FIELD_DRAWLINETOOFFSET, isDrawLineToOffset());

        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(true);

                definition.addDynFieldBoolean(FIELD_DRAWLINETOOFFSET).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);

            }

            return true;

        }

    }

}