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

* 

*/

/*

* AUTHORS (In addition to CIT):

* 2009 {Iver T.I.}   {Task}

*/

package org.gvsig.fmap.mapcontext.layers.vectorial.impl;

import java.awt.Graphics2D;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.util.Iterator;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.exceptions.LegendLayerException;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.exceptions.ReprojectLayerException;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.layers.vectorial.GraphicLayer;

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default {@link GraphicLayer} implementation. 

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class DefaultGraphicLayer extends FLyrVect implements GraphicLayer{

        private static final String DEFAULT = "default";

        protected static final Logger logger = LoggerFactory.getLogger(DefaultGraphicLayer.class);

        private static DataManager dataManager = DALLocator.getDataManager();

        private IVectorialUniqueValueLegend legend = null;

        private FeatureStore store = null;

        private long ids = 0;

        private int symbolId = -1;

        private int featureIdIndex;

        private int groupIdIndex;

        private int geomIndex;

        private int idsymIndex;

        private int labelIndex;

        private int tagIndex;

        private int priorityIndex;

        public void initialize(IProjection projection) throws ValidateDataParametersException, DataException, LoadLayerException { 

                store = dataManager.createMemoryStore(FEATURE_ATTR_PRIORITY);

                store.edit();

                EditableFeatureType editableFeatureType = store.getDefaultFeatureType().getEditable();

                editableFeatureType.add(GraphicLayer.FEATURE_ATTR_GROUPID, DataTypes.STRING);

                EditableFeatureAttributeDescriptor geometryDescriptor = editableFeatureType.add(GraphicLayer.FEATURE_ATTR_GEOMETRY, DataTypes.GEOMETRY);

                geometryDescriptor.setGeometryType(TYPES.GEOMETRY);

                geometryDescriptor.setGeometrySubType(SUBTYPES.GEOM2D);

                geometryDescriptor.setSRS(projection);

                editableFeatureType.setDefaultGeometryAttributeName(GraphicLayer.FEATURE_ATTR_GEOMETRY);

                editableFeatureType.add(GraphicLayer.FEATURE_ATTR_IDSYMBOL, DataTypes.INT);

                editableFeatureType.add(GraphicLayer.FEATURE_ATTR_LABEL, DataTypes.STRING);

                EditableFeatureAttributeDescriptor featureIdDescriptor = 

                        editableFeatureType.add(GraphicLayer.FEATURE_ATTR_FEATUREID, DataTypes.LONG);

                editableFeatureType.add(GraphicLayer.FEATURE_ATTR_TAG, DataTypes.OBJECT);

                editableFeatureType.add(GraphicLayer.FEATURE_ATTR_PRIORITY, DataTypes.INT);

                featureIdDescriptor.setIsPrimaryKey(true);

                editableFeatureType.setHasOID(true);

                store.update(editableFeatureType);        

                store.finishEditing();

                FeatureType ftype = store.getDefaultFeatureType();

                featureIdIndex = ftype.getIndex(GraphicLayer.FEATURE_ATTR_FEATUREID);

                groupIdIndex = ftype.getIndex(GraphicLayer.FEATURE_ATTR_GROUPID);

                geomIndex = ftype.getIndex(GraphicLayer.FEATURE_ATTR_GEOMETRY);

                idsymIndex = ftype.getIndex(GraphicLayer.FEATURE_ATTR_IDSYMBOL);

                labelIndex = ftype.getIndex(GraphicLayer.FEATURE_ATTR_LABEL);

                tagIndex = ftype.getIndex(GraphicLayer.FEATURE_ATTR_TAG);

                priorityIndex = ftype.getIndex(GraphicLayer.FEATURE_ATTR_PRIORITY);

                this.setDataStore(store);

                setName("Graphic Layer");

        }

        public void addGraphic(String groupId, Geometry geom, int idsym) {

                addGraphic(groupId, geom, idsym, null, null, DEFAULT_PRIORITY);

        }

        public void addGraphic(Geometry geom, int idsym) {

                addGraphic(DEFAULT, geom, idsym, null, null, DEFAULT_PRIORITY);

        }

        public void addGraphic(Geometry geom, int idsym, String label) {

                addGraphic(DEFAULT, geom, idsym, label, null, DEFAULT_PRIORITY);

        }

        public void addGraphic(String groupId, Geometry geom, int idsym, String label) {

                addGraphic(groupId, geom, idsym, label, null, DEFAULT_PRIORITY);

        }

        public void addGraphic(String groupId, Geometry geom, int idsym, String label,

                        Object tag, int priority) {

                try{

                        store.beginComplexNotification();

                // Just in case another thread is going to read from the store

                        synchronized (store) {                                

                                if (!store.isEditing()){

                                        store.edit(FeatureStore.MODE_APPEND);

                                }

                                insertGeometry(groupId, geom, idsym, label, tag, priority);

                                store.finishEditing();

                        }

                        store.endComplexNotification();

                } catch (DataException e) {

                        logger.error("Error adding a geometry to the graphic layer", e);

                }

        }

    private void insertGeometry(String groupId, Geometry geom, int idsym,

        String label, Object tag, int priority) throws DataException {

        EditableFeature feature = store.createNewFeature().getEditable();

        feature.setString(groupIdIndex, groupId);

        feature.setGeometry(geomIndex, geom);

        feature.setInt(idsymIndex, idsym);        

        feature.setString(labelIndex, label);        

        feature.setLong(featureIdIndex, ids);

        feature.set(tagIndex, tag);

        feature.setInt(priorityIndex, priority);

        ids++;

        store.insert(feature);

    }        

    public void addGraphics(String groupId, Iterator geoms, int idsym) {

        addGraphics(groupId, geoms, idsym, null, null, DEFAULT_PRIORITY);

    }

    public void addGraphics(String groupId, Iterator geoms, int idsym,

        String label) {

        addGraphics(groupId, geoms, idsym, label, null, DEFAULT_PRIORITY);

    }

    public void addGraphics(String groupId, Iterator geoms, int idsym,

        String label, Object tag, int priority) {

        try {

                // Just in case another thread is going to read from the store

                synchronized (store) {                                

                        if (!store.isEditing()) {

                                store.edit(FeatureStore.MODE_APPEND);

                        }

                        store.disableNotifications();

                        for (; geoms.hasNext();) {

                                Geometry geom = (Geometry) geoms.next();

                                insertGeometry(groupId, geom, idsym, label, tag, priority);

                        }

                        store.enableNotifications();

                        store.finishEditing();

                        }

        } catch (DataException e) {

            logger.error("Error adding a geometry to the graphic layer", e);

        }

    }

        public int addSymbol(ISymbol newSymbol) {

                symbolId++;

                legend.addSymbol(new Integer(symbolId), newSymbol);

                return symbolId;

        }

        public ISymbol getSymbol(int symbolPos) {

                return legend.getSymbolByValue(new Integer(symbolPos));                

        }

        public int getSymbolId(ISymbol symbol) {

                Object key = legend.getSymbolKey(symbol);

                return key == null ? -1 : ((Number) key).intValue();

        }

        public void clearAllGraphics() {

                DisposableIterator iterator = null;

                FeatureSet featureSet = null;

                try{

                        if (!store.isEditing()){

                                store.edit();

                        }

                        featureSet = store.getFeatureSet();

                        for (iterator = featureSet.fastIterator(); iterator.hasNext();) {

                                Feature feature = (Feature) iterator.next();

                                featureSet.delete(feature);

                        }

                        store.finishEditing();                        

                } catch (DataException e) {

                        logger.error("Error clearing all the geometry of the graphic layer", e);

                } finally {

                        if (featureSet != null) {

                                featureSet.dispose();

                        }

                        if (iterator != null) {

                                iterator.dispose();

                        }

                }

        }

        public int clearAllSymbols() {

                legend.clear();

                symbolId = -1;

                return symbolId;

        }

        public void removeGraphics(String groupId) {

                DisposableIterator iterator = null;

                FeatureSet featureSet = null;

                try{

                        store.beginComplexNotification();

                        if (!store.isEditing()){

                                store.edit();

                        }

                        featureSet = store.getFeatureSet();

                        store.beginEditingGroup(groupId);

                        for (iterator = featureSet.fastIterator(); iterator.hasNext();) {

                                Feature feature = (Feature) iterator.next();

                                if (feature.get(FEATURE_ATTR_GROUPID).equals(groupId)) {

                                        featureSet.delete(feature);

                                }

                        }

                        store.endEditingGroup();

                        store.finishEditing();

                        store.endComplexNotification();

                } catch (DataException e) {

                        logger.error("Error clearing all the geometry of the graphic layer", e);

                } finally {

                        if (featureSet != null) {

                                featureSet.dispose();

                        }

                        if (iterator != null) {

                                iterator.dispose();

                        }

                }

        }

        protected void doDispose() throws BaseException {

                super.doDispose();

                if (store != null) {

                        store.dispose();

                        store = null;

                }

        }

        public void setLegend(IVectorLegend legend) throws LegendLayerException {

                if (legend instanceof IVectorialUniqueValueLegend){                

                        super.setLegend(legend);

                        this.legend = (IVectorialUniqueValueLegend)legend;

                        this.legend.setClassifyingFieldNames(new String[]{FEATURE_ATTR_IDSYMBOL});

                }else{

                        logger.warn("The legend for the graphics layer must be a instance of IVectorialUniqueValueLegend");

                }

        }

    public Envelope getFullEnvelope() throws ReadException {

        Envelope rAux;

        try {

            rAux = getFeatureStore().getEnvelope();

        } catch (BaseException e) {

            throw new ReadException(getName(), e);

        }

        if (rAux == null) {

                return null;

        }

        ICoordTrans ct = getCoordTrans();

        if (ct != null) {

                rAux = rAux.convert(ct);

        }

        return rAux;

    }

}