Application: gvSIG desktop » gvSIG legends: base legends

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 */

package org.gvsig.symbology.fmap.rendering;

import java.awt.Color;

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.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

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

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

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

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

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

import org.gvsig.symbology.fmap.symbols.DotDensityFillSymbol;

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 magnitudes of a specific area of the

 * map are represented by the density of the points that are distributed

 * in the surface.

 *

 *

 */

public class DotDensityLegend extends VectorialUniqueValueLegend {

    private static Logger logger = LoggerFactory.getLogger(

        DotDensityLegend.class);

    public static final String

    DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME = 

    "DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME";

    public static final String

    DOT_DENSITY_LEGEND_NAME = "DOT_DENSITY_LEGEND_NAME";

        private double dotValue;

        private Color dotColor = Color.BLACK;

        private Color backgroundColor = Color.WHITE;

        private static final int SIMPLE_FILL_LAYER_INDEX = 0;

        private static final int DOT_DENSITY_LAYER_INDEX = 1;

        public ISymbol getSymbolByValue(Object val) {

                MultiLayerFillSymbol sym = (MultiLayerFillSymbol) getDefaultSymbol();

                DotDensityFillSymbol densitySym = (DotDensityFillSymbol) sym.getLayer(DOT_DENSITY_LAYER_INDEX);

                if (val instanceof Number) {

                    Number dou = (Number) val;

                densitySym.setDotCount(

                    (int) (dou.doubleValue()/dotValue));

                return sym;

                } else {

                    logger.info("Error: Unexpected value in dot density legend: " + val);

                    return null;

                }

        }

        public ISymbol getSymbolByFeature(Feature feat) {

            String[] ff = this.getClassifyingFieldNames();

            Object val = feat.get(ff[0]);

            return this.getSymbolByValue(val);

        }

        /**

         * Establishes the value for the dot used in the dot density legend

         *

         * @param dotValue

         */

        public void setDotValue(double dotValue) {

                this.dotValue = dotValue;

        }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set("dotValue", dotValue);

        state.set("dotColor", getDotColor());

        state.set("bgColor", getBGColor());

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        dotValue = state.getDouble("dotValue");

        Object obj_col = state.get("dotColor");

        this.setDotColor((Color) obj_col);

        obj_col = state.get("bgColor");

