Aplicación gvSIG con fines educativos » Mapas temáticos

/* 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.educa.thematicmap.app.editor.impl;

import java.io.File;

import java.io.IOException;

import java.util.List;

import javax.swing.JFileChooser;

import javax.swing.SwingUtilities;

import org.apache.commons.lang3.ObjectUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.educa.thematicmap.ThematicMapException;

import org.gvsig.educa.thematicmap.ThematicMapFileServices;

import org.gvsig.educa.thematicmap.ThematicMapLocator;

import org.gvsig.educa.thematicmap.ThematicMapManager;

import org.gvsig.educa.thematicmap.app.editor.CompilationListener;

import org.gvsig.educa.thematicmap.app.editor.ThematicMapEditorManager;

import org.gvsig.educa.thematicmap.app.viewer.ThematicMapDocument;

import org.gvsig.educa.thematicmap.app.viewer.ThematicMapDocumentManager;

import org.gvsig.educa.thematicmap.compilation.ThematicMapCompilation;

import org.gvsig.educa.thematicmap.compilation.ThematicMapCompilationInformation;

import org.gvsig.educa.thematicmap.compilation.ThematicMapCompiler;

import org.gvsig.educa.thematicmap.compilation.ThematicMapCompilerStatus;

import org.gvsig.educa.thematicmap.map.CantLoadContextException;

import org.gvsig.educa.thematicmap.map.InvalidThematicMapFormatException;

import org.gvsig.educa.thematicmap.map.ThematicMap;

import org.gvsig.educa.thematicmap.map.ThematicMapInformation;

import org.gvsig.educa.thematicmap.swing.ThematicMapSwingLocator;

import org.gvsig.educa.thematicmap.swing.ThematicMapSwingManager;

import org.gvsig.educa.thematicmap.swing.ThematicMapWindowManager;

import org.gvsig.educa.thematicmap.swing.ThematicMapWindowManager.MESSAGE_DIALOG_TYPE;

import org.gvsig.educa.thematicmap.swing.editor.ThematicMapCompilationEditor;

import org.gvsig.educa.thematicmap.swing.editor.ThematicMapCompilationEditorListener;

import org.gvsig.fmap.mapcontext.MapContext;

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

import org.gvsig.tools.swing.api.windowmanager.WindowManager.MODE;

/**

 * <p>

 * Default implementation of {@link ThematicMapEditorManager}

 * </p>

 * 

 * @author gvSIG Team

 * @version $Id$

 * 

 */

