Application: gvSIG desktop

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

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

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.desktop.framework</artifactId>

    <packaging>pom</packaging>

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

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.desktop</artifactId>

        <version>2.0.424</version>

    </parent>

    <modules>

        <module>org.gvsig.andami</module>

        <module>org.gvsig.andami.updater</module>

    </modules>

    <description>Contains the launcher and plugin framework used in gvSIG.</description>

</project>

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.andami;

import junit.framework.Test;

import junit.framework.TestSuite;

public class AllTests {

	public static Test suite() {

		TestSuite suite = new TestSuite("Test for com.iver.andami");

		//$JUnit-BEGIN$

		//$JUnit-END$

		return suite;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.andami.impl;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.net.URI;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Date;

import java.util.Enumeration;

import java.util.Iterator;

import java.util.List;

import javax.swing.SwingUtilities;

import org.apache.commons.io.FileUtils;

import org.gvsig.andami.Arguments;

import org.gvsig.andami.Launcher;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsManager;

import org.gvsig.andami.Utilities;

import org.gvsig.andami.config.generate.AndamiConfig;

import org.gvsig.andami.config.generate.Plugin;

import org.gvsig.andami.firewall.FirewallConfiguration;

import org.gvsig.andami.plugins.ExclusiveUIExtension;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.andami.plugins.IExtension;

import org.gvsig.andami.plugins.PluginClassLoader;

import org.gvsig.andami.plugins.status.IExtensionStatus;

import org.gvsig.andami.plugins.status.IUnsavedData;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.packageutils.PackageManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultPluginsManager implements PluginsManager {

    private class Task implements Comparable, Runnable {

        private String type = "";

        private Runnable task = null;

        private boolean in_event_thread = false;

        private int priority = 0;

        private String name = null;

        public Task(String type, String name, Runnable task, boolean in_event_thread, int priority) {

            this.type = type;

            this.in_event_thread = in_event_thread;

            this.task = task;

            this.priority = priority;

            this.name = name;

        }

        public int compareTo(Object t) {

            return this.priority - ((Task) t).priority;

        }

        public boolean equals(Object t) {

            return this.compareTo(t) == 0;

        }

        public void run() {

            if ( this.in_event_thread ) {

                if ( !SwingUtilities.isEventDispatchThread() ) {

                    try {

                        SwingUtilities.invokeAndWait(new Runnable() {

                            public void run() {

                                Task.this.run();

                            }

                        });

                    } catch (InterruptedException ex) {

                        // Do nothing

                    } catch (InvocationTargetException ex) {

                        logger.warn("Errors in execution of " + type + " task '" + name + "'.", ex);

                    }

                    return;

                }

            }

            logger.info("Running " + type + " task '" + name + "' (priority " + priority + ").");

            try {

                task.run();

                logger.info("Terminated " + type + " task '" + name + "'.");

            } catch (Throwable ex) {

                // Catch Exceptions and Errors (class not found)

                logger.warn("Errors in execution of " + type + " task '" + name + "'.", ex);

            }

        }

    }

    private static Logger logger

            = LoggerFactory.getLogger(DefaultPluginsManager.class);

    private List<File> pluginsFolders = null;

    private List<Task> startupTasks = new ArrayList<Task>();

    private List<Task> shutdownTasks = new ArrayList<Task>();

    public ExclusiveUIExtension getExclusiveUIExtension() {

        return PluginServices.getExclusiveUIExtension();

    }

    public IExtension getExtension(Class<? extends IExtension> extension) {

        return PluginServices.getExtension(extension);

    }

    public IExtension getExtension(String extension) {

        return Launcher.getExtensionByName(extension);

    }

    @SuppressWarnings("unchecked")

    public Iterator<IExtension> getExtensions() {

        return PluginServices.getExtensions();

    }

    /**

     * Return the associated pluginServices to the extension class passed as

     * parameter.

     *

     */

    public PluginServices getPlugin(Class<? extends IExtension> extension) {

        if (!(extension.getClassLoader() instanceof PluginClassLoader)) {

            return null;

        }

        String pluginName = ((PluginClassLoader) extension.getClassLoader()).getPluginName();

        return this.getPlugin(pluginName);

    }

    public PluginServices getPlugin(Object obj) {

        if ( obj instanceof Extension ) {

            return ((Extension)obj).getPlugin();

        }

        if ( obj instanceof IExtension ) {

            Class<? extends IExtension> klass = (Class<? extends IExtension>) obj.getClass();

            return this.getPlugin(klass);

        }

        ClassLoader loader = obj.getClass().getClassLoader();

        if( loader instanceof PluginClassLoader ) {

            String pluginName = ((PluginClassLoader)loader).getPluginName();

            return this.getPlugin(pluginName);

        }

        return null;

    }

    @Override

    public PluginServices getPlugin(String pluginName) {

        return Launcher.getPluginServices(pluginName);

    }

    @Override

	public File getPluginHomeFolder(String pluginName) {

        File folder = FileUtils.getFile( 

            this.getApplicationHomeFolder(), "plugins", pluginName

        );

		if (!folder.exists()) {

			folder.mkdirs();

		}

		return folder;

	}    

    @Override

    public PackageInfo getPackageInfo(Class<? extends IExtension> extension) {

        PackageManager pkgmgr = ToolsLocator.getPackageManager();

        File pinfo_file = new File(this.getPlugin(extension).getPluginDirectory(), "package.info");

        PackageInfo packageInfo = null;

        try {

            packageInfo = pkgmgr.createPackageInfo(pinfo_file);

        } catch (Exception e) {

            logger.info("Error while reading package info file from "

                    + pinfo_file.toString(), e);

        }

        return packageInfo;

    }

    public PackageInfo getPackageInfo(String pluginName) {

        PackageManager pkgmgr = ToolsLocator.getPackageManager();

        File pinfo_file = new File(this.getPlugin(pluginName)

                .getPluginDirectory(), "package.info");

        PackageInfo packageInfo = null;

        try {

            packageInfo = pkgmgr.createPackageInfo(pinfo_file);

        } catch (Exception e) {

            logger.info("Error while reading package info file from "

                    + pinfo_file.toString(), e);

        }

        return packageInfo;

    }

    public PackageInfo getPackageInfo() {

        PackageManager pkgmgr = ToolsLocator.getPackageManager();

        File pinfo_file = new File(

                this.getApplicationFolder(), "package.info");

        PackageInfo packageInfo = null;

        try {

            packageInfo = pkgmgr.createPackageInfo(pinfo_file);

        } catch (Exception e) {

            logger.info("Error while reading package info file from "

                    + pinfo_file.toString(), e);

        }

        return packageInfo;

    }

    @SuppressWarnings("unchecked")

    public List<PluginServices> getPlugins() {

        List<PluginServices> pluginServices = new ArrayList<PluginServices>();

        AndamiConfig config = Launcher.getAndamiConfig();

        Enumeration<Plugin> plugins = config.enumeratePlugin();

        while ( plugins.hasMoreElements() ) {

            Plugin plugin = plugins.nextElement();

            pluginServices.add(PluginServices.getPluginServices(plugin.getName()));

        }

        return pluginServices;

    }

    public void setExclusiveUIExtension(ExclusiveUIExtension extension) {

        PluginServices.setExclusiveUIExtension(extension);

    }

    public String getText(Object obj, String msg) {

        return PluginServices.getText(obj, msg);

    }

    public String translate(String msg) {

        return org.gvsig.i18n.Messages.translate(msg);

    }

    public File getApplicationFolder() {

        return Launcher.getApplicationFolder();

    }

    /**

     * @deprecated use {@link #getPluginsFolders()}

     */

    public File getPluginsDirectory() {

        return getPluginsFolder();

    }

    /**

     * @deprecated use {@link #getPluginsFolders()}

     */

    public File getPluginsFolder() {

        List<File> l = this.getPluginsFolders();

        if ( l == null || l.size() < 1 ) {

            return null;

        }

        return l.get(0);

    }

    public List<File> getPluginsFolders() {

        if ( this.pluginsFolders != null ) {

            return this.pluginsFolders;

        }

        File folder;

        String folderPath = "gvSIG/extensiones";

        if ( !(Launcher.getAndamiConfig() == null || Launcher.getAndamiConfig().getPluginsDirectory() == null) ) {

            folderPath = Launcher.getAndamiConfig().getPluginsDirectory();

        }

        this.pluginsFolders = new ArrayList<File>();

        folder = new File(this.getApplicationFolder(), folderPath);

        if( !folder.exists() ) {

            try {

                FileUtils.forceMkdir(folder);

            } catch (IOException ex) {

                logger.warn("The plugins folder '"+folder.getAbsolutePath()+"' don't exist and can't create.",ex);

            }

        }

        this.pluginsFolders.add(folder);

        folder = new File(this.getApplicationHomeFolder(), "installation");

        folder = new File(folder, folderPath);

        if( !folder.exists() ) {

            try {

                FileUtils.forceMkdir(folder);

            } catch (IOException ex) {

                logger.warn("The plugins folder '"+folder.getAbsolutePath()+"' don't exist and can't create.",ex);

            }

        }

        this.pluginsFolders.add(folder);

        return this.pluginsFolders;

    }

    public File getInstallFolder() {

        return new File(getApplicationFolder(), "install");

    }

    public File getApplicationHomeFolder() {

        return Launcher.getApplicationHomeFolder();

    }

    public void addStartupTask(String name, Runnable task, boolean in_event_thread, int priority) {

        this.startupTasks.add(new Task("startup", name, task, in_event_thread, priority));

    }

    public void addShutdownTask(String name, Runnable task, boolean in_event_thread, int priority) {

        this.shutdownTasks.add(new Task("shutdown", name, task, in_event_thread, priority));

    }

    public void executeStartupTasks() {

        logger.info("Executing startup tasks.");

        Thread th = new Thread(new Runnable() {

            public void run() {

                try {

                    Thread.sleep(3);

                } catch (Exception exc) {

                    // Ignore error

                }

                Collections.sort(startupTasks);

                for ( int i = startupTasks.size() - 1; i >= 0; i-- ) {

                    Task task = startupTasks.get(i);

                    logger.info("Task ["+i+"] "+task.priority+", "+task.name+", in event thread "+task.in_event_thread);

                }

                for ( int i = startupTasks.size() - 1; i >= 0; i-- ) {

                    Task task = startupTasks.get(i);

                    task.run();

                }

                logger.info("Running startup tasks terminated.");

            }

        });

        th.start();

    }

    public void executeShutdownTasks() {

        logger.info("Executing shutdown tasks.");

        Collections.sort(shutdownTasks);

        for ( int i = shutdownTasks.size() - 1; i >= 0; i-- ) {

            Task task = shutdownTasks.get(i);

            task.run();

        }

    }

    public File getApplicationI18nFolder() {

        return new File(this.getApplicationFolder(), "i18n");

    }

    public FirewallConfiguration getFirewallConfiguration() {

    	return (FirewallConfiguration) ToolsLocator.getFirewallManager();

    }

    public Version getApplicationVersion() {

        PackageInfo pinfo = this.getPackageInfo();

        Version version = pinfo.getVersion();

        return version;

    }

    public List<IUnsavedData> getUnsavedData() {

        List<IUnsavedData> unsavedDatas = new ArrayList<IUnsavedData>();

        Iterator<IExtension> extensions = getExtensions();

        while(extensions.hasNext()){

            IExtension extension = extensions.next();

            IExtensionStatus status = extension.getStatus();

            if(status != null && status.hasUnsavedData()){

              IUnsavedData[] unsavedData = status.getUnsavedData();

              if (unsavedData != null){

                  unsavedDatas.addAll(Arrays.asList(unsavedData));

              }

            }

        }

        return unsavedDatas;

    }

    public void saveUnsavedData(List<IUnsavedData> unsavedData) throws UnsavedDataException {

        List<IUnsavedData> errors = new ArrayList<IUnsavedData>();

        for (Iterator iterator = unsavedData.iterator(); iterator.hasNext();) {

            IUnsavedData itemUnsavedData = (IUnsavedData) iterator.next();

            try {

                itemUnsavedData.saveData();

            } catch (Exception e) {

                errors.add(itemUnsavedData);

                logger.warn("Can't save '"+itemUnsavedData.getResourceName()+"'.",e);

            }

        }

        if(!errors.isEmpty()){

            throw new UnsavedDataException(errors);

        }

    }

    @Override

    public String getApplicationName() {

        return Launcher.getApplicationName();

    }

    @Override

    public File getTempFolder() {

        return new File(Utilities.TEMPDIRECTORYPATH);

    }

    @Override

    public File getTempFile(String name) {

        return new File(Utilities.TEMPDIRECTORYPATH, name);

    }

    @Override

    public File getTempFile(String name, String sufix) {

        File tempFolder = new File(Utilities.TEMPDIRECTORYPATH);

        if( !tempFolder.exists() ) {

            try {

                FileUtils.forceMkdir(tempFolder);

            } catch(Throwable th) {

                throw new RuntimeException(th);

            }

        }

        long t = new Date().getTime();

        String fname = String.format("%s-%x%x%s", name,t,sufix);

        return new File(tempFolder,fname);

    }

    @Override

    public boolean desktopBrowse(URI uri){

        return DesktopApi.browse(uri);

    }

    @Override

    public boolean desktopOpen(File file){

        return DesktopApi.open(file);

    }

    @Override

    public Arguments getArguments() {

        return Launcher.getArguments();

    }    

}

package org.gvsig.andami.impl;

/*

 * Based on portions of code of MightyPork, http://www.ondrovo.com/

 * extracted from :

 * http://stackoverflow.com/questions/18004150/desktop-api-is-not-supported-on-the-current-platform

 */

import java.awt.Desktop;

import java.io.File;

import java.io.IOException;

import java.net.URI;

import java.util.ArrayList;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DesktopApi {

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

    public static boolean browse(URI uri) {

        if ( browseDESKTOP(uri) ) {

            return true;

        }

        if ( openSystemSpecific(uri.toString()) ) {

            return true;

        }

        return false;

    }

    public static boolean open(File file) {

        if ( openDESKTOP(file) ) {

            return true;

        }

        if ( openSystemSpecific(file.getPath()) ) {

            return true;

        }

        return false;

    }

    public static boolean edit(File file) {

        if ( editDESKTOP(file) ) {

            return true;

        }

        if ( openSystemSpecific(file.getPath()) ) {

            return true;

        }

        return false;

    }

    private static boolean openSystemSpecific(String what) {

        EnumOS os = getOs();

        if (os.isLinux()) {

//            if (runCommand("gnome-open", "%s", what)) {

//                return true;

//            }

//            if (runCommand("kde-open", "%s", what)) {

//                return true;

//            }

            if (runCommand("xdg-open", "%s", what)) {

                return true;

            }

        }

        if ( os.isMac() ) {

            if ( runCommand("open", "%s", what) ) {

                return true;

            }

        }

        if ( os.isWindows() ) {

            if ( runCommand("explorer", "%s", what) ) {

                return true;

            }

        }

        return false;

    }

    private static boolean browseDESKTOP(URI uri) {

        logOut("Trying to use Desktop.getDesktop().browse() with " + uri.toString());

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logErr("Platform is not supported.");

                return false;

            }

            if ( !Desktop.getDesktop().isSupported(Desktop.Action.BROWSE) ) {

                logErr("BROWSE is not supported.");

                return false;

            }

            Desktop.getDesktop().browse(uri);

            return true;

        } catch (Throwable t) {

            logErr("Error using desktop browse.", t);

            return false;

        }

    }

