Application: gvSIG desktop » gvSIG scripting

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

import java.io.File;

import java.io.IOException;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.logging.Level;

import javax.swing.JOptionPane;

import org.apache.commons.io.FileUtils;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

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

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

import org.gvsig.installer.lib.spi.InstallerProviderLocator;

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingHelpManager;

import org.gvsig.scripting.ScriptingLocator;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.swing.api.JScriptingComposer;

import org.gvsig.scripting.swing.api.ScriptingSwingLocator;

import org.gvsig.scripting.swing.api.ScriptingUIManager;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.service.spi.ProviderFactory;

import org.gvsig.tools.service.spi.ProviderManager;

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

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

import org.gvsig.tools.swing.impl.windowmanager.DefaultWindowManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ScriptingExtension extends Extension {

    private static final Logger logger = LoggerFactory.getLogger(ScriptingExtension.class);

    public void execute(String actionCommand) {

        this.execute(actionCommand, null);

    }

    @Override

    public void execute(String command, Object[] args) {

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

        WindowManager winmanager = ToolsSwingLocator.getWindowManager();

        if ("tools-scripting-launcher".equalsIgnoreCase(command)) {

            winmanager.showWindow(uimanager.createLauncher(), uimanager.getTranslation("Scripting_Launcher"), WindowManager.MODE.TOOL);

        } else if ("tools-scripting-composer".equalsIgnoreCase(command)) {

            DynObject preferences = this.getPlugin().getPluginProperties();

            Boolean composerUseHisWindowManager = (Boolean) preferences.getDynValue("ComposerUseHisWindowManager");

            ScriptingUIManager uiManager = ScriptingSwingLocator.getUIManager();

            if (composerUseHisWindowManager.booleanValue()) {

                winmanager = new DefaultWindowManager();

                uiManager.setWindowManager(winmanager);

            }

            JScriptingComposer composer = uimanager.createComposer();

            uiManager.showWindow(composer, uimanager.getTranslation("Scripting_Composer"));

        } else {

            ScriptingBaseScript script = uimanager.getManager().getScript(command);

            if (script != null) {

                script.run(args);

            } else {

                ApplicationManager application = ApplicationLocator.getManager();

                application.messageDialog("Can't locate script '" + command + "'.", "ScriptLaunch", JOptionPane.OK_OPTION);

            }

        }

    }

    public void initialize() {

        IconThemeHelper.registerIcon("action", "tools-scripting-launcher", this);

        IconThemeHelper.registerIcon("action", "tools-scripting-composer", this);

        IconThemeHelper.registerIcon("action", "tools-scripting-console-jython", this);

    }

    private void addLinkToPreviousVersion(ScriptingManager manager) {

        String contents = "[Unit]\n"

                + "type = Folder\n"

                + "name = Previous version\n"

                + "description =\n"

                + "createdBy =\n"

                + "version =\n"

                + "\n"

                + "[Folder]\n"

                + "path = ../../org.gvsig.scripting.app.extension/scripts\n\n\n";

        File previousVersion = new File(manager.getUserFolder().getFile(), "previous_version.inf");

        if (!previousVersion.exists()) {

            try {

                FileUtils.writeStringToFile(previousVersion, contents);

            } catch (IOException ex) {

                logger.warn("Can't create ScriptingFolder file in '" + previousVersion.getAbsolutePath() + "'.", ex);

            }

        }

    }

    @Override

    public void postInitialize() {

        super.postInitialize();

        ScriptingManager manager = ScriptingLocator.getManager();

        PluginsManager pluginManager = PluginsLocator.getManager();

        File home = this.getPlugin().getPluginHomeFolder();

        manager.setHomeFolder(home);

        this.addLinkToPreviousVersion(manager);

        List<File> pluginsFolders = new ArrayList<>();

        for (File f : pluginManager.getPluginsFolders()) {

            pluginsFolders.addAll(Arrays.asList(f.listFiles()));

        }

        for (File pluginFolder : pluginsFolders) {

            File scriptsFolder = new File(pluginFolder, "scripting/scripts");

            if (scriptsFolder.exists()) {

                manager.registerSystemFolder(pluginFolder.getName(), scriptsFolder);

            }

            File libFolder = new File(pluginFolder, "scripting/lib");

            if (libFolder.exists()) {

                manager.addLibFolder(libFolder);

            }

        }

        pluginManager.addStartupTask(

                "ExecuteAutorunScripts",

                new ExecuteAutorunScriptsOnStartup(),

                true,

                600

        );

        manager.setPackagesFolder(pluginManager.getInstallFolder());

        File localAddonRepositoryFolder = new File(manager.getRootUserFolder(), "addons");

        if (!localAddonRepositoryFolder.exists()) {

            try {

                FileUtils.forceMkdir(localAddonRepositoryFolder);

            } catch (IOException ex) {

                logger.info("Can't create addons folder in '"+localAddonRepositoryFolder.getAbsolutePath()+"'.",ex);

            }

        }

        ProviderManager providerManager = InstallerProviderLocator.getProviderManager();

        ProviderFactory factory = manager.getInstallerFactory();

        providerManager.addProviderFactory(factory);

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

        installerManager.setDefaultLocalAddonRepository(

                localAddonRepositoryFolder,

                factory.getName()

        );

    }

    public boolean isEnabled() {

        return true;

    }

    public boolean isVisible() {

        return true;

    }

    private static class ExecuteAutorunScriptsOnStartup implements Runnable {

        public void run() {

            Thread th = new Thread(new ExecuteAutorunScripts());

            th.start();

        }

    }

    private static class ExecuteAutorunScripts implements Runnable {

        public void run() {

            final ScriptingManager manager = ScriptingLocator.getManager();

            PluginsManager pluginManager = PluginsLocator.getManager();

            try {

                ScriptingHelpManager helpmanager = manager.getHelpManager();

                PluginServices plugin = pluginManager.getPlugin(this);

                File scriptingfolder = new File(plugin.getPluginDirectory(), "scripting");

                File helpfolder = new File(scriptingfolder, "help");

                for (File folder : helpfolder.listFiles()) {

                    File helpindex = new File(folder, "IdeHelpIndex.xml");

                    try {

                        helpmanager.addMethods(helpindex.toURI().toURL());

                    } catch (Exception e) {

                        logger.info("Can't add metothods from '" + helpindex.getAbsolutePath() + "'.", e);

                    }

                }

            } catch (Exception e) {

                logger.info("Can't add metothods.", e);

            }

            List<File> pluginsFolders = new ArrayList<File>();

            for (File f : pluginManager.getPluginsFolders()) {

                pluginsFolders.addAll(Arrays.asList(f.listFiles()));

            }

            File autorun_file = null;

            ScriptingBaseScript autorun = null;

            for (File pluginFolder : pluginsFolders) {

                autorun_file = new File(pluginFolder, "scripting/scripts/autorun.inf");

                if (autorun_file.exists()) {

                    logger.info("running autorun script '" + autorun_file.getAbsolutePath() + "'.");

                    autorun = manager.getScript(autorun_file);

                    try {

                        autorun.run();

                    } catch (Exception ex) {

                        logger.warn("Can't execute autorun from '" + autorun_file.getAbsolutePath() + "'.", ex);

                    }

                }

            }

            SimpleFileVisitor<Path> visitor = new SimpleFileVisitor<Path>() {

                @Override

                public FileVisitResult visitFile(Path path, BasicFileAttributes bfa) throws IOException {

                    File file = path.toFile();

                    if ("autorun.inf".equalsIgnoreCase(file.getName())) {

                        if (file.exists()) {

                            logger.info("running autorun script '" + file.getAbsolutePath() + "'.");

                            ScriptingBaseScript autorun = manager.getScript(file);

                            try {

                                autorun.run();

                            } catch (Exception ex) {

                                logger.warn("Can't execute autorun from '" + file.getAbsolutePath() + "'.", ex);

                            }

                        }

                    }

                    return FileVisitResult.CONTINUE;

                }

            };

            try {

                Files.walkFileTree(Paths.get(manager.getRootUserFolder().toURI()), visitor);

                List<ScriptingFolder> folders = manager.getAlternativeUserFolders();

                for (ScriptingFolder folder : folders) {

                    Files.walkFileTree(Paths.get(folder.getFile().toURI()), visitor);

                }

            } catch (Exception ex) {

                logger.warn("Can't execute autoruns in home.", ex);

            }

            logger.info("Running autorun scripts terminated.");

        }

    }

}