Application: gvSIG desktop » gvSIG scripting

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.scripting.app</artifactId>

	<packaging>pom</packaging>

	<name>${project.artifactId}</name>

	<parent>

	  <groupId>org.gvsig</groupId>

	  <artifactId>org.gvsig.scripting</artifactId>

	  <version>2.3.136</version>

  	</parent>

	<modules>

		<module>org.gvsig.scripting.app.mainplugin</module>

	</modules>

</project>

#Wed Jun 30 20:15:12 CEST 2021

buildNumber=216

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

        <fileSet>

            <directory>target/abeille</directory>

            <outputDirectory>.</outputDirectory>

        </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <!--

            Plugin libraries

        -->  

        <include>org.ini4j:ini4j</include>

        <include>net.sourceforge.thinlet:thinlet</include>

        <include>org.gvsig:org.gvsig.scripting.thing</include>

        <include>org.gvsig:org.gvsig.scripting.lib.api</include>

        <include>org.gvsig:org.gvsig.scripting.swing.api</include>

        <include>org.gvsig:org.gvsig.scripting.lib.impl</include>

        <include>org.gvsig:org.gvsig.scripting.swing.impl</include>

        <include>org.apache.tika:tika-core</include>        

        <!--

            Utility libraries

        -->

        <!-- JOpenDocument -->    

        <include>org.jopendocument:jOpenDocument</include>

        <!-- CSSBox webbrowser -->

        <include>net.sf.cssbox:cssbox</include>

        <include>net.sf.cssbox:swingbox</include>

        <include>net.sf.cssbox:jstyleparser</include>

        <include>net.sourceforge.nekohtml:nekohtml</include>

        <include>org.antlr:antlr-runtime</include>

        <!--

            Script engines libraries

        -->

        <include>org.codehaus.groovy:groovy-all</include>

        <!--

        <include>org.renjin:renjin-script-engine:jar:jar-with-dependencies</include>

        -->

        <include>org.python:${jython.artifactId}</include>

        <include>com.github.tbekolay.jnumeric:jnumeric</include>

      </includes>

    </dependencySet>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>true</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <!--

            JGit support runtime libraries

        -->        

        <include>org.eclipse.jgit:org.eclipse.jgit</include>

        <include>com.jcraft:jsch</include>

        <include>com.googlecode.javaewah:JavaEWAH</include>

        <include>org.apache.httpcomponents:httpclient</include>

        <include>org.apache.httpcomponents:httpcore</include>

      </includes>

    </dependencySet>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>true</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <!--

            ICEPDF support runtime libraries

        -->        

        <include>org.icepdf.os:icepdf-viewer</include>

        <include>org.icepdf.os:icepdf-core</include>

      </includes>

    </dependencySet>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>true</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <!--

            java-diff-utils libraries

            https://github.com/java-diff-utils/java-diff-utils

        -->        

        <include>com.sksamuel.diff:diff</include>

      </includes>

    </dependencySet>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>true</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <!--

            flexmark-java, Markdown support libraries

        -->        

        <include>com.vladsch.flexmark:flexmark-all</include>

        <include>com.vladsch.flexmark:flexmark</include>

        <include>com.vladsch.flexmark:flexmark-ext-abbreviation</include>

        <include>com.vladsch.flexmark:flexmark-util</include>

        <include>com.vladsch.flexmark:flexmark-ext-admonition</include>

        <include>com.vladsch.flexmark:flexmark-ext-anchorlink</include>

        <include>com.vladsch.flexmark:flexmark-ext-aside</include>

        <include>com.vladsch.flexmark:flexmark-ext-attributes</include>

        <include>com.vladsch.flexmark:flexmark-ext-autolink</include>

        <include>org.nibor.autolink:autolink</include>

        <include>com.vladsch.flexmark:flexmark-ext-definition</include>

        <include>com.vladsch.flexmark:flexmark-ext-emoji</include>

        <include>com.vladsch.flexmark:flexmark-ext-enumerated-reference</include>

        <include>com.vladsch.flexmark:flexmark-ext-escaped-character</include>

        <include>com.vladsch.flexmark:flexmark-ext-footnotes</include>

        <include>com.vladsch.flexmark:flexmark-ext-gfm-issues</include>

        <include>com.vladsch.flexmark:flexmark-ext-gfm-strikethrough</include>

        <include>com.vladsch.flexmark:flexmark-ext-gfm-tasklist</include>

        <include>com.vladsch.flexmark:flexmark-ext-gfm-users</include>

        <include>com.vladsch.flexmark:flexmark-ext-gitlab</include>

        <include>com.vladsch.flexmark:flexmark-ext-jekyll-front-matter</include>

        <include>com.vladsch.flexmark:flexmark-ext-jekyll-tag</include>

        <include>com.vladsch.flexmark:flexmark-ext-media-tags</include>

        <include>com.vladsch.flexmark:flexmark-ext-macros</include>

        <include>com.vladsch.flexmark:flexmark-ext-ins</include>

        <include>com.vladsch.flexmark:flexmark-ext-xwiki-macros</include>

        <include>com.vladsch.flexmark:flexmark-ext-superscript</include>

        <include>com.vladsch.flexmark:flexmark-ext-tables</include>

        <include>com.vladsch.flexmark:flexmark-ext-toc</include>

        <include>com.vladsch.flexmark:flexmark-ext-typographic</include>

        <include>com.vladsch.flexmark:flexmark-ext-wikilink</include>

        <include>com.vladsch.flexmark:flexmark-ext-yaml-front-matter</include>

        <include>com.vladsch.flexmark:flexmark-ext-youtube-embedded</include>

        <include>com.vladsch.flexmark:flexmark-html2md-converter</include>

        <include>org.jsoup:jsoup</include>

        <include>com.vladsch.flexmark:flexmark-jira-converter</include>

        <include>com.vladsch.flexmark:flexmark-pdf-converter</include>

        <include>com.openhtmltopdf:openhtmltopdf-core</include>

        <include>com.openhtmltopdf:openhtmltopdf-pdfbox</include>

        <include>org.apache.pdfbox:xmpbox</include>

        <include>de.rototor.pdfbox:graphics2d</include>

        <include>com.openhtmltopdf:openhtmltopdf-rtl-support</include>

        <include>com.ibm.icu:icu4j</include>

        <include>com.openhtmltopdf:openhtmltopdf-jsoup-dom-converter</include>

        <include>com.vladsch.flexmark:flexmark-profile-pegdown</include>

        <include>com.vladsch.flexmark:flexmark-util-ast</include>

        <include>org.jetbrains:annotations</include>

        <include>com.vladsch.flexmark:flexmark-util-builder</include>

        <include>com.vladsch.flexmark:flexmark-util-collection</include>

        <include>com.vladsch.flexmark:flexmark-util-data</include>

        <include>com.vladsch.flexmark:flexmark-util-dependency</include>

        <include>com.vladsch.flexmark:flexmark-util-format</include>

        <include>com.vladsch.flexmark:flexmark-util-html</include>

        <include>com.vladsch.flexmark:flexmark-util-misc</include>

        <include>com.vladsch.flexmark:flexmark-util-options</include>

        <include>com.vladsch.flexmark:flexmark-util-sequence</include>

        <include>com.vladsch.flexmark:flexmark-util-visitor</include>

        <include>com.vladsch.flexmark:flexmark-youtrack-converter</include>

        <include>org.apache.pdfbox:pdfbox</include>

        <include>org.apache.pdfbox:fontbox</include>

        <include>commons-logging:commons-logging</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

