Aplicación gvSIG con fines educativos » Interfaz de usuario

/* 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.batovi.mapviewer;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.util.List;

import java.util.Locale;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.Box;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JToolBar;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.WindowConstants;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.educa.thematicmap.ThematicMapLocator;

import org.gvsig.educa.thematicmap.ThematicMapManager;

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

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

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

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

import org.gvsig.educa.thematicmap.swing.viewer.ThematicMapViewer;

import org.gvsig.installer.swing.api.SwingInstallerLocator;

import org.gvsig.installer.swing.api.SwingInstallerManager;

import org.gvsig.installer.swing.api.execution.InstallPackageWizardException;

import org.gvsig.installer.swing.api.wizard.AbstractInstallerWizard;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableManager;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

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

import org.gvsig.tools.swing.api.usability.UsabilitySwingManager;

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

/**

 * Main executable class for testing the ThematicMap library.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class Main {

    private static final Logger LOG = LoggerFactory.getLogger(Main.class);

    private static Main instance = null;

    private ResourceBundle resourceBundle = null;

    private final ThematicMapManager manager;

    private final ThematicMapSwingManager swingManager;

    private final ThematicMapWindowManager winManager;

    private final UsabilitySwingManager usabManager;

    private final DisposableManager disposeManager;

    private final SwingInstallerManager swingInstallerManager;

    private final JFileChooser fileChooser;

    private JFrame mainFrame;

    private ThematicMapViewer curViewer = null;

    private AbstractAction setPanToolAction;

    private AbstractAction setZoomToolAction;

    private AbstractAction zoomAllAction;

    private AbstractAction setThematiMapFolderAction;

    private AbstractAction showOpenThematicMapDialogAction;

    private AbstractAction exitAction;

    private AbstractAction closeThematicMapAction;

    private AbstractAction installThematicMaps;

    private AbstractAction addInstallUrl;

    private MapToolsRegistrant mapToolsRegistrant;

    private StatusBar statusBar;

    private AbstractAction showHideTocAction;

    private AbstractAction setMeasuerToolAction;

    private AbstractAction setAreaToolAction;

    private AbstractAction setInfoToolAction;

    private ImageIcon defaultIcon;

    public static void main(String args[]) {

        new DefaultLibrariesInitializer().fullInitialize();

        instance = new Main();

        instance.init();

        instance.show();

    }

    public static Main getInstance() {

        return instance;

    }

    /**

     * New instance of Main

     */

    public Main() {

        manager = ThematicMapLocator.getManager();

        swingManager = ThematicMapSwingLocator.getSwingManager();

        winManager = swingManager.getWindowManager();

        usabManager = ToolsSwingLocator.getUsabilitySwingManager();

        disposeManager = ToolsLocator.getDisposableManager();

        swingInstallerManager =

            SwingInstallerLocator.getSwingInstallerManager();

        fileChooser = new JFileChooser();

        LOG.info("Strating application");

    }

    private void init() {

        String defaultFolderPath =

            "gvSIG/plugins/org.gvsig.educa.thematicmap.app.viewer/thematicMaps";

        File defaultFolder =

            new File(System.getProperty("user.home"), defaultFolderPath);

        if (!defaultFolder.exists()) {

            defaultFolder.mkdirs();

        }

        LOG.info("Default map folder: {}", defaultFolder);

        manager.setInstallationMapFolder(defaultFolder.getAbsolutePath());

        mapToolsRegistrant = new MapToolsRegistrant();

        swingManager.addMapControlRegistrant(mapToolsRegistrant);

        try {

            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

        } catch (Exception ex) {

            LOG.error("Exception setting system LookAndFeel: ".concat(UIManager

                .getSystemLookAndFeelClassName()), ex);

            throw new RuntimeException(ex);

        }

    }

    public ThematicMapWindowManager getWindowsManager() {

        return winManager;

    }

    /**

     * Shows main frame

     */

    public void show() {

        // Create actions

        createActions();

        // Create JFrame to show data

        mainFrame = new JFrame(translate("gvSIG_Batovi_Map_Viewer"));

        mainFrame.setUndecorated(true);

        mainFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        mainFrame.setLayout(new BorderLayout(10, 10));

        // Create menu bar

        // createMenu();

        // Create tools bar

        createToolBar();

        // Create status bar

        createStatusBar();

        updateControls();

        // Display the window.

        mainFrame.pack();

        Toolkit toolkit = Toolkit.getDefaultToolkit();

        Dimension dimension = toolkit.getScreenSize();

        mainFrame.setSize(dimension);

        mainFrame.setExtendedState(JFrame.MAXIMIZED_BOTH);

        mainFrame.setLocation(0, 0);

        mainFrame.setVisible(true);

    }

    /**

     * Creates all the action for menu and tools bar

     * 

     */

    @SuppressWarnings("serial")

    private void createActions() {

        setThematiMapFolderAction =

            new AbstractAction(translate("Select_Thematic_Map_folder")) {

                public void actionPerformed(ActionEvent e) {

                    setThematicMapFolder();

                }

            };

        showOpenThematicMapDialogAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                showOpenThematicMapDialog();

            }

        };

        showOpenThematicMapDialogAction.setEnabled(false);

        setActionIconAndTip(showOpenThematicMapDialogAction, "open",

            translate("Open_Thematic_map"));

        setZoomToolAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                setZoomTool();

            }

        };

        setZoomToolAction.setEnabled(false);

        setActionIconAndTip(setZoomToolAction, "zoom-in", translate("Zoom"));

        setPanToolAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                setPanTool();

            }

        };

        setPanToolAction.setEnabled(false);

        setActionIconAndTip(setPanToolAction, "pan", translate("Pan"));

        zoomAllAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                zoomAll();

            }

        };

        zoomAllAction.setEnabled(false);

        setActionIconAndTip(zoomAllAction, "zoom-all", translate("Zoom_all"));

        setMeasuerToolAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                setMeasuerTool();

            }

        };

        setMeasuerToolAction.setEnabled(false);

        setActionIconAndTip(setMeasuerToolAction, "rule", translate("measure"));

        setAreaToolAction = new AbstractAction(translate("area")) {

            public void actionPerformed(ActionEvent e) {

                setAreaTool();

            }

        };

        setAreaToolAction.setEnabled(false);

        setActionIconAndTip(setAreaToolAction, "area", translate("area"));

        setInfoToolAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                setInfoTool();

            }

        };

        setInfoToolAction.setEnabled(false);

        setActionIconAndTip(setInfoToolAction, "info", translate("infoByPoint"));

        closeThematicMapAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                closeMap();

            }

        };

        closeThematicMapAction.setEnabled(false);

        setActionIconAndTip(closeThematicMapAction, "close",

            translate("Close_Map"));

        exitAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                exit();

            }

        };

        setActionIconAndTip(exitAction, "exit", translate("Exit"));

        addInstallUrl =

            new AbstractAction(translate("Add_a_ThematicMap_install_URL")) {

                public void actionPerformed(ActionEvent e) {

                    addThematicMapUrl();

                }

            };

        installThematicMaps = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                installThematicMap();

            }

        };

        installThematicMaps.setEnabled(false);

        setActionIconAndTip(installThematicMaps, "install-map",

            translate("Install_ThematicMaps"));

        showHideTocAction = new AbstractAction() {

            public void actionPerformed(ActionEvent e) {

                showHideToc();

            }

        };

        showHideTocAction.setEnabled(false);

        setActionIconAndTip(showHideTocAction, "show-hide-toc",

            translate("Show_Hide_Toc"));

    }

    /**

     * Show/hides TOC of current view

     */

    public void showHideToc() {

        if (curViewer == null) {

            return;

        }

        curViewer.setTocVisible(!curViewer.isTocVisible());

    }

    /**

     * Creates the tools bar

     */

    private void createToolBar() {

        Dimension sepSize = new Dimension(20, 5);

        JToolBar toolBar = new JToolBar();

        toolBar.add(usabManager.createJButton(showOpenThematicMapDialogAction));

        toolBar.add(usabManager.createJButton(closeThematicMapAction));

        toolBar.addSeparator(sepSize);

        toolBar.add(usabManager.createJButton(showHideTocAction));

        toolBar.addSeparator(sepSize);

        toolBar.add(usabManager.createJButton(setPanToolAction));

        toolBar.add(usabManager.createJButton(setZoomToolAction));

        toolBar.add(usabManager.createJButton(setMeasuerToolAction));

        toolBar.add(usabManager.createJButton(setAreaToolAction));

        toolBar.add(usabManager.createJButton(setInfoToolAction));

        toolBar.addSeparator(sepSize);

        toolBar.add(usabManager.createJButton(zoomAllAction));

        toolBar.add(Box.createHorizontalGlue());

        toolBar.add(new JButton(installThematicMaps));

        toolBar.addSeparator(sepSize);

        toolBar.add(new JButton(exitAction));

        mainFrame.add(toolBar, BorderLayout.PAGE_START);

    }

    /**

     * Creates the tools bar

     */

    private void createStatusBar() {

        statusBar = new StatusBar();

        mapToolsRegistrant.setStatusBar(statusBar);

        mainFrame.add(statusBar, BorderLayout.PAGE_END);

    }

    /**

     * Shows file chooser to select thematic map folder

     */

    public void setThematicMapFolder() {

        fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);

        int result =

            fileChooser.showDialog(mainFrame, translate("Select_folder"));

        if (result != JFileChooser.APPROVE_OPTION) {

            return;

        }

        File folder = fileChooser.getSelectedFile();

        List<ThematicMap> maps =

            manager.getInstalledMaps(folder.getAbsolutePath());

        if (maps.isEmpty()) {

            LOG.info("No maps foudn in required folder: {}",

                folder.getAbsolutePath());

            CONFIRM_DIALOG_OPTION resp =

                winManager.showConfirmDialog(mainFrame,

                    translate("No_maps_found._Select_this_folder_anyway"),

                    translate("Select_Thematic_Map_folder"),

                    CONFIRM_DIALOG_TYPE.YES_NO, MESSAGE_DIALOG_TYPE.WARNING);

            if (resp != CONFIRM_DIALOG_OPTION.OK_YES) {

                return;

            }

        }

        LOG.info("Selected map folder: {}", folder.getAbsolutePath());

        try {

            manager.setInstallationMapFolder(folder.getAbsolutePath());

        } catch (Exception e) {

            LOG.error("Error setting thematic map folder", e);

            winManager.showMessageDialog(mainFrame,

                translate("Select_Thematic_Map_folder"),

                translate("Problem_found_setting_Thematic_Map_folder"),

                MESSAGE_DIALOG_TYPE.ERROR);

        }

        updateControls();

    }

    /**

     * Shows a dialog to select a Thematic Map to open

     */

    public void showOpenThematicMapDialog() {

        if (manager.getInstallationMapFolder() == null) {

            LOG.warn("thematic map folder not set on open Thematic Map request");

            winManager.showMessageDialog(mainFrame,

                translate("Open_Thematic_map"),

                translate("Select_a_Thematic_Map_folder_first"),

                MESSAGE_DIALOG_TYPE.INFO);

            return;

        }

        OpenThematicMap openThematicMap =

            new OpenThematicMap(this, manager.getInstalledMaps());

        winManager.showWindow(openThematicMap, translate("Open_Thematic_map"),

            MODE.DIALOG);

    }

    /**

     * Opens a thematic map in main frame

     * 

     * @param curMap

     * @return

     */

    public boolean openMap(ThematicMap curMap) {

        LOG.info("Opening map: {}", curMap.getSourceFilePath());

        ThematicMapViewer viewer;

        try {

            viewer = swingManager.getViewer(curMap);

        } catch (Exception e) {

            LOG.error("Can't open map", e);

            winManager.showMessageDialog(mainFrame,

                translate("Open_Thematic_map"),

                translate("Problem_found_opening_map_see_log_for_details"),

                MESSAGE_DIALOG_TYPE.ERROR);

            return false;

        }

        doCloseMap();

        mainFrame.add(viewer.getSwingComponent(), BorderLayout.CENTER);

        curViewer = viewer;

        updateControls();

        LOG.info("Map opened");

        return true;

    }

    /**

     * Closes the current thematic map

     */

    public void closeMap() {

        doCloseMap();

        updateControls();

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                mainFrame.repaint();

            }

        });

    }

    /**

     * Removes thematic map view from main frame

     */

    private void doCloseMap() {

        if (curViewer != null) {

            mainFrame.remove(curViewer.getSwingComponent());

            try {

                curViewer.getThematicMap().close();

            } catch (IOException e) {

                LOG.warn("Exception clossing map", e);

            }

            statusBar.clear();

            curViewer = null;

            LOG.info("Closed last map");

        }

    }

    /**

     * Update actions ability and updates main frame content

     */

    public void updateControls() {

        showOpenThematicMapDialogAction.setEnabled(manager

            .getInstallationMapFolder() != null);

        setZoomToolAction.setEnabled(curViewer != null);

        setPanToolAction.setEnabled(curViewer != null);

        setMeasuerToolAction.setEnabled(curViewer != null);

        setAreaToolAction.setEnabled(curViewer != null);

        setInfoToolAction.setEnabled(curViewer != null);

        showHideTocAction.setEnabled(curViewer != null);

        closeThematicMapAction.setEnabled(curViewer != null);

        zoomAllAction.setEnabled(curViewer != null);

        installThematicMaps

            .setEnabled(manager.getInstallationMapFolder() != null);

        mainFrame.getContentPane().invalidate();

        mainFrame.doLayout();

        Dimension d = mainFrame.getSize();

        d.width--;

        mainFrame.setSize(d);

        d.width++;

        mainFrame.setSize(d);

    }

    /**

     * Sets the zoom tool

     */

    public void setZoomTool() {

        if (curViewer != null) {

            curViewer.setTool(MapToolsRegistrant.TOOL_ZOOM_ID);

            statusBar.setInfo("");

            LOG.info("Selected Tool: {}", curViewer.getCurrentToolId());

        }

    }

    /**

     * Sets the pan tool

     */

    public void setPanTool() {

        if (curViewer != null) {

            curViewer.setTool(MapToolsRegistrant.TOOL_PAN_ID);

            statusBar.setInfo("");

            LOG.info("Selected Tool: {}", curViewer.getCurrentToolId());

        }

    }

    /**

     * Sets the pan tool

     */

    public void setInfoTool() {

        if (curViewer != null) {

            curViewer.setTool(MapToolsRegistrant.TOOL_INFO_ID);

            statusBar.setInfo("");

            LOG.info("Selected Tool: {}", curViewer.getCurrentToolId());

        }

    }

    /**

     * Zoom to all thematic map contents

     */

    public void zoomAll() {

        if (curViewer != null) {

            curViewer.zoomAll();

            LOG.info("Zoom all");

        }

    }

    /**

     * Exit from app

     */

    public void exit() {

        // Close current thematic map

        closeMap();

        // clean resources

        try {

            disposeManager.releaseAll();

        } catch (BaseException e) {

            LOG.warn("Problems dispossing", e);

        }

        try {

            Thread.sleep(200);

        } catch (InterruptedException e) {

            // Do nothing

        }

        LOG.info("Application exit");

        // exit app

        System.exit(0);

    }

    public void setMeasuerTool() {

        if (curViewer == null) {

            return;

        }

        curViewer.setTool(MapToolsRegistrant.TOOL_MEASURE_ID);

        statusBar.setInfo("");

        LOG.info("Selected Tool: {}", curViewer.getCurrentToolId());

    }

    public void setAreaTool() {

        if (curViewer == null) {

            return;

        }

        curViewer.setTool(MapToolsRegistrant.TOOL_AREA_ID);

        statusBar.setInfo("");

        LOG.info("Selected Tool: {}", curViewer.getCurrentToolId());

    }

    public void installThematicMap() {

        LOG.info("Opening install dialog");

        AbstractInstallerWizard panel;

        try {

            panel =

                swingInstallerManager.createInstallPackageWizard(new File("."),

                    new File(manager.getInstallationMapFolder()));

        } catch (InstallPackageWizardException ex) {

            LOG.error("Error opening installer panel", ex);

            winManager.showMessageDialog(translate("Install_Thematic_Map"),

                translate("Error_opening_installer_panel"),

                MESSAGE_DIALOG_TYPE.ERROR);

            return;

        }

        winManager.showWindow(panel, translate("Install_Thematic_Map"),

            MODE.DIALOG);

    }

    public void addThematicMapUrl() {

        String inUrl =

            winManager.showInputStringDialog(translate("Input_the_url"),

                translate("Add_a_ThematicMap_install_URL"), "http://",

                MESSAGE_DIALOG_TYPE.QUESTION);

        URL url;

        try {

            url = new URL(inUrl);

        } catch (Exception ex) {

            LOG.error("Invalid URL: ".concat(inUrl).concat("'"), ex);

            winManager.showMessageDialog(

                translate("Add_install_Thematic_Map_URL"),

                translate("Invalid_URL").concat(": '").concat(inUrl)

                    .concat("'"), MESSAGE_DIALOG_TYPE.ERROR);

            return;

        }

        swingInstallerManager.addDefaultDownloadURL(url);

        LOG.info("Added install URL: '{}'", url);

    }

    public String translate(String key) {

        if (resourceBundle == null) {

            try {

                resourceBundle = ResourceBundle.getBundle("mapviewer");

            } catch (MissingResourceException e) {

                Locale loc = new Locale(Locale.getDefault().getLanguage());

                LOG.warn("Can't load translation. Trying with ".concat(loc

                    .toString()), e);

                try {

                    resourceBundle = ResourceBundle.getBundle("mapviewer", loc);

                } catch (MissingResourceException e1) {

                    LOG.error("Can't load translation", e1);

                }

            }

            return key;

        }

        try {

            return resourceBundle.getString(key);

        } catch (MissingResourceException e) {

            LOG.warn("Missing Translation: '".concat(key).concat("'"));

            return key;

        } catch (NullPointerException e) {

            LOG.warn("No bundle for translation: '".concat(key).concat("'"));

            return key;

        } catch (Exception e) {

            LOG.warn("Missing Translation: '".concat(key).concat("'"), e);

            return key;

        }

    }

    public ImageIcon getImage(String id) {

        String location = "images/".concat(id).concat(".png");

        ImageIcon icon;

        try {

            icon =

                new ImageIcon(getClass().getClassLoader().getResource(location));

        } catch (Exception ex) {

            LOG.error(

                "Can't load icon '".concat(id).concat("' (").concat(location)

                    .concat(")"), ex);

            if (defaultIcon == null) {

                BufferedImage image =

                    new BufferedImage(24, 24, BufferedImage.TYPE_INT_RGB);

                Graphics g = image.getGraphics();

                g.setColor(Color.RED);

                g.drawRect(6, 6, 18, 18);

                defaultIcon = new ImageIcon(image);

            }

            icon = defaultIcon;

        }

        return icon;

    }

    /**

     * Set icon and tooltip to Action

     * 

     * @param action

     * @param iconId

     * @param tooltip

     */

    public void setActionIconAndTip(AbstractAction action, String iconId,

        String tooltip) {

        action.putValue(Action.LARGE_ICON_KEY, getImage(iconId));

        action.putValue(Action.SHORT_DESCRIPTION, tooltip);

    }

}