Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {DiSiD Technologies}  {Create Manager to register MapContextDrawer implementation}

 */

package org.gvsig.fmap.mapcontext.impl;

import java.awt.Color;

import java.awt.Font;

import java.io.File;

import java.io.FileFilter;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.lang.reflect.Method;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

import org.gvsig.fmap.mapcontext.MapContextDrawer;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.MapContextRuntimeException;

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

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.LayerFactory;

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

import org.gvsig.fmap.mapcontext.layers.vectorial.impl.DefaultGraphicLayer;

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

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendReader;

import org.gvsig.fmap.mapcontext.rendering.legend.driver.ILegendWriter;

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelingStrategy;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException;

import org.gvsig.tools.persistence.PersistenceManager;

/**

 * Default implementation of the {@link MapContextManager}.

 *

 * @author <a href="mailto:cordinyana@gvsig.org">C?sar Ordi?ana</a>

 */

public class DefaultMapContextManager implements MapContextManager {

    private static final Logger logger = LoggerFactory

        .getLogger(DefaultMapContextManager.class);

        private Class drawerClazz = DefaultMapContextDrawer.class;

        private Map legends = Collections.synchronizedMap(new HashMap());

        private Map legendReaders = Collections.synchronizedMap(new HashMap());

        private Map legendWriters = Collections.synchronizedMap(new HashMap());

        private String defaultVectorLegend;

        public SymbolManager getSymbolManager() {

                return MapContextLocator.getSymbolManager();

        }

        private SymbolPreferences getSymbolPreferences() {

                return getSymbolManager().getSymbolPreferences();

        }

        public String getSymbolLibraryPath() {

                return getSymbolPreferences().getSymbolLibraryPath();

        }

        public void setSymbolLibraryPath(String symbolLibraryPath) {

                getSymbolPreferences().setSymbolLibraryPath(symbolLibraryPath);

        }

        public void resetSymbolLibraryPath() {

                getSymbolPreferences().resetSymbolLibraryPath();

        }

        public Color getDefaultSymbolColor() {

                return getSymbolPreferences().getDefaultSymbolColor();

        }

        public Color getDefaultSymbolFillColor() {

                return getSymbolPreferences().getDefaultSymbolFillColor();

        }

        public Font getDefaultSymbolFont() {

                return getSymbolPreferences().getDefaultSymbolFont();

        }

        public String getSymbolFileExtension() {

                return getSymbolPreferences().getSymbolFileExtension();

        }

        public boolean isDefaultSymbolFillColorAleatory() {

                return getSymbolPreferences().isDefaultSymbolFillColorAleatory();

        }

        public void resetDefaultSymbolColor() {

                getSymbolPreferences().resetDefaultSymbolColor();

        }

        public void resetDefaultSymbolFillColor() {

                getSymbolPreferences().resetDefaultSymbolFillColor();

        }

        public void resetDefaultSymbolFillColorAleatory() {

                getSymbolPreferences().resetDefaultSymbolFillColorAleatory();

        }

        public void resetDefaultSymbolFont() {

                getSymbolPreferences().resetDefaultSymbolFont();

        }

        public void setDefaultSymbolColor(Color defaultSymbolColor) {

                getSymbolPreferences().setDefaultSymbolColor(defaultSymbolColor);

        }

        public void setDefaultSymbolFillColor(Color defaultSymbolFillColor) {

                getSymbolPreferences().setDefaultSymbolFillColor(defaultSymbolFillColor);

        }

        public void setDefaultSymbolFillColorAleatory(

                        boolean defaultSymbolFillColorAleatory) {

                getSymbolPreferences().setDefaultSymbolFillColorAleatory(

                                defaultSymbolFillColorAleatory);

        }

        public void setDefaultSymbolFont(Font defaultSymbolFont) {

                getSymbolPreferences().setDefaultSymbolFont(defaultSymbolFont);

        }

        public void setSymbolFileExtension(String extension) {

                getSymbolPreferences().setSymbolFileExtension(extension);

        }

        public int getDefaultCartographicSupportMeasureUnit() {

                return getSymbolPreferences().getDefaultCartographicSupportMeasureUnit();

        }

        public void setDefaultCartographicSupportMeasureUnit(

                        int defaultCartographicSupportMeasureUnit) {

                getSymbolPreferences().setDefaultCartographicSupportMeasureUnit(

                                defaultCartographicSupportMeasureUnit);

        }

        public int getDefaultCartographicSupportReferenceSystem() {

                return getSymbolPreferences().getDefaultCartographicSupportReferenceSystem();

        }