package org.gvsig.scripting.app;

/*

 * Copyright 2006 Sun Microsystems, Inc.  All Rights Reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   - Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *

 *   - Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 *   - Neither the name of Sun Microsystems nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/**

 * Originally from:

 * http://blogs.sun.com/andreas/resource/InstallCert.java

 * Use:

 * java InstallCert hostname

 * Example:

 *% java InstallCert ecc.fedora.redhat.com

 */

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.security.KeyStore;

import java.security.MessageDigest;

import java.security.cert.CertificateException;

import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;

import javax.net.ssl.SSLException;

import javax.net.ssl.SSLSocket;

import javax.net.ssl.SSLSocketFactory;

import javax.net.ssl.TrustManager;

import javax.net.ssl.TrustManagerFactory;

import javax.net.ssl.X509TrustManager;

/**

 * Class used to add the server's certificate to the KeyStore

 * with your trusted certificates.

 * 

 * NOTE: modified to install the certificate always into the main cacerts

 * keystore.

 */

public class InstallCert {

    public static void install(String host, Integer port, String passphrase) throws Exception {

        if( passphrase==null ) {

            passphrase = "changeit";

        }

        if( port == null || port <1) {

            port = 443;

        }

        main(

            new String[] {

                host +":"+port,

                passphrase

            }

        );

    }

