Application: gvSIG desktop » gvSIG scripting

#Sun Dec 17 20:01:32 CET 2023

buildNumber=314

<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.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 java.util.logging.Level;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.collections4.CollectionUtils;

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.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionUtils;

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;

        }

        String method = null;

        if( name.contains(".") ) {

            String[] ss = StringUtils.split(name, '.');

            name = ss[0];

            if( StringUtils.isAlphanumeric(ss[1]) ) {

                method = ss[1];

            } else {

                try {

                    Code.Callable code = (Code.Callable) ExpressionUtils.compile(ss[1]);

                    method = code.name();

                    try {

                        code.link();

                        List<Object> args2 = new ArrayList<>();

                        for (Code param : code.parameters()) {

                            args2.add(((Code.Constant)param).value());

                        }

                        if( !CollectionUtils.isEmpty(args2) ) {

                            args = args2.toArray(new Object[args2.size()]);

                        }

                    } catch(Throwable t) {

                        LOGGER.warn("Can't process command args ("+name+").",t);

                    }

                } catch(Throwable t) {

                    LOGGER.warn("Can't process command ("+name+").",t);

                    method = StringUtils.left(ss[1], indexOfNonAlphanumeric(ss[1])+1);

                }

            }

        }

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

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

        if( script != null ) {

            if( StringUtils.isNotBlank(method) && script instanceof ScriptingScript ) {

                try {

                    ((ScriptingScript)script).invokeFunction(method, args);

                } catch (NoSuchMethodException ex) {

                    LOGGER.warn("Can't call method '"+method+"' of script '"+name+"'.", ex);

                    dialogs.messageDialog(

                            "Can't call method '"+method+"' of script '"+name+"'.", 

                            "ScriptLaunch", 

                            JOptionPane.OK_OPTION

                    );

                }

            } else {

                script.run(args);

            }

        } else {

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

            try {

                Runnable process = new ExecuteScriptsFromFilesystem(

                        this.pluginsFolders,

                        "autorun", 

                        "autorun.inf"

                );

                process.run();

            } catch(Throwable t) {

                LOGGER.error("Problems runing autorun scripts",t);

                I18nManager i18n = ToolsLocator.getI18nManager();

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                dialogs.messageDialog(

                        i18n.getTranslation("_There_was_a_problem_starting_the_application_It_is_convenient_that_you_close_it_and_start_it_again"), 

                        "gvSIG desktop", 

                        JOptionPane.ERROR_MESSAGE

                );

            }

        }

    }

    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(o1).compareToIgnoreCase(getScriptOrderKey(o2));

                }

            });

        }

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

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            final I18nManager i18nManager = ToolsLocator.getI18nManager();

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

                LOGGER.info("Scripts to run:");

                for (ScriptingBaseScript script : scripts) {

                    try {

                        LOGGER.info(StringUtils.abbreviateMiddle(script.getFile().getParent(),"...",50) + " (" + getScriptOrderKey(script) + ", " + script.getIsolationGroup() + ")");

                    } catch(Throwable t) {

                        LOGGER.info("...Error...");

                    }

                }                

                if (status != null) {

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

                }

                int n = 0;

                for (ScriptingBaseScript script : scripts) {

                    if (status != null) {

                        status.setCurValue(n++);

                    }

                    try {

                        if( StringUtils.equals("autorun", title) ) {

                            LOGGER.info("running '" + script.getFile().getParent() + "'.");

                        } else {

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

                        }

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

        }

    }

    private int indexOfNonAlphanumeric(String s) {

        if( StringUtils.isBlank(s) ) {

            return -1;

        }

        char ch = s.charAt(0);

        if( !Character.isJavaIdentifierStart(ch) ) {

            return -1;

        }

        int i = 0;

        for (; i < s.length(); i++) {

            ch = s.charAt(i);

            if( !Character.isJavaIdentifierPart(ch) ) {

                return i-1;

            }

        }

        return i-1;

    }

}

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;

    }

    public Version getApplicationVersion() throws BaseException {

        if (applicacionVersion == null) {

            PackageManager packageManager = ToolsLocator.getPackageManager();

            PackageInfo packageInfo = packageManager.createPackageInfo(

                    new File(this.applicationFolder, "package.info")

            );

            applicacionVersion = (Version) packageInfo.getVersion();

        }

        return applicacionVersion;

    }

    public int getApplicationBuildNumber() throws BaseException {

        if (applicacionBuildNumber == 0) {

            applicacionBuildNumber = getApplicationVersion().getBuild();

        }

        return this.applicacionBuildNumber;

    }

    public List<File> getPluginsFolder() {

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

        folders.add(FileUtils.getFile(this.getApplicationFolder(), "gvSIG", "extensiones"));

        folders.add(FileUtils.getFile(this.getApplicationHomeFolder(), "gvSIG", "installation", "gvSIG", "extensiones"));

        return folders;

    }

    public File getPluginHomeFolder() {

        File f = this.getApplicationHomeFolder();

        f = FileUtils.getFile(f, "gvSIG", "plugins", "org.gvsig.scripting.app.mainplugin");

        return f;

    }

    private void initializeAbout() throws Exception {

        AboutManager aboutManager = AboutLocator.getManager();

        String build = String.valueOf(this.getApplicationBuildNumber());

        String version = this.getApplicationVersion().toString();

        Map<String, String> gvsig_vars = new HashMap<>();

        gvsig_vars.put("version", version);

        gvsig_vars.put("build", build);

        aboutManager.setProject(

                "gvSIG Desktop", 

                getResource("gvsig.html"),

                null, 

                gvsig_vars);

        aboutManager.getProject().set("build", build);

        aboutManager.addSponsor(

                "Generalitat Valenciana",

                getResource("gva.html"), 

                1);

        aboutManager.addDeveloper(

                "gvSIG Asocicion",

                getResource("gvSIG-asociacion.html"), 

                2);

    }

    public void doMain(String args[]) throws Exception {

        String lookAndFeel = "com.jgoodies.looks.plastic.PlasticXPLookAndFeel";

        try {

            UIManager.setLookAndFeel(lookAndFeel);

        } catch(Throwable th) {

        }

        new DefaultLibrariesInitializer().fullInitialize();

        initializeAbout();

        this.utils = new ScriptingUtils();

        this.utils.initializaPaths(

                this.getPluginsFolder(),

                this.getInstallFolder(),

                this.getPluginHomeFolder(),

                this.getApplicationVersion().format("%M.%m.%r")

        );

        ScriptingUIManager uimanager = ScriptingSwingLocator.getUIManager();

        ScriptingManager manager = uimanager.getManager();

        Options options = new Options();

        options.addOption("d",

                "debug",

                false,

                "");

        options.addOption("p",

                "pause",

                false,

                "");

        options.addOption("l",

                "launcher",

                false,

                "Show the launcher window");

        options.addOption("c",

                "composer",

                false,

                "Show the composer window");

        options.addOption("r",

                "run",

                true,

                "Run the specified script");

        options.addOption("h",

                "home",

                true,

                "Specify for the home of the script framework");

        CommandLineParser parser = new PosixParser();

        CommandLine line = null;

        boolean runLauncherAtEnd = true;

        line = parser.parse(options, args);

        if (line.hasOption("home")) {

            manager.setHomeFolder(new File(line.getOptionValue("home")));

        }

        if (line.hasOption("composer")) {

            runLauncherAtEnd = false;

            utils.runComposer();

        }

        if (line.hasOption("run")) {

            runLauncherAtEnd = false;

            utils.runScript(line.getOptionValue("run"), line.getArgs());

        }

        if( runLauncherAtEnd ) {

            utils.runLauncher();

        }

    }

    private URL getResource(String name) {

        URL resource = this.getClass().getResource(name);

        return resource;

    }

}