    private static boolean openDESKTOP(File file) {

        logOut("Trying to use Desktop.getDesktop().open() with " + file.toString());

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logErr("Platform is not supported.");

                return false;

            }

            if ( !Desktop.getDesktop().isSupported(Desktop.Action.OPEN) ) {

                logErr("OPEN is not supported.");

                return false;

            }

            Desktop.getDesktop().open(file);

            return true;

        } catch (Throwable t) {

            logErr("Error using desktop open.", t);

            return false;

        }

    }

    private static boolean editDESKTOP(File file) {

        logOut("Trying to use Desktop.getDesktop().edit() with " + file);

        try {

            if ( !Desktop.isDesktopSupported() ) {

                logErr("Platform is not supported.");

                return false;

            }

            if ( !Desktop.getDesktop().isSupported(Desktop.Action.EDIT) ) {

                logErr("EDIT is not supported.");

                return false;

            }

            Desktop.getDesktop().edit(file);

            return true;

        } catch (Throwable t) {

            logErr("Error using desktop edit.", t);

            return false;

        }

    }

    private static boolean runCommand(String command, String args, String file) {

        logOut("Trying to exec:\n   cmd = " + command + "\n   args = " + args + "\n   %s = " + file);

        String[] parts = prepareCommand(command, args, file);

        try {

            Process p = Runtime.getRuntime().exec(parts);

            if ( p == null ) {

                return false;

            }

            try {

                int retval = p.exitValue();

                if ( retval == 0 ) {

                    logErr("Process ended immediately.");

                    return false;

                } else {

                    logErr("Process crashed.");

                    return false;

                }

            } catch (IllegalThreadStateException itse) {

                logErr("Process is running.");

                return true;

            }

        } catch (IOException e) {

            logErr("Error running command.", e);

            return false;

        }

    }

    private static String[] prepareCommand(String command, String args, String file) {

        List<String> parts = new ArrayList<String>();

        parts.add(command);

        if ( args != null ) {

            for ( String s : args.split(" ") ) {

                s = String.format(s, file); // put in the filename thing

                parts.add(s.trim());

            }

        }

        return parts.toArray(new String[parts.size()]);

    }

    private static void logErr(String msg, Throwable t) {

        logger.warn(msg,t);

    }

    private static void logErr(String msg) {

        logger.warn(msg);

    }

    private static void logOut(String msg) {

        logger.info(msg);

    }

    public static enum EnumOS {

        linux, macos, solaris, unknown, windows;

        public boolean isLinux() {

            return this == linux || this == solaris;

        }

        public boolean isMac() {

            return this == macos;

        }

        public boolean isWindows() {

            return this == windows;

        }

    }

    public static EnumOS getOs() {

        String s = System.getProperty("os.name").toLowerCase();

        if ( s.contains("win") ) {

            return EnumOS.windows;

        }

        if ( s.contains("mac") ) {

            return EnumOS.macos;

        }

        if ( s.contains("solaris") ) {

            return EnumOS.solaris;

        }

        if ( s.contains("sunos") ) {

            return EnumOS.solaris;

        }

        if ( s.contains("linux") ) {

            return EnumOS.linux;

        }

        if ( s.contains("unix") ) {

            return EnumOS.linux;

        } else {

            return EnumOS.unknown;

        }

    }

}