        this.setBGColor((Color) obj_col);

    }

        /**

         * Returns the outline

         *

         * @return

         */

        public ILineSymbol getOutline() {

                // defined by the SimpleFillSymbol layer

                ISymbol symbol = getDefaultSymbol();

                if (!(symbol instanceof IFillSymbol)){

                        return null;

                }

                IFillSymbol fillsym = (IFillSymbol) symbol;

                if (fillsym instanceof MultiLayerFillSymbol){

                        fillsym = (IFillSymbol) ((MultiLayerFillSymbol) fillsym).

                        getLayer(SIMPLE_FILL_LAYER_INDEX);

                }

                if (fillsym == null){

                        return null;

                }

                return fillsym.getOutline();

        }

        /**

         * Returns the color for the dot used in the dot density legend.

         * @return

         */

        public Color getDotColor() {

//                try {

//                        // defined by the DotDensitySymbol layer

//                        DotDensityFillSymbol sym = (DotDensityFillSymbol) ((MultiLayerFillSymbol) getDefaultSymbol()).

//                        getLayer(DOT_DENSITY_LAYER_INDEX);

//                        return sym.getDotColor();

//                } catch (NullPointerException npE) {

//                        return null;

//                }

                return dotColor;

        }

        /**

         * Sets the color for the dot used in the dot density legend.

         * @return

         */

        public void setDotColor(Color color){

//                DotDensityFillSymbol sym = (DotDensityFillSymbol) ((MultiLayerFillSymbol) getDefaultSymbol()).

//                getLayer(DOT_DENSITY_LAYER_INDEX);

//                sym.setDotColor(color);

                this.dotColor = color;

        }

        /**

         * Obtains the background color for the dot density legend

         * @return

         */

        public Color getBGColor() {

//                try {

//                        // defined by the SimpleFillSymbol layer

//                        IFillSymbol symbol = (IFillSymbol) ((MultiLayerFillSymbol) getDefaultSymbol()).

//                        getLayer(SIMPLE_FILL_LAYER_INDEX);

//                        return symbol.getFillColor();

//                } catch (NullPointerException npE) {

//                        return null;

//                }

                return backgroundColor;

        }

        /**

         * Sets the background color for the dot density legend

         * @return

         */

        public void setBGColor(Color color) {

                this.backgroundColor = color;

        }

        /**

         * Returns the value for the dot that is used in the dot density legend

         * @return

         */

        public double getDotValue() {

            return this.dotValue;

        }

        /**

         * Obtains the size of the dot that is used in the dot density legend

         * @return

         */

        public double getDotSize() {

                // defined by the SimpleFillSymbol layer

                ISymbol symbol = getDefaultSymbol();

                if (symbol == null){

                        return -1;

                }

                if (symbol instanceof DotDensityFillSymbol){

                        return ((DotDensityFillSymbol)symbol).getDotSize();

                }

                if (!(symbol instanceof IFillSymbol)){

                        return -1;

                }

                IFillSymbol fillsym = (IFillSymbol) symbol;

                if (fillsym instanceof MultiLayerFillSymbol){

                        fillsym = (DotDensityFillSymbol) ((MultiLayerFillSymbol) fillsym).

                        getLayer(DOT_DENSITY_LAYER_INDEX);

                }

                if (fillsym instanceof DotDensityFillSymbol){

                        return ((DotDensityFillSymbol)fillsym).getDotSize();

                }

                return -1;

        }

        /**

         * Sets the size of the dot that is used in the dot density legend

         */

        public void setDotSize(double value) {

                DotDensityFillSymbol sym = (DotDensityFillSymbol) ((MultiLayerFillSymbol) getDefaultSymbol()).

                getLayer(DOT_DENSITY_LAYER_INDEX);

                sym.setDotSize(value);

        }

    public static boolean isPolygonal(int ty) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.isSubtype(Geometry.TYPES.MULTISURFACE, ty) || 

            geomManager.isSubtype(Geometry.TYPES.SURFACE, ty);

    }

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

    public static class RegisterPersistence implements Callable {

        public Object call() throws Exception {

            PersistenceManager manager = ToolsLocator.getPersistenceManager();

            if (manager.getDefinition(

                DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME) == null) {

                DynStruct definition = manager

                    .addDefinition(DotDensityLegend.class,

                        DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME,

                        DOT_DENSITY_LEGEND_PERSISTENCE_DEFINITION_NAME

                        + " Persistence definition", null, null);

                definition.extend(manager.getDefinition(

                    VectorialUniqueValueLegend

                    .VECTORIAL_UNIQUE_VALUE_LEGEND_PERSISTENCE_DEFINITION_NAME));

                definition.addDynFieldDouble("dotValue").setMandatory(true);

                definition.addDynFieldObject("dotColor")

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

                definition.addDynFieldObject("bgColor")

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

            }

            return Boolean.TRUE;

        }

    }

    public static class RegisterLegend implements Callable {

        public Object call() throws Exception {

            MapContextManager manager =

                MapContextLocator.getMapContextManager();

            manager.registerLegend(

                DOT_DENSITY_LEGEND_NAME,

                DotDensityLegend.class);

            return Boolean.TRUE;

        }

    }

    public Object clone() throws CloneNotSupportedException {

        DotDensityLegend resp = (DotDensityLegend) super.clone();

        resp.setDotColor(this.getDotColor());

        resp.setDotSize(this.getDotSize());

        resp.setDotValue(this.getDotValue());

        return resp;

    }

    public String[] getDescriptions() {

        try {

            return new String[]{String.format("%s, %.3f",getClassifyingFieldNames()[0], getDotValue())};

        }catch (Exception ex){

            return new String[]{"Dot density"};

        }

    }

}