| gvSIG desktop 1

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

 *

 * Copyright (C) 2004 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.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

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

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.mapcontext.rendering.legend.ISingleSymbolLegend;

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

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.MultiShapeSymbol;

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

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.utils.XMLEntity;

import org.gvsig.utils.XMLException;

/**

 * Implements a legend composed by single symbols.

 * 

 * @author Vicente Caballero Navarro

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

 */

public class SingleSymbolLegend extends AbstractVectorialLegend implements

                ISingleSymbolLegend {

        public static final String SINGLE_SYMBOL_DYNCLASS_NAME =

                        "SimgleSymbolLegend";

        private ISymbol defaultSymbol;

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

        /**

         * Constructor method, needed by persistence.

         */

        public SingleSymbolLegend() {

                // Nothing to do

        }

        /**

         * Convenience fast constructor.

         *

         * @param style S?mbolo.

         */

        public SingleSymbolLegend(ISymbol style) {

                defaultSymbol = style;

                if (style instanceof MultiShapeSymbol) {

                        shapeType = Geometry.TYPES.GEOMETRY;

                } else if (style instanceof IMarkerSymbol) {

                        shapeType = Geometry.TYPES.POINT;

                } else if (style instanceof ILineSymbol) {

                        shapeType = Geometry.TYPES.CURVE;

                } else if (style instanceof IFillSymbol) {

                        shapeType = Geometry.TYPES.SURFACE;

                }

        }

        public void setDefaultSymbol(ISymbol s) {

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

                setShapeType(s.getSymbolType());

                ISymbol old = defaultSymbol;

                defaultSymbol = s;

                fireDefaultSymbolChangedEvent(new SymbolLegendEvent(old, s));

        }

        public ISymbol getSymbol(int recordIndex) {

                return defaultSymbol;

        }

        public ISymbol getDefaultSymbol() {

                if(defaultSymbol==null) {

                        defaultSymbol =

                                        getSymbolManager().createSymbol(IFillSymbol.SYMBOL_NAME);

                }

                return defaultSymbol;

        }

        public XMLEntity getXMLEntity() throws XMLException {

                XMLEntity xml = new XMLEntity();

//                xml.putProperty("className",this.getClass().getName());

//                xml.addChild(defaultSymbol.getXMLEntity());

//

//                if (zSort != null) {

//                        XMLEntity zSortXML = zSort.getXMLEntity();

//                        zSortXML.putProperty("id", "zSort");

//                        xml.addChild(zSortXML);

//                }

                return xml;

        }

        /**

         * TODO: replace with the new persistence API

         */

        public void setXMLEntity(XMLEntity xml) {

//        ISymbol auxSym = SymbologyFactory.createSymbolFromXML(xml.getChild(0), null);

//                setDefaultSymbol(auxSym);

//

//                XMLEntity zSortXML = xml.firstChild("id", "zSort");

//                if (zSortXML != null) {

//                        zSort = new ZSort(this);

//                        zSort.setXMLEntity(zSortXML);

//                }

        }

//        public ILegend cloneLegend() throws XMLException {

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

//        }

        public int getShapeType() {

                return shapeType;

        }

        public void setShapeType(int shapeType) {

                if (this.shapeType != shapeType) {

                        defaultSymbol = getSymbolManager().createSymbol(shapeType);

                        this.shapeType = shapeType;

                }

        }

    public ISymbol getSymbolByFeature(Feature feat) {

        return defaultSymbol;

    }

        public void useDefaultSymbol(boolean b) {

                // TODO Auto-generated method stub

        }

    public String[] getUsedFields() {

        return new String[0];

    }

    public boolean isUseDefaultSymbol() {

            return true;

    }

    public String getClassName() {

                return getClass().getName();

        }

    public boolean isSuitableForShapeType(int shapeType) {

                return getShapeType() == shapeType;

        }

        public void setFeatureStore(FeatureStore fs) throws DataException {

                // TODO Auto-generated method stub

        }

        protected String[] getRequiredFeatureAttributeNames(

                        FeatureStore featureStore) throws DataException {

                // We only need the default Geometry to draw

                return new String[] { featureStore

                                .getDefaultFeatureType().getDefaultGeometryAttributeName() };

        }

        public Object clone() throws CloneNotSupportedException {

                SingleSymbolLegend clone = (SingleSymbolLegend) super.clone();

                // Clone default symbol

                if (defaultSymbol != null) {

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

                }

                return clone;

        }

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                // Set parent properties

                super.loadFromState(state);

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                // Save parent properties

                super.saveToState(state);

        }

        public static void registerPersistence() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.addDefinition(

                                SingleSymbolLegend.class,

                                SINGLE_SYMBOL_DYNCLASS_NAME,

                                SINGLE_SYMBOL_DYNCLASS_NAME+" Persistence definition",

                                null, 

                                null

                );

                // Extend the Vectorial Legend base definition

                definition.extend(VECTORIAL_LEGEND_DYNCLASS_NAME);

        }

}