package org.gvsig.andami.impl;

import java.time.LocalDate;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.Arguments;

import org.gvsig.tools.dataTypes.DataTypeUtils;

public class DefaultArguments implements Arguments {

    private final String[] args;

    protected Map<String, String> flags;

    protected List<String> parameters;

    public DefaultArguments(String args[]) {

        this.args = args;

        this.flags = new HashMap<>();

        this.parameters = new ArrayList<>();

        this.parse();

    }

    private void parse() {

        String name;

        String value;

        boolean acceptFlags = true;

        for( String arg : args ) {

            if( acceptFlags ) {

                if( arg.equals("--") ) {

                    acceptFlags = false;

                    continue;

                }

                if( arg.startsWith("--") ) {

                    int n = arg.indexOf("=");

                    if( n < 0 ) {

                        name = arg.substring(2);

                        value = "true";

                    } else {

                        name = arg.substring(2, n);

                        value = arg.substring(n + 1);

                    }

                    this.flags.put(name, value);

                } else {

                    this.parameters.add(arg);

                }

            } else {

                this.parameters.add(arg);

            }

        }

    }

    @Override

    public String get(String name) {

        return this.flags.get(name);

    }

    @Override

    public Object get(String name, Object defaultValue) {

        String value = this.get(name);

        if( defaultValue == null ) {

            return value;

        }

        if( StringUtils.isBlank(value) ) {

            return defaultValue;

        }

        if( defaultValue instanceof CharSequence ) {

            return value;

        }

        if( defaultValue instanceof Integer ) {

            return DataTypeUtils.toInteger(value, (Integer) defaultValue);

        }

        if( defaultValue instanceof Long ) {

            return DataTypeUtils.toLong(value, (Long) defaultValue);

        }

        if( defaultValue instanceof Boolean ) {

            try {

                return DataTypeUtils.toBoolean(value, (Boolean) defaultValue);

            } catch(Throwable th) {

                return BooleanUtils.toBoolean(value);

            }

        }

        if( defaultValue instanceof Double ) {

            return DataTypeUtils.toDouble(value, (Double) defaultValue);

        }

        if( defaultValue instanceof Float ) {

            return DataTypeUtils.toDouble(value, (Float) defaultValue);

        }

        if( defaultValue instanceof Date ) {

            return DataTypeUtils.toDate(value, (Date) defaultValue);

        }

        return value;

    }

