Application: gvSIG desktop » gvSIG legends: base legends

package org.gvsig.symbology.fmap.rendering;

import java.util.ArrayList;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.gvsig.fmap.geom.Geometry;

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

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

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

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

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

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

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

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

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

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;

/**

 * Implements a legend where the user can compare two different characteristics

 * of a region in the map. These two "fields" will be compared, on one side,

 * using a color for the region and , on the other side, using a graduated symbol.

 * Both methods will change (the color or the size of the symbol) depending on

 * the value of the fields.

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 */

public class QuantityByCategoryLegend extends AbstractClassifiedVectorLegend {

    private static final Logger logger =

        LoggerFactory.getLogger(QuantityByCategoryLegend.class);

    public static final String

    QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME =

    "QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME";

    public static final String

    QUANTITY_BY_CATEGORY_LEGEND_NAME = "QUANTITY_BY_CATEGORY_LEGEND_NAME";

        private GraduatedSymbolsLegend graduatedSymbol;

        private VectorialIntervalLegend colorRamp;

        private ISymbol defaultSymbol = null;

        private int shapeType = Geometry.TYPES.SURFACE;

        private boolean isUseDefaultSymbol;

        // private DataSource ds;

        public QuantityByCategoryLegend() {

                graduatedSymbol = new GraduatedSymbolsLegend();

                colorRamp = new VectorialIntervalLegend(getShapeType());

                this.setShapeType(Geometry.TYPES.SURFACE);

                ISymbol def = MapContextLocator.getSymbolManager().

            createSymbol(getShapeType());

                this.setDefaultSymbol(def);

        }

        public void clear() {

                colorRamp.clear();

                graduatedSymbol.clear();

        }

        public String[] getClassifyingFieldNames() {

                ArrayList<String> l = new ArrayList<String>();

                for (int i = 0; i < graduatedSymbol.getClassifyingFieldNames().length; i++) {

                        l.add(graduatedSymbol.getClassifyingFieldNames()[i]);

                }

                for (int i = 0; i < colorRamp.getClassifyingFieldNames().length; i++) {

                        l.add(colorRamp.getClassifyingFieldNames()[i]);

                }

                return l.toArray(new String[l.size()]);

        }

        @Override

        public int[] getClassifyingFieldTypes() {

        ArrayList<Integer> l = new ArrayList<Integer>();

        for (int i = 0; i < graduatedSymbol.getClassifyingFieldTypes().length; i++) {

            l.add(graduatedSymbol.getClassifyingFieldTypes()[i]);

        }

        for (int i = 0; i < colorRamp.getClassifyingFieldTypes().length; i++) {

            l.add(colorRamp.getClassifyingFieldTypes()[i]);

        }

        int len = l.size();

        int[] resp = new int[len];

        for (int i=0; i<len; i++) {

            resp[i] = l.get(i).intValue();

        }

        return resp;

        }

        public void setClassifyingFieldTypes(int[] fieldTypes) {

                if (fieldTypes.length == 2) {

                colorRamp.setClassifyingFieldTypes(new int[] {fieldTypes[1]});

                graduatedSymbol.setClassifyingFieldTypes(new int[] {fieldTypes[0]});

                } else {

                    logger.info("Error: Unexpected array size (should be 2)");

                }

                super.setClassifyingFieldTypes(fieldTypes);

        }

        /**

         * Sets the field names required to build this legend. In this case

         * fieldNames is an array of length 2 where the first element is

         * the field name for the embedded GraduatedSymbolLegend, and the

         * second is the field name for the embedded colorRamp (VectorialIntervalLegend)

         * legend.

         */

        public void setClassifyingFieldNames(String[] fieldNames) {

                if (fieldNames.length == 2) {

                colorRamp.setClassifyingFieldNames(new String[] {fieldNames[1]});

                graduatedSymbol.setClassifyingFieldNames(new String[] {fieldNames[0]});

                } else {

            logger.info("Error: Unexpected array size (should be 2)");

                }

                super.setClassifyingFieldNames(fieldNames);

        }