        public void setDefaultCartographicSupportReferenceSystem(

                        int defaultCartographicSupportReferenceSystem) {

                getSymbolPreferences().setDefaultCartographicSupportReferenceSystem(

                                defaultCartographicSupportReferenceSystem);

        }

        public MapContextDrawer createMapContextDrawerInstance(Class drawerClazz)

        throws MapContextException {

                return createMapContextDrawerInstance(drawerClazz, "NONE");

        }

        public MapContextDrawer createDefaultMapContextDrawerInstance()

        throws MapContextException {

                return createMapContextDrawerInstance(drawerClazz, "default");

        }

        private MapContextDrawer createMapContextDrawerInstance(Class drawerClazz,

                        String name) throws RegisteredClassInstantiationException {

                try {

                        return (MapContextDrawer) drawerClazz.newInstance();

                } catch (Exception ex) {

                        throw new RegisteredClassInstantiationException(

                                        MapContextDrawer.class, drawerClazz, name, ex);

                }

        }

        public void setDefaultMapContextDrawer(Class drawerClazz)

        throws MapContextException {

                validateMapContextDrawer(drawerClazz);

                this.drawerClazz = drawerClazz;

        }

        public void validateMapContextDrawer(Class drawerClazz)

        throws MapContextException {

                if (!MapContextDrawer.class.isAssignableFrom(drawerClazz)) {

                        throw new InvalidRegisteredClassException(MapContextDrawer.class,

                                        drawerClazz, "UNKNOWN");

                }

        }

        public GraphicLayer createGraphicsLayer(IProjection projection) {

                DefaultGraphicLayer layer = new DefaultGraphicLayer();

                try {

                        layer.initialize(projection);        

                        layer.setLegend((IVectorLegend)createLegend(IVectorialUniqueValueLegend.LEGEND_NAME));

                } catch (Exception e) {

                        logger.error("Error initializing the graphics layer", e);

                }

                return layer;

        }

        public String getDefaultVectorLegend() {

                return defaultVectorLegend;

        }

        public void setDefaultVectorLegend(String defaultVectorLegend) {

                this.defaultVectorLegend = defaultVectorLegend;

        }

        public void registerLegend(String legendName, Class legendClass)

        throws MapContextRuntimeException {

                if (legendClass == null || !ILegend.class.isAssignableFrom(legendClass)) {

                        throw new InvalidRegisteredClassException(ILegend.class,

                                        legendClass, legendName);

                }

                legends.put(legendName, legendClass);

        }

        public ILegend createLegend(String legendName)

        throws MapContextRuntimeException {

                Class legendClass = (Class) legends.get(legendName);

                if (legendClass != null) {

                        try {

                                return (ILegend) legendClass.newInstance();

                        } catch (InstantiationException e) {

                                throw new RegisteredClassInstantiationException(ILegend.class,

                                                legendClass, legendName, e);

                        } catch (IllegalAccessException e) {

                                throw new RegisteredClassInstantiationException(ILegend.class,

                                                legendClass, legendName, e);

                        }

                }

                return null;

        }

    public IVectorLegend createDefaultVectorLegend(int shapeType)

    throws MapContextRuntimeException {

        try {

            // Create legend

            IVectorLegend legend =

                (IVectorLegend) createLegend(getDefaultVectorLegend());

            if (legend == null) {

                return null;

            }

            // Set legend values

            legend.setShapeType(shapeType);

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

            return legend;

        } catch(Exception e) {

            throw new MapContextRuntimeException(e);

        }

    }

        public void registerLegendReader(String format, Class readerClass)

        throws MapContextRuntimeException {

                if (readerClass == null

                                || !ILegendReader.class.isAssignableFrom(readerClass)) {

                        throw new InvalidRegisteredClassException(ILegendReader.class,

                                        readerClass, format);

                }

                legendReaders.put(format, readerClass);

        }

        public ILegendReader createLegendReader(String format)

        throws MapContextRuntimeException {

                Class legendReaderClazz = (Class) legendReaders.get(format);

                if (legendReaderClazz != null) {

                        try {

                                return (ILegendReader) legendReaderClazz.newInstance();

                        } catch (InstantiationException e) {

                                throw new RegisteredClassInstantiationException(

                                                ILegendReader.class, legendReaderClazz, format, e);

                        } catch (IllegalAccessException e) {

                                throw new RegisteredClassInstantiationException(

                                                ILegendReader.class, legendReaderClazz, format, e);

                        }

                }

                return null;

        }

