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.app.extension;

import java.awt.GridBagConstraints;

import java.beans.PropertyVetoException;

import java.io.BufferedReader;

import java.io.File;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.StringWriter;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Properties;

import java.util.prefs.Preferences;

import javax.swing.JOptionPane;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.andami.actioninfo.ActionInfoManager;

import org.gvsig.andami.plugins.Extension;

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

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import static org.gvsig.app.extension.ProjectExtension.PROJECT_FILE_CHOOSER_ID;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.ProjectPreferences;

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

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

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.app.project.documents.view.toolListeners.InfoListener;

import org.gvsig.app.util.BaseOpenErrorHandler;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorerPool;

import org.gvsig.fmap.dal.DataServerExplorerPoolEntry;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

import org.gvsig.fmap.dal.OpenErrorHandler;

import org.gvsig.fmap.dal.feature.AbstractDataProfile;

import org.gvsig.fmap.dal.resource.ResourceManager;

import org.gvsig.fmap.dal.resource.exception.DisposeResorceManagerException;

import static org.gvsig.fmap.dal.serverexplorer.filesystem.swing.FilesystemExplorerWizardPanelController.OPEN_LAYER_FILE_CHOOSER_ID;

import org.gvsig.installer.lib.api.InstallerLocator;

import org.gvsig.installer.lib.api.InstallerManager;

