Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.dynamiclegend;

import java.awt.BasicStroke;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.Stroke;

import java.awt.geom.AffineTransform;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.ISimpleFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.impl.SimpleFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ISimpleLineSymbol;

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

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol.CIRCLE_STYLE;

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol.CROSS_STYLE;

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol.DIAMOND_STYLE;

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol.SQUARE_STYLE;

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol.STAR_STYLE;

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol.TRIANGLE_STYLE;

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol.VERTICAL_LINE_STYLE;

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol.X_STYLE;

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

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

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

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

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

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.Cancellable;

import org.slf4j.LoggerFactory;

public class DefaultDynamicSymbol implements DynamicSymbol {

    private Feature feature;

    private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(SimpleFillSymbol.class);

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

    public static final String OUTLINECOLOR = "COUTLINE";

    public static final String FILLCOLOR = "CFILL";

    public static final String SIZE = "CSIZE";

    private MutableSymbolTable symbolTable;

    private final boolean isShapeVisible = true;

    private ISimpleMarkerSymbol pointSymbol = null;

    private ISimpleLineSymbol lineSymbol = null;

    private ISimpleFillSymbol polygonSymbol = null;

    public DefaultDynamicSymbol() {

        feature = null;

    }

    @Override

    public void setFeature(Feature feat) {

        feature = feat;

    }

    @Override

    public DynamicSymbol clone() throws CloneNotSupportedException {

        return null;

    }

    private DynamicSymbol symbolForSelection;

    @Override

    public ISymbol getSymbolForSelection() {

        if (symbolForSelection == null) {

            DynamicSymbol selectionSymbol;

            try {

                selectionSymbol = (DynamicSymbol) this.clone();

                if (selectionSymbol != null) {

//                    selectionSymbol.setHasFill(true);

//                    setSymbolForSelection(selectionSymbol);

                }

            } catch (CloneNotSupportedException ex) {

//                Logger.getLogger(DefaultDynamicSymbol.class.getName()).log(Level.SEVERE, null, ex);

            }

        } else {

            symbolForSelection.setColor(MapContext.getSelectionColor());

        }

        return symbolForSelection;

    }

    @Override

    public void draw(Graphics2D g, AffineTransform affineTransform, Geometry geom, Feature f, Cancellable cancel) {

        Color c = getColor(); //TODO

        int typeGeom = geom.getGeometryType().getType();

        if (typeGeom == Geometry.TYPES.POINT || typeGeom == Geometry.TYPES.MULTIPOINT) {

            drawPoint(g, affineTransform, geom, f, cancel);

        } else if (typeGeom == Geometry.TYPES.LINE || typeGeom == Geometry.TYPES.MULTILINE) {

            drawLine(g, affineTransform, geom, f, cancel);

        } else if (typeGeom == Geometry.TYPES.POLYGON || typeGeom == Geometry.TYPES.MULTIPOLYGON) {

            drawPolygon(g, affineTransform, geom, f, cancel);

        } else if (true) {

            // Optimiza el pintado de geometrias grandes.

            try {

                Geometry env = geom.getEnvelope().getGeometry();

                env.transform(affineTransform);

                Envelope env2 = env.getEnvelope();

                if (env2.getLength(0) < 1.5 && env2.getLength(1) < 1.5) {

                    geom = env2.getUpperCorner();

                }

            } catch (Exception ex) {

                LOG.warn("Error optimizing the drawing of the geometry. Continues with normal drawing.", ex);

                // Do nothing, continue with the draw of the original geometry

            }

            g.setColor(c);

            g.fill(geom.getShape(affineTransform));

            g.draw(geom.getShape(affineTransform));

        }

    }