<?xml version="1.0" encoding="UTF-8"?>

<object classname="com.jeta.forms.store.memento.FormPackage">

 <at name="fileversion">

  <object classname="com.jeta.forms.store.memento.FormsVersion2">

   <at name="major">2</at>

   <at name="minor">0</at>

   <at name="sub">0</at>

  </object>

 </at>

 <at name="form">

  <object classname="com.jeta.forms.store.memento.FormMemento">

   <super classname="com.jeta.forms.store.memento.ComponentMemento">

    <at name="cellconstraints">

     <object classname="com.jeta.forms.store.memento.CellConstraintsMemento">

      <at name="column">1</at>

      <at name="row">1</at>

      <at name="colspan">1</at>

      <at name="rowspan">1</at>

      <at name="halign">default</at>

      <at name="valign">default</at>

      <at name="insets" object="insets">0,0,0,0</at>

     </object>

    </at>

    <at name="componentclass">com.jeta.forms.gui.form.FormComponent</at>

   </super>

   <at name="id">/home/jjdelcerro/datos/devel/org.gvsig.scripting/org.gvsig.scripting.app/org.gvsig.scripting.app.mainplugin/src/main/java/org/gvsig/scripting/app/extension/DataFoldersRecoverPanelView.xml</at>

   <at name="rowspecs">CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:DEFAULT:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,FILL:DEFAULT:GROW(1.0),CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE,CENTER:DEFAULT:NONE,CENTER:2DLU:NONE</at>

   <at name="colspecs">FILL:DEFAULT:NONE,FILL:DEFAULT:NONE,FILL:DEFAULT:NONE</at>

   <at name="components">

    <object classname="java.util.LinkedList">

     <item >

      <at name="value">

       <object classname="com.jeta.forms.store.memento.BeanMemento">

        <super classname="com.jeta.forms.store.memento.ComponentMemento">

         <at name="cellconstraints">

          <object classname="com.jeta.forms.store.memento.CellConstraintsMemento">

           <at name="column">2</at>

           <at name="row">2</at>

           <at name="colspan">1</at>

           <at name="rowspan">1</at>

           <at name="halign">default</at>

           <at name="valign">default</at>

           <at name="insets" object="insets">0,0,0,0</at>

          </object>

         </at>

         <at name="componentclass">com.jeta.forms.gui.form.StandardComponent</at>

        </super>

        <at name="jetabeanclass">com.jeta.forms.gui.beans.JETABean</at>

        <at name="beanclass">com.jeta.forms.components.label.JETALabel</at>

        <at name="beanproperties">

         <object classname="com.jeta.forms.store.memento.PropertiesMemento">

          <at name="classname">com.jeta.forms.components.label.JETALabel</at>

          <at name="properties">

           <object classname="com.jeta.forms.store.support.PropertyMap">

            <at name="border">

             <object classname="com.jeta.forms.store.properties.CompoundBorderProperty">

              <super classname="com.jeta.forms.store.properties.BorderProperty">

               <at name="name">border</at>

              </super>

              <at name="borders">

               <object classname="java.util.LinkedList">

                <item >

                 <at name="value">

                  <object classname="com.jeta.forms.store.properties.DefaultBorderProperty">

                   <super classname="com.jeta.forms.store.properties.BorderProperty">

                    <at name="name">border</at>

                   </super>

                  </object>

                 </at>

                </item>

               </object>

              </at>

             </object>

            </at>

            <at name="name">lblMsg1</at>

            <at name="width">583</at>

            <at name="text">&lt;html&gt;Han sido encontradas preferencias de versiones anteriores para algunos complementos.&lt;/html&gt;</at>

            <at name="fill">

             <object classname="com.jeta.forms.store.properties.effects.PaintProperty">

              <at name="name">fill</at>

             </object>

            </at>

            <at name="height">14</at>

           </object>

          </at>

         </object>

        </at>

       </object>

      </at>

     </item>

     <item >

      <at name="value">

       <object classname="com.jeta.forms.store.memento.BeanMemento">

        <super classname="com.jeta.forms.store.memento.ComponentMemento">

         <at name="cellconstraints">

          <object classname="com.jeta.forms.store.memento.CellConstraintsMemento">

           <at name="column">2</at>

           <at name="row">4</at>

           <at name="colspan">1</at>

           <at name="rowspan">1</at>

           <at name="halign">default</at>

           <at name="valign">default</at>

           <at name="insets" object="insets">0,0,0,0</at>

          </object>

         </at>

         <at name="componentclass">com.jeta.forms.gui.form.StandardComponent</at>

        </super>

        <at name="jetabeanclass">com.jeta.forms.gui.beans.JETABean</at>

        <at name="beanclass">com.jeta.forms.components.label.JETALabel</at>

        <at name="beanproperties">

         <object classname="com.jeta.forms.store.memento.PropertiesMemento">

          <at name="classname">com.jeta.forms.components.label.JETALabel</at>

          <at name="properties">

           <object classname="com.jeta.forms.store.support.PropertyMap">

            <at name="border">

             <object classname="com.jeta.forms.store.properties.CompoundBorderProperty">

              <super classname="com.jeta.forms.store.properties.BorderProperty">

               <at name="name">border</at>

              </super>

              <at name="borders">

               <object classname="java.util.LinkedList">

                <item >

                 <at name="value">

                  <object classname="com.jeta.forms.store.properties.DefaultBorderProperty">

                   <super classname="com.jeta.forms.store.properties.BorderProperty">

                    <at name="name">border</at>

                   </super>

                  </object>

                 </at>

                </item>

               </object>

              </at>

             </object>