import org.gvsig.installer.lib.api.PackageInfo;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.bookmarksandhistory.Bookmark;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class InitializeApplicationExtension extends Extension {

    private static final Logger LOGGER = LoggerFactory.getLogger(InitializeApplicationExtension.class);

    // Copiadas de org.gvsig.coreplugin.PreferencesExtension

    public static final String PROJECTS_FOLDER_PROPERTY_NAME = "ProjectsFolder";

    public static final String DATA_FOLDER_PROPERTY_NAME = "DataFolder";

    public static final String TEMPLATES_FOLDER_PROPERTY_NAME = "TemplatesFolder";

    public static final String SYMBOL_LIBRARY_FOLDER_PROPERTY_NAME = "SymbolLibraryFolder";

    private OpenErrorHandler openErrorHandler = null;

    private static class SimpleImageDataProfile extends AbstractDataProfile {

        public SimpleImageDataProfile() {

            super("Image", SimpleImage.class);

        }

        @Override

        public Object createData(Object data, Tags tags) {

            final ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

            SimpleImage image = toolsSwingManager.createSimpleImage(data);

            return image;

        }

        @Override

        public Object coerce(DataType dataType, Object data, Tags tags) throws CoercionException {

            final ToolsSwingManager toolsSwingManager;

            final SimpleImage image;

            try {

                switch(dataType.getType()) {

                    case DataTypes.BYTEARRAY:

                        toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

                        image = toolsSwingManager.createSimpleImage(data);

                        return image.toBytearray();

                    case DataTypes.STRING:

                        toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

                        image = toolsSwingManager.createSimpleImage(data);

                        return image.toString();

                    default:

                        break;

                }

            } catch(Exception ex) {

                throw new CoercionException("Can't convert imagen to "+dataType.getName(), ex);

            }

            throw new CoercionException("Can't convert imagen to "+dataType.getName());

        }

    }

    @Override

    public void initialize() {

        DALLocator.registerFeatureTypeDefinitionsManager(DefaultFeatureTypeDefinitionsManager.class);

        ExpressionEvaluatorLocator.getManager().registerClassLoader(this.getClass().getClassLoader());

        DataManager dataManager = DALLocator.getDataManager();

        dataManager.registerDataProfile(new SimpleImageDataProfile());

        InfoListener.initializeExtensionPoint();

        initLastPath();

        registerIcons();

        loadExpressionBookmarks();

        loadExpressionHistory();

    }

    public void loadExpressionHistory() {

        PluginsManager pluginManager = PluginsLocator.getManager();

        final PluginServices plugin = pluginManager.getPlugin(this);

        DynObject pluginProperties = plugin.getPluginProperties();

        List<Expression> dynBookmarks = (List<Expression>) pluginProperties.getDynValue("expressionHistory");

        if (dynBookmarks == null) {

            return;

        }

        final ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

        History<Expression> history = expressionManager.getHistory();

        for (Expression expression : dynBookmarks) {

            history.add(expression);

        }

        pluginManager.addShutdownTask("saveExpressionHistory", new Runnable() {

            @Override

            public void run() {

                DynObject properties = plugin.getPluginProperties();

                ArrayList<Expression> var = new ArrayList<>();

                for (Expression expression : history) {

                    var.add(expression);

                }

                properties.setDynValue("expressionHistory", var);

            }

        }, false, 100);

    }

    public void loadExpressionBookmarks() {

        PluginsManager pluginManager = PluginsLocator.getManager();

        final PluginServices plugin = pluginManager.getPlugin(this);

        DynObject pluginProperties = plugin.getPluginProperties();

        Map<String, Expression> dynBookmarks = (Map<String, Expression>) pluginProperties.getDynValue("expressionBookmarks");

        if (dynBookmarks == null) {

            return;

        }

        final ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

        Bookmarks<Expression> bookmarks = expressionManager.getBookmarks();

        for (String key : dynBookmarks.keySet()) {

            Expression bookmark = dynBookmarks.get(key);

            bookmarks.add(bookmark);

        }

        pluginManager.addShutdownTask("saveExpressionBookmarks", new Runnable() {

            @Override

            public void run() {

                DynObject properties = plugin.getPluginProperties();

                Map<String, Expression> var = new HashMap<>();

                for (Bookmark<Expression> bookmark : bookmarks) {

                    var.put(bookmark.getName(), bookmark.getValue());

                }

                properties.setDynValue("expressionBookmarks", var);

            }

        }, false, 100);

    }

    private void initLastPath() {

        Preferences prefs = Preferences.userRoot().node("gvsig.foldering");

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        String v;

        v = prefs.get(DATA_FOLDER_PROPERTY_NAME, folderManager.getHome().getAbsolutePath());

        folderManager.setLastPath(OPEN_LAYER_FILE_CHOOSER_ID, new File(v));

        v = prefs.get(PROJECTS_FOLDER_PROPERTY_NAME, folderManager.getHome().getAbsolutePath());

        folderManager.setLastPath(PROJECT_FILE_CHOOSER_ID, new File(v));

        v = prefs.get("LegendsFolder", folderManager.getHome().getAbsolutePath());

        folderManager.setLastPath("LegendsFolder", new File(v));

    }

    @Override

    public void postInitialize() {

        PluginsManager pluginManager = PluginsLocator.getManager();

        openErrorHandler = new BaseOpenErrorHandler();

        ApplicationLocator.getManager().getDataManager().setOpenErrorHandler(openErrorHandler);

        DALLocator.getResourceManager().startResourceCollector(

                3 * (60 * 1000), // minutes --> miliseconds

                null);

        // showAddOnManagerOnStartIfNeed();

        ProjectPreferences projectPreferences = ApplicationLocator.getProjectManager().getProjectPreferences();

        if (projectPreferences.getOpenWithANewMaximizedView()) {

            pluginManager.addStartupTask(

                    "showNewViewMaximized",

                    new ShowNewMaximizedView(),

                    true,

                    750

            );

        }

        pluginManager.addStartupTask("OpenLayerOnStart", new OpenLayerOnStart(), true, 740);

        pluginManager.addStartupTask("ApplicationStartedMessage", new Runnable() {

            @Override

            public void run() {

                I18nManager i18n = ToolsLocator.getI18nManager();

                ApplicationManager application = ApplicationLocator.getManager();

                application.message(

                        i18n.getTranslation("StatusBar.Aplicacion_iniciada"),

                        JOptionPane.INFORMATION_MESSAGE

                );

            }

        }, true, -1);

        pluginManager.addStartupTask("ConnectoToDefaultWorkspace", () -> {

          connectToDefaultWorkspace();

        }, false, 500);

    }

    private void connectToDefaultWorkspace() {

      String workspaceName = null;

      try {

        DataManager dataManager = DALLocator.getDataManager();

        PluginsManager pluginManager = PluginsLocator.getPluginsManager();

        PluginServices plugin = pluginManager.getPlugin(this);

        DynObject preferences = plugin.getPluginProperties();

        if ((Boolean) (preferences.getDynValue("connectAutomaticallyToDatabaseWorkspace"))) {

          workspaceName = (String) preferences.getDynValue("databaseWorkspaceToConnect");

          DataServerExplorerPool pool = dataManager.getDataServerExplorerPool();

          DataServerExplorerPoolEntry entry = pool.get(workspaceName);

          if (entry != null) {

            DatabaseWorkspaceManager workspace = dataManager.createDatabaseWorkspaceManager(

                    entry.getExplorerParameters()

            );

            if (workspace != null && workspace.isValid() ) {

              workspace.connect();

            }

          }

        }

      } catch (Exception ex) {

          LOGGER.warn("Can't connect to default workspace ("+Objects.toString(workspaceName)+").", ex);

      }

    }

    private void showAddOnManagerOnStartIfNeed() {

        PluginsManager pluginManager = PluginsLocator.getManager();

        PluginServices plugin = pluginManager.getPlugin(this);

        DynObject pluginProperties = plugin.getPluginProperties();

        Map<String, Boolean> showAddOnmanagerOnStart = null;

        try {

            showAddOnmanagerOnStart = (Map<String, Boolean>) pluginProperties.getDynValue("showAddOnmanagerOnStart");

        } catch (Exception ex) {

            // Do nothing

        }

        if (showAddOnmanagerOnStart == null) {

            showAddOnmanagerOnStart = new HashMap<>();

            pluginProperties.setDynValue("showAddOnmanagerOnStart", showAddOnmanagerOnStart);

        }

        Boolean showAddOnmanagerOnStartForCurrentVersion = showAddOnmanagerOnStart.get(pluginManager.getApplicationVersion().fullFormat());

        if (showAddOnmanagerOnStartForCurrentVersion == null || showAddOnmanagerOnStartForCurrentVersion) {

            pluginManager.addStartupTask(

                    "showAddOnmanagerOnStart",

                    new ShowAddOnManagerOnStart(),

                    true,

                    500

            );

        }

    }

    private static class ShowNewMaximizedView implements Runnable {

        @Override

        public void run() {

            ApplicationManager application = ApplicationLocator.getManager();

            ProjectManager projectManager = application.getProjectManager();

            ViewManager viewManager = (ViewManager) projectManager.getDocumentManager(ViewManager.TYPENAME);

            ViewDocument view = (ViewDocument) viewManager.createDocument();

            projectManager.getCurrentProject().add(view);

            IView viewWindow = (IView) viewManager.getMainWindow(view);

            application.getUIManager().addWindow(viewWindow, GridBagConstraints.CENTER);

            try {

                application.getUIManager().setMaximum((IWindow) viewWindow, true);

            } catch (PropertyVetoException e) {

                LOGGER.info("Can't maximize view.", e);

            }

        }

    }

    private static class ShowAddOnManagerOnStart implements Runnable {

        @Override

        public void run() {

            ApplicationManager application = ApplicationLocator.getManager();

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            PluginsManager pluginManager = PluginsLocator.getManager();

            PluginServices plugin = pluginManager.getPlugin(this);

            DynObject pluginProperties = plugin.getPluginProperties();

            String msg = i18nManager.getTranslation("_Instalar_complementos_adicionales_no_disponibles_durante_el_proceso_de_instalacion");

            int resp = application.confirmDialog(

                    msg,

                    i18nManager.getTranslation("_Finalizando_proceso_de_instalacion"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE

            );

            if (resp == JOptionPane.YES_OPTION) {

                ActionInfoManager actionManager = PluginsLocator.getActionInfoManager();

                actionManager.execute(

                        "tools-addonsmanager",

                        new Object[]{"skipBundleSelection"}

                );

            }

            Map<String, Boolean> showAddOnmanagerOnStart = (Map<String, Boolean>) pluginProperties.getDynValue("showAddOnmanagerOnStart");

            showAddOnmanagerOnStart.put(pluginManager.getApplicationVersion().fullFormat(), Boolean.FALSE);

        }

    }

    private void registerIcons() {

        IconThemeHelper.registerIcon("action", "edit-clear", this);

        IconThemeHelper.registerIcon("action", "edit-copy", this);

        IconThemeHelper.registerIcon("action", "edit-cut", this);

        IconThemeHelper.registerIcon("action", "edit-delete", this);

        IconThemeHelper.registerIcon("action", "edit-find", this);

        IconThemeHelper.registerIcon("action", "edit-find-replace", this);

        IconThemeHelper.registerIcon("action", "edit-paste", this);

        IconThemeHelper.registerIcon("action", "edit-redo", this);

        IconThemeHelper.registerIcon("action", "edit-select-all", this);

        IconThemeHelper.registerIcon("action", "edit-undo", this);

        IconThemeHelper.registerIcon("action", "edit-undo-redo-actions", this);

        IconThemeHelper.registerIcon("action", "document-print", this);

        IconThemeHelper.registerIcon("toolbar-go", "go-next", this);

        IconThemeHelper.registerIcon("toolbar-go", "go-previous", this);

        IconThemeHelper.registerIcon("toolbar-go", "go-next-fast", this);

        IconThemeHelper.registerIcon("toolbar-go", "go-previous-fast", this);

        IconThemeHelper.registerIcon("toolbar-go", "go-first", this);

        IconThemeHelper.registerIcon("toolbar-go", "go-last", this);

    }

    @Override

    public void execute(String actionCommand) {

    }

    @Override

    public boolean isEnabled() {

        return false;

    }

    @Override

    public boolean isVisible() {

        return false;

    }

    private void addToLogInfo() {

        String info[] = this.getStringInfo().split("\n");

        for (String line : info) {

            LOGGER.info(line);

        }

    }

    public String getStringInfo() {

        ApplicationManager application = ApplicationLocator.getManager();

        PluginsManager pluginmgr = PluginsLocator.getManager();

        InstallerManager installmgr = InstallerLocator.getInstallerManager();

        StringWriter writer = new StringWriter();

        Properties props = System.getProperties();

        // OS information

        String osName = props.getProperty("os.name");

        writer.write("OS\n");

        writer.write("    name   : " + osName + "\n");

        writer.write("    arch   : " + props.get("os.arch") + "\n");

        writer.write("    version: " + props.get("os.version") + "\n");

        if (osName.startsWith("Linux")) {

            try {

                String[] command = {"lsb_release", "-a"};

                Process p = Runtime.getRuntime().exec(command);

                InputStream is = p.getInputStream();

                BufferedReader reader = new BufferedReader(new InputStreamReader(is));

                String line;

                while ((line = reader.readLine()) != null) {

                    writer.write("    " + line + "\n");

                }

            } catch (Exception ex) {

                writer.write("Can't get detailled os information (lsb_release -a).");

            }

        }

        // JRE information

        writer.write("JRE\n");

        writer.write("    vendor : " + props.get("java.vendor") + "\n");

        writer.write("    version: " + props.get("java.version") + "\n");

        writer.write("    home   : " + props.get("java.home") + "\n");

        writer.write("gvSIG\n");

        writer.write("    version                 : " + application.getVersion().getLongFormat() + "\n");

        writer.write("    locale language         : " + application.getLocaleLanguage() + "\n");

        writer.write("    application forlder     : " + pluginmgr.getApplicationFolder() + "\n");

        writer.write("    install forlder         : " + pluginmgr.getInstallFolder() + "\n");

        writer.write("    application home forlder: " + pluginmgr.getApplicationHomeFolder() + "\n");

        writer.write("    plugins forlder         : " + StringUtils.join(pluginmgr.getPluginsFolders()) + "\n");

        try {

            PackageInfo[] pkgs = installmgr.getInstalledPackages();

            writer.write("Installed packages\n");

            for (PackageInfo pkg : pkgs) {

                writer.write("    ");

                writer.write(pkg.toStringCompact());

                writer.write("\n");

            }

        } catch (Throwable e) {

            writer.write("Can't get installed package information.");

        }

        return writer.toString();

    }

    @Override

    public void terminate() {

        ResourceManager resMan = DALLocator.getResourceManager();

        resMan.stopResourceCollector();

        try {

            resMan.dispose();

        } catch (DisposeResorceManagerException e) {

            LOGGER.warn(e.getMessageStack());

        }

        super.terminate();

    }

}