    @Override

    public boolean contains(String name) {

        return this.flags.containsKey(name);

    }

    @Override

    public boolean contains(String name, String value) {

        String x = this.flags.get(name);

        if( x==null ) {

            return false;

        }

        return StringUtils.equalsIgnoreCase(value, x);

    } 

    @Override

    public List<String> parameters() {

        return Collections.unmodifiableList(parameters);

    }

    @Override

    public Map<String, String> flags() {

        return Collections.unmodifiableMap(flags);

    }

    @Override

    public int size() {

        return this.parameters.size();

    }

    @Override

    public String get(int n) {

        return this.parameters.get(n);

    }

    @Override

    public Iterator<String> iterator() {

        return this.parameters.iterator();

    }

}

package org.gvsig.andami.impl;

import java.util.List;

import org.gvsig.andami.plugins.status.IUnsavedData;

import org.gvsig.tools.exception.BaseException;

public class UnsavedDataException extends BaseException {

    /**

     *

     */

    private static final long serialVersionUID = 7764186865062216316L;

    private final static String MESSAGE_FORMAT = "Has not been able to save the following data: %(errors)\n";

    private final static String MESSAGE_KEY = "_UnsavedDataException";

    private List<IUnsavedData> errors;

    public UnsavedDataException(List<IUnsavedData> errors) {

        super(MESSAGE_FORMAT, MESSAGE_KEY, serialVersionUID);

        this.errors = errors;

        StringBuilder errorsString = new StringBuilder();

        for (IUnsavedData error : errors) {

            errorsString.append(" - ");

            errorsString.append(error.getResourceName());

            errorsString.append(" -- ");

            errorsString.append(error.getDescription());

            errorsString.append("\n");

        }

        setValue("errors", errorsString);

    }

