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.

 */

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

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataFactory;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

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.dal.raster.BandDescriptor;

import org.gvsig.fmap.dal.raster.RasterStore;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.mapcontext.MapContext;

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.layers.operations.SingleLayer;

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

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.raster.lib.legend.api.RasterLegend;

import org.gvsig.raster.lib.legend.api.RasterLegendLocator;

import org.gvsig.raster.lib.legend.api.RasterLegendManager;

import org.gvsig.raster.lib.legend.api.colorinterpretation.ColorInterpretation;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

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

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

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource;

import org.gvsig.tools.swing.api.TransparencySupport;

import org.gvsig.tools.util.Factory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementation of the {@link MapContextManager}.

 *

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultMapContextManager implements MapContextManager {

    private static final Logger LOGGER = LoggerFactory

            .getLogger(DefaultMapContextManager.class);

    private static final double DEFAULT_SYMBOL_TRANSPARENCY = 0.6;

    private Class drawerClazz = DefaultMapContextDrawer.class;

    private final Map<String,Class<ILegend>> legends = new HashMap();

    private final Map<String, Class<ILegendReader>> legendReaders = new LinkedHashMap<>();

    private final Map<String, Map<Class<ILegend>,Class<ILegendWriter>>> legendWriters = new LinkedHashMap<>();

    private final Map<Object,Class<? extends FLayer>> layerClassFromStoreClass = new HashMap<>();

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

    private String defaultVectorLegend;

    private final ObservableHelper observableHelper = new ObservableHelper();

    private File colorTableLibraryFolder = null;

    private String defaultRasterLegend;

    @Override

    public MapContext createMapContext() {

        MapContext mapcontext = new MapContext(new ViewPort());

        return (MapContext) notifyObservers(CREATE_MAPCONTEXT, mapcontext).getValue();

    }

    @Override

    public SymbolManager getSymbolManager() {

        return MapContextLocator.getSymbolManager();

    }

    private SymbolPreferences getSymbolPreferences() {

        return getSymbolManager().getSymbolPreferences();

    }

    @Override

    public String getSymbolLibraryPath() {

        return getSymbolPreferences().getSymbolLibraryPath();

    }

    @Override

    public void setSymbolLibraryPath(String symbolLibraryPath) {

        getSymbolPreferences().setSymbolLibraryPath(symbolLibraryPath);

    }

    @Override

    public void resetSymbolLibraryPath() {

        getSymbolPreferences().resetSymbolLibraryPath();

    }

    @Override

    public Color getDefaultSymbolColor() {

        return getSymbolPreferences().getDefaultSymbolColor();

    }

    @Override

    public Color getDefaultSymbolFillColor() {

        return getSymbolPreferences().getDefaultSymbolFillColor();

    }

    @Override

    public Font getDefaultSymbolFont() {

        return getSymbolPreferences().getDefaultSymbolFont();

    }

    public String getSymbolFileExtension() {

        return getSymbolPreferences().getSymbolFileExtension();

    }

    @Override

    public boolean isDefaultSymbolFillColorAleatory() {

        return getSymbolPreferences().isDefaultSymbolFillColorAleatory();

    }

    @Override

    public void resetDefaultSymbolColor() {

        getSymbolPreferences().resetDefaultSymbolColor();

    }

    @Override

    public void resetDefaultSymbolFillColor() {

        getSymbolPreferences().resetDefaultSymbolFillColor();

    }

    @Override

    public void resetDefaultSymbolFillColorAleatory() {

        getSymbolPreferences().resetDefaultSymbolFillColorAleatory();

    }

    @Override

    public void resetDefaultSymbolFont() {

        getSymbolPreferences().resetDefaultSymbolFont();

    }

    @Override

    public void setDefaultSymbolColor(Color defaultSymbolColor) {

        getSymbolPreferences().setDefaultSymbolColor(defaultSymbolColor);

    }

    @Override

    public void setDefaultSymbolFillColor(Color defaultSymbolFillColor) {

        getSymbolPreferences().setDefaultSymbolFillColor(defaultSymbolFillColor);

    }

    @Override

    public void setDefaultSymbolFillColorAleatory(

            boolean defaultSymbolFillColorAleatory) {

        getSymbolPreferences().setDefaultSymbolFillColorAleatory(

                defaultSymbolFillColorAleatory);

    }

    @Override

    public void setDefaultSymbolFont(Font defaultSymbolFont) {

        getSymbolPreferences().setDefaultSymbolFont(defaultSymbolFont);

    }

    public void setSymbolFileExtension(String extension) {

        getSymbolPreferences().setSymbolFileExtension(extension);

    }

    @Override

    public int getDefaultCartographicSupportMeasureUnit() {

        return getSymbolPreferences().getDefaultCartographicSupportMeasureUnit();

    }

    @Override

    public void setDefaultCartographicSupportMeasureUnit(

            int defaultCartographicSupportMeasureUnit) {

        getSymbolPreferences().setDefaultCartographicSupportMeasureUnit(

                defaultCartographicSupportMeasureUnit);

    }

    @Override

    public int getDefaultCartographicSupportReferenceSystem() {

        return getSymbolPreferences().getDefaultCartographicSupportReferenceSystem();

    }

    @Override

    public void setDefaultCartographicSupportReferenceSystem(

            int defaultCartographicSupportReferenceSystem) {

        getSymbolPreferences().setDefaultCartographicSupportReferenceSystem(

                defaultCartographicSupportReferenceSystem);

    }

    @Override

    public MapContextDrawer createMapContextDrawerInstance(Class drawerClazz)

            throws MapContextException {

        return createMapContextDrawerInstance(drawerClazz, "NONE");

    }

    @Override

    public MapContextDrawer createDefaultMapContextDrawerInstance()

            throws MapContextException {

        return createMapContextDrawerInstance(drawerClazz, "default");

    }

    private MapContextDrawer createMapContextDrawerInstance(Class drawerClazz,

            String name) throws RegisteredClassInstantiationException {

        try {

            MapContextDrawer drawer = (MapContextDrawer) drawerClazz.newInstance();

            notifyObservers(CREATE_MAPCONTEXT_DRAWER, drawer);

            return drawer;

        } catch (Exception ex) {

            throw new RegisteredClassInstantiationException(

                    MapContextDrawer.class, drawerClazz, name, ex);

        }

    }

    @Override

    public void setDefaultMapContextDrawer(Class drawerClazz)

            throws MapContextException {

        validateMapContextDrawer(drawerClazz);

        this.drawerClazz = drawerClazz;

        notifyObservers(SET_MAPCONTEXT_DRAWER, drawerClazz);

    }

    @Override

    public void validateMapContextDrawer(Class drawerClazz)

            throws MapContextException {

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

            throw new InvalidRegisteredClassException(MapContextDrawer.class,

                    drawerClazz, "UNKNOWN");

        }

    }

    @Override

    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 (GraphicLayer) notifyObservers(CREATE_GRAPHICS_LAYER, layer).getValue();

    }

    @Override

    public String getDefaultVectorLegend() {

        return defaultVectorLegend;

    }

    @Override

    public void setDefaultVectorLegend(String defaultVectorLegend) {

        this.defaultVectorLegend = defaultVectorLegend;

    }

    @Override

    public String getDefaultRasterLegend() {

        return defaultRasterLegend;

    }

    @Override

    public void setDefaultRasterLegend(String defaultRasterLegend) {

        this.defaultRasterLegend = defaultRasterLegend;

    }

    @Override

    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);

        notifyObservers(REGISTER_LEGEND, legendName, legendClass);

    }

    @Override

    public ILegend createLegend(String legendName)

            throws MapContextRuntimeException {

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

        if (legendClass != null) {

            try {

                ILegend legend = (ILegend) legendClass.newInstance();

                return (ILegend) notifyObservers(CREATE_LEGEND, legend).getValue();

            } catch (InstantiationException | IllegalAccessException e) {

                throw new RegisteredClassInstantiationException(ILegend.class,

                        legendClass, legendName, e);

            }

        }

        return null;

    }

    @Override

    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);

            ISymbol symbol = getSymbolManager().createSymbol(shapeType);

            if (symbol == null) {

                String msg = "Can't create a legend for the shape type " + shapeType + ". The type can be incorrect or there is not registered a symbol by default for that value. If this a was obtained from the store settings, review your FeatureType have correctly configured this value.";

                throw new RuntimeException(msg);

            } 

            if( symbol instanceof TransparencySupport && (

                    GeometryUtils.isSubtype(Geometry.TYPES.SURFACE,shapeType) ||

                    GeometryUtils.isSubtype(Geometry.TYPES.MULTISURFACE,shapeType) )

                ) {

                ((TransparencySupport)symbol).setTransparency(DEFAULT_SYMBOL_TRANSPARENCY);

            }

            legend.setDefaultSymbol(symbol);

            return legend;

        } catch (Exception e) {

            throw new MapContextRuntimeException(e);

        }

    }

    @Override

    public RasterLegend createDefaultRasterLegend(List<BandDescriptor> bands)

            throws MapContextRuntimeException {

        try {

            // Create legend

            RasterLegend legend = (RasterLegend) createLegend(getDefaultRasterLegend());

            if (legend == null) {

                return null;

            }

            ColorInterpretation colorInterpretation;

            RasterLegendManager legendManager = RasterLegendLocator.getRasterLegendManager();

            switch (bands.size()) {

                case 3:

                    colorInterpretation = legendManager.createColorInterpretation(ColorInterpretation.RGB);

                    break;

                case 4:

                    colorInterpretation = legendManager.createColorInterpretation(ColorInterpretation.ARGB);

                    break;

                default:

                    String[] colorBands = new String[bands.size()];

                    colorBands[0] = ColorInterpretation.GRAY_BAND;

                    for (int i = 1; i < colorBands.length; i++) {

                        colorBands[i] = ColorInterpretation.UNDEFINED_BAND;

                    }   colorInterpretation = legendManager.createColorInterpretation(colorBands);

                    break;

            }

            legend.setColorInterpretation(colorInterpretation);

            legend.addLinearStretchEnhancementOperationIfNeeded(colorInterpretation, bands, 0);

            return legend;

        } catch (Exception e) {

            throw new MapContextRuntimeException(e);

        }

    }

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

    // Legend reading/writing

    private Map<Class<ILegend>,Class<ILegendWriter>> getLegendWritersForFormat(String format) {

        synchronized(legendWriters) {

            return legendWriters.get(format);

        }

    }

    private Class<ILegendReader> getLegendReaderForFormat(String format) {

        synchronized(legendReaders) {

            return legendReaders.get(format);

        }

    }

    @Override

    public List<String> getLegendReadingFormats() {

        synchronized(legendReaders) {

            List<String> resp = new ArrayList();

            resp.addAll(legendReaders.keySet());

            return resp;

        }

    }

    @Override

    public List<String> getLegendWritingFormats() {

        synchronized(legendWriters) {

            List<String> resp = new ArrayList();

            resp.addAll(legendWriters.keySet());

            return resp;

        }

    }

    @Override

    public void registerLegendReader(String format, Class readerClass)

            throws MapContextRuntimeException {

        if (readerClass == null

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

            throw new InvalidRegisteredClassException(ILegendReader.class,

                    readerClass, format);

        }

        synchronized (legendReaders) {

            legendReaders.put(format, readerClass);

        }

        notifyObservers(REGISTER_LEGEND_READER, format, readerClass);

    }

    @Override

    public void registerLegendWriter(Class legendClass, String format,

            Class writerClass) throws MapContextRuntimeException {

        if (writerClass == null || legendClass == null

                || !ILegendWriter.class.isAssignableFrom(writerClass)

                || !ILegend.class.isAssignableFrom(legendClass)) {

            throw new InvalidRegisteredClassException(ILegendWriter.class,

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

                            legendClass == null ? "Null" : legendClass.getName()));

        }

        synchronized (legendWriters) {

            Map<Class<ILegend>, Class<ILegendWriter>> legendWriterOfFormat = legendWriters.get(format);

            if (legendWriterOfFormat == null) {

                legendWriterOfFormat = new LinkedHashMap();

                legendWriters.put(format, legendWriterOfFormat);

            }

            legendWriterOfFormat.put(legendClass, writerClass);

        }

        notifyObservers(REGISTER_LEGEND_WRITER, format, writerClass);

    }

    @Override

    public ILegendReader createLegendReader(String format)

            throws MapContextRuntimeException {

        Class<ILegendReader> legendReaderClazz = getLegendReaderForFormat(format);

        if (legendReaderClazz != null) {

            try {

                ILegendReader reader = (ILegendReader) legendReaderClazz.newInstance();

                return (ILegendReader) notifyObservers(CREATE_LEGEND_READER, reader).getValue();

            } catch (InstantiationException|IllegalAccessException e) {

                throw new RegisteredClassInstantiationException(

                        ILegendReader.class, legendReaderClazz, format, e);

            }

        }

        return null;

    }

    @Override

    public ILegendWriter createLegendWriter(Class legendClass, String format)

            throws MapContextRuntimeException {

        if (legendClass == null || format == null) {

            return null;

        }

        Map<Class<ILegend>, Class<ILegendWriter>> legendFormatWriters = getLegendWritersForFormat(format);

        if (legendFormatWriters != null) {

            Class<ILegendWriter> legendWriterClazz = legendFormatWriters.get(legendClass);

            if (legendWriterClazz != null) {

                /*

                 * Found exact match

                 */

                try {

                    ILegendWriter writer = (ILegendWriter) legendWriterClazz.newInstance();

                    return (ILegendWriter) notifyObservers(CREATE_LEGEND_READER, writer).getValue();

                } catch (InstantiationException|IllegalAccessException e) {

                    throw new RegisteredClassInstantiationException(

                            ILegendWriter.class, 

                            legendWriterClazz,

                            format.concat("-").concat(legendClass.getName()), 

                            e

                    );

                }

            } else {

                /*

                 * Trying to find superclass/superinterface of parameter

                 */

                try {

                    return getSuperClassLegendWriter(legendFormatWriters, legendClass);

                } catch (Exception exc) {

                    throw new MapContextRuntimeException(exc);

                }

            }

        }

        return null;

    }

    private ILegendWriter getSuperClassLegendWriter(Map<Class<ILegend>, Class<ILegendWriter>> clsToWtr, Class<ILegend> legclass)

            throws Exception {

        Iterator kiter = clsToWtr.keySet().iterator();

        Object oitem;

        Class<ILegendWriter> citem;

        while (kiter.hasNext()) {

            oitem = kiter.next();

            if (oitem instanceof Class) {

                citem = (Class) oitem;

                if (citem.isAssignableFrom(legclass)) {

                    /*

                     * Found superclass/superinterface

                     */

                    citem = clsToWtr.get(oitem);

                    return (ILegendWriter) citem.newInstance();

                }

            }

        }

        /*

         * No superclass/superinterface found

         */

        return null;

    }

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

    @Override

    public IMultiLayerSymbol createMultiLayerSymbol(int shapeType)

            throws MapContextRuntimeException {

        IMultiLayerSymbol symbol = getSymbolManager().createMultiLayerSymbol(shapeType);

        return (IMultiLayerSymbol) notifyObservers(CREATE_SYMBOL, symbol).getValue();

    }

    @Override

    public IMultiLayerSymbol createMultiLayerSymbol(String symbolName)

            throws MapContextRuntimeException {

        IMultiLayerSymbol symbol = getSymbolManager().createMultiLayerSymbol(symbolName);

        return (IMultiLayerSymbol) notifyObservers(CREATE_SYMBOL, symbol).getValue();

    }

    @Override

    public ISymbol createSymbol(int shapeType, Color color)

            throws MapContextRuntimeException {

        ISymbol symbol = getSymbolManager().createSymbol(shapeType, color);

        return (ISymbol) notifyObservers(CREATE_SYMBOL, symbol).getValue();

    }

    @Override

    public ISymbol createSymbol(int shapeType)

            throws MapContextRuntimeException {

        ISymbol symbol = getSymbolManager().createSymbol(shapeType);

        return (ISymbol) notifyObservers(CREATE_SYMBOL, symbol).getValue();

    }

    @Override

    public ISymbol createSymbol(String symbolName, Color color)

            throws MapContextRuntimeException {

        ISymbol symbol = getSymbolManager().createSymbol(symbolName, color);

        return (ISymbol) notifyObservers(CREATE_SYMBOL, symbol).getValue();

    }

    @Override

    public ISymbol createSymbol(String symbolName)

            throws MapContextRuntimeException {

        ISymbol symbol = getSymbolManager().createSymbol(symbolName);

        return (ISymbol) notifyObservers(CREATE_SYMBOL, symbol).getValue();

    }

    @Override

    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 {

        ISymbol[] symbols = getSymbolManager().loadSymbols(folder, filter);

        return (ISymbol[]) notifyObservers(LOAD_SYMBOLS, symbols).getValue();

    }

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

        ISymbol[] symbols = getSymbolManager().loadSymbols(folder);

        return (ISymbol[]) notifyObservers(LOAD_SYMBOLS, symbols).getValue();

    }

    @Override

    public void registerMultiLayerSymbol(String symbolName, Class symbolClass)

            throws MapContextRuntimeException {

        getSymbolManager().registerMultiLayerSymbol(symbolName, symbolClass);

        notifyObservers(REGISTER_MULTILAYER_SYMBOL, symbolName, symbolClass);

    }

    @Override

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

            Class symbolClass) throws MapContextRuntimeException {

        getSymbolManager().registerMultiLayerSymbol(symbolName, shapeTypes,

                symbolClass);

        notifyObservers(REGISTER_MULTILAYER_SYMBOL, symbolName, symbolClass, shapeTypes);

    }

    @Override

    public void registerSymbol(String symbolName, Class symbolClass)

            throws MapContextRuntimeException {

        getSymbolManager().registerSymbol(symbolName, symbolClass);

        notifyObservers(REGISTER_SYMBOL, symbolName, symbolClass);

    }

    @Override

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

            Class symbolClass) throws MapContextException {

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

        notifyObservers(REGISTER_SYMBOL, symbolName, symbolClass, shapeTypes);

    }

    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);

    }

    @Override

    public boolean registerLayer(

        Class theClass,

        Class<? extends FLayer> layerClass) 

    {

        this.layerClassFromStoreClass.put(theClass, layerClass);

        return true;

    }    

    @Override

    public boolean registerLayer(Factory<FLayer> factory) {

        this.layerClassFromStoreClass.put(factory, null);

        return true;

    }

    private FLayer newLayer(DataStore dataStore) {

        for (Map.Entry<Object, Class<? extends FLayer>> entry : layerClassFromStoreClass.entrySet()) {

            Object  currentKey = entry.getKey();

            if( currentKey instanceof Factory ) {

                Factory<FLayer> factory = (Factory<FLayer>) currentKey;

                FLayer layer = factory.create(dataStore.getParameters(), dataStore);

                if( layer != null ) {

                    return layer;

                }

            }

        }

        return null;

    }

    private Class<? extends FLayer> getLayerClass(

            Class keyClass) {

        Class<? extends FLayer> layerClass = this.layerClassFromStoreClass.get(keyClass);

        if( layerClass!=null ) {

            return layerClass;

        }

        for (Map.Entry<Object, Class<? extends FLayer>> entry : layerClassFromStoreClass.entrySet()) {

            Object  currentKey = entry.getKey();

            if( currentKey instanceof Class ) {

                Class  currentKeyClass = (Class) currentKey;

                layerClass = entry.getValue();

                if( currentKeyClass.isAssignableFrom(keyClass) ) {

                    return layerClass;

                }

            }

        }

        return null;

    }

    @Override

    public FLayer createLayer(String layerName, DataStoreParameters dataParameters)

            throws LoadLayerException {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataStore dataStore = dataManager.openStore(

                    dataParameters.getDataStoreName(), 

                    dataParameters

            );

            return this.createLayer(layerName, dataStore, null);

        } catch (Exception e) {

            throw new LoadLayerException(layerName, e);

        }

    }

    @Override

    public FLayer createLayer(String layerName, DataStore dataStore)

            throws LoadLayerException {

        return this.createLayer(layerName, dataStore, null);

    }

    @Override

    public FLayer createLayer(String layerName, CreateLayerParameters parameters) throws LoadLayerException {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataStoreParameters dataParameters = parameters.getDataParameters();

            DataFactory sf = dataManager.getStoreFactory(dataParameters);

            if( sf==null 

                    || !StringUtils.equalsIgnoreCase(sf.getName(), "FeatureStore") 

                    || parameters.getCoordTrans()!=null 

                    || parameters.useCache() 

                    || parameters.isVisible()

                ) {

                DataStore dataStore = dataManager.openStore(

                        dataParameters.getProviderName(), 

                        dataParameters

                );

                return this.createLayer(layerName, dataStore, parameters);

            }

            Class<? extends FLayer> layerClass = this.getLayerClass(FeatureStore.class);

            if (layerClass == null) {

                throw new CantRetrieveLayerByStoreException(layerName, FeatureStore.class.getName());

            }

            FLayer layer;

            try {

                layer = (FLayer) layerClass.newInstance();

            } catch (InstantiationException | IllegalAccessException e) {

                throw new LoadLayerException(layerName, e);

            }

            layer.setName(layerName);

            layer.setVisible(false);

            ((FLyrVect) layer).setDataStoreParameters(dataParameters);

            layer.load();

            return (FLayer) notifyObservers(CREATE_LAYER, layer).getValue();

        } catch (Exception e) {

            throw new LoadLayerException(layerName, e);

        }

    }    

    @Override

    public FLayer createLayer(String layerName, DataStore dataStore, CreateLayerParameters parameters) throws LoadLayerException {

        try {

            boolean useCache = false;

            ICoordTrans coordTrans = null;

            IProjection projection = (IProjection) dataStore.getDynValue(FeatureStore.METADATA_CRS);

            if( parameters!=null ) {

                if( parameters.getDataParameters()!=dataStore.getParameters() ) {

                    throw new IllegalArgumentException("The dataStore parameters are not the same of the store pased to create layer.");

                }

                useCache = parameters.useCache();

                coordTrans = parameters.getCoordTrans();

                // TODO: Aqui comprobacion de que si hay transformacion es adecuada

                // para la proyeccion del store.

            }

            if( useCache ) {

                DataStoreProviderFactory factory = dataStore.getProviderFactory();

                if( factory.isTiledSupported() != DataStoreProviderFactory.NO ) {

                    if( !factory.getClass().getSimpleName().equals("TileProviderFactory")) {

                        DataManager dataManager = DALLocator.getDataManager();

                        DynObject tileParameters = dataManager.createStoreParameters("TileCache");

                        File cacheFolder;

                        FoldersManager folderManager = ToolsLocator.getFoldersManager();

                        File applicationHome = folderManager.get("ApplicationHome");

                        if( applicationHome==null ) {

                            cacheFolder = folderManager.getTemporaryFile("gvsig_rcache");

                        } else {

                            cacheFolder = new File(applicationHome, "gvsig_rcache");

                        }

                        if (tileParameters.getDynClass().getDynField("rootFolder") != null) {

                            tileParameters.setDynValue("rootFolder", cacheFolder);

                        }

                        try {

                            dataStore.useCache("TileCache", tileParameters);

                        } catch (DataException e) {

                            LOGGER.warn("Can't cache the layer.", e);

                        }

                    }

                }

            }

            FLayer layer = this.newLayer(dataStore);

            if( layer == null ) {

                Class<? extends FLayer> layerClass = this.getLayerClass(dataStore.getParameters().getClass());

                if (layerClass == null) {

                    layerClass = this.getLayerClass(dataStore.getProviderFactory().getClass());

                    if (layerClass == null) {

                        layerClass = this.getLayerClass(dataStore.getClass());

                    }

                    if (layerClass == null) {

                        throw new CantRetrieveLayerByStoreException(layerName, dataStore.getName());

                    }

                }

                try {

                    layer = (FLayer) layerClass.newInstance();

                } catch (InstantiationException | IllegalAccessException e) {

                    throw new LoadLayerException(layerName, e);

                }

            }

            layer.setName(layerName);

            ((SingleLayer) layer).setDataStore(dataStore);

            if (projection != null) {

                layer.setProjection(projection);

                if( coordTrans != null ) {

                    layer.setCoordTrans(coordTrans);

                }

            }

            layer.load();

            return (FLayer) notifyObservers(CREATE_LAYER, layer).getValue();

        } catch (Exception e) {

            throw new LoadLayerException(layerName, e);

        }

    }

    @Override

    public ILegend getLegend(DataStore dataStore) {

        ILegend legend = null;

        ResourcesStorage resourcesStorage = null;

        try {

            resourcesStorage = dataStore.getResourcesStorage();

            if( resourcesStorage!=null ) {

                Resource resource = resourcesStorage.getResource(SymbolManager.LEGEND_FILE_EXTENSION.substring(1));

                try {

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

                        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

                        InputStream is = resource.asInputStream();

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

                        is.close();

                    }

                } catch (Exception e) {

                    LOGGER.warn("Can't loasd legend", e);

                } finally {

                    IOUtils.closeQuietly(resource);

                }

            }

        } finally {

            DisposeUtils.disposeQuietly(resourcesStorage);

        }

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

        if (legend == null) {

            try {

                legend = (ILegend) dataStore.invokeDynMethod("getLegend", null);

            } catch (DynMethodNotSupportedException e) {

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

                        dataStore.getName());

            } catch (DynMethodException e) {

                LOGGER.warn(

                        "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) {

            if( dataStore instanceof FeatureStore ) {

                FeatureType featureType;

                try {

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

                    int indexGeom = featureType.getDefaultGeometryAttributeIndex();

                    if (indexGeom < 0) {

                        throw new IllegalArgumentException("The layer don't has a geometry column.");

                    }

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

                    legend = createDefaultVectorLegend(typeShape);

                } catch (DataException e) {

                    LOGGER.warn("Error getting the default feature type", e);

                }

            } else if( dataStore instanceof RasterStore ) {

                RasterStore rasterStore = (RasterStore) dataStore;

                List<BandDescriptor> bands = rasterStore.getBandDescriptors();

                legend = createDefaultRasterLegend(bands);

            }

        }

        if( legend instanceof RasterLegend ) {

            RasterLegend rasterLegend = (RasterLegend) legend;

            RasterStore rasterStore = (RasterStore) dataStore;

            ColorInterpretation colorInterpretation = rasterLegend.getColorInterpretation();

            if (colorInterpretation.isPalette()) {

                rasterLegend.addColorTableOperation(colorInterpretation, 0);

            } else {

                rasterLegend.addLinearStretchEnhancementOperationIfNeeded(

                        colorInterpretation, 

                        rasterStore.getBandDescriptors(), 

                        0);

            }

            if (colorInterpretation.hasAnyHSLBand()) {

                rasterLegend.addHSLToRGBOperation(colorInterpretation);

            } else if (colorInterpretation.hasAnyCMYKBand()) {

                rasterLegend.addCMYKToRGBOperation(colorInterpretation);

            } else if (colorInterpretation.hasAnyYCBCRBand()) {

              //TODO: Not implemented yet, meanwhile do nothing

    //                legend.addYCBCRToRGBOperation(colorInterpretation);

            }        

        }

        return legend;

    }

    @Override

    public ILabelingStrategy getLabelingStrategy(DataStore dataStore) {

        ILabelingStrategy labelingStrategy = null;

        ResourcesStorage resourcesStorage = dataStore.getResourcesStorage();

        if( resourcesStorage!=null ) {

            Resource resource = resourcesStorage.getResource(SymbolManager.LABELINGSTRATEGY_FILE_EXTENSION.substring(1));

            try {

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

                    PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

                    InputStream is = resource.asInputStream();

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

                    is.close();

                }

            } catch (Exception e) {

                LOGGER.warn("Can't load Label strategy", e);

            } finally {

                IOUtils.closeQuietly(resource);

            }

        }

        //If the legend is null, next option is to check if the store has the getLabeling 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 labeling strategy provided for the datastore {}.",

                        dataStore.getName(),

                        e1);

            }

        }

        return labelingStrategy;

    }

    private Object call(Object instance, String methodName, Class[] signature, Object[] params) {

        try {

            Method method = instance.getClass().getMethod(methodName, signature);

            if (method == null) {

                return null;

            }

            Object value = method.invoke(instance, params);

            return value;

        } catch (Exception ex) {

            return null;

        }

    }

    @Override

    public void registerIconLayer(String storeProviderName, String iconName) {

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

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

            return;

        }

        String storeName = storeProviderName.trim().toLowerCase();

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

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

            return;

        }

        iconLayers.put(storeName, iconName);

        notifyObservers(REGISTER_ICON_LAYER, storeName, iconName);

    }

        @Override

    public String getIconLayer(DataStore store) {

        try {

            return this.getIconLayer(store.getProviderName());

        } catch (Throwable th){

            return "layer-icon";

        }

    }

    @Override

    public String getIconLayer(String providerName) {

                String name = null;

                try {

                        name = (String) iconLayers.get(providerName.trim().toLowerCase());

                } catch(Throwable th) {

                        // Do nothing

                }

                if( StringUtils.isEmpty(name) ) {

                        name = "layer-icon";

                }

        return name;

    }

    /* (non-Javadoc)

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

     */

    @Override

    public IProjection getDefaultCRS() {

        IProjection crs = CRSFactory.getCRS("EPSG:4326");

        return (IProjection) notifyObservers(GET_DEFAULT_CRS, crs).getValue();

    }

    public Notification notifyLoadMapContext(MapContext mapContext) {

        return this.observableHelper.notifyObservers(this, LOAD_MAPCONTEXT, mapContext);

    }

    public Notification notifyLoadLayer(FLayer layer) {

        return this.observableHelper.notifyObservers(this, LOAD_LAYER, layer);

    }

    @Override

    public void addObserver(Observer o) {

        this.observableHelper.addObserver(o);

    }

    @Override

    public void deleteObserver(Observer o) {

        this.observableHelper.deleteObserver(o);

    }

    @Override

    public void deleteObservers() {

        this.observableHelper.deleteObservers();

    }

    protected Notification notifyObservers(String type, Object value) {

        return this.observableHelper.notifyObservers(this, type, value);

    }

    protected Notification notifyObservers(String type, Object value1, Object value2) {

        return this.observableHelper.notifyObservers(this, type, value1, value2);

    }

    protected Notification notifyObservers(String type, Object value1, Object value2, Object value3) {

        return this.observableHelper.notifyObservers(this, type, value1, value2, value3);

    }

    @Override

    public File getColorTableLibraryFolder() {

        if (this.colorTableLibraryFolder == null) {

            // Provide a default value to the location for the color

            // table library.

            String colorTableLibraryPath = System.getProperty("user.home")

                    + File.separator

                    + "gvSIG"

                    + File.separator

                    + "colortable";

            this.colorTableLibraryFolder = new File(colorTableLibraryPath);

        }

        return this.colorTableLibraryFolder;

    }

    @Override

    public void setColorTableLibraryFolder(File colorTableLibraryFolder) {

        this.colorTableLibraryFolder = colorTableLibraryFolder;

    }

    @Override

    public LayerInformationBuilder createLayerInformationBuilder() {

        return new DefaultLayerInformationBuilder();

    }

    @Override

    public Icon getIcon(int geometryType, boolean withSelection) {

        try {

            String name;

            switch (geometryType) {

                case Geometry.TYPES.LINE:

                    name = "layer-type-line";

                    break;

                case Geometry.TYPES.POINT:

                    name = "layer-type-point";

                    break;

                case Geometry.TYPES.POLYGON:

                    name = "layer-type-polygon";

                    break;

                case Geometry.TYPES.MULTILINE:

                    name = "layer-type-multiline";

                    break;

                case Geometry.TYPES.MULTIPOINT:

                    name = "layer-type-multipoint";

                    break;

                case Geometry.TYPES.MULTIPOLYGON:

                    name = "layer-type-multipolygon";

                    break;

                case Geometry.TYPES.GEOMETRY:

                    name = "layer-type-mix";

                    break;

                default:

                    return null;

            }

            if (withSelection) {

                name = name + "-sel";

            }

            name = name + ".png";

            URL url = this.getClass().getResource("/layertypes/" + name);

            if (url == null) {

                return null;

            }

            Icon icon = new ImageIcon(url);

            return icon;

        } catch (Exception ex) {

            return null;

        }

    }

}