    public static void main(String[] args) throws Exception {

        String host;

        int port;

        char[] passphrase;

        if ((args.length == 1) || (args.length == 2)) {

            String[] c = args[0].split(":");

            host = c[0];

            port = (c.length == 1) ? 443 : Integer.parseInt(c[1]);

            String p = (args.length == 1) ? "changeit" : args[1];

            passphrase = p.toCharArray();

        } else {

            System.out.println("Usage: java InstallCert [:port] [passphrase]");

            return;

        }

        File file = null;

        // File file = new File("jssecacerts");

        // if (file.isFile() == false) {

        char SEP = File.separatorChar;

        File dir =

            new File(System.getProperty("java.home") + SEP + "lib" + SEP

                + "security");

        // file = new File(dir, "jssecacerts");

        // if (file.isFile() == false) {

                file = new File(dir, "cacerts");

        if (!file.canWrite()) {

            System.err

                .println("Unable to write in the file "

                    + file

                + ".\nRun InstallCert as an administrator or a user with "

                + "privileges to write in the cacerts file");

            System.exit(-1);

        }

        // }

        // }

        System.out.println("Loading KeyStore " + file + "...");

        InputStream in = new FileInputStream(file);

        KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());

        ks.load(in, passphrase);

        in.close();

        SSLContext context = SSLContext.getInstance("TLS");

        TrustManagerFactory tmf =

            TrustManagerFactory.getInstance(TrustManagerFactory

                .getDefaultAlgorithm());

        tmf.init(ks);

        X509TrustManager defaultTrustManager =

            (X509TrustManager) tmf.getTrustManagers()[0];

        SavingTrustManager tm = new SavingTrustManager(defaultTrustManager);

        context.init(null, new TrustManager[] { tm }, null);

        SSLSocketFactory factory = context.getSocketFactory();

        System.out

            .println("Opening connection to " + host + ":" + port + "...");

        SSLSocket socket = (SSLSocket) factory.createSocket(host, port);

        socket.setSoTimeout(10000);

        try {

            System.out.println("Starting SSL handshake...");

            socket.startHandshake();

            socket.close();

            System.out.println();

            System.out.println("No errors, certificate is already trusted");

        } catch (SSLException e) {

            System.out.println();

            e.printStackTrace(System.out);

        }

        X509Certificate[] chain = tm.chain;

        if (chain == null) {

            System.out.println("Could not obtain server certificate chain");

            return;

        }

        BufferedReader reader =

            new BufferedReader(new InputStreamReader(System.in));

        System.out.println();

        System.out.println("Server sent " + chain.length + " certificate(s):");

        System.out.println();

        MessageDigest sha1 = MessageDigest.getInstance("SHA1");

        MessageDigest md5 = MessageDigest.getInstance("MD5");

        for (int i = 0; i < chain.length; i++) {

            X509Certificate cert = chain[i];

            System.out.println(" " + (i + 1) + " Subject "

                + cert.getSubjectDN());

            System.out.println("   Issuer  " + cert.getIssuerDN());

            sha1.update(cert.getEncoded());

            System.out.println("   sha1    " + toHexString(sha1.digest()));

            md5.update(cert.getEncoded());

            System.out.println("   md5     " + toHexString(md5.digest()));

            System.out.println();

        }

//        int k=0;

//        System.out

//            .println("Enter certificate to add to trusted keystore or 'q' to quit: [1]");

//        String line = reader.readLine().trim();

//        try {

//            k = (line.length() == 0) ? 0 : Integer.parseInt(line) - 1;

//        } catch (NumberFormatException e) {

//            System.out.println("KeyStore not changed");

//            return;

//        }

        for( int k=0; k<chain.length; k++ ) {

            X509Certificate cert = chain[k];

            String alias = host + "-" + (k + 1);

            ks.setCertificateEntry(alias, cert);

            // OutputStream out = new FileOutputStream("jssecacerts");

            OutputStream out = new FileOutputStream(file);

            ks.store(out, passphrase);

            out.close();

            System.out.println();

            System.out.println(cert);

            System.out.println();

            System.out

                .println("Added certificate to keystore '" +

                        file + "' using alias '" + alias + "'");

        }

    }

    private static final char[] HEXDIGITS = "0123456789abcdef".toCharArray();

    private static String toHexString(byte[] bytes) {

        StringBuilder sb = new StringBuilder(bytes.length * 3);

        for (int b : bytes) {

            b &= 0xff;

            sb.append(HEXDIGITS[b >> 4]);

            sb.append(HEXDIGITS[b & 15]);

            sb.append(' ');

        }

        return sb.toString();

    }

    private static class SavingTrustManager implements X509TrustManager {

        private final X509TrustManager tm;

        private X509Certificate[] chain;

        SavingTrustManager(X509TrustManager tm) {

            this.tm = tm;

        }

        public X509Certificate[] getAcceptedIssuers() {

            throw new UnsupportedOperationException();

        }

        public void checkClientTrusted(X509Certificate[] chain, String authType)

            throws CertificateException {

            throw new UnsupportedOperationException();

        }

        public void checkServerTrusted(X509Certificate[] chain, String authType)

            throws CertificateException {

            this.chain = chain;

            tm.checkServerTrusted(chain, authType);

        }

    }

}

