| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

package org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl;

import java.awt.Color;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

/**

 * <p>

 * VectorialIntervalLegend (which should be better called GraduatedColorLegend)

 * is a legend that allows to classify ranges of values using a color gradient

 * based on a value.<b>

 * </p>

 * <p>

 * The color gradient will be calculated according the starting color, the

 * ending color and the amount of intervals.

 * </p>

 * 

 * @author Vicente Caballero Navarro

 * @author 2009- <a href="cordinyana@gvsig.org">C?sar Ordi?ana</a> - gvSIG team

 */

public class VectorialIntervalLegend extends AbstractIntervalLegend {

        public static final String VECTORIAL_INTERVAL_LEGEND_DYNCLASS_NAME =

                        "VectorialIntervalLegend";

        private static final String FIELD_START_COLOR = "startColor";

        private static final String FIELD_END_COLOR = "endColor";

        private int shapeType;

    private Color startColor = Color.red;

    private Color endColor = Color.blue;

    /**

     * Constructor method

     */

    public VectorialIntervalLegend() {

        //defaultSymbol = LegendFactory.DEFAULT_POLYGON_SYMBOL;

    }

    /**

     * Constructor method

     *

     * @param type type of the shape.

     */

    public VectorialIntervalLegend(int type) {

            setShapeType(type);

    }

//    public ILegend cloneLegend() throws XMLException {

//        return LegendFactory.createFromXML(getXMLEntity());

//    }

    /**

         * Returns the final color

         * @return Color  final color.

         * @uml.property  name="endColor"

         */

    public Color getEndColor() {

        return endColor;

    }

    /**

         * Inserts the final color.

         * @param endColor final color.

         * @uml.property  name="endColor"

         */

    public void setEndColor(Color endColor) {

        this.endColor = endColor;

    }

    /**

         * Returns the initial color.

         * @return  Color initial color.

         * @uml.property  name="startColor"

         */

    public Color getStartColor() {

        return startColor;

    }

    /**

         * Inserts the initial color

         * @param startColor initial color.

         * @uml.property  name="startColor"

         */

    public void setStartColor(Color startColor) {

        this.startColor = startColor;

    }

        public int getShapeType() {

                return shapeType;

        }

        public void setShapeType(int shapeType) {

                if (this.shapeType != shapeType) {

                        setDefaultSymbol(getSymbolManager().createSymbol(shapeType));

                        this.shapeType = shapeType;

                }

        }

        public String getClassName() {

                return getClass().getName();

        }

        public Object clone() throws CloneNotSupportedException {

                VectorialIntervalLegend clone = (VectorialIntervalLegend) super.clone();

                // Nothing to clone, as Color objects are inmutable, keep the original

                // references.

                return clone;

        }

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                // Set parent properties

                super.loadFromState(state);

                // Set own properties

                setStartColor((Color) state.get(FIELD_START_COLOR));

                setEndColor((Color) state.get(FIELD_END_COLOR));

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                // Save parent properties

                super.saveToState(state);

                // Save own properties

                state.set(FIELD_START_COLOR, getStartColor());

                state.set(FIELD_END_COLOR, getEndColor());

        }

        public static void registerPersistence() {

                // Add the DynClass definition.

                DynClass dynClass =

                                ToolsLocator.getDynObjectManager().add(

                                                VECTORIAL_INTERVAL_LEGEND_DYNCLASS_NAME);

                // Extend the Interval Legend base definition

                dynClass.extend(INTERVAL_LEGEND_DYNCLASS_NAME);

                // Start color

                dynClass.addDynFieldObject(FIELD_START_COLOR)

                                .setMandatory(true)

                                .setDescription("Start color");

                // End color

                dynClass.addDynFieldObject(FIELD_END_COLOR)

                                .setMandatory(true)

                                .setDescription("End color");

                ToolsLocator.getPersistenceManager().registerClass(

                                VectorialIntervalLegend.class, dynClass);

        }

        public IInterval createInterval(double min, double max) {

                return new FInterval(min, max);

        }

        //

        /**

         * <p>This method does not exist officially. But what it does is just apply the

         * values of a VectorialIntervalLegend to other so, It is not needed to

         * replicate the code of populating the legend in every panel that produces

         * a legend by intervals.<br>

         * </p>

         * <p>

         * ok this method is messy, but it's useful ;-)

         * </p>

         */

//        public static void initializeVectorialIntervalLegend(

//                        AbstractIntervalLegend srcLegend,

//                        AbstractIntervalLegend targetLegend) {

//                targetLegend.shapeType        = srcLegend.shapeType;

//                targetLegend.symbols          = srcLegend.symbols;

//                targetLegend.keys             = srcLegend.keys;

//                targetLegend.index            = srcLegend.index;

//                targetLegend.setClassifyingFieldNames(srcLegend.getClassifyingFieldNames());

//                targetLegend.setClassifyingFieldTypes(srcLegend.getClassifyingFieldTypes());

////                targetLegend.fieldId          = srcLegend.fieldId;

//                targetLegend.defaultSymbol    = srcLegend.defaultSymbol;

////                targetLegend.featureStore       = srcLegend.featureStore;

//                targetLegend.intervalType     = srcLegend.intervalType;

//                targetLegend.useDefaultSymbol = srcLegend.useDefaultSymbol;

//        }

}