        public void registerLegendWriter(String legendName, String format,

                        Class writerClass) throws MapContextRuntimeException {

                if (writerClass == null

                                || !ILegendWriter.class.isAssignableFrom(writerClass)) {

                        throw new InvalidRegisteredClassException(ILegendWriter.class,

                                        writerClass, format.concat("-").concat(legendName));

                }

                Map legendFormatWriters = (Map) legendWriters.get(format);

                synchronized (legendWriters) {

                        if (legendFormatWriters == null) {

                                legendFormatWriters = Collections

                                .synchronizedMap(new HashMap());

                                legendWriters.put(format, legendFormatWriters);

                        }

                }

                legendFormatWriters.put(legendName, writerClass);

        }

        public ILegendWriter createLegendWriter(String legendName, String format)

        throws MapContextRuntimeException {

                Map legendFormatWriters = getLegendWritersForFormat(format);

                if (legendFormatWriters != null) {

                        Class legendWriterClazz = (Class) legendFormatWriters

                        .get(legendName);

                        if (legendWriterClazz != null) {

                                try {

                                        return (ILegendWriter) legendWriterClazz.newInstance();

                                } catch (InstantiationException e) {

                                        throw new RegisteredClassInstantiationException(

                                                        ILegendWriter.class, legendWriterClazz, format

                                                        .concat("-").concat(legendName), e);

                                } catch (IllegalAccessException e) {

                                        throw new RegisteredClassInstantiationException(

                                                        ILegendWriter.class, legendWriterClazz, format

                                                        .concat("-").concat(legendName), e);

                                }

                        }

                }

                return null;

        }

        private Map getLegendWritersForFormat(String format) {

                return (Map) legendWriters.get(format);

        }

        public IMultiLayerSymbol createMultiLayerSymbol(int shapeType)

        throws MapContextRuntimeException {

                return getSymbolManager().createMultiLayerSymbol(shapeType);

        }

        public IMultiLayerSymbol createMultiLayerSymbol(String symbolName)

        throws MapContextRuntimeException {

                return getSymbolManager().createMultiLayerSymbol(symbolName);

        }

        public ISymbol createSymbol(int shapeType, Color color)

        throws MapContextRuntimeException {

                return getSymbolManager().createSymbol(shapeType, color);

        }

        public ISymbol createSymbol(int shapeType)

        throws MapContextRuntimeException {

                return getSymbolManager().createSymbol(shapeType);

        }

        public ISymbol createSymbol(String symbolName, Color color)

        throws MapContextRuntimeException {

                return getSymbolManager().createSymbol(symbolName, color);

        }

        public ISymbol createSymbol(String symbolName)

        throws MapContextRuntimeException {

                return getSymbolManager().createSymbol(symbolName);

        }

        public IWarningSymbol getWarningSymbol(String message, String symbolDesc,

                        int symbolDrawExceptionType) throws MapContextRuntimeException {

                return getSymbolManager().getWarningSymbol(message, symbolDesc,

                                symbolDrawExceptionType);

        }

        public ISymbol[] loadSymbols(File folder, FileFilter filter)

        throws SymbolException {

                return getSymbolManager().loadSymbols(folder, filter);

        }

        public ISymbol[] loadSymbols(File folder) throws SymbolException {

                return getSymbolManager().loadSymbols(folder);

        }

        public void registerMultiLayerSymbol(String symbolName, Class symbolClass)

        throws MapContextRuntimeException {

                getSymbolManager().registerMultiLayerSymbol(symbolName, symbolClass);

        }

        public void registerMultiLayerSymbol(String symbolName, int[] shapeTypes,

                        Class symbolClass) throws MapContextRuntimeException {

                getSymbolManager().registerMultiLayerSymbol(symbolName, shapeTypes,

                                symbolClass);

        }

        public void registerSymbol(String symbolName, Class symbolClass)

        throws MapContextRuntimeException {

                getSymbolManager().registerSymbol(symbolName, symbolClass);

        }

        public void registerSymbol(String symbolName, int[] shapeTypes,

                        Class symbolClass) throws MapContextException {

                getSymbolManager().registerSymbol(symbolName, shapeTypes, symbolClass);

        }

        public void saveSymbol(ISymbol symbol, String fileName, File folder,

                        boolean overwrite) throws SymbolException {

                getSymbolManager().saveSymbol(symbol, fileName, folder, overwrite);

        }

        public void saveSymbol(ISymbol symbol, String fileName, File folder)

        throws SymbolException {

                getSymbolManager().saveSymbol(symbol, fileName, folder);

        }

        public FLayer createLayer(String layerName, DataStoreParameters parameters)

        throws LoadLayerException {

                return LayerFactory.getInstance().createLayer(layerName, parameters);

        }

        public FLayer createLayer(String layerName, DataStore store)

        throws LoadLayerException {

                return LayerFactory.getInstance().createLayer(layerName, store);

        }