package org.gvsig.scripting.app.extension;

import java.awt.Dimension;

import java.util.ArrayList;

import java.util.List;

import javax.swing.DefaultListModel;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import org.gvsig.scripting.DataFolderFound;

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

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

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

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

/**

 *

 * @author jjdelcerro

 */

public class DataFoldersRecoverPanel extends DataFoldersRecoverPanelView {

    private final List<DataFolderFound> dataFoldersFound;

    private JListWithCheckbox lstCheckedDataFolders;

    public DataFoldersRecoverPanel(List<DataFolderFound> dataFoldersFound) {

        this.dataFoldersFound = dataFoldersFound;

        this.initComponents();

    }

    private void initComponents() {

        ToolsSwingManager manager = ToolsSwingLocator.getToolsSwingManager();

        this.lstCheckedDataFolders = manager.createJListWithCheckbox(lstDataFolders);

        DefaultListModel model = new DefaultListModel();

        for (DataFolderFound dataFolderFound : dataFoldersFound) {

            if( dataFolderFound.getApplicationFolder()==null ) {

                continue;

            }

            model.addElement(

                new ListElement<>(

                    dataFolderFound.getApplicationName() + " ("+dataFolderFound.getDataFolderId()+")", 

                    dataFolderFound

                )

            );

        }

        this.lstDataFolders.setModel(model);

        this.lstDataFolders.addListSelectionListener(new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent e) {

                if( e.getValueIsAdjusting() ) {

                    return;

                }

                updateInterfaceData();

            }

        });

        this.setPreferredSize(new Dimension(500, 420));

    }

    private void updateInterfaceData() {

        DataFolderFound dataFolder = (DataFolderFound) ListElement.getSelected(this.lstDataFolders);

        if (dataFolder == null) {

            return;

        }

        this.txtApplication.setText(dataFolder.getApplicationName());

        this.txtPreferencias.setText(dataFolder.getDataFolderId());

        this.txtPath.setText(dataFolder.getApplicationFolder().getUserPath());

        String path = dataFolder.getOldDataFolder().getAbsolutePath();

        this.txtOldFolder.setText(path);

        this.txtOldFolder.setCaretPosition(path.length());

    }

    public List<DataFolderFound> getSelectedDataFolders() {

        List<DataFolderFound> r = new ArrayList<>();

        ListSelectionModel checkedModel = this.lstCheckedDataFolders.getCheckedModel();

        for (int i = 0; i < dataFoldersFound.size(); i++) {

            if (checkedModel.isSelectedIndex(i)) {

                r.add(dataFoldersFound.get(i));

            }

        }

        return r;

    }

}