    public List<IUnsavedData> getUnsavedData(){

        return errors;

    }

}

package org.gvsig.andami.impl;

import java.io.File;

import java.net.URL;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Set;

import java.util.TreeSet;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import org.apache.commons.configuration.PropertiesConfiguration;

import org.apache.commons.lang3.LocaleUtils;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.Launcher;

import org.gvsig.andami.LocaleManager;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.andami.config.generate.AndamiConfig;

import org.gvsig.andami.installer.translations.TranslationsInstallerFactory;

import org.gvsig.andami.ui.mdiFrame.MDIFrame;

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

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

import org.gvsig.utils.XMLEntity;

public class DefaultLocaleManager implements LocaleManager {

    private static final Logger logger

            = LoggerFactory.getLogger(DefaultLocaleManager.class);

    private static final String LOCALE_CODE_VALENCIANO = "vl";

    private static final String I18N_EXTENSION = "org.gvsig.i18n.extension";

    private static final String INSTALLED_TRANSLATIONS_HOME_FOLDER = "i18n";

    private static final String VARIANT = "variant";

    private static final String COUNTRY = "country";

    private static final String LANGUAGE = "language";

    private static final String REGISTERED_LOCALES_PERSISTENCE = "RegisteredLocales";

    private static final String LOCALE_CONFIG_FILENAME = "locale.config";

