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.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.logging.Level;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractVectorialLegend;

import static org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractVectorialLegend.VECTORIAL_LEGEND_PERSISTENCE_DEFINITION_NAME;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.VectorialUniqueValueLegend;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author osc

 */

public class DefaultDynamicVectorLegend extends AbstractVectorialLegend implements DynamicVectorLegend {

    final static private Logger LOG = LoggerFactory.getLogger(VectorialUniqueValueLegend.class);

    public static final String DYNAMIC_VECTOR_PERSISTENCE_DEFINITION_NAME

            = "SimgleSymbolLegend";

    public static final String LEGEND_NAME = "DynamicSymbol";

    private ISymbol defaultSymbol;

    private int shapeType = Geometry.TYPES.SURFACE; // Por defecto, tipo pol?gono

    public static Expression expOutlineColor = null;

    public static Expression expFillColor = null;

    public static Expression expSize = null;

    public static Expression expRotation = null;

    public static String[] requiredAttributes = null;

//    public static final String FIELD_OUTLINECOLOR = "COUTLINE";

//    public static final String FIELD_FILLCOLOR = "CFILL";

//    public static final String FIELD_SIZE = "CSIZE";

//    public static final String FIELD_ROTATION = "CROTATION";

    /**

     * Constructor method, needed by persistence.

     */

    public DefaultDynamicVectorLegend() {

    }

    /**

     * Convenience fast constructor.

     *

     * @param style S?mbolo.

     */

    public DefaultDynamicVectorLegend(ISymbol style) {

        setDefaultSymbol(style);

    }

    @Override

    public void setDefaultSymbol(ISymbol s) {

        if (s == null) {

            throw new NullPointerException("Default symbol cannot be null");

        }

        ISymbol old = defaultSymbol;

        defaultSymbol = s;

//        fireDefaultSymbolChangedEvent(new SymbolLegendEvent(old, s));

    }

    public ISymbol getSymbol(int recordIndex) {

        return defaultSymbol;

    }

    @Override

    public ISymbol getDefaultSymbol() {

        if (defaultSymbol == null) {

            SymbologyManager symbolManager = SymbologyLocator.getSymbologyManager();

            defaultSymbol = symbolManager.createDynamicSymbol();

        }

        return defaultSymbol;

    }

    @Override

    public int getShapeType() {

        return shapeType;

    }

    @Override

    public void setShapeType(int shapeType) {

        if (this.shapeType != shapeType) {

            if (defaultSymbol == null || defaultSymbol.getSymbolType() != shapeType) {

                defaultSymbol = getSymbolManager().createSymbol(shapeType);

            }

            this.shapeType = shapeType;

        }

    }

    private Expression getExpressionFromString(String value) {

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

        expression.setPhrase(value);

        return expression;

    }

    public void setOutlineColor(Expression expression) {

        expOutlineColor = expression;

    }

    public void setFillColor(Expression expression) {

        expFillColor = expression;

    }

    public void setSize(Expression expression) {

        expSize = expression;

    }

    public void setRotation(Expression expression) {

        expRotation = expression;

    }

    @Override

    public ISymbol getSymbolByFeature(Feature feat) {

        DynamicSymbol symbol = (DynamicSymbol) getDefaultSymbol();

        symbol.setFillColor(expFillColor);

        symbol.setOutlineColor(expOutlineColor);

        symbol.setSize(expSize);

        symbol.setRotation(expRotation);

        //OFFSET TODO

        Point pointOffset = null;

        String value = "";

        try {

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

            value = pointOffset.convertToWKT();

        } catch (Exception ex) {

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

        }

        Expression offset = getExpressionFromString(value);

        symbol.setOffset(offset);

        try {

            String[] strList = this.getRequiredFeatureAttributeNames((FeatureStore) feat.getStore());

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

            reqAttr.addAll(Arrays.asList(strList));

            symbol.setRequiredFeatureAttributesNames(reqAttr);

        } catch (DataException ex) {

            java.util.logging.Logger.getLogger(DefaultDynamicVectorLegend.class.getName()).log(Level.SEVERE, null, ex);

        }

        symbol.setFeature(feat);

        return symbol;

    }

    @Override

    public void useDefaultSymbol(boolean b) {

        LOG.warn("TODO: DefaultDynamicVectorLegend.useDefaultSymbol");

    }

    public String[] getUsedFields() {

        return new String[0];

    }

    @Override

    public boolean isUseDefaultSymbol() {

        return true;

    }

    public String getClassName() {

        return getClass().getName();

    }

    @Override

    public boolean isSuitableForShapeType(int shapeType) {

        return getShapeType() == shapeType;

    }

    public void setFeatureStore(FeatureStore fs) throws DataException {

        LOG.warn("TODO: DefaultDynamicVectorLegend.useDefaultSymbol");

    }

    @Override

    protected String[] getRequiredFeatureAttributeNames(

            //TODO: Optimizar por obtener solo los campos que usan las expresiones

            FeatureStore featureStore) throws DataException {

        if (requiredAttributes == null) {

            int arraySize = featureStore.getDefaultFeatureType().size();

            requiredAttributes = new String[arraySize];

            for (int i = 0; i < featureStore.getDefaultFeatureType().size(); i++) {

                FeatureAttributeDescriptor att = featureStore.getDefaultFeatureType().get(i);

                requiredAttributes[i] = att.getName();

            }

        }

        return requiredAttributes;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DynamicVectorLegend clone = (DynamicVectorLegend) super.clone();

//        // Clone default symbol

//        if (defaultSymbol != null) {

//            clone.defaultSymbol = (ISymbol) defaultSymbol.clone();

//        }

        return clone;

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        super.loadFromState(state);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

    }

    public static class RegisterPersistence implements Callable {

        @Override

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

                DynStruct definition = manager.addDefinition(

                        DynamicVectorLegend.class,

                        DYNAMIC_VECTOR_PERSISTENCE_DEFINITION_NAME,

                        DYNAMIC_VECTOR_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

                        null,

                        null

                );

                // Extend the Vectorial Legend base definition

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

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        @Override

        public Object call() throws Exception {

            MapContextManager manager = MapContextLocator.getMapContextManager();

//            manager.registerLegend(ISingleSymbolLegend.LEGEND_NAME,

            manager.registerLegend(LEGEND_NAME,

                    DynamicVectorLegend.class);

            return Boolean.TRUE;

        }

    }

}