/* 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.

        }

    }

    public ScriptingUtils getScriptingUtils() {

        return this.utils;

    } 

    @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) ) {

            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

        );

        pluginManager.addStartupTask(

            "PostProcessArguments",

            new PostProcessArguments(),

            false,

            199

        );

        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;

    }

}

package org.gvsig.scripting.app.extension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.IOException;

import java.nio.file.FileVisitOption;

import static java.nio.file.FileVisitOption.FOLLOW_LINKS;

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.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.List;

import java.util.function.Predicate;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOCase;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.scripting.DataFolderFound;

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingLocator;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.scripting.ScriptingUnit;

import org.gvsig.scripting.app.extension.messagewait.MessageWait;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.packageutils.PackageManager;

import org.gvsig.tools.packageutils.Version;

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

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

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

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

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

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

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.tools.util.FolderSet;

import org.gvsig.tools.util.impl.DefaultFolderSet;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ScriptingUtils {

    public static final String SKIP_AUTORUNS = "skipAutoruns";

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

    private boolean executingAutorunScripts = false;

    private static boolean composer_initialized = false;

    private final MessageWait message;

    /*

     * la funcion log y las constantes estan pensadas para usarlas desde los scripts.

     */

    public static final int INFO = 0;

    public static final int TRACE = 1;

    public static final int WARN = 2;

    public static final int ERROR = 3;

    public static void log(String message) {

        log(INFO, message, null);

    }

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

        log(level, message, null);

    }

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

        switch( level ) {

        case TRACE:

            LOGGER.trace(message, th);

            break;

        case ERROR:

            LOGGER.error(message, th);

            break;

        case WARN:

            LOGGER.warn(message, th);

            break;

        default:

        case INFO:

            LOGGER.info(message, th);

            break;

        }

    }

    private String appversion;

    private File pluginHomeFolder;

    public ScriptingUtils() {

        message = new MessageWait();

    }

    public static File getScriptsHomeFolder(File pluginHomeFolder, String appversion) {

        File scriptsHomeFolder;

        File f = FileUtils.getFile(pluginHomeFolder, "scripts-folder.txt");

        if( f.exists() ) {

            try {

                List<String> lines = FileUtils.readLines(f);

                for( String line : lines ) {

                    line = line.trim();

                    if( !line.startsWith("#") ) {

                        scriptsHomeFolder = new File(line);

                        if( !scriptsHomeFolder.isAbsolute() ) {

                            scriptsHomeFolder = new File(pluginHomeFolder, line);

                        }

                        scriptsHomeFolder = new File(

                            FilenameUtils.normalizeNoEndSeparator(

                                scriptsHomeFolder.getAbsolutePath(),

                                true

                            )

                        );

                        if( scriptsHomeFolder.exists() ) {

                            return scriptsHomeFolder;

                        }

                    }

                }

            } catch (IOException ex) {

            }

        } else {

            try {

                FileUtils.touch(f);

            } catch (IOException ex) {

            }

        }

        scriptsHomeFolder = FileUtils.getFile(pluginHomeFolder, appversion) ;

        return scriptsHomeFolder;

    }

    public void initializaPaths(List<File> pluginsFolder, File installFolder, File pluginHoneFolder, String appversion) {

        this.appversion = appversion;

        this.pluginHomeFolder = pluginHoneFolder;

        ScriptingManager manager = ScriptingLocator.getManager();

        manager.setHomeFolder(getScriptsHomeFolder(pluginHoneFolder, appversion));

        ScriptingFolder folder = manager.createLink(

            "Common",

            manager.getUserFolder(), 

            "../../scripts"

        );

        folder.setProperty(ScriptingUtils.SKIP_AUTORUNS, BooleanUtils.toStringTrueFalse(true));

        folder.save();

//        manager.createLink(

//            "Previous version",

//            manager.getUserFolder(), 

//            "../../../org.gvsig.scripting.app.extension/scripts"

//        );

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

        for( File f : pluginsFolder ) {

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

            }

        }

        manager.setPackagesFolder(installFolder);

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

            }

        }

        File initAddonFile = new File(localAddonRepositoryFolder, "__init__.py");

        if( !initAddonFile.exists() ) {

            try {

                FileUtils.touch(initAddonFile);

            } catch (IOException ex) {

                LOGGER.info("Can't create addons __init__ file in '" + localAddonRepositoryFolder.getAbsolutePath() + "'.", ex);

            }

        }

    }

    public void runScript(String name, Object[] args) {

        if( StringUtils.isBlank(name) ) {

            return;

        }

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

        WindowManager winmanager = ToolsSwingLocator.getWindowManager();        

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

        if( script != null ) {

            script.run(args);

        } else {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(

                    "Can't locate script '" + name + "'.", 

                    "ScriptLaunch", 

                    JOptionPane.OK_OPTION

            );

        }

    }

    public void runLauncher() {

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

        WindowManager winmanager = ToolsSwingLocator.getWindowManager();        

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

    }

    public void runComposer() {

        PluginsManager pluginsManager = PluginsLocator.getPluginsManager();

        PluginServices plugin = pluginsManager.getPlugin(ScriptingExtension.class);

        if( plugin!=null ) {

            DynObject preferences = plugin.getPluginProperties();

            if( preferences!=null ) {

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

                if( composerUseHisWindowManager!=null && composerUseHisWindowManager ) {

                    DefaultWindowManager winmanager = new DefaultWindowManager();

                    ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

                    uimanager.setWindowManager(winmanager);

                }

            }

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        message.showMessage(

                i18n.getTranslation("_notice"),

                i18n.getTranslation("_Initializing_the_scripting_plugin_Xhorizontal_ellipsisX") + "\n"

                + i18n.getTranslation("_Waiting_to_terminate"),

                new MessageWait.WaitingCondition() {

            private Thread th = null;

            @Override

            public boolean stopWaiting() {

                if (executingAutorunScripts) {

                    return false;

                }

                if (composer_initialized) {

                    return true;

                }

                if (th == null) {

                    th = new Thread(new ExecuteScriptsFromScriptingFolders(null, "scautorun", SCRIPT_COMPOSER_AUTORUN), "StartupScriptingComposer");

                    th.start();

                }

                return false;

            }

        },

                new Runnable() {

            @Override

            public void run() {

                showScriptingComposer();

            }

        }

        );

    }

    public Runnable getAutorunScriptsOnStartup(List<File> pluginsFolders) {

        return new ExecuteAutorunScriptsOnStartup(pluginsFolders);

    }

    private void showScriptingComposer() {

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

        JScriptingComposer composer = uimanager.createComposer();

        uimanager.showWindow(

            composer.asJComponent(),

            uimanager.getTranslation("Scripting_Composer")

        );

    }

    private class ExecuteScriptsFromScriptingFolders extends AbstractExecuteScripts {

        public ExecuteScriptsFromScriptingFolders(List<File> pluginsFolders, String title, String patternName) {

            super(pluginsFolders, title, patternName);

        }

        @Override

        public void run() {            

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            SimpleTaskStatus status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Scripts startup");

            status.setIndeterminate();

            status.setAutoremove(true);

            status.add();

            final I18nManager i18nManager = ToolsLocator.getI18nManager();            

            try {

                LOGGER.info("Searching "+title+" scripts...");

                dialogs.message(

                    i18nManager.getTranslation("_Searching_autorun_scripts_Xhorizontal_ellipsisX"),

                    JOptionPane.INFORMATION_MESSAGE

                );

                ScriptingManager manager = ScriptingLocator.getManager();

                final List<ScriptingScript> scripts = new ArrayList<>();

                Visitor visitor = new Visitor() {

                    @Override

                    public void visit(Object o) throws VisitCanceledException, BaseException {

                        ScriptingUnit unit = (ScriptingUnit) o;

                        if( unit instanceof ScriptingScript && 

                            FilenameUtils.wildcardMatch(unit.getName(), patternName, IOCase.INSENSITIVE) ) {

                            ScriptingScript script = (ScriptingScript) unit;

                            if( script.isEnabled() ) {

                                scripts.add(script);

                            } else {

                                LOGGER.info("Skip "+title+" script '" + script.getFile().getAbsolutePath() + "'.");

                            }

                        }

                    }

                };

                Predicate<ScriptingUnit> includeFilter = new Predicate<ScriptingUnit>() {

                    @Override

                    public boolean test(ScriptingUnit unit) {

                        if( unit instanceof ScriptingFolder ) {

                            return !BooleanUtils.toBoolean(unit.getProperty(SKIP_AUTORUNS));

                        }

                        return false;

                    }

                };

                manager.getSystemFolder().accept(visitor, includeFilter);

                manager.getUserFolder().accept(visitor, includeFilter);

                sortScripts(scripts);

                executeScripts(scripts, status);

            } catch(Throwable th) {

            } finally {

                composer_initialized = true;

                LOGGER.info("Running "+title+" scripts terminated.");

                dialogs.message("", JOptionPane.INFORMATION_MESSAGE);

                status.terminate();

            }

        }

    }

    public class ExecuteAutorunScriptsOnStartup implements Runnable {

        private final List<File> pluginsFolders;

        public ExecuteAutorunScriptsOnStartup(List<File> pluginsFolders) {

            this.pluginsFolders = pluginsFolders;

        }

        @Override

        public void run() {

            Runnable process = new ExecuteScriptsFromFilesystem(

                    this.pluginsFolders,

                    "autorun", 

                    "autorun.inf"

            );

            process.run();

        }

    }

    private abstract class AbstractExecuteScripts implements Runnable {

        protected String patternName;

        protected String title;

        private final List<File> pluginsFolders;

        public AbstractExecuteScripts(List<File> pluginsFolders, String title, String patternName) {

            if( pluginsFolders==null ) {

                this.pluginsFolders = Collections.EMPTY_LIST;

            } else {

                this.pluginsFolders = pluginsFolders;

            }

            this.patternName = patternName;

            this.title = title;

        }

        protected List<File> getPluginsFolders() {

            return this.pluginsFolders;

        }

        private String getScriptOrderKey(ScriptingBaseScript o) {

            int groupOrder = 500;

            String groupName = "default";

            int scriptOrder = 500;

            String s = o.getProperty("autorun.group.order");

            if (s != null) {

                try {

                    groupOrder = Integer.parseInt(s);

                } catch (Exception ex) {

                    // Do nothing.

                }

            }

            s = o.getProperty("autorun.group.name");

            if (s != null) {

                groupName = s;

            }

            s = o.getProperty("autorun.order");

            if (s != null) {

                try {

                    scriptOrder = Integer.parseInt(s);

                } catch (Exception ex) {

                    // Do nothing.

                }

            }

            String key = MessageFormat.format(

                    "{0,number,000000}.{1}.{2,number,000000}",

                    groupOrder,

                    groupName,

                    scriptOrder

            );

            return key;

        }

        protected void sortScripts(List<ScriptingScript> scripts) {

            Collections.sort(scripts, new Comparator<ScriptingBaseScript>() {

                @Override

                public int compare(ScriptingBaseScript o1, ScriptingBaseScript o2) {

                    return getScriptOrderKey(o2).compareToIgnoreCase(getScriptOrderKey(o1));

                }

            });

        }

        protected void executeScripts(List<ScriptingScript> scripts, SimpleTaskStatus status) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            final I18nManager i18nManager = ToolsLocator.getI18nManager();

            if (scripts != null && !scripts.isEmpty()) {

                if (status != null) {

                    status.setRangeOfValues(0, scripts.size());

                }

                int n = 0;

                for (ScriptingBaseScript script : scripts) {

                    if (status != null) {

                        status.setCurValue(n++);

                    }

                    try {

                        LOGGER.info("running " + title + " script '" + script.getFile().getAbsolutePath() + "' (" + getScriptOrderKey(script) + ", " + script.getIsolationGroup() + ").");

                        dialogs.message(

                                i18nManager.getTranslation(

                                        "_Starting_XnameX",

                                        new String[]{

                                            script.getFile().getParentFile().getName()}

                                ),

                                JOptionPane.INFORMATION_MESSAGE

                        );

                    } catch (Exception ex) {

                        // Ignore it

                    }

                    try {

                        // Hacemos un reload por si un sript deshabilito a otro.

                        script.reload();

                        if( script.isEnabled() ) {

                            script.run();

                        } else {

                            LOGGER.info("Skip " + title + " script '" + script.getFile().getAbsolutePath() + "' (" + getScriptOrderKey(script) + ", " + script.getIsolationGroup() + ").");

                        }

                    } catch (Exception ex) {

                        LOGGER.warn("Can't execute " + title + " from '" + script.getFile().getAbsolutePath() + "'.", ex);

                    }

                }

            }

        }

    }

    private class ExecuteScriptsFromFilesystem extends AbstractExecuteScripts {

        public ExecuteScriptsFromFilesystem(List<File> pluginsFolder, String title, String patternName) {

            super(pluginsFolder, title, patternName);

        }

        @Override

        public void run() {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            executingAutorunScripts = true;

            try {

                final ScriptingManager manager = ScriptingLocator.getManager();

                manager.loadEngines();

//                final PluginsManager pluginManager = PluginsLocator.getManager();

                final I18nManager i18nManager = ToolsLocator.getI18nManager();

                final List<ScriptingScript> scripts = new ArrayList<>();

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

                for (File pluginsFolders2 : this.getPluginsFolders()) {

                    for (File pluginFolder : pluginsFolders2.listFiles()) {

                        File f = FileUtils.getFile(pluginFolder, "scripting", "scripts");

                        if (f.exists()) {

                            pluginsFolders.add(f);

                        }

                    }

                }

                dialogs.message(

                        i18nManager.getTranslation("_Searching_autorun_scripts_Xhorizontal_ellipsisX"),

                        JOptionPane.INFORMATION_MESSAGE

                );

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

                    @Override

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

                        File file = path.toFile();

                        if (FilenameUtils.wildcardMatch(file.getName(), patternName, IOCase.INSENSITIVE)) {

                            if (file.exists()) {

                                ScriptingScript script = (ScriptingScript) manager.getScript(file);

                                if (script.isEnabled()) {

                                    scripts.add(script);

                                } else {

                                    LOGGER.info("Skip " + title + " script '" + file.getAbsolutePath() + "'.");

                                }

                            }

                        }

                        return FileVisitResult.CONTINUE;

                    }

                };

                try {

                    EnumSet<FileVisitOption> opts = EnumSet.of(FOLLOW_LINKS);

                    for (File pluginFolder : pluginsFolders) {

                        Files.walkFileTree(Paths.get(pluginFolder.toURI()), opts, Integer.MAX_VALUE, visitor);

                    }

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

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

                    for (ScriptingFolder folder : folders) {

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

                    }

                } catch (Exception ex) {

                    LOGGER.warn("Can't execute " + title + " in home.", ex);

                }

                sortScripts(scripts);

                executeScripts(scripts, null);

            } finally {

                LOGGER.info("Running " + title + " scripts terminated.");

                dialogs.message("", JOptionPane.INFORMATION_MESSAGE);

                executingAutorunScripts = false;

            }

            checkDataFoldersVersions();

        }

    }

    private void checkDataFoldersVersions() {

        final ScriptingManager manager = ScriptingLocator.getManager();

        PackageManager versionFactory = ToolsLocator.getPackageManager();

        Version currentVersion = versionFactory.createVersion(this.appversion);

        FolderSet folders = new DefaultFolderSet();

        folders.add(this.pluginHomeFolder);

        final List<DataFolderFound> dataFoldersFound = manager.searchOldVersions(currentVersion, folders);

        if( dataFoldersFound == null || dataFoldersFound.isEmpty() ) {

            return;

        }

        Runnable askUser = new Runnable() {

            @Override

            public void run() {

                WindowManager_v2 winManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

                final DataFoldersRecoverPanel panel = new DataFoldersRecoverPanel(dataFoldersFound);

                final Dialog dialog = winManager.createDialog(

                        panel,

                        "Recuperacion de preferencias",

                        null,

                        WindowManager_v2.BUTTONS_OK_CANCEL

                );

                dialog.addActionListener(new ActionListener() {

                    @Override

                    public void actionPerformed(ActionEvent e) {

                        if (dialog.getAction() == WindowManager_v2.BUTTON_OK) {

                            List<DataFolderFound> toRestore = panel.getSelectedDataFolders();

                            for (DataFolderFound dataFolderFound : dataFoldersFound) {

                                if (toRestore.contains(dataFolderFound)) {

                                    dataFolderFound.restore();

                                } else {

                                    dataFolderFound.leave();

                                }

                            }

                        }

                    }

                });

                dialog.show(WindowManager.MODE.WINDOW);

            }

        };

        if( SwingUtilities.isEventDispatchThread() ) {

            askUser.run();

        } else {

            SwingUtilities.invokeLater(askUser);

        }

    }

}

