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

import java.net.MalformedURLException;

import java.net.URL;

import java.util.List;

import org.apache.commons.io.IOUtils;

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.plugins.Extension;

import org.gvsig.andami.plugins.PluginClassLoader;

import org.gvsig.scripting.ScriptingLocator;

import org.gvsig.scripting.ScriptingManager;

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

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

import org.gvsig.tools.dynobject.DynObject;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.util.Invocable;

@SuppressWarnings("UseSpecificCatch")

public class ScriptingExtension extends Extension {

    @SuppressWarnings("FieldNameHidesFieldInSuperclass")

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

    private ScriptingUtils utils;

    @Deprecated

    public static void log(String message) {

        ScriptingUtils.log(ScriptingUtils.INFO, message, null);

    }

    @Deprecated

    public static void log(int level, String message) {

        ScriptingUtils.log(level, message, null);

    }

    @Deprecated

    public static void log(int level, String message, Throwable th) {

        ScriptingUtils.log(level, message, th);

    }

    @Override

    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);

        PluginsManager pluginManager = PluginsLocator.getManager();

        this.utils = new ScriptingUtils();

        this.utils.initializaPaths(

                pluginManager.getPluginsFolders(),

                pluginManager.getInstallFolder(),

                this.getPlugin().getPluginHomeFolder(),

                pluginManager.getApplicationVersion().format(ScriptsInstallerInitializer.VERSION_FORMAT)

        );

        Thread th = new Thread(new Runnable() {

            @Override

            public void run() {

                preloadPythonEngine();

            }

        }, "ScriptEnginesInitializer");

        th.start();

        try {

            th.join(1000); // force change to other thread

        } catch (InterruptedException ex) {

            // Ignore.

        }

    }

    @Override

    public void execute(String actionCommand) {

        this.execute(actionCommand, null);

    }

    @Override

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

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

            utils.runLauncher();

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

            DynObject preferences = getPlugin().getPluginProperties();

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

            if( composerUseHisWindowManager ) {

                DefaultWindowManager winmanager = new DefaultWindowManager();

                ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

                uimanager.setWindowManager(winmanager);

            }

            utils.runComposer();

        } else {

            utils.runScript(command, args);

        }

    }

    private void preloadPythonEngine() {

        ScriptingManager manager = (ScriptingManager) ScriptingLocator.getManager();

        synchronized (manager) {

            String respath = "/scripting/langs/python/preload.py";

            InputStream res = this.getClass().getResourceAsStream(respath);

            if( res != null ) {

                LOGGER.info("Scan for script engines");

                List<String> lines;

                try {

                    lines = IOUtils.readLines(res);

                    String code = StringUtils.join(lines, "\n");

                    LOGGER.info("Preload python script engine");

                    Script script = manager.createScript(

                        "preload",

                        code,

                        ScriptingManager.PYTHON_LANGUAGE_NAME

                    );

                    LOGGER.info("Preload python modules");

                    script.invokeFunction("main", null);

                } catch (Exception ex) {

                    LOGGER.warn("Can't run preload script for python.", ex);

                }

                LOGGER.info("Preload of script engines finished");

            }

        }

    }

    @Override

    public void postInitialize() {

        super.postInitialize();

        PluginsManager pluginManager = PluginsLocator.getManager();

        pluginManager.addStartupTask(

            "ExecuteAutorunScripts",

            utils.getAutorunScriptsOnStartup(pluginManager.getPluginsFolders()),

            false,

            200

        );

        Invocable initializer = new ScriptsInstallerInitializer();

        initializer.call(this.getPlugin().getPluginName());

    }

    @Override

    public boolean isEnabled() {

        return true;

    }

    @Override

    public boolean isVisible() {

        return true;

    }

    public static void add_classpath(URL url) {

        if( url==null ) {

            LOGGER.warn("Can't add to the plugin classloader a null URL.");

            return;

        }

        try {

            PluginsManager manager = PluginsLocator.getManager();

            PluginServices thePlugin = manager.getPlugin(ScriptingExtension.class);

            PluginClassLoader loader = thePlugin.getClassLoader();

            loader.addURL(url);

        } catch(Throwable th) {

            LOGGER.warn("Can't add the url '"+url.toString()+"' to the plugin classloader.",th);

        }

    }

    public static void add_classpath(File path) {

        if( path==null ) {

            LOGGER.warn("Can't create a url from a null file.");

            return;

        }

        try {

            URL url = path.toURI().toURL();

            add_classpath(url);

        } catch (MalformedURLException ex) {

            LOGGER.warn("Can't create a url from the path '"+path+"'.", ex);

        }

    }

    public static void add_classpath(String path) {

        if( path==null ) {

            LOGGER.warn("Can't create a url from a null path.");

            return;

        }

        File f = new File(path);

        add_classpath(f);

    }

    @Override

    public PluginServices getPlugin() {

        PluginServices thePlugin = super.getPlugin();

        if (thePlugin == null) {

            thePlugin = PluginsLocator.getManager().getPlugin(ScriptingExtension.class);

            this.setPlugin(thePlugin);

        }

        return thePlugin;

    }

}