    private final Locale[] hardcoredLocales = new Locale[]{

        // Default supported locales

        SPANISH, // Spanish

        ENGLISH, // English

        new Locale("en", "US"), // English US

        new Locale("ca"), // Catalan

        new Locale("gl"), // Galician

        new Locale("eu"), // Basque

        new Locale("de"), // German

        new Locale("cs"), // Czech

        new Locale("fr"), // French

        new Locale("it"), // Italian

        new Locale("pl"), // Polish

        new Locale("pt"), // Portuguese

        new Locale("pt", "BR"), // Portuguese Brazil

        new Locale("ro"), // Romanian

        new Locale("zh"), // Chinese

        new Locale("ru"), // Russian

        new Locale("el"), // Greek

        new Locale("ro"), // Romanian

        new Locale("pl"), // Polish

        new Locale("tr"), // Turkish

        new Locale("sr"), // Serbio

        new Locale("sw") // Swahili

    };

    private Set installedLocales = null;

    private Set defaultLocales = null;

    private boolean storedInstalledLocales = false;

    public DefaultLocaleManager() {

        Locale currentLocale = org.gvsig.i18n.Messages.getCurrentLocale();

        if( currentLocale==null ) {

            // Is run from test, currentLocale is null.

            currentLocale = Locale.getDefault();

        }

        this.setCurrentLocale(currentLocale);

    }

    public Locale getCurrentLocale() {

        return org.gvsig.i18n.Messages.getCurrentLocale();

    }

    public void setCurrentLocale(final Locale locale) {

        Locale nearestLocale = getNearestLocale(locale);

        if(nearestLocale == null){

            nearestLocale = this.getLocaleAlternatives(locale)[0];

        }

        org.gvsig.i18n.Messages.setCurrentLocale(nearestLocale, this.getLocaleAlternatives(nearestLocale));

        String localeStr = nearestLocale.getLanguage();

        if (localeStr.equalsIgnoreCase(LOCALE_CODE_VALENCIANO)) {

            Locale.setDefault(new Locale("ca"));

        } else {

            Locale.setDefault(nearestLocale);

        }

        AndamiConfig config = Launcher.getAndamiConfig();

        if( config != null ) {

            config.setLocaleLanguage(nearestLocale.getLanguage());

            config.setLocaleCountry(nearestLocale.getCountry());

            config.setLocaleVariant(nearestLocale.getVariant());

        }

        setCurrentLocaleUI(nearestLocale);

    }

    public Locale getDefaultSystemLocale() {

        String language, region, country, variant;

        language = getSystemProperty("user.language", "en");

        // for compatibility, check for old user.region property

        region = getSystemProperty("user.region", null);

        if (region != null) {

            // region can be of form country, country_variant, or _variant

            int i = region.indexOf('_');

            if (i >= 0) {

                country = region.substring(0, i);

                variant = region.substring(i + 1);

            } else {

                country = region;

                variant = "";

            }

        } else {

            country = getSystemProperty("user.country", "");

            variant = getSystemProperty("user.variant", "");

        }

        return new Locale(language, country, variant);

    }

    private Set<Locale> loadLocalesFromConfing(File localesFile)  {

        PropertiesConfiguration config = null;

        if (!localesFile.canRead()) {

            return null;

        }

        try {

            config = new PropertiesConfiguration(localesFile);

        } catch (Exception ex) {

            logger.warn("Can't open locale configuration '" + localesFile + "'.", ex);

            return null;

        }

        Set<Locale> locales = new HashSet<Locale>();

        List localeCodes = config.getList("locale");

        for (Object localeCode : localeCodes) {

            try {

                Locale locale = LocaleUtils.toLocale((String) localeCode);

                locales.add(locale);

            } catch(IllegalArgumentException ex) {

                logger.warn("Can't load locale '"+localeCode+"' from config '"+localesFile.getAbsolutePath()+"'.",ex);

            }

        }

        return locales;

    }

    public Set<Locale> getDefaultLocales() {

        if (this.defaultLocales == null) {

            PluginsManager pluginsManager = PluginsLocator.getManager();

            File localesFile = new File(pluginsManager.getApplicationI18nFolder(), LOCALE_CONFIG_FILENAME);

            Set<Locale> locales = loadLocalesFromConfing(localesFile);

            defaultLocales = new HashSet<Locale>();

            if( locales == null ) {

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

                    defaultLocales.add(hardcoredLocales[i]);

                }

            } else {

                defaultLocales.addAll(locales);

            }

        }

