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

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

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

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

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

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

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

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 = null;

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

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

    public static Expression eOutlineColor = null;

    public static Expression eFillColor = null;

    public static Expression eSize = null;

    public static Expression eRotation = null;

    private final boolean isShapeVisible = true;

    private ISimpleMarkerSymbol pointSymbol = null;

    private ISimpleLineSymbol lineSymbol = null;

    private ISimpleFillSymbol polygonSymbol = null;

    public FeatureSymbolTable featureSymbolTable = null;

    public SymbolTable symbolTable = null;

    private Expression eOffset;

    private List<String> listRequiredAttributeNames;

    public DefaultDynamicSymbol() {

        symbolTable = ExpressionEvaluatorLocator.getManager().createSymbolTable();

        featureSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();

        symbolTable.addSymbolTable(featureSymbolTable);

    }

    @Override

    public void setFeature(Feature feat) {

        feature = feat;

        if (featureSymbolTable == null) {

            getFeatureSymbolTable();

        }

        featureSymbolTable.setFeature(feat);

    }

    @Override

    public DynamicSymbol clone() throws CloneNotSupportedException {

        return null;

    }

    @Override

    public ISymbol getSymbolForSelection() {

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

        if (GeometryUtils.isSubtype(Geometry.TYPES.POINT, typeGeom)

                || GeometryUtils.isSubtype(Geometry.TYPES.MULTIPOINT, typeGeom)) {

            setPointSymbolValues();

            pointSymbol.setColor(MapContext.getSelectionColor());

            pointSymbol.setOutlineColor(MapContext.getSelectionColor());

            return pointSymbol;

        } else if (GeometryUtils.isSubtype(Geometry.TYPES.CURVE, typeGeom)

                || GeometryUtils.isSubtype(Geometry.TYPES.MULTICURVE, typeGeom)) {

            setLineSymbolValues();

            lineSymbol.setColor(MapContext.getSelectionColor());

            return lineSymbol;

        } else if (GeometryUtils.isSubtype(Geometry.TYPES.SURFACE, typeGeom)

                || GeometryUtils.isSubtype(Geometry.TYPES.MULTISURFACE, typeGeom)) {

            setPolygonSymbolValues();

            polygonSymbol.setFillColor(MapContext.getSelectionColor());

            return polygonSymbol;

        } else {

            return null;

        }

    }

    @Override

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

        Color c = getColor(); //TODO

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

        if (GeometryUtils.isSubtype(Geometry.TYPES.POINT, typeGeom)

                || GeometryUtils.isSubtype(Geometry.TYPES.MULTIPOINT, typeGeom)) {

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

        } else if (GeometryUtils.isSubtype(Geometry.TYPES.CURVE, typeGeom)

                || GeometryUtils.isSubtype(Geometry.TYPES.MULTICURVE, typeGeom)) {

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

        } else if (GeometryUtils.isSubtype(Geometry.TYPES.SURFACE, typeGeom)

                || GeometryUtils.isSubtype(Geometry.TYPES.MULTISURFACE, typeGeom)) {

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

        } else {

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

        setPolygonSymbolValues();

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

    }

    protected void setPolygonSymbolValues() {

        if (polygonSymbol == null) {

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

        }

        setLineSymbolValues();

        lineSymbol.setColor(getComputedOutlineColor());

        polygonSymbol.setOutline(lineSymbol);

        polygonSymbol.setFillColor(getComputedFillColor());

        polygonSymbol.setHasOutline(true);

        polygonSymbol.setHasFill(true);

    }

    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 setPointSymbolValues() {

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

    }

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

        setPointSymbolValues();

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

            if (feature != null) {

                fst.setFeature(feature);

            }

            symbolTable = s;

        }

        return symbolTable;

    }

    @Override

    public Color getColor() {

        Expression value = this.getComputedColor();

        return getColorFromExpression(value);

    }

    public Expression getComputedColor() {

        return eFillColor;

    }

    public Expression getOutlineColor() {

        return eOutlineColor;

    }

    public Color getComputedOutlineColor() {

        return getColorFromExpression(getOutlineColor());

    }

    public void setOutlineColor(Expression exp) {

        eOutlineColor = exp;

    }

    public Expression getFillColor() {

        return eFillColor;

    }

    public Color getComputedFillColor() {

        return getColorFromExpression(getFillColor());

    }

    public void setFillColor(Expression exp) {

        eFillColor = exp;

    }

    public Expression getSize() {

        return eSize;

    }

    public int getComputedSize() {

        Expression exp = getSize();

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

        return size;

    }

    public void setSize(Expression exp) {

        eSize = exp;

    }

    public Expression getOffset() {

        return eOffset;

    }

    public void setOffset(Expression offset) {

        eOffset = offset;

    }

    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 Expression getRotation() {

        return eRotation;

    }

    public int getComputedRotation() {

        Expression exp = getRotation();

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

        return size;

    }

    public void setRotation(Expression exp) {

        eRotation = exp;

    }

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

        eOutlineColor = 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 {

        return this.listRequiredAttributeNames;

    }

    public void setRequiredFeatureAttributesNames(List<String> listRequiredAttributeNames) {

        this.listRequiredAttributeNames = listRequiredAttributeNames;

    }

    public static void selfRegister() {

        MapContextLocator.getSymbolManager().registerSymbol(NAME, DefaultDynamicSymbol.class);

    }

}