package org.gvsig.scripting.app.extension;

import java.io.File;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.swing.UIManager;

import org.apache.commons.cli.CommandLine;

import org.apache.commons.cli.CommandLineParser;

import org.apache.commons.cli.Options;

import org.apache.commons.cli.PosixParser;

import org.apache.commons.io.FileUtils;

import org.gvsig.about.AboutLocator;

import org.gvsig.about.AboutManager;

import org.gvsig.scripting.ScriptingManager;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

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

import org.gvsig.tools.packageutils.PackageInfo;

import org.gvsig.tools.packageutils.PackageManager;

import org.gvsig.tools.packageutils.Version;

/**

 *

 * @author jjdelcerro

 */

public class ScriptingMain {

    private File applicationFolder = null;

    private Version applicacionVersion = null;

    private List<File> pluginsFolder = null;

    private File applicationHomeFolder;

    private File installFolder;

    private int applicacionBuildNumber;

    private ScriptingUtils utils;

    public static void main(String args[]) throws Exception {

        ScriptingMain main = new ScriptingMain();

        main.doMain(args);

    }

    public File getApplicationFolder() {

        if (applicationFolder == null) {

            applicationFolder = new File(System.getProperty("user.dir"));

        }

        return applicationFolder;

    }

    public File getApplicationHomeFolder() {

        if (applicationHomeFolder == null) {

            applicationHomeFolder = new File(System.getProperty("user.home"));

        }

        return applicationHomeFolder;

    }

    public File getInstallFolder() {

        if (installFolder == null) {

            installFolder = FileUtils.getFile(getApplicationFolder(), "install");

        }

        return this.installFolder;