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

import java.io.FileNotFoundException;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

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 org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

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

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

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

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

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

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

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

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.exception.DynMethodException;

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

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 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 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 String defaultVectorLegend;

    private ObservableHelper observableHelper = new ObservableHelper();

    private File colorTableLibraryFolder = null;

    private String defaultRasterLegend;

    public MapContext createMapContext() {

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

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

    }

    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 {

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

            notifyObservers(CREATE_MAPCONTEXT_DRAWER, drawer);

            return drawer;

        } catch (Exception ex) {

            throw new RegisteredClassInstantiationException(

                    MapContextDrawer.class, drawerClazz, name, ex);

        }

    }

    public void setDefaultMapContextDrawer(Class drawerClazz)

            throws MapContextException {

        validateMapContextDrawer(drawerClazz);

        this.drawerClazz = drawerClazz;

        notifyObservers(SET_MAPCONTEXT_DRAWER, drawerClazz);

    }

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

            }

            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 = null;

        Class citem = null;

        while (kiter.hasNext()) {

            oitem = kiter.next();

            if (oitem instanceof Class) {

                citem = (Class) oitem;

                if (citem.isAssignableFrom(legclass)) {

                    /*

                     * Found superclass/superinterface

                     */

                    citem = (Class) clsToWtr.get(oitem);

                    return (ILegendWriter) citem.newInstance();

                }

            }

        }

        /*

         * No superclass/superinterface found

         */

        return null;

    }

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

    public IMultiLayerSymbol createMultiLayerSymbol(int shapeType)

            throws MapContextRuntimeException {

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

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

    }

    public IMultiLayerSymbol createMultiLayerSymbol(String symbolName)

            throws MapContextRuntimeException {

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

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

    }

    public ISymbol createSymbol(int shapeType, Color color)

            throws MapContextRuntimeException {

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

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

    }

    public ISymbol createSymbol(int shapeType)

            throws MapContextRuntimeException {

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

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

    }

    public ISymbol createSymbol(String symbolName, Color color)

            throws MapContextRuntimeException {

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

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

    }

    public ISymbol createSymbol(String symbolName)

            throws MapContextRuntimeException {

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

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

    }

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

    }

    public void registerMultiLayerSymbol(String symbolName, Class symbolClass)

            throws MapContextRuntimeException {

        getSymbolManager().registerMultiLayerSymbol(symbolName, symbolClass);

        notifyObservers(REGISTER_MULTILAYER_SYMBOL, symbolName, symbolClass);

    }

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

            Class symbolClass) throws MapContextRuntimeException {

        getSymbolManager().registerMultiLayerSymbol(symbolName, shapeTypes,

                symbolClass);

        notifyObservers(REGISTER_MULTILAYER_SYMBOL, symbolName, symbolClass, shapeTypes);

    }

    public void registerSymbol(String symbolName, Class symbolClass)

            throws MapContextRuntimeException {

        getSymbolManager().registerSymbol(symbolName, symbolClass);

        notifyObservers(REGISTER_SYMBOL, symbolName, symbolClass);

    }

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

    }

    public FLayer createLayer(String layerName, DataStoreParameters parameters)

            throws LoadLayerException {

        FLayer layer = LayerFactory.getInstance().createLayer(layerName, parameters);

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

    }

    @Override

    public FLayer createLayer(String layerName, DataStore store)

            throws LoadLayerException {

        FLayer layer = LayerFactory.getInstance().createLayer(layerName, store);

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

    }

    @Override

    public ILegend getLegend(DataStore dataStore) {

        ILegend legend = null;

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

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

            FileInputStream is = null;

            try {

                PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

                is = new FileInputStream(file);

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

            } catch (FileNotFoundException e) {

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

            } finally {

                IOUtils.closeQuietly(is);

            }

        }

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

        File file = getResourcePath(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 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 (NoSuchMethodException ex) {

            return null;

        } catch (SecurityException ex) {

            return null;

        } catch (IllegalAccessException ex) {

            return null;

        } catch (IllegalArgumentException ex) {

            return null;

        } catch (InvocationTargetException ex) {

            return null;

        }

    }

    private File getResourcePath(DataStore dataStore, String resource) {

        //Loading the file from a store based on file

        DataServerExplorer explorer = null;

        try {

            explorer = dataStore.getExplorer();

            if (explorer == null) {

                return null;

            }

            return explorer.getResourcePath(dataStore, resource);

        } catch (Exception e) {

            logger.warn(

                    "Can't locate a specific legend provided by the explorer "

                    + explorer, e);

            return null;

        } finally {

            DisposeUtils.disposeQuietly(explorer);

        }

    }

    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;

        }

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

     */

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

    }

    public void addObserver(Observer o) {

        this.observableHelper.addObserver(o);

    }

    public void deleteObserver(Observer o) {

        this.observableHelper.deleteObserver(o);

    }

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

    }

    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;

    }

    public void setColorTableLibraryFolder(File colorTableLibraryFolder) {

        this.colorTableLibraryFolder = colorTableLibraryFolder;

    }

    @Override

    public LayerInformationBuilder createLayerInformationBuilder() {

        return new DefaultLayerInformationBuilder();

    }

}