        public void addSymbol(Object key, ISymbol symbol) {

//                System.out.println("adding "+key+"["+symbol+"]");

                if(symbol instanceof IFillSymbol)

                        colorRamp.addSymbol(key, symbol);

                else if(symbol instanceof IMarkerSymbol)

                        graduatedSymbol.addSymbol(key, symbol);

                fireClassifiedSymbolChangeEvent(

                    new SymbolLegendEvent(null, symbol));

        }

        public void delSymbol(Object key) {

                colorRamp.delSymbol(key);

                graduatedSymbol.delSymbol(key);

                fireClassifiedSymbolChangeEvent(

                                new SymbolLegendEvent(

                                                null,

                                                null));

        }

        public String[] getDescriptions() {

                String[] desc1 = colorRamp.getDescriptions();

                String[] desc2 = graduatedSymbol.getDescriptions();

        Object[] objects1 = colorRamp.getValues();

        Object[] objects2 = graduatedSymbol.getValues();

        List descriptionsList = new ArrayList<String>();

        for (int i = 0; i < objects1.length; i++) {

            //Pretend?a saltar el valor por defecto pero no es necesario si en getValues se pone como clave null

//            if(objects1[i] instanceof IInterval){

                descriptionsList.add(desc1[i]);

//            }

        }

        for (int i = 0; i < objects2.length; i++) {

            //Pretend?a saltar el valor por defecto pero no es necesario si en getValues se pone como clave null

//            if(objects2[i] instanceof IInterval){

                descriptionsList.add(desc2[i]);

//            }

        }

        String[] descriptions = new String[descriptionsList.size()];

        descriptions = (String[]) descriptionsList.toArray(descriptions);

        return descriptions;

        }

        public ISymbol[] getSymbols() {

                ISymbol[] symbols1 = colorRamp.getSymbols();

                ISymbol[] symbols2 = graduatedSymbol.getSymbols();

            Object[] objects1 = colorRamp.getValues();

            Object[] objects2 = graduatedSymbol.getValues();

        List symbolsList = new ArrayList<ISymbol>();

        for (int i = 0; i < objects1.length; i++) {

            //Pretend?a saltar el valor por defecto pero no es necesario si en getValues se pone como clave null

//            if(objects1[i] instanceof IInterval){

                symbolsList.add(symbols1[i]);

//            }

        }

        for (int i = 0; i < objects2.length; i++) {

            //Pretend?a saltar el valor por defecto pero no es necesario si en getValues se pone como clave null

//            if(objects2[i] instanceof IInterval){

                symbolsList.add(symbols2[i]);

//            }

        }

        ISymbol[] symbols = new ISymbol[symbolsList.size()];

        symbols = (ISymbol[]) symbolsList.toArray(symbols);

        return symbols;

        }

        public Object[] getValues() {

                Object[] objects1 = colorRamp.getValues();

                Object[] objects2 = graduatedSymbol.getValues();

                List objectsList = new ArrayList<IInterval>();

                for (int i = 0; i < objects1.length; i++) {

            if(objects1[i] instanceof IInterval){

                objectsList.add(objects1[i]);

            } else {

                objectsList.add(null); //Si no es un IInterval es el valor por defecto

            }

        }

        for (int i = 0; i < objects2.length; i++) {

            if(objects2[i] instanceof IInterval){

                objectsList.add(objects2[i]);

            } else {

                objectsList.add(null); //Si no es un IInterval es el valor por defecto

            }

        }

        Object[] objects = new IInterval[objectsList.size()];

        objects = objectsList.toArray(objects);

                return objects;

        }

