Application: gvSIG desktop » gvSIG scripting

#Mon Jun 19 01:38:41 CEST 2023

buildNumber=299

<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.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 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">