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 org.gvsig.fmap.dal.exception.DataException;

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.type.GeometryType;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.rendering.legend.ISingleSymbolLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.events.SymbolLegendEvent;

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

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

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

    /**

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

        }

    }

    @Override

    public ISymbol getSymbolByFeature(Feature feat) {

        DynamicSymbol symbol = (DynamicSymbol) getDefaultSymbol();

        symbol.setFeature(feat);

        return symbol;

    }

    @Override

    public void useDefaultSymbol(boolean b) {

        LOG.warn("TODO: SingleSymbolLegend.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: SingleSymbolLegend.useDefaultSymbol");

    }

    @Override

    protected String[] getRequiredFeatureAttributeNames(

            FeatureStore featureStore) throws DataException {

        // We only need the default Geometry to draw

        return new String[]{featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName()};

    }

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

        }

    }

}