        public Object clone() throws CloneNotSupportedException {

            QuantityByCategoryLegend resp =

                (QuantityByCategoryLegend) super.clone();

        resp.setShapeType(this.getShapeType());

            resp.useDefaultSymbol(this.isUseDefaultSymbol());

            ISymbol defsym = this.getDefaultSymbol();

            defsym = (ISymbol) defsym.clone();

            resp.setDefaultSymbol(defsym);

            GraduatedSymbolsLegend gleg = this.getGraduatedSymbolsLegend();

            gleg = (GraduatedSymbolsLegend) gleg.cloneLegend();

            resp.setGraduateSymbolLegend(gleg);

            VectorialIntervalLegend interleg = this.getColorRampLegend();

            interleg = (VectorialIntervalLegend) interleg.cloneLegend();

            resp.setColorRampLegend(interleg);

                return resp;

        }

        /**

         * Obtains the GraduatedSymbolLegend

         *

         * @return GraduatedSymbolLegend

         */

        public GraduatedSymbolsLegend getGraduatedSymbolsLegend() {

                return graduatedSymbol;

        }

        /**

         * Obtains the VectorialIntervalLegend

         *

         * @return VectorialIntervalLegend

         */

        public VectorialIntervalLegend getColorRampLegend() {

                return colorRamp;

        }

        /*

        public void setDataSource(DataSource ds) throws FieldNotFoundException, ReadDriverException {

                // TODO remove it when FLyrVect.forTestOnlyVariableUseIterators_REMOVE_THIS_FIELD is removed

//                if (FLyrVect.forTestOnlyVariableUseIterators_REMOVE_THIS_FIELD) {

                        this.ds = ds;

//                }

                graduatedSymbol.setDataSource(ds);

                colorRamp.setDataSource(ds);

        }

        */

        /*

        public ISymbol getSymbol(int i) {

                IMarkerSymbol sym1 = (IMarkerSymbol) graduatedSymbol.getSymbol(i);

                ISymbol sym2 =  colorRamp.getSymbol(i);

                IMultiLayerSymbol multiSym = null;

                int shpt = this.getShapeType();

                if (isPolygonal(shpt)) {

            // symbol from the GraduatedSymbolLegend is a marker, but

            // what we need is a fill symbol. Will use a MarkerFillSymbol

            // to enable support for Polygons

            MarkerFillSymbol aux = new MarkerFillSymbol();

            // tell the fill style to draw the IMarkerSymbol

            // as a IFillSymbol centering it in the shape polygon

            // centroid and applying offset (if any).

            aux.setMarker(sym1);

            SimpleMarkerFillPropertiesStyle p =

                new SimpleMarkerFillPropertiesStyle();

            p.setFillStyle(SimpleMarkerFillPropertiesStyle.SINGLE_CENTERED_SYMBOL);

            aux.setMarkerFillProperties(p);

            multiSym = MapContextLocator.getSymbolManager().

                createMultiLayerSymbol(Geometry.TYPES.SURFACE);

            multiSym.addLayer(sym2);

            multiSym.addLayer(aux);

            break;

                } else {

                    logger.info("Error: unexpected shape type (should be surface): " + shpt);

                }

                return multiSym;

        }

        */

        public ISymbol getSymbolByFeature(Feature feat) throws MapContextException {

                ISymbol sym1 = null, sym2 = null;

                sym1 = graduatedSymbol.getSymbolByFeature(feat);

                // Ensure fill symbol

                sym1 = GraduatedSymbolsLegend.toFillSymbol(sym1);

                sym2 = colorRamp.getSymbolByFeature(feat);

                IMultiLayerSymbol multiSym = null;

                int shpt = this.getShapeType();

                if (isPolygonal(shpt)) {

            multiSym = MapContextLocator.getSymbolManager().

                createMultiLayerSymbol(Geometry.TYPES.SURFACE);

            if (sym2 != null) multiSym.addLayer(sym2);

            if (sym1 != null) multiSym.addLayer(sym1);

                } else {

                    logger.info("Error: unexpected shape type (should be surface): " + shpt);

                }

                return multiSym;

        }

