| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {DiSiD Technologies}  {{Task}}

 */

package org.gvsig.fmap.mapcontext.rendering.symbols.impl;

import java.awt.Color;

import java.io.File;

import java.io.FileFilter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import java.util.Random;

import org.gvsig.fmap.mapcontext.MapContextRuntimeException;

import org.gvsig.fmap.mapcontext.impl.InvalidRegisteredClassException;

import org.gvsig.fmap.mapcontext.impl.RegisteredClassInstantiationException;

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.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Default {@link SymbolManager} implementation.

 * 

 * @author gvSIG team

 */

public class DefaultSymbolManager implements SymbolManager {

        private SymbolPreferences symbolPreferences =

                        new DefaultSymbolPreferences();

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

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

        private Map multiLineSymbolsByName =

                        Collections.synchronizedMap(new HashMap());

        private Map multiLineSymbolsByShapeType =

                        Collections.synchronizedMap(new HashMap());

        private IWarningSymbol warningSymbol;

        private Object warningSymbolLock = new Object();

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

                return loadSymbols(folder, null);

        }

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

                        throws SymbolException {

                // TODO: add symbol caching

                if (folder.exists()) {

                        File[] symbolFiles = null;

                        if (fileFilter == null) {

                                symbolFiles = folder.listFiles();

                        } else {

                                symbolFiles = folder.listFiles(fileFilter);

                        }

                        if (symbolFiles != null) {

                                ISymbol[] symbols = new ISymbol[symbolFiles.length];

                                for (int i = 0; i < symbolFiles.length; i++) {

                                        symbols[i] = loadSymbol(symbolFiles[i]);

                                }

                                return symbols;

                        }

                }

                return null;

        }

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

                        throws SymbolException {

                saveSymbol(symbol, fileName, folder, false);

        }

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

                        boolean overwrite) throws SymbolException {

                // TODO: add symbol caching

                PersistenceManager persistenceManager = ToolsLocator

                                .getPersistenceManager();

                File symbolFile = new File(folder, fileName);

                if (!overwrite && symbolFile.exists()) {

                        throw new SymbolFileAlreadyExistsException(symbolFile);

                }

                try {

                        FileOutputStream fos = new FileOutputStream(symbolFile);

                        persistenceManager.saveState(persistenceManager.getState(symbol),

                                        fos);

                        fos.flush();

                        fos.close();

                } catch (PersistenceException e) {

                        throw new SaveSymbolException(e);

                } catch (IOException e) {

                        throw new SaveSymbolException(e);

                }

        }

        /**

         * Loads a persisted symbol from the given file.

         */

        private ISymbol loadSymbol(File file) throws SymbolException {

                if (file.exists()) {

                        try {

                                FileInputStream fis = new FileInputStream(file);

                                PersistenceManager persistenceManager = ToolsLocator

                                                .getPersistenceManager();

                                PersistentState state = persistenceManager.loadState(fis);

                                ISymbol symbol = (ISymbol) persistenceManager.create(state);

                                fis.close();

                                return symbol;

                        } catch (PersistenceException e) {

                                throw new LoadSymbolException(e);

                        } catch (IOException e) {

                                throw new LoadSymbolException(e);

                        }

                }

                return null;

        }

        public SymbolPreferences getSymbolPreferences() {

                return symbolPreferences;

        }

        public ISymbol createSymbol(String symbolName)

                        throws MapContextRuntimeException {

                return createSymbol(symbolName, (Class) symbolsByName.get(symbolName),

                                ISymbol.class);

        }

        public ISymbol createSymbol(int shapeType)

                        throws MapContextRuntimeException {

                String symbolName =

                                (String) symbolsByShapeType.get(new Integer(shapeType));

                return symbolName == null ? null : createSymbol(symbolName);

        }

        public ISymbol createSymbol(String symbolName, Color color)

                        throws MapContextRuntimeException {

                ISymbol symbol = createSymbol(symbolName);

                if (symbol != null) {

                        symbol.setColor(color);

                }

                return symbol;

        }

        public ISymbol createSymbol(int shapeType, Color color)

                        throws MapContextRuntimeException {

                String symbolName =

                                (String) symbolsByShapeType.get(new Integer(shapeType));

                return symbolName == null ? null : createSymbol(symbolName, color);

        }

        public IMultiLayerSymbol createMultiLayerSymbol(String symbolName)

                        throws MapContextRuntimeException {

                return (IMultiLayerSymbol) createSymbol(symbolName,

                                (Class) multiLineSymbolsByName.get(symbolName),

                                IMultiLayerSymbol.class);

        }

        public IMultiLayerSymbol createMultiLayerSymbol(int shapeType)

                        throws MapContextRuntimeException {

                String symbolName =

                                (String) multiLineSymbolsByShapeType.get(new Integer(shapeType));

                return symbolName == null ? null : createMultiLayerSymbol(symbolName);

        }

        public void registerSymbol(String symbolName, Class symbolClass)

                        throws MapContextRuntimeException {

                if (symbolClass == null || !ISymbol.class.isAssignableFrom(symbolClass)) {

                        throw new InvalidRegisteredClassException(ISymbol.class,

                                        symbolClass, symbolName);

                }

                symbolsByName.put(symbolName, symbolClass);

        }

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

                        Class symbolClass) throws MapContextRuntimeException {

                registerSymbol(symbolName, symbolClass);

                if (shapeTypes != null) {

                        for (int i = 0; i < shapeTypes.length; i++) {

                                symbolsByShapeType.put(new Integer(shapeTypes[i]), symbolName);

                        }

                }

        }

        public void registerMultiLayerSymbol(String symbolName, Class symbolClass)

                        throws MapContextRuntimeException {

                if (symbolClass == null

                                || !IMultiLayerSymbol.class.isAssignableFrom(symbolClass)) {

                        throw new InvalidRegisteredClassException(IMultiLayerSymbol.class,

                                        symbolClass, symbolName);

                }

                multiLineSymbolsByName.put(symbolName, symbolClass);

        }

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

                        Class symbolClass) throws MapContextRuntimeException {

                registerMultiLayerSymbol(symbolName, symbolClass);

                if (shapeTypes != null) {

                        for (int i = 0; i < shapeTypes.length; i++) {

                                multiLineSymbolsByShapeType.put(new Integer(shapeTypes[i]),

                                                symbolName);

                        }

                }

        }

        public IWarningSymbol getWarningSymbol(String message, String symbolDesc,

                        int symbolDrawExceptionType) throws MapContextRuntimeException {

                synchronized (warningSymbolLock) {

                        if (warningSymbol == null) {

                                warningSymbol = (IWarningSymbol) createSymbol("warning");

                        }

                }

                // TODO: set those values as parameter values in the draw method.

                warningSymbol.setDescription(symbolDesc);

                warningSymbol.setMessage(message);

                warningSymbol.setDrawExceptionType(symbolDrawExceptionType);

                return warningSymbol;

        }

        private ISymbol createSymbol(String symbolName, Class symbolClass,

                        Class expectedType) throws MapContextRuntimeException {

                ISymbol symbol;

                try {

                        symbol =

                                        (ISymbol) (symbolClass == null ? null

                                                        : symbolClass.newInstance());

                } catch (InstantiationException e) {

                        throw new RegisteredClassInstantiationException(expectedType,

                                        symbolClass, symbolName, e);

                } catch (IllegalAccessException e) {

                        throw new RegisteredClassInstantiationException(expectedType,

                                        symbolClass, symbolName, e);

                }

        Color symbolColor;

        if (getSymbolPreferences().isDefaultSymbolFillColorAleatory()) {

            Random rand = new Random();

            int numreg = rand.nextInt(255 / 2);

            double div = (1 - rand.nextDouble() * 0.66) * 0.9;

            symbolColor =

                new Color(

                    ((int) (255 * div + (numreg * rand.nextDouble()))) % 255,

                    ((int) (255 * div + (numreg * rand.nextDouble()))) % 255,

                    ((int) (255 * div + (numreg * rand.nextDouble()))) % 255);

        }

        else {

            symbolColor = getSymbolPreferences().getDefaultSymbolFillColor();

        }

        symbol.setColor(symbolColor);

                // Perform this initialization into the Symbol implementation

                // if (symbol instanceof CartographicSupport) {

                // CartographicSupport cs = (CartographicSupport) symbol;

                // cs.setUnit(getDefaultCartographicSupportMeasureUnit());

                // cs

                // .setReferenceSystem(getDefaultCartographicSupportReferenceSystem();

                // }

                return symbol;

        }

        public void setSymbolPreferences(SymbolPreferences symbolPreferences) {

                this.symbolPreferences = symbolPreferences;

        }

}