        public ILegend getLegend(DataStore dataStore) {

                ILegend legend = null;

                File file = getResourcePathByReflection(dataStore, SymbolManager.LEGEND_FILE_EXTENSION.substring(1));

                try{

                if ((file != null) && (file.exists())){

                        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

                        FileInputStream is = new FileInputStream(file);

                        legend = (ILegend) persistenceManager.getObject(is);

                        is.close();

                }

                } catch (FileNotFoundException e){

                    logger.error("Legend not found", e);

                } catch (IOException e) {

                    logger.error("Error reading the legend", e);

        }

                //If the legend is null, next option is to check if the store has the getLegend method

                if (legend == null){

                        try {

                                legend = (IVectorLegend) dataStore.invokeDynMethod(

                                                "getLegend", null);

                        } catch (DynMethodNotSupportedException e) {

                logger.debug("This store {} does not provide a legend.",

                    dataStore.getName());

                        } catch (DynMethodException e) {

                logger.error(

                    "Can't load the specific legend provided for the store {}.",

                    dataStore.getName(), e);

                        }

                }

                //If legend is null, last step is just try to create the legend by default

                if( legend == null ) {

                        FeatureType featureType;

                        try {

                                featureType = (((FeatureStore)dataStore).getDefaultFeatureType());

                                int indexGeom = featureType.getDefaultGeometryAttributeIndex();

                                int typeShape = featureType.getAttributeDescriptor(indexGeom).getGeometryType();

                                legend = createDefaultVectorLegend(typeShape);

                        } catch (DataException e) {

                                logger.error("Error getting the default feature type", e);

                        }                        

                }

                return legend;

        }

    public ILabelingStrategy getLabelingStrategy(DataStore dataStore) {

        ILabelingStrategy labelingStrategy = null;

        File file = getResourcePathByReflection(dataStore, SymbolManager.LABELINGSTRATEGY_FILE_EXTENSION.substring(1));

        try{

            if ((file != null) && (file.exists())){

                PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

                FileInputStream is = new FileInputStream(file);

                labelingStrategy = (ILabelingStrategy) persistenceManager.getObject(is);

                is.close();

            }

        } catch (FileNotFoundException e){

            logger.error("Label strategy not found", e);

        } catch (IOException e) {

            logger.error("Error reading the labeling strategy", e);

        }

        //If the legend is null, next option is to check if the store has the getLegend method

        if (labelingStrategy == null){

            try {

                labelingStrategy =

                    (ILabelingStrategy) dataStore.invokeDynMethod("getLabeling",

                        null);

            } catch (DynMethodNotSupportedException e1) {

                labelingStrategy = null;

            } catch (DynMethodException e1) {

                logger.error("Can't load the specific lebeling strategy provided for the datastore {}.",

                    dataStore.getName(),

                    e1);

            }

        }        

        return labelingStrategy;

    }

    private File getResourcePathByReflection(DataStore dataStore, String resource){

        //Loading the file from a store based on file

        DataServerExplorer dataServerExplorer = null;

        try {

            dataServerExplorer = dataStore.getExplorer();

            Class[] args = new Class[2];

            args[0] = DataStore.class;

            args[1] = String.class;

            Method method = dataStore.getExplorer().getClass().getMethod("getResourcePath", args);

            if (method != null){

                Object[] params = new Object[2];

                params[0] = dataStore;

                params[1] = resource;

                return (File)method.invoke(dataServerExplorer, params);

            }

        } catch (Exception e) {

            logger.debug(

                "Can't load the specific legend provided by the explorer "

                + dataServerExplorer, e);

        } 

        return null;

    }

    private Map iconLayers = new HashMap(); //  (Map<String storeProviderName, String iconName>)

    public void registerIconLayer(String storeProviderName, String iconName) {

            if( storeProviderName == null || iconName == null ) {

                    logger.info("registerIconLayer, storeProviderName or iconName are null");

                    return;

            }

            if( storeProviderName.trim().length()==0 || iconName.trim().length()==0 ) {

                    logger.info("registerIconLayer, invalid storeProviderName or iconName");

                    return;

            }

            iconLayers.put(storeProviderName.trim().toLowerCase(), iconName);

    }

    public String getIconLayer(DataStore store) {

            String name = (String) iconLayers.get(store.getProviderName().trim().toLowerCase());

            if( name == null ) {

                    return "layer-icon";

            }

            return name;

    }

    /* (non-Javadoc)

     * @see org.gvsig.fmap.mapcontext.MapContextManager#getDefaultCRS()

     */

    public IProjection getDefaultCRS() {

        return CRSFactory.getCRS("EPSG:4326");

    }

}