        public void setShapeType(int shpt) {

            this.shapeType = shpt;

            ISymbol sym = null;

                graduatedSymbol.setShapeType(Geometry.TYPES.POINT);

                sym = MapContextLocator.getSymbolManager().createSymbol(

                    Geometry.TYPES.POINT);

                graduatedSymbol.setDefaultSymbol(sym);

                colorRamp.setShapeType(shpt);

                sym = MapContextLocator.getSymbolManager().createSymbol(shpt);

                colorRamp.setDefaultSymbol(sym);

        }

        public boolean isUseDefaultSymbol() {

                return isUseDefaultSymbol;

        }

        public void useDefaultSymbol(boolean b) {

                this.isUseDefaultSymbol = b;

        }

        public void setGraduateSymbolLegend(GraduatedSymbolsLegend legend) {

                this.graduatedSymbol = legend;

        }

        public void setColorRampLegend(VectorialIntervalLegend legend) {

                this.colorRamp = legend;

        }

        public String getClassName() {

                return getClass().getName();

        }

        public void replace(ISymbol oldSymbol, ISymbol newSymbol) {

                ISymbol[] symbols;

                // look first in the graduated symbol legend

                symbols = graduatedSymbol.getSymbols();

                for (int i = 0; i < symbols.length; i++) {

                        if (symbols[i].equals(oldSymbol)) {

                                graduatedSymbol.replace(oldSymbol, newSymbol);

                                return;

                        }

                }

                // if the symbol wasn't found yet, proceed with color ramp

                symbols = colorRamp.getSymbols();

                for (int i = 0; i < symbols.length; i++) {

                        if (symbols[i].equals(oldSymbol)) {

                                colorRamp.replace(oldSymbol, newSymbol);

                                return;

                        }

                }

        }

    public static boolean isPolygonal(int ty) {

        if (ty == Geometry.TYPES.MULTISURFACE

            || ty == Geometry.TYPES.SURFACE

            ) {

            return true;

        } else {

            return false;

        }

    }

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    public int getShapeType() {

        return this.shapeType;

    }

    public void setDefaultSymbol(ISymbol s) {

        this.defaultSymbol = s;

    }

    // =============================

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(

                QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager

                    .addDefinition(QuantityByCategoryLegend.class,

                        QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME,

                        QUANTITY_BY_CATEGORY_LEGEND_PERSISTENCE_DEFINITION_NAME

                        + " Persistence definition", null, null);

                definition.extend(manager.getDefinition(

                    AbstractClassifiedVectorLegend

                    .CLASSIFIED_VECTOR_LEGEND_PERSISTENCE_DEFINITION_NAME));

                definition.addDynFieldBoolean("useDefaultSymbol")

                .setMandatory(true);

                definition.addDynFieldObject("graduatedLegend")

                .setClassOfValue(ILegend.class).setMandatory(true);

                definition.addDynFieldObject("rampLegend")

                .setClassOfValue(ILegend.class).setMandatory(true);

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager =

                MapContextLocator.getMapContextManager();

            manager.registerLegend(

                QUANTITY_BY_CATEGORY_LEGEND_NAME,

                QuantityByCategoryLegend.class);

            return Boolean.TRUE;

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("useDefaultSymbol", this.isUseDefaultSymbol());

        state.set("graduatedLegend", this.getGraduatedSymbolsLegend());

        state.set("rampLegend", this.getColorRampLegend());

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        Boolean b = state.getBoolean("useDefaultSymbol");

        this.useDefaultSymbol(b);

        ILegend leg = (ILegend) state.get("graduatedLegend");

        if (leg instanceof GraduatedSymbolsLegend) {

            this.setGraduateSymbolLegend((GraduatedSymbolsLegend) leg);

        } else {

            throw new PersistenceException(new ClassCastException(

                "Unexpected legend type (" + leg + "). Should be GraduatedSymbolsLegend"));

        }

        leg = (ILegend) state.get("rampLegend");

        if (leg instanceof VectorialIntervalLegend) {

            this.setColorRampLegend((VectorialIntervalLegend) leg);

        } else {

            throw new PersistenceException(new ClassCastException(

                "Unexpected legend type (" + leg + "). Should be VectorialIntervalLegend"));

        }

    }

}