        return this.defaultLocales;

    }

    public boolean installLocales(URL localesFile) {

        PluginsManager pluginsManager = PluginsLocator.getManager();

        PropertiesConfiguration config = null;

        try {

            config = new PropertiesConfiguration(localesFile);

        } catch (Exception ex) {

            logger.warn("Can't open configuration '" + localesFile + "'.", ex);

        }

        if (config == null) {

            return false;

        }

        List localeCodes = config.getList("locale");

        for (Object localeCode : localeCodes) {

            Locale locale = LocaleUtils.toLocale((String) localeCode);

            if (!getInstalledLocales().contains(locale)) {

                this.installedLocales.add(locale);

            }

        }

        storeInstalledLocales();

        return true;

    }

    public Set<Locale> getInstalledLocales() {

        if (installedLocales == null) {

            installedLocales = new TreeSet<Locale>(new Comparator<Locale>() {

                public int compare(Locale t0, Locale t1) {

                    if (t1 == null || t0 == null) {

                        return 0;

                    }

                    // return getLanguageDisplayName(t0).compareToIgnoreCase(getLanguageDisplayName(t1));

                    return t0.toString().compareToIgnoreCase(t1.toString());

                }

            });

            XMLEntity child = getRegisteredLocalesPersistence();

            // If the list of registered locales is not already persisted,

            // this should be the first time gvSIG is run with the I18nPlugin

            // so we will take the list of default locales

            if (child == null) {

                installedLocales.addAll(getDefaultLocales());

            } else {

                XMLEntity localesEntity = child;

                for (int i = 0; i < localesEntity.getChildrenCount(); i++) {

                    Locale locale = null;

                    XMLEntity localeEntity = localesEntity.getChild(i);

                    String language = localeEntity.getStringProperty(LANGUAGE);

                    String country = localeEntity.getStringProperty(COUNTRY);

                    String variant = localeEntity.getStringProperty(VARIANT);

                    locale = new Locale(language, country, variant);

                    installedLocales.add(locale);

                }

            }

            Set<Locale> lfp = getAllLocalesFromPackages();

            installedLocales.addAll(lfp);

        }

        storeInstalledLocales();

        return Collections.unmodifiableSet(installedLocales);

    }

    public void updateInstalledLocales(){

        installedLocales.addAll(getAllLocalesFromPackages());

        storedInstalledLocales = false;

        storeInstalledLocales();

    }

    public boolean installLocale(Locale locale) {

        // Add the locale to the list of installed ones, if it

        // is new, otherwise, update the texts.

        if (!getInstalledLocales().contains(locale)) {

            getInstalledLocales().add(locale);

            storeInstalledLocales();

        }

        return true;

    }

    public boolean uninstallLocale(Locale locale) {

        if (!getInstalledLocales().remove(locale)) {

            return false;

        }

        storeInstalledLocales();

        return true;

    }

    public String getLanguageDisplayName(Locale locale) {

        String displayName;

        if ("eu".equals(locale.getLanguage())

                && "vascuence".equals(locale.getDisplayLanguage())) {

            // Correction for the Basque language display name,

            // show it in Basque, not in Spanish

            displayName = "Euskera";

        } else if (LOCALE_CODE_VALENCIANO.equals(locale.getLanguage())) {

            // Patch for Valencian/Catalan

            displayName = "Valenci?";

        } else {

            displayName = locale.getDisplayLanguage(locale);

        }

        return StringUtils.capitalize(displayName);

    }

    public String getLocaleDisplayName(Locale locale) {

        String displayName = this.getLanguageDisplayName(locale);

        if( !StringUtils.isBlank(locale.getCountry()) ) {

            if( !StringUtils.isBlank(locale.getVariant()) ) {

                displayName = displayName + " (" +

                        StringUtils.capitalize(locale.getDisplayCountry(locale)) + "/" +

                        locale.getDisplayVariant(locale) + ")";

            } else {

                displayName = displayName + " ("+locale.getDisplayCountry(locale)+")";

            }

        }

        return displayName;

    }

    public Locale[] getLocaleAlternatives(Locale locale) {

        Locale alternatives[] = null;

        String localeStr = locale.getLanguage();

        if (localeStr.equals("es")

                || localeStr.equals("ca")

                || localeStr.equals("gl")

                || localeStr.equals("eu")

                || localeStr.equals(LOCALE_CODE_VALENCIANO)) {

            alternatives = new Locale[2];

            alternatives[0] = new Locale("es");

            alternatives[1] = new Locale("en");

        } else {

            // prefer English for the rest

            alternatives = new Locale[2];

            alternatives[0] = new Locale("en");

            alternatives[1] = new Locale("es");

        }

        return alternatives;

    }

    private void setCurrentLocaleUI(final Locale locale) {

        if (!SwingUtilities.isEventDispatchThread()) {

            try {

                SwingUtilities.invokeAndWait(new Runnable() {

                    public void run() {

                        setCurrentLocaleUI(locale);

                    }

                });

            } catch (Exception ex) {

                // Ignore

            }

        }

        try {

            JComponent.setDefaultLocale(locale);

        } catch (Exception ex) {

            logger.warn("Problems setting locale to JComponent.", ex);

        }

        if (MDIFrame.isInitialized()) {

            try {

                MDIFrame.getInstance().setLocale(locale);

            } catch (Exception ex) {

                logger.warn("Problems settings locale to MDIFrame.", ex);

            }

        }

    }

    public File getResourcesFolder() {

        File i18nFolder = new File(

                PluginsLocator.getManager().getApplicationHomeFolder(),

                INSTALLED_TRANSLATIONS_HOME_FOLDER

        );

        if (!i18nFolder.exists()) {

            i18nFolder.mkdirs();

        }

        return i18nFolder;

    }

    /**

     * Returns the child XMLEntity with the RegisteredLocales.

     */

    private XMLEntity getRegisteredLocalesPersistence() {

        XMLEntity entity = getI18nPersistence();

        if (entity == null) {

            return null;

        }

        XMLEntity child = null;

        for (int i = entity.getChildrenCount() - 1; i >= 0; i--) {

            XMLEntity tmpchild = entity.getChild(i);

            if (tmpchild.getName().equals(REGISTERED_LOCALES_PERSISTENCE)) {

                child = tmpchild;

                break;

            }

        }

        return child;

    }

    /**

     * Stores the list of installed locales into the plugin persistence.

     */

    private void storeInstalledLocales() {

        if(this.storedInstalledLocales ){

            return;

        }

        XMLEntity i18nPersistence = getI18nPersistence();

        if(i18nPersistence == null){

            return;

        }

        XMLEntity localesEntity = getRegisteredLocalesPersistence();

        // Remove the previous list of registered languages

        if (localesEntity != null) {

            for (int i = i18nPersistence.getChildrenCount() - 1; i >= 0; i--) {

                XMLEntity child = i18nPersistence.getChild(i);

                if (child.getName().equals(REGISTERED_LOCALES_PERSISTENCE)) {

                    i18nPersistence.removeChild(i);

                    break;

                }

            }

        }

        // Create the new persistence for the registered languages

        localesEntity = new XMLEntity();

        localesEntity.setName(REGISTERED_LOCALES_PERSISTENCE);

        Set<Locale> locales = this.installedLocales; //getInstalledLocales();

        for (Iterator iterator = locales.iterator(); iterator.hasNext();) {

            Locale locale = (Locale) iterator.next();

            XMLEntity localeEntity = new XMLEntity();

            localeEntity.setName(locale.getDisplayName());

            localeEntity.putProperty(LANGUAGE, locale.getLanguage());

            localeEntity.putProperty(COUNTRY, locale.getCountry());

            localeEntity.putProperty(VARIANT, locale.getVariant());

            localesEntity.addChild(localeEntity);

        }

        getI18nPersistence().addChild(localesEntity);

        this.storedInstalledLocales = true;

    }

    /**

     * Returns the I18n Plugin persistence.

     */

    private XMLEntity getI18nPersistence() {

        try {

            XMLEntity entity = PluginServices.getPluginServices(I18N_EXTENSION).getPersistentXML();

            return entity;

        } catch (Throwable t) {

            // logger.warn("Can't get I18nPersistence",t);

            return null;

        }

    }

    @SuppressWarnings("unchecked")

    private String getSystemProperty(final String property, String defaultValue) {

        String value

                = (String) AccessController.doPrivileged(new PrivilegedAction() {

                    public Object run() {

                        return System.getProperty(property);

                    }

                });

        return value == null ? defaultValue : value;

    }

    private Set<Locale> getAllLocalesFromPackages() {

        Set<Locale> locales = new HashSet<Locale>();

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

        List<File> folders = installerManager.getAddonFolders(TranslationsInstallerFactory.PROVIDER_NAME);

        for( File folder : folders ) {

            File file = new File(folder,LOCALE_CONFIG_FILENAME);

            Set<Locale> l = this.loadLocalesFromConfing(file);

            locales.addAll(l);

        }

        return locales;

    }

    public Locale getNearestLocale(Locale locale) {

        if( locale == null ) {

            return null;

        }

        String language = locale.getLanguage();

        String country = locale.getCountry();

        String variant = locale.getVariant();

        Locale nearestLocale;

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

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

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

                    nearestLocale = new Locale(language, country, variant);

                    if (getInstalledLocales().contains(nearestLocale)) {

                        return nearestLocale;

                    }

                }

                nearestLocale = new Locale(language, country);

                if (getInstalledLocales().contains(nearestLocale)) {

                    return nearestLocale;

                }

            }

            nearestLocale = new Locale(language);

            if (getInstalledLocales().contains(nearestLocale)) {

                return nearestLocale;