    protected void drawPolygon(Graphics2D g, AffineTransform affineTransform, Geometry geom, Feature f, Cancellable cancel) {

        if (polygonSymbol == null) {

            polygonSymbol = SymbologyLocator.getSymbologyManager().createSimpleFillSymbol();

        }

        setLineSymbolValues();

        lineSymbol.setColor(getComputedOutlineColor());

        polygonSymbol.setOutline(lineSymbol);

        polygonSymbol.setFillColor(getComputedFillColor());

        polygonSymbol.setHasOutline(true);

        polygonSymbol.setHasFill(true);

        polygonSymbol.draw(g, affineTransform, geom, f, cancel);

    }

    protected void setLineSymbolValues() {

        if (lineSymbol == null) {

            lineSymbol = SymbologyLocator.getSymbologyManager().createSimpleLineSymbol();

        }

        lineSymbol.setLineColor(getComputedFillColor());

        lineSymbol.setLineWidth(getComputedSize());

        ISimpleLineStyle lineStyle = SymbologyLocator.getSymbologyManager().createSimpleLineStyle();

        lineStyle.setOffset(0);

//        Stroke stroke = lineStyle.getStroke();

        BasicStroke stroke = new BasicStroke(getComputedSize(),

                BasicStroke.CAP_BUTT,

                BasicStroke.JOIN_MITER);

        lineStyle.setStroke(stroke);

        lineSymbol.setLineStyle(lineStyle);

    }

    protected void drawLine(Graphics2D g, AffineTransform affineTransform, Geometry geom, Feature f, Cancellable cancel) {

        setLineSymbolValues();

        lineSymbol.draw(g, affineTransform, geom, f, cancel);

    }

    protected void drawPoint(Graphics2D g, AffineTransform affineTransform, Geometry geom, Feature f, Cancellable cancel) {

        if (pointSymbol == null) {

            pointSymbol = SymbologyLocator.getSymbologyManager().createSimpleMarkerSymbol();

        }

        pointSymbol.setColor(getColor());

        pointSymbol.setSize(getComputedSize());

        pointSymbol.setRotation(0);

        pointSymbol.setStyle(IMarkerSymbol.CIRCLE_STYLE);

        pointSymbol.setOutlined(true);

        pointSymbol.setOutlineSize(2);

        pointSymbol.setOutlineColor(getComputedOutlineColor());

        pointSymbol.draw(g, affineTransform, geom, f, cancel);

    }

    @Override

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

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public boolean isOneDotOrPixel(Geometry geom, double[] positionOfDotOrPixel, ViewPort viewPort, int dpi) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public int getOnePointRgb() {

        return Color.ORANGE.getRGB();

    }

    @Override

    public String getDescription() {

        return "";

    }

    @Override

    public boolean isShapeVisible() {

        return isShapeVisible;

    }

    @Override

    public void setDescription(String desc) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public int getSymbolType() {

        int type = feature.getDefaultGeometry().getGeometryType().getType();

        return type;

    }

    @Override

    public boolean isSuitableFor(Geometry geom) {

        return true;

    }

    @Override

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

