Application: gvSIG desktop

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

 *

 */

package org.gvsig.symbology.app.importsymbols;

import java.awt.Component;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.net.URL;

import java.text.MessageFormat;

import java.util.HashSet;

import java.util.Set;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import javax.swing.filechooser.FileFilter;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.fmap.mapcontext.MapContextLocator;

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

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IPictureMarkerSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

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

public class ImportSymbolsExtension extends Extension {

    private static Logger LOG =

        LoggerFactory.getLogger(ImportSymbolsExtension.class);

    private static final Set<String> imageExtensionsAllowed;

    static {

        imageExtensionsAllowed = new HashSet<String>();

        imageExtensionsAllowed.add("png");

        imageExtensionsAllowed.add("jpg");

        imageExtensionsAllowed.add("jpeg");

        imageExtensionsAllowed.add("gif");

        imageExtensionsAllowed.add("bmp");

        imageExtensionsAllowed.add("svg");

    }

    // returns the output folder (/home/user/gvSIG/Symbols)

    private File getOutputFolderPath() {

        SymbolManager manager = MapContextLocator.getSymbolManager();

        return new File(manager.getSymbolPreferences().getSymbolLibraryPath());

    }

    private String deleteExtension(File file) {

        String outFileName =

            file.getPath().substring(0, file.getPath().lastIndexOf("."));

        return outFileName;

    }

    // gets the selection image (from filename.png it returns filenamesel.png,

    // for example)

    private File getSelImage(File imageIn) {

        String cadena = deleteExtension(imageIn);

        String extension =

            imageIn.getPath().substring(imageIn.getPath().lastIndexOf("."),

                imageIn.getPath().length());

        String selPath = cadena + "sel" + extension;

        File imageOut = new File(selPath);

        return imageOut;

    }

    // Copies File imageIn to imageOut

    private void copy(File imageIn, File imageOut) throws IOException {

        FileInputStream from = null;

        FileOutputStream to = null;

        from = new FileInputStream(imageIn.getPath());

        to = new FileOutputStream(imageOut.getPath());

        try {

            byte[] buffer = new byte[4096];

            int bytesRead;

            while ((bytesRead = from.read(buffer)) != -1) {

                to.write(buffer, 0, bytesRead); // write

            }

        } finally {

            if (from != null) {

                try {

                    from.close();

                } catch (IOException e) {

                    ;

                }

            }

            if (to != null) {

                try {

                    to.close();

                } catch (IOException e) {

                    ;

                }

            }

        }

    }

    private void addImageSymbol(File image) throws IOException {

        int option;

        boolean sobreescribir = true;

        File selImage = getSelImage(image);

        File imageOut = new File(getOutputFolderPath() + "/" + image.getName());

        File selImageOut =

            new File(getOutputFolderPath() + "/" + selImage.getName());

        // Overwrite or not

        if (imageOut.exists()) {

            Object[] options = { getText("_Overwrite"), getText("_Cancel") };

            option =

                JOptionPane

                    .showOptionDialog(

                        null,

                        MessageFormat

                            .format(

                                getText("The file_{0}_already_exists.\n\n_Do_you_want_to_overwrite_it?"),

                                imageOut.getPath()),

                        getText("_Import_symbols"), JOptionPane.DEFAULT_OPTION,

                        JOptionPane.INFORMATION_MESSAGE, null, options,

                        options[0]);

            if (option == 1) {

                sobreescribir = false;

            }

        }

        SymbologyManager manager = SymbologyLocator.getSymbologyManager();

        SymbolManager symbolManager = MapContextLocator.getSymbolManager();

        if (sobreescribir) {

            try {

                // Copies the image to the output folder

                copy(image, imageOut);

                URL imageURL = imageOut.toURI().toURL();

                URL selImageURL = null;

                // tries to copy the selection image

                if (selImage.exists()) {

                    copy(selImage, selImageOut);

                    selImageURL = selImageOut.toURI().toURL();

                }

                IPictureMarkerSymbol symbol =

                    manager.createPictureMarkerSymbol(imageURL, selImageURL);

                PersistenceManager persistenceManager =

                    ToolsLocator.getPersistenceManager();

                PersistentState state = persistenceManager.getState(symbol);

                // change file extension

                String outFileName =

                    deleteExtension(imageOut)

                        + symbolManager.getSymbolPreferences()

                            .getSymbolFileExtension();

                FileOutputStream out = new FileOutputStream(outFileName);

                persistenceManager.saveState(state, out);

            } catch (PersistenceValidateExceptions e) {

                IOException ioex = new IOException();

                ioex.initCause(e);

                throw ioex;

            } catch (PersistenceException e) {

                IOException ioex = new IOException();

                ioex.initCause(e);

                throw ioex;

            }

        } else {

        }

    }

    public void execute(String actionCommand) {

        if (actionCommand.equalsIgnoreCase("Import_symbols")) {

            // Create a file chooser

            final JFileChooser fc = new JFileChooser();

            Component parent = null;

            // the fileChooser will only accept jpg, gif, png, jpeg, bmp and svg

            // image formats

            fc.setFileFilter(new FileFilter() {

                /*

                 * Get the extension of a file.

                 */

                public String getExtension(File f) {

                    String ext = null;

                    String s = f.getName();

                    int i = s.lastIndexOf('.');

                    if (i > 0 && i < s.length() - 1) {

                        ext = s.substring(i + 1).toLowerCase();

                    }

                    return ext;

                }

                @Override

                public String getDescription() {

                    return "JPG, GIF, PNG, JPEG, BMP & SVG Images";

                }

                @Override

                public boolean accept(File f) {

                    if (f.isDirectory()) {

                        return true;

                    }

                    String extension = getExtension(f);

                    return extension != null

                        && imageExtensionsAllowed.contains(extension);

                }

            });

            fc.setMultiSelectionEnabled(true);

            fc.showDialog(parent, getText("_Import_symbols"));

            // for every selected file, a symbol is created

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

                File image = fc.getSelectedFiles()[i];

                try {

                    addImageSymbol(image);

                } catch (IOException e) {

                    LOG.error(MessageFormat.format(

                        getText("_An error_ocurred_creating_the_symbol_related_to_{0}"),

                        image.getAbsolutePath()), e);

                    // Error message, the symbol may not have been imported.

                    JOptionPane

                        .showMessageDialog(

                            null,

                            MessageFormat

                                .format(

                                    getText("_An_error_ocurred_creating_the_simbol_related_to_{0}"),

                                    image.getAbsolutePath()),

                            "_Import_symbols", JOptionPane.ERROR_MESSAGE);

                }

            }

            // Message that the import has finished, with or without errors.

            JOptionPane.showMessageDialog(null,

                getText("_Importing_symbols_has_finished."),

                "_Import_symbols", JOptionPane.INFORMATION_MESSAGE);

        }

    }

    public void initialize() {

    }

    @Override

    public void postInitialize() {

    }

    public boolean isEnabled() {

        return true;

    }

    public boolean isVisible() {

        return true;

    }

}