public class DefaultThematicMapEditorManager implements

    ThematicMapEditorManager {

    private ThematicMapDocumentManager docManager;

    private final ThematicMapManager manager;

    private final ThematicMapSwingManager swingManager;

    private final ThematicMapWindowManager winManager;

    private final ThematicMapFileServices fileServices;

    private File workFolder;

    private final JFileChooser fileChooser;

    /**

     *

     */

    public DefaultThematicMapEditorManager() {

        swingManager = ThematicMapSwingLocator.getSwingManager();

        manager = swingManager.getManager();

        fileServices = ThematicMapLocator.getFileServices();

        winManager = swingManager.getWindowManager();

        fileChooser = new JFileChooser();

    }

    /**

     * <p>

     * {@link CompilationListener} instance which create a new

     * {@link ThematicMapDocument} from a {@link ViewDocument}

     * </p>

     * <p>

     * Delegates on previously received listener (if any)

     * </p>

     * 

     * @author gvSIG Team

     * @version $Id$

     * 

     */

    private class CreateDocumentListener implements CompilationListener {

        private final CompilationListener delegate;

        private final boolean openWindow;

        private final ViewDocument sourceView;

        /**

         * @param openWindow

         * 

         */

        public CreateDocumentListener(ViewDocument sourceView,

            CompilationListener delegate, boolean openWindow) {

            this.sourceView = sourceView;

            this.delegate = delegate;

            this.openWindow = openWindow;

        }

        /** {@inheridDoc} */

        public void finished(ThematicMapCompilerStatus status) {

            // Gets created map

            ThematicMap map =

                manager.getMapById(status.getResultCompilation()

                    .getInformation().getId());

            // Check if a document already exist for this map

            ThematicMapDocumentManager docManager = getDocManager();

            ThematicMapDocument doc = docManager.getDocumentForMap(map);

            if (doc == null) {

                doc = docManager.createDocument(map);

                getProject().add(doc);

            } else {

                // If exist reload

                try {

                    doc.reloadThematicMap();

                } catch (Exception ex) {

                    NotificationManager.addError(swingManager

                        .getTranslation("problems_reloading_thematic_map"), ex);

                }

            }

            // Link view to thematic map

            doc.setSourceView(sourceView);

            if (openWindow) {

                final IWindow window = docManager.getMainWindow(doc);

                SwingUtilities.invokeLater(new Runnable() {

                    public void run() {

                        PluginServices.getMDIManager().addWindow(window);

                    }

                });

            }

            if (delegate != null) {

                delegate.finished(status);

            }

        }

        /** {@inheridDoc} */

        public void canceledCompilation(ThematicMapCompilerStatus status) {

            if (delegate != null) {

                delegate.canceledCompilation(status);

            }

        }

        /** {@inheridDoc} */

        public void canceledEditing(ThematicMapCompilation compilation) {

            if (delegate != null) {

                delegate.canceledEditing(compilation);

            }

        }

        /** {@inheridDoc} */

        public void fail(ThematicMapCompilerStatus status) {

            if (delegate != null) {

                delegate.fail(status);

            } else {

                String msg =

                    swingManager

                        .getTranslation(

                            "problems_creating_thematic_map_from_a_view")

                        .concat(": ").concat(status.getFailMessage());

                if (status.getException() != null) {

                    NotificationManager.addWarning(msg, status.getException());

                } else {

                    NotificationManager.addWarning(msg);

                }

            }

        }

        public void exception(String message, Throwable exception) {

            if (delegate != null) {

                delegate.exception(message, exception);

            } else {

                String msg =

                    swingManager

                        .getTranslation(

                            "problems_creating_thematic_map_from_a_view")

                        .concat(": ").concat(message);

                NotificationManager.addError(msg, exception);

            }

        }

    }

    /**

     * <p>

     * {@link CompilationListener} instance which update the

     * {@link ThematicMapDocument} from its related {@link ViewDocument} (

     * {@link ThematicMapDocument#getSourceView()})

     * </p>

     * <p>

     * Delegates on previously received listener (if any)

     * </p>

     * 

     * @author gvSIG Team

     * @version $Id$

     * 

     */

    private class UpdateDocumentListener implements CompilationListener {

        private final CompilationListener delegate;

        private final boolean openWindow;

        private final ThematicMapDocument toUpdate;

        /**

         * @param openWindow

         * 

         */

        public UpdateDocumentListener(ThematicMapDocument toUpdate,

            CompilationListener delegate, boolean openWindow) {

            this.toUpdate = toUpdate;

            this.delegate = delegate;

            this.openWindow = openWindow;

        }

        /** {@inheridDoc} */

        public void finished(ThematicMapCompilerStatus status) {

            // close doc windows if it was opened

            PluginServices.getMDIManager().closeSingletonWindow(toUpdate);

            // Reload maps

            try {

                toUpdate.reloadThematicMap();

            } catch (Exception ex) {

                NotificationManager.addError(swingManager

                    .getTranslation("problems_reloading_thematic_map"), ex);

                return;

            }

            if (openWindow) {

                final IWindow window =

                    toUpdate.getFactory().getMainWindow(toUpdate);

                SwingUtilities.invokeLater(new Runnable() {

                    public void run() {

                        PluginServices.getMDIManager().addWindow(window);

                    }

                });

            }

            if (delegate != null) {

                delegate.finished(status);

            }

        }

        /** {@inheridDoc} */

        public void canceledCompilation(ThematicMapCompilerStatus status) {

            if (delegate != null) {

                delegate.canceledCompilation(status);

            }

        }

        /** {@inheridDoc} */

        public void canceledEditing(ThematicMapCompilation compilation) {

            if (delegate != null) {

                delegate.canceledEditing(compilation);

            }

        }

        /** {@inheridDoc} */

        public void fail(ThematicMapCompilerStatus status) {

            if (delegate != null) {

                delegate.fail(status);

            } else {

                String msg =

                    swingManager

                        .getTranslation("problems_regeneration_thematic_map")

                        .concat(": ").concat(status.getFailMessage());

                if (status.getException() != null) {

                    NotificationManager.addWarning(msg, status.getException());

                } else {

                    NotificationManager.addWarning(msg);

                }

            }

        }

        public void exception(String message, Throwable exception) {

            if (delegate != null) {

                delegate.exception(message, exception);

            } else {

                String msg =

                    swingManager

                        .getTranslation("problems_regeneration_thematic_map")

                        .concat(": ").concat(message);

                NotificationManager.addError(msg, exception);

            }

        }

    }

    /** {@inheridDoc} */

    public void createThematicMapFromView(ViewDocument view,

        CompilationListener listener, boolean openWindow) {

        if (view == null) {

            throw new IllegalArgumentException("View document required");

        }

        ThematicMapCompilation compilation =

            manager.createCompilationInstance();

        ThematicMapCompilationInformation info = compilation.getInformation();

        info.setName(view.getName());

        info.setId(generateIdForViewName(view.getName()));

        info.setVersion(1);

        compilation.setMapContext(view.getMapContext().cloneFMap());

        ThematicMapCompilationEditor editor =

            swingManager.getCopilationEditor(compilation, false);

        final CreateDocumentListener myListener =

            new CreateDocumentListener(view, listener, openWindow);

        editor.setListener(new ThematicMapCompilationEditorListener() {

            public void finished(final ThematicMapCompilationEditor editor) {

                editor.getSwingComponent().setVisible(false);

                SwingUtilities.invokeLater(new Runnable() {

                    public void run() {

                        try {

                            compileInInstallFolder(editor.getCompilation(),

                                myListener);

                        } catch (Exception ex) {

                            myListener.exception("Exception compiling", ex);

                        }

                    }

                });

            }

            public void canceled(final ThematicMapCompilationEditor editor) {

                editor.getSwingComponent().setVisible(false);

                SwingUtilities.invokeLater(new Runnable() {

                    public void run() {

                        myListener.canceledEditing(editor.getCompilation());

                    }

                });

            }

        });

        winManager.showCompilationEditor(editor, MODE.WINDOW);

    }

    /** {@inheridDoc} */

    public void compileInInstallFolder(ThematicMapCompilation compilation,

        CompilationListener listener) {

        if (compilation == null) {

            throw new IllegalArgumentException("Compilation required");

        }

        ThematicMapCompiler compiler = manager.createCompilerInstance();

        compiler.setTargetFolder(manager.getInstallationMapFolder());

        // prepare a temp folder

        compiler.setWorkFolder(getWorkFolder());

        ThematicMapCompilerStatus result = compiler.compile(compilation);

        if (listener != null) {

            if (result.getStatus() == ThematicMapCompilerStatus.Status.finished_ok) {

                listener.finished(result);

                return;

            }

            if (result.getStatus() == ThematicMapCompilerStatus.Status.canceled) {

                listener.canceledCompilation(result);

                return;

            }

            listener.fail(result);

        }

    }

    /**

     * Generates a ThematicMap id from a View Document name

     * 

     * @param viewName

     * @return

     */

    private String generateIdForViewName(String viewName) {

        String name = StringUtils.replace(viewName.trim(), " ", "_");

        return name;

    }

    /**

     * Prepare a work folder for compiler base on

     * {@link ThematicMapManager#getTemporalFolder()}

     * 

     * @return

     */

    private String getWorkFolder() {

        if (workFolder == null) {

            workFolder =

                fileServices.getNewWritableFolder(

                    new File(manager.getTemporalFolder()), "_compiler_");

            workFolder.deleteOnExit();

        }

        return workFolder.getAbsolutePath();

    }

    /** {@inheridDoc} */

    public ThematicMapDocumentManager getDocManager() {

        if (docManager == null) {

            docManager =

                (ThematicMapDocumentManager) ProjectManager.getInstance()

                    .getDocumentManager(ThematicMapDocumentManager.TYPENAME);

        }

        return docManager;

    }

    /** {@inheridDoc} */

    public File generatePackage(ThematicMapDocument thematicMap,

        File targetFolder) throws ThematicMapException, IOException {

        if (thematicMap == null) {

            throw new IllegalArgumentException("Thematic Map document required");

        }

        return manager.generatePackageFile(thematicMap.getThematicMap()

            .getInformation().getId(), targetFolder);

    }

    /** {@inheridDoc} */

    public File generatePackage(ThematicMapDocument thematicMap)

        throws ThematicMapException, IOException {

        File target =

            askForAOutputFolder(swingManager

                .getTranslation("Select_folder_to_store_package"));

        return generatePackage(thematicMap, target);

    }

    /** {@inheridDoc} */

    public ThematicMapDocument getThematicMapDocumentByView(ViewDocument view) {

        if (view == null) {

            throw new IllegalArgumentException("View document required");

        }

        List<Document> documents =

            getProject().getDocuments(ThematicMapDocumentManager.TYPENAME);

        ThematicMapDocument map;

        for (Document doc : documents) {

            map = (ThematicMapDocument) doc;

            if (ObjectUtils.equals(map.getSourceView(), view)) {

                return map;

            }

        }

        return null;

    }

    /**

     * Gets current gvSIG project

     * 

     * @return

     */

    public Project getProject() {

        return ProjectManager.getInstance().getCurrentProject();

    }

    /**

     * Shows a dialog to ask a output folder

     * 

     * @param description

     *            of the file is for

     * @return

     */

    public File askForAOutputFolder(String description) {

        fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);

        int targetFolderAnswere = fileChooser.showDialog(null, description);

        if (targetFolderAnswere != JFileChooser.APPROVE_OPTION) {

            return null;

        }

        return fileChooser.getSelectedFile();

    }

    /** {@inheridDoc} */

    public ViewDocument exportThematicMapToView(ThematicMapDocument map,

        boolean openViewWindow) throws IOException,

        InvalidThematicMapFormatException, PersistenceException {

        File target;

        while (true) {

            target =

                askForAOutputFolder(swingManager

                    .getTranslation("Select_folder_to_extract_data"));

            if (target == null) {

                return null;

            }

            if (!target.exists()) {

                continue;

            }

            if (target.list().length == 0) {

                break;

            } else {

                winManager.showMessageDialog(swingManager

                    .getTranslation("Select_folder_to_extract_data"),

                    swingManager.getTranslation("folder_must_be_empty"),

                    MESSAGE_DIALOG_TYPE.WARNING);

            }

        }

        return exportThematicMapToView(map, target, openViewWindow);

    }

    /** {@inheridDoc} */

    public ViewDocument exportThematicMapToView(ThematicMapDocument map,

        File exportFolder, boolean openViewWindow) throws IOException,

        InvalidThematicMapFormatException, PersistenceException {

        if (map == null) {

            throw new IllegalArgumentException("Thematic Map document required");

        }

        if (!fileServices.isWritableFolder(exportFolder)) {

            throw new IllegalArgumentException(

                "Not a writable folder: ".concat(exportFolder.getAbsolutePath()));

        }

        if (exportFolder.list().length > 0) {

            throw new IllegalArgumentException(

                "Not a empty folder: ".concat(exportFolder.getAbsolutePath()));

        }

        File mapFile = new File(map.getThematicMap().getSourceFilePath());

        fileServices.unzipFile(mapFile, exportFolder);

        // Prepares mapContext file path

        File mapContextFile =

            new File(exportFolder, "mapContext/mapContext.xml");

        // Check if mapContext file exists

        if (!mapContextFile.exists()) {

            throw new InvalidThematicMapFormatException(mapFile,

                "Missing mapContext/mapContext.xml file in deployed map: "

                    .concat(mapContextFile.getAbsolutePath()));

        }

        if (!mapContextFile.isFile()) {

            throw new InvalidThematicMapFormatException(mapFile,

                "mapContext/mapContext.xml file in deployed map is not a file: "

                    .concat(mapContextFile.getAbsolutePath()));

        }

        // Load map context

        MapContext mapContext =

            fileServices.loadMapContext(mapContextFile, exportFolder);

        // Create view document

        ProjectManager projectManager = ProjectManager.getInstance();

        final ViewDocument view =

            (ViewDocument) projectManager.createDocument(ViewManager.TYPENAME);

        ThematicMapInformation info = map.getThematicMap().getInformation();

        // Fill view values

        view.setName(map.getName());

        view.setComment(String.format(

            swingManager.getTranslation("generated_from_thematic_map"),

            info.getId(), info.getName(), info.getVersion(),

            info.getBuildNumber()));

        view.setMapContext(mapContext);

        // Add view document to project

        getProject().add(view);

        if (openViewWindow) {

            // Open view window

            SwingUtilities.invokeLater(new Runnable() {

                public void run() {

                    IWindow viewWindow = view.getFactory().getMainWindow(view);

                    PluginServices.getMDIManager().addWindow(viewWindow);

                }

            });

        }

        // If map has no source view link it to the new one

        if (map.getSourceView() == null) {

            map.setSourceView(view);

        }

        return view;

    }

    /** {@inheridDoc} */

    public void regenerateThematicMap(ThematicMapDocument map,

        CompilationListener listener, boolean openWindow)

        throws InvalidThematicMapFormatException, CantLoadContextException,

        IOException {

        if (map == null) {

            throw new IllegalArgumentException(

                "Thematic Map document is required");

        }

        if (map.getSourceView() == null) {

            // No source view it can't regenerate it

            return;

        }

        ViewDocument document = map.getSourceView();

        // Get a compilation instance from map

        ThematicMapCompilation compilation =

            manager.createCompilationInstanceFromMap(map.getThematicMap());

        // Update map context from view

        compilation.setMapContext(document.getMapContext());

        // Create a editor and disable id change

        ThematicMapCompilationEditor editor =

            swingManager.getCopilationEditor(compilation, false);

        editor.allowChangeId(false);

        // Add update listener

        final UpdateDocumentListener myListener =

            new UpdateDocumentListener(map, listener, openWindow);

        // Add editor listener which call to compiler or notify cancel to

        // listener

        editor.setListener(new ThematicMapCompilationEditorListener() {

            public void finished(final ThematicMapCompilationEditor editor) {

                editor.getSwingComponent().setVisible(false);

                SwingUtilities.invokeLater(new Runnable() {

                    public void run() {

                        try {

                            compileInInstallFolder(editor.getCompilation(),

                                myListener);

                        } catch (Exception ex) {

                            myListener.exception("Exception compiling", ex);

                        }

                    }

                });

            }

            public void canceled(final ThematicMapCompilationEditor editor) {

                editor.getSwingComponent().setVisible(false);

                SwingUtilities.invokeLater(new Runnable() {

                    public void run() {

                        myListener.canceledEditing(editor.getCompilation());

                    }

                });

            }

        });

        // Show editor

        winManager.showCompilationEditor(editor, MODE.WINDOW);

    }

}