        throw new UnsupportedOperationException("Not supported yet.");

    }

    public SymbolTable getFeatureSymbolTable() {

        if (symbolTable == null) {

            MutableSymbolTable s = ExpressionEvaluatorLocator.getManager().createSymbolTable();

            FeatureSymbolTable fst = DALLocator.getDataManager().createFeatureSymbolTable();

            s.addSymbolTable(fst);

            fst.setFeature(feature);

            symbolTable = s;

        }

        return symbolTable;

    }

    @Override

    public Color getColor() {

        Expression value = this.getComputedColor();

        return getColorFromExpression(value);

    }

    public Expression getComputedColor() {

        String value = feature.get(FILLCOLOR).toString();

        Expression expression = getExpressionFromString(value);

        return expression;

    }

    public Expression getOutlineColor() {

        String value = feature.get(OUTLINECOLOR).toString();

        Expression expression = getExpressionFromString(value);

        return expression;

    }

    public Color getComputedOutlineColor() {

        return getColorFromExpression(getOutlineColor());

    }

    public void setOutlineColor(Expression exp) {

    }

    public Expression getFillColor() {

        String value = feature.get(FILLCOLOR).toString();

        Expression expression = getExpressionFromString(value);

        return expression;

    }

    public Color getComputedFillColor() {

        return getColorFromExpression(getFillColor());

    }

    public void setFillColor(Expression exp) {

    }

    public Expression getSize() {

        String value = feature.get(SIZE).toString();

        Expression expression = getExpressionFromString(value);

        return expression;

    }

    public int getComputedSize() {

        Expression exp = getSize();

        Integer size = (Integer) exp.execute(getFeatureSymbolTable());

        return size;

    }

    public void setSize(Expression exp) {

    }

    public Expression getOffset() {

        // TODO

        Point pointOffset = null;

        String value = "";

        try {

            pointOffset = GeometryLocator.getGeometryManager().createPoint(0, 0, Geometry.SUBTYPES.GEOM2D);

            value = pointOffset.convertToWKT();

        } catch (Exception ex) {

            Logger.getLogger(DefaultDynamicSymbol.class.getName()).log(Level.SEVERE, null, ex);

        }

        Expression expression = getExpressionFromString(value);

        return expression;

    }

    public Point getComputedOffset() {

//        Expression exp = getSize();

//        Integer size = (Integer) exp.execute(getFeatureSymbolTable());

        Point pointOffset = null;

        try {

            pointOffset = GeometryLocator.getGeometryManager().createPoint(0, 0, Geometry.SUBTYPES.GEOM2D);

        } catch (CreateGeometryException ex) {

            Logger.getLogger(DefaultDynamicSymbol.class.getName()).log(Level.SEVERE, null, ex);

        }

        return pointOffset;

    }

    public void setOffset(Expression exp) {

    }

    public Expression getRotation() {

//        String value = feature.get(SIZE).toString();

        String value = "0";

        Expression expression = getExpressionFromString(value);

        return expression;

    }

    public int getComputedRotation() {

        Expression exp = getRotation();

        Integer size = (Integer) exp.execute(getFeatureSymbolTable());

        return size;

    }

    public void setRotation(Expression exp) {

    }

    private Expression getExpressionFromString(String value) {

        Expression expression = ExpressionEvaluatorLocator.getManager().createExpression();

        expression.setPhrase(value);

        return expression;

    }

    private Color getColorFromExpression(Expression exp) {

        Integer rgbcolor = (Integer) exp.execute(getFeatureSymbolTable());

        Color color = new Color(rgbcolor, true);

        return color;

    }

    public Object getComputedValue(String field) {

        Object value;

        value = feature.get(field);

        return value;

    }

    @Override

    public void setColor(Color color) {

    }

    @Override

    public void setColor(Expression color) {

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

    }

    @Override

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

        if (shape.getGeometryType().getType() == Geometry.TYPES.POLYGON) {

            Color c = getColor();

            if (c != null) {

                g.setColor(c);

                g.fill(shape.getShape(at));

            }

            if (getComputedOutlineColor() != null) {

//                getOutline().print(g, at, geom, properties);

            }

        } else if (shape.getGeometryType().getType() == Geometry.TYPES.POINT) {

            double originalSize = getComputedSize();

//            double size = originalSize;

//            // scale it to size

//            int pq = properties.getPrintQuality();

//            switch (pq) {

//                case PrintAttributes.PRINT_QUALITY_NORMAL:

//                    size *= (double) 300 / 72;

//                    break;

//                case PrintAttributes.PRINT_QUALITY_HIGH:

//                    size *= (double) 600 / 72;

//                    break;

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

//                case PrintAttributes.PRINT_QUALITY_DRAFT:

//                    break;

//                default:

//                    break;

//            }

//                setSize(size);

            draw(g, at, shape, null, null);

//                setSize(originalSize);

        }

    }

    @Override

    public List<String> getRequiredFeatureAttributeNames(FeatureStore featureStore) throws DataException {

        List<String> myList = new ArrayList<>();

        myList.add(OUTLINECOLOR);

        myList.add(FILLCOLOR);

        myList.add(SIZE);

        return myList;

    }

}