Application: gvSIG desktop

/**

 * 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 java.awt.BorderLayout;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.Frame;

import java.awt.KeyboardFocusManager;

import java.awt.Point;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileFilter;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.Reader;

import java.io.StringWriter;

import java.net.Authenticator;

import java.net.MalformedURLException;

import java.net.PasswordAuthentication;

import java.net.URL;

import java.net.URLClassLoader;

import java.nio.channels.FileChannel;

import java.security.AllPermission;

import java.security.CodeSource;

import java.security.PermissionCollection;

import java.security.Permissions;

import java.security.Policy;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Properties;

import java.util.Set;

import java.util.TreeSet;

import java.util.prefs.Preferences;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JDialog;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.JPopupMenu;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

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

import org.apache.commons.cli.PosixParser;

import org.apache.commons.configuration.PropertiesConfiguration;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.JavaVersion;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.SystemUtils;

import org.apache.log4j.AppenderSkeleton;

import org.apache.log4j.PatternLayout;

import org.apache.log4j.PropertyConfigurator;

import org.apache.log4j.RollingFileAppender;

import org.apache.log4j.spi.LoggingEvent;

import org.apache.log4j.spi.ThrowableInformation;

import org.exolab.castor.xml.MarshalException;

import org.exolab.castor.xml.ValidationException;

import org.gvsig.andami.actioninfo.ActionInfo;

import org.gvsig.andami.actioninfo.ActionInfoManager;

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

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

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

import org.gvsig.andami.impl.DefaultArguments;

import org.gvsig.andami.impl.UnsavedDataException;

import org.gvsig.andami.messages.Messages;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.persistence.serverData.ServerDataPersistence;

import org.gvsig.andami.plugins.ExclusiveUIExtension;

import org.gvsig.andami.plugins.ExtensionDecorator;

import org.gvsig.andami.plugins.IExtension;

import org.gvsig.andami.plugins.PluginClassLoader;

import org.gvsig.andami.plugins.config.generate.Action;

import org.gvsig.andami.plugins.config.generate.ActionTool;

import org.gvsig.andami.plugins.config.generate.AlternativeNames;

import org.gvsig.andami.plugins.config.generate.ComboButton;

import org.gvsig.andami.plugins.config.generate.ComboButtonElement;

import org.gvsig.andami.plugins.config.generate.ComboScale;

import org.gvsig.andami.plugins.config.generate.Depends;

import org.gvsig.andami.plugins.config.generate.Extension;

import org.gvsig.andami.plugins.config.generate.Extensions;

import org.gvsig.andami.plugins.config.generate.LabelSet;

import org.gvsig.andami.plugins.config.generate.Menu;

import org.gvsig.andami.plugins.config.generate.PluginConfig;

import org.gvsig.andami.plugins.config.generate.PopupMenu;

import org.gvsig.andami.plugins.config.generate.PopupMenus;

import org.gvsig.andami.plugins.config.generate.SelectableTool;

import org.gvsig.andami.plugins.config.generate.SkinExtension;

import org.gvsig.andami.plugins.config.generate.SkinExtensionType;

import org.gvsig.andami.plugins.config.generate.ToolBar;

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

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

import org.gvsig.andami.ui.AndamiEventQueue;

import org.gvsig.andami.ui.DisablePluginsConflictingLayoutPanel;

import org.gvsig.andami.ui.MDIManagerLoadException;

import org.gvsig.andami.ui.ToolsWindowManager;

import org.gvsig.andami.ui.fonts.FontUtils;

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

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

import org.gvsig.andami.ui.mdiManager.MDIManagerFactory;

import org.gvsig.andami.ui.splash.MultiSplashWindow;

import org.gvsig.andami.ui.theme.Theme;

import org.gvsig.andami.ui.wizard.UnsavedDataPanel;

import org.gvsig.andami.ui.wizard.UnsavedDataPanel.UnsavedDataPanelListener;

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

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

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

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

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

import org.gvsig.installer.lib.api.creation.MakePluginPackageServiceException;

import org.gvsig.installer.swing.api.SwingInstallerLocator;

import org.gvsig.installer.swing.api.execution.InstallWizardPanel;

import org.gvsig.installer.swing.api.wizard.InstallerWizardActionListener;

import org.gvsig.installer.swing.api.wizard.InstallerWizardPanel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.ListBaseException;

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

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

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

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.swing.icontheme.IconThemeManager;

import org.gvsig.tools.util.FolderSet;

import org.gvsig.tools.util.FolderSet.FolderEntry;

import org.gvsig.utils.DateTime;

import org.gvsig.utils.DefaultListModel;

import org.gvsig.utils.XMLEntity;

import org.gvsig.utils.xml.XMLEncodingUtils;

import org.gvsig.utils.xmlEntity.generate.XmlTag;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * <p>

 * Andami's launching class. This is the class used to create the Andami's

 * plugin environment.<br>

 * </p>

 *

 * <p>

 * <b>Syntax:</b> <br>

 * java [-Xmx512M (for 512MB of RAM)] [-classpath={a colon-separated(unix) or

 * semicolon-separated(windows) list of files containg base library of classes}]

 * [-Djava.library.path=PATH_TO_NATIVE_LIBRARIES]

 * PATH_TO_APPLICATION_HOME_DIRECTORY PATH_TO_APPLICATION_PLUGINS_DIRECTORY

 * [{list of additional custom application arguments separated by spaces}]

 * </p>

 *

 *

 * @author $author$

 * @version $Revision: 40305 $

 */

public class Launcher {

    private static Arguments arguments;

    public static abstract class MapWithAlias<Item> extends HashMap<String, Item> {

        private HashMap<String, String> aliases = new HashMap<String, String>();

        public abstract String[] getAliases(Item item);

        public boolean isAlias(String key) {

            return aliases.get(key) != null;

        }

        public String getMainKey(String key) {

            Item item = super.get(key);

            if (item != null) {

                return key;

            }

            String alias = aliases.get(key);

            if (alias != null) {

                return alias;

            }

            return null;

        }

        public Item get(Object key) {

            Item item = super.get(key);

            if (item != null) {

                return item;

            }

            String alias = aliases.get(key);

            if (alias != null) {

                return super.get(alias);

            }

            return null;

        }

        public boolean containsKey(Object key) {

            boolean contains = super.containsKey(key);

            if (contains) {

                return true;

            }

            String alias = aliases.get(key);

            return super.containsKey(alias);

        }

        public Item put(String key, Item value) {

            super.put(key, value);

            String[] aliases = getAliases(value);

            if (aliases == null) {

                return value;

            }

            for (int n = 0; n < aliases.length; n++) {

                this.aliases.put(aliases[n].trim(), key);

            }

            return value;

        }

        public void putAll(Map<? extends String, ? extends Item> m) {

            Iterator<?> it = m.entrySet().iterator();

            while (it.hasNext()) {

                Map.Entry<String, Item> x = (Map.Entry<String, Item>) it.next();

                this.put(x.getKey(), x.getValue());

            }

        }

        public Item remove(Object key) {

            Item item = super.get(key);

            if (item == null) {

                String alias = aliases.get(key);

                if (alias == null) {

                    return null;

                }

                item = super.get(alias);

                super.remove(alias);

            } else {

                super.remove(key);

            }

            String[] aliases = getAliases(item);

            if (aliases == null) {

                return item;

            }

            // Rebuild the alias list

            this.aliases = new HashMap<String, String>();

            Iterator<java.util.Map.Entry<String, Item>> it = this.entrySet().iterator();

            while (it.hasNext()) {

                java.util.Map.Entry<String, Item> entry = it.next();

                aliases = getAliases(entry.getValue());

                if (aliases == null) {

                    continue;

                }

                for (int n = 0; n < aliases.length; n++) {

                    this.aliases.put(aliases[n].trim(), entry.getKey());

                }

            }

            return item;

        }

    }

    public static class PluginsConfig extends MapWithAlias<org.gvsig.andami.plugins.config.generate.PluginConfig> {

        public String[] getAliases(

                org.gvsig.andami.plugins.config.generate.PluginConfig item) {

            return getAlternativeNames(item);

        }

        static String[] getAlternativeNames(org.gvsig.andami.plugins.config.generate.PluginConfig item) {

            AlternativeNames[] x = item.getAlternativeNames();

            if (x == null) {

                return null;

            }

            String[] r = new String[x.length];

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

                r[i] = x[i].getName();

            }

            return r;

        }

    }

    public static class PluginsServices extends MapWithAlias<org.gvsig.andami.PluginServices> {

        public String[] getAliases(org.gvsig.andami.PluginServices item) {

            return item.getAlternativeNames();

        }

    }

    protected static Logger logger = LoggerFactory.getLogger(Launcher.class

            .getName());

    protected static Preferences prefs = Preferences.userRoot().node(

            "gvsig.connection");

    protected static AndamiConfig andamiConfig;

    protected static MultiSplashWindow splashWindow;

    protected static String appName;

    protected static Locale locale;

    protected static PluginsConfig pluginsConfig = new PluginsConfig();

    protected static PluginsServices pluginsServices = new PluginsServices();

    protected static MDIFrame frame;

    protected static HashMap<Class<? extends IExtension>, ExtensionDecorator> classesExtensions = new HashMap<Class<? extends IExtension>, ExtensionDecorator>();

    protected static String andamiConfigPath;

    protected static final String nonWinDefaultLookAndFeel = "com.jgoodies.looks.plastic.PlasticXPLookAndFeel";

    protected static List<String> pluginsOrdered = new ArrayList<String>();

    protected static List<IExtension> extensions = new ArrayList<IExtension>();

    protected static String appHomeDir = null;

    // it seems castor uses this encoding

    protected static final String CASTORENCODING = "UTF8";

    protected static ListBaseException launcherrors = null;

    protected static Theme theme = null;

    private List<String> deprecatedPluginNames = null;

    private static final class ProxyAuth extends Authenticator {

        private PasswordAuthentication auth;

        private ProxyAuth(String user, String pass) {

            auth = new PasswordAuthentication(user, pass.toCharArray());

        }

        protected PasswordAuthentication getPasswordAuthentication() {

            return auth;

        }

    }

    private static Launcher launcherInstance;

    public static Launcher getInstance() {

        if (launcherInstance == null) {

            launcherInstance = new Launcher();

        }

        return launcherInstance;

    }

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

        arguments = new DefaultArguments(args);

        Launcher launcher = getInstance();

        try {

            if (arguments.contains("install")) {

                launcher.doInstall(args);

            } else {

                launcher.doMain(args);

            }

        } catch (Exception e) {

            logger.error("excepcion al arrancar", e);

            System.exit(-1);

        }

    }

    protected void downloadExtensions(String extDir) {

        // do nothing

    }

    public static class LaunchException extends ListBaseException {

        private static final long serialVersionUID = 4541192746962684705L;

        public LaunchException() {

            super("Errors in initialization of application.",

                    "_errors_in_initialization_of_application",

                    serialVersionUID);

        }

    }

    protected void addError(Throwable ex) {

        if (launcherrors == null) {

            launcherrors = new LaunchException();

        }

        launcherrors.add(ex);

    }

    protected void addError(String msg, Throwable cause) {

        logger.error(msg, cause);

        this.addError(new RuntimeException(msg, cause));

    }

    protected void addError(String msg) {

        this.addError(msg, null);

    }

    private String translate(String msg) {

        return PluginServices.getText(Launcher.class, msg);

    }

    private List<String> getDeprecatedPluginNames() {

        if (deprecatedPluginNames == null) {

            String[] ss = new String[]{

                "org.gvsig.app",

                "org.gvsig.coreplugin",

                "org.gvsig.editing",

                "org.gvsig.installer.app.extension",

                "org.gvsig.exportto.app.extension"

            };

            deprecatedPluginNames = Arrays.asList(ss);

        }

        return deprecatedPluginNames;

    }

    public static Arguments getArguments() {

        return arguments;

    }

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

        if (args.length < 1) {

            System.err.println("Usage: Launcher appName plugins-directory [--language=locale]");

            System.err.println("No arguments specified.");

            System.err.println("Use default arguments 'gvSIG gvSIG/extensiones'");

            args = new String[]{"gvSIG", "gvSIG/extensiones"};

        }

        initializeApp(args, null);

        // Solucionamos el problema de permisos que se produc?do con Java

        // Web Start con este codigo.

        Policy.setPolicy(new Policy() {

            public PermissionCollection getPermissions(CodeSource codesource) {

                Permissions perms = new Permissions();

                perms.add(new AllPermission());

                return (perms);

            }

            public void refresh() {

            }

        });

        new DefaultLibrariesInitializer().fullInitialize(true);

        InstallerLocator.getInstallerManager().setDownloadBaseURL(

                new URL("http://downloads.gvsig.org/download/gvsig-desktop/"));

        try {

            initIconThemes();

        } catch (Exception ex) {

            this.addError("Can't initialize icon theme", ex);

        }

        // Registramos los iconos base

        try {

            registerIcons();

        } catch (Exception ex) {

            this.addError("Can't register icons", ex);

        }

        // Obtener la personalizaci?n de la aplicacion.

        try {

            logger.info("Initialize andami theme");

            theme = getTheme(andamiConfig.getPluginsDirectory());

        } catch (Exception ex) {

            this.addError("Can't get personalized theme for the application",

                    ex);

        }

        UIManager.put("Desktop.background", theme.getBackgroundColor());

        // Mostrar la ventana de inicio

        Frame f = new Frame();

        splashWindow = new MultiSplashWindow(f, theme, 27);

        // Ponemos los datos del proxy

        splashWindow.process(translate("SplashWindow.configuring_proxy"));

        logger.info("Configute http proxy");

        configureProxy();

        // Buscar actualizaciones de los plugins

        splashWindow.process(translate("SplashWindow.looking_for_updates"));

        try {

//                        this.downloadExtensions(andamiConfig.getPluginsDirectory());

        } catch (Exception ex) {

            this.addError("Can't downloads plugins", ex);

        }

        splashWindow.process(translate("SplashWindow.initialize_install_manager"));

        initializeInstallerManager();

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

        PackageInfo[] installedPackages = null;

        try {

            installedPackages = installerManager.getInstalledPackages();

        } catch (MakePluginPackageServiceException e) {

            // Do nothing, ignore errors

        }

        logger.info("Dump system information");

        logger_info(getInformation(installedPackages));

        saveEnvironInformation(installedPackages);

        // Se leen los config.xml de los plugins

        splashWindow.process(translate("SplashWindow.load_plugins_configuration"));

        try {

            logger.info("Load plugins information");

            this.loadPluginConfigs();

            if (pluginsConfig.isEmpty()) {

                logger.warn("No valid plugin was found.");

                System.exit(-1);

            }

        } catch (Throwable ex) {

            this.addError("Can't load plugins", ex);

        }

        splashWindow.process(translate("SplashWindow.check_incompatible_plugins"));

        fixIncompatiblePlugins(installedPackages);

        // Se configura el classloader del plugin

        splashWindow.process(translate("SplashWindow.setup_plugins_configuration"));

        try {

            logger.info("Configure plugins class loader");

            this.loadPluginServices();

        } catch (Throwable ex) {

            logger.warn("Can't initialize plugin's classloaders  ", ex);

        }

        try {

            registerActions();

        } catch (Throwable ex) {

            logger.warn("Can't register actions of plugins", ex);

        }

        initializeIdentityManagement(new File(andamiConfig.getPluginsDirectory()).getAbsoluteFile());

        // Initialize libraries

        splashWindow.process(translate("SplashWindow.initialize_plugins_libraries"));

        initializeLibraries();

        // Se carga un Skin si alguno ide los plugins trae informacion para ello

        splashWindow.process(translate("SplashWindow.looking_for_a_skin"));

        logger.info("Initialize skin");

        skinPlugin(null);

        // Se configura la cola de eventos

        splashWindow.process(translate("setting_up_event_queue"));

        EventQueue waitQueue = new AndamiEventQueue();

        Toolkit.getDefaultToolkit().getSystemEventQueue().push(waitQueue);

        // Se configura la internacionalizacion del plugin

        splashWindow.process(translate("SplashWindow.starting_plugin_internationalization_system"));

        pluginsMessages();

        // Se modifica el andami-config con los plugins nuevos

        splashWindow.process(translate("SplashWindow.update_framework_configuration"));

        updateAndamiConfig();

        frame = MDIFrame.getInstance();

        // Se configura el nombre e icono de la aplicacion

        splashWindow.process(translate("SplashWindow.setting_up_applications_name_and_icons"));

        frameIcon(theme);

        // Se prepara el MainFrame para albergar las extensiones

        splashWindow.process(translate("SplashWindow.preparing_workbench"));

        JPopupMenu.setDefaultLightWeightPopupEnabled(false);

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                frame.init();

            }

        });

        ToolsSwingLocator.registerWindowManager(ToolsWindowManager.class);

        // Leer el fichero de persistencia de los plugins

        splashWindow.process(translate("SplashWindow.loading_plugin_settings"));

        loadPluginsPersistence();

                // Se instalan los controles del skin

        // Se inicializan todas las extensiones de todos los plugins

        splashWindow.process(translate("SplashWindow.initializing_extensions"));

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                initializeExtensions();

            }

        });

        // Se inicializan la extension exclusiva

        splashWindow.process(translate("SplashWindow.setting_up_master_extension"));

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                initializeExclusiveUIExtension();

            }

        });

        frame.setClassesExtensions(classesExtensions);

        // Se instalan los controles de las extensiones de los plugins

        message(translate("SplashWindow.installing_extensions_controls"));

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                installPluginsControls();

            }

        });

        // Se instalan los menus de las extensiones de los plugins

        message(translate("SplashWindow.installing_extensions_menus"));

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                installPluginsMenus();

            }

        });

        message(translate("SplashWindow.initializing_server_data_persistence"));

        ServerDataPersistence.registerPersistence();

        // Se instalan las etiquetas de las extensiones de los plugins

        message(translate("SplashWindow.installing_extensions_labels"));

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                installPluginsLabels();

            }

        });

        // Se muestra el frame principal

        message(translate("creating_main_window"));

        frame.setVisible(true);

        frame.setCursor(Cursor.WAIT_CURSOR);

                // Definimos un KeyEventDispatcher global para que las extensiones

        // puedan registrar sus "teclas rapidas".

        message(translate("SplashWindow.initializing_accelerator_keys"));

        GlobalKeyEventDispatcher keyDispatcher = GlobalKeyEventDispatcher.getInstance();

        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(keyDispatcher);

        message(translate("SplashWindow.enable_controls"));

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                try {

                    frame.enableControls();

                } catch (Throwable th) {

                    logger.warn("Problems enabling controls", th);

                }

            }

        });

        // Se ejecuta el postInitialize

        message(translate("SplashWindow.post_initializing_extensions"));

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                postInitializeExtensions();

            }

        });

        message(translate("SplashWindow.enable_controls"));

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                try {

                    frame.enableControls();

                    message(translate("StatusBar.Aplicacion_iniciada"));

                } catch (Throwable th) {

                    logger.warn("Problems enabling controls", th);

                }

            }

        });

        splashWindow.close();

        frame.setCursor(Cursor.DEFAULT_CURSOR);

        if (launcherrors != null) {

            NotificationManager.addError(launcherrors);

        }

        org.apache.log4j.Logger.getRootLogger().addAppender(

                new NotificationAppender());

        /*

         * Executes additional tasks required by plugins

         */

        PluginsLocator.getManager().executeStartupTasks();

    }

    private void initializeInstallerManager() {

        PluginsManager pluginmgr = PluginsLocator.getManager();

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

            //

        // Configure repository of plugins

        //

        List<File> folders = pluginmgr.getPluginsFolders();

        for (File folder : folders) {

            installerManager.addLocalAddonRepository(folder, "plugin");

        }

        installerManager.setDefaultLocalAddonRepository(folders.get(0), "plugin");

            //

        // Configure repository of iconsets

        //

        IconThemeManager iconManager = ToolsSwingLocator.getIconThemeManager();

        FolderSet fset = iconManager.getRepository();

        Iterator<FolderSet.FolderEntry> it = fset.iterator();

        boolean first = true;

        while (it.hasNext()) {

            FolderEntry entry = it.next();

            installerManager.addLocalAddonRepository(entry.getFolder(), "iconset");

            if (first) {

                first = false;

                installerManager.setDefaultLocalAddonRepository(entry.getFolder(), "iconset");

            }

        }

    }

    private void message(final String msg) {

        if (!SwingUtilities.isEventDispatchThread()) {

            try {

                SwingUtilities.invokeAndWait(new Runnable() {

                    public void run() {

                        message(msg);

                    }

                });

            } catch (Exception e) {

                logger.info(msg);

                logger.warn("Error showing message.", e);

            }

            return;

        }

        if (splashWindow.isVisible()) {

            splashWindow.process(msg);

        }

        if (frame.isVisible()) {

            frame.message(msg, JOptionPane.INFORMATION_MESSAGE);

        }

    }

    private void initializeLibraries() {

        List<ClassLoader> classLoaders = new ArrayList<ClassLoader>(

                pluginsOrdered.size() + 1);

        classLoaders.add(getClass().getClassLoader());

        Iterator<String> iter = pluginsOrdered.iterator();

        logger.info("Initializing plugins libraries: ");

        while (iter.hasNext()) {

            String pName = (String) iter.next();

            PluginServices ps = (PluginServices) pluginsServices.get(pName);

            logger.info("Initializing plugin libraries (" + pName + ")");

            classLoaders.add(ps.getClassLoader());

        }

                // Create the libraries initializer and

        // initialize the plugin libraries

        new DefaultLibrariesInitializer(classLoaders

                .toArray(new ClassLoader[classLoaders.size()]))

                .fullInitialize(true);

        // Remove them all, we don't need them anymore

        classLoaders.clear();

        classLoaders = null;

    }

    /**

     * @param args

     * @throws IOException

     * @throws ConfigurationException

     */

    private void initializeApp(String[] args, String applicationClasifier) throws IOException, ConfigurationException {

        if (args.length < 1) {

            appName = "gvSIG"; // Nombre de aplicacion por defecto es "gvSIG"

        } else {

            appName = args[0];

        }

        // Hacemos visibles los argumentos como una propiedad est?tica

        // de plugin services para quien lo quiera usar (por ejemplo, para

        // cargar un proyecto por l?nea de comandos)

        PluginServices.setArguments(args);

        getOrCreateConfigFolder();

        configureLogging(appName, applicationClasifier);

        if (!validJVM()) {

            logger.error("Not a valid JRE. Exit application.");

            System.exit(-1);

        }

        ToolsLocator.registerDefaultToolsLibraries();

        ToolsLocator.getFoldersManager().cleanTemporaryFiles();

        if (args.length < 2) {

            loadAndamiConfig("gvSIG/extensiones"); // Valor por defecto

        } else {

            loadAndamiConfig(args[1]);

        }

        configureLocales();

        logger.info("Configure LookAndFeel");

        configureLookAndFeel();

    }

    /**

     *

     */

    private void configureLookAndFeel() {

        // Se pone el lookAndFeel

        try {

            String lookAndFeel = getAndamiConfig().getLookAndFeel();

            if (lookAndFeel == null) {

                lookAndFeel = getDefaultLookAndFeel();

            }

            UIManager.setLookAndFeel(lookAndFeel);

        } catch (Exception e) {

            logger.warn(Messages.getString("Launcher.look_and_feel"), e);

        }

        FontUtils.initFonts();

    }

    /**

     * @param args

     * @throws ConfigurationException

     */

    private void loadAndamiConfig(String pluginFolder)

            throws ConfigurationException {

        andamiConfigPath = appHomeDir + File.separator + "andami-config.xml";

        andamiConfigFromXML(andamiConfigPath);

        andamiConfig.setPluginsDirectory(pluginFolder);

    }

    /**

     *

     */

    private void getOrCreateConfigFolder() {

        // Create application configuration folder

        appHomeDir = System.getProperty(appName + ".home");

        if (appHomeDir == null) {

            appHomeDir = System.getProperty("user.home");

        }

        appHomeDir += File.separator + appName;

        File parent = new File(appHomeDir);

        parent.mkdirs();

    }

    /**

     * @param args

     * @throws IOException

     */

    private void configureLogging(String appName, String applicationClasifier) throws IOException {

        // Configurar el log4j

        String pathname;

        if (StringUtils.isBlank(applicationClasifier)) {

            pathname = appHomeDir + File.separator + appName + ".log";

        } else {

            pathname = appHomeDir + File.separator + appName + "-" + applicationClasifier + ".log";

        }

        URL config = Launcher.class.getClassLoader().getResource("log4j.properties");

        if (config == null) {

            config = Launcher.class.getClassLoader().getResource("default-log4j/log4j.properties");

        }

        PropertyConfigurator.configure(config);

        PatternLayout l = new PatternLayout("%p %r %t %C - %m%n");

        RollingFileAppender fa = new RollingFileAppender(l, pathname, false);

        fa.setMaxFileSize("512KB");

        fa.setMaxBackupIndex(3);

        org.apache.log4j.Logger.getRootLogger().addAppender(fa);

        logger.info("Loadded log4j.properties from " + config.toString());

        if (StringUtils.isBlank(applicationClasifier)) {

            logger.info("Application " + appName);

        } else {

            logger.info("Application " + appName + "-" + applicationClasifier);

        }

    }

    public static String getApplicationName() {

        return appName;

    }

    private class NotificationAppender extends AppenderSkeleton {

        @Override

        protected void append(LoggingEvent event) {

            if (event.getLevel() == org.apache.log4j.Level.ERROR

                    || event.getLevel() == org.apache.log4j.Level.FATAL) {

                Throwable th = null;

                ThrowableInformation thi = event.getThrowableInformation();

                if (thi != null) {

                    th = thi.getThrowable();

                }

                NotificationManager.dispatchError(event.getRenderedMessage(), th);

                return;

            }

                        // if (event.getLevel() == org.apache.log4j.Level.WARN) {

            // NotificationManager.dispatchWarning(event.getRenderedMessage(),

            // null);

            // return;

            // }

        }

        @Override

        public void close() {

            // TODO Auto-generated method stub

        }

        @Override

        public boolean requiresLayout() {

            // TODO Auto-generated method stub

            return false;

        }

    }

    /**

     * Return the directory applicaction is installed.

     */

    public static String getApplicationDirectory() {

        return getApplicationFolder().getAbsolutePath();

    }

    public static File getApplicationFolder() {

        // TODO: check if there is a better way to handle this

        return new File(System.getProperty("user.dir"));

    }

    private void registerIcons() {

        IconTheme theme = PluginServices.getIconTheme();

        ClassLoader loader = Launcher.class.getClassLoader();

        String[][] icons = {

            // MultiSplashWindow

            {"main", "splash-default"},

            // NewStatusBar

            {"main", "statusbar-info"},

            {"main", "statusbar-warning"},

            {"main", "statusbar-error"}

        };

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

            try {

                IconThemeHelper.registerIcon(icons[i][0], icons[i][1], Launcher.class);

            } catch (Exception e) {

                logger.info("Can't register icon '" + icons[i][0] + "' (" + icons[i][1] + ").");

            }

        }

        theme.setDefaultIcon(loader.getResource("images/main/default-icon.png"));

    }

    private Properties loadProperties(File f) {

        FileInputStream fin = null;

        Properties p = null;

        try {

            fin = new FileInputStream(f);

            p = new Properties();

            p.load(fin);

        } catch (IOException ex) {

            // Do nothing

        }

        return p;

    }

    /**

     * Obtiene la personalizaci?n de los iconos, splash, fondo y el nombre de

     * la aplicaci?n.

     *

     * @return Theme

     */

    private Theme getTheme(String pluginsDirectory) {

        File infoFile = new File(Launcher.getApplicationFolder(), "package.info");

        File themeFile = null;

        List<Theme> themes = new ArrayList<Theme>();

        // Try to get theme from args

        String name = PluginServices.getArgumentByName("andamiTheme");

        if (name != null) {

            themeFile = new File(name);

            logger.info("search andami-theme in {}", themeFile.getAbsolutePath());

            if (themeFile.exists()) {

                Theme theme = new Theme(loadProperties(infoFile));

                theme.readTheme(themeFile);

                logger.info("andami-theme found in {}", themeFile.getAbsolutePath());

                return theme;

            }

        }

        // Try to get theme from a plugin

        File pluginsDir = new File(pluginsDirectory);

        if (!pluginsDir.isAbsolute()) {

            pluginsDir = new File(getApplicationFolder(), pluginsDirectory);

        }

        if (pluginsDir.exists()) {

            logger.info("search andami-theme in plugins folder '" + pluginsDir.getAbsolutePath() + "'.");

            File[] pluginDirs = pluginsDir.listFiles();

            if (pluginDirs.length > 0) {

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

                    File pluginThemeFile = new File(pluginDirs[i],

                            "theme" + File.separator + "andami-theme.xml");

                    if (pluginThemeFile.exists()) {

                        Theme theme = new Theme(loadProperties(infoFile));

                        theme.readTheme(pluginThemeFile);

                        themes.add(theme);

                    }

                }

            }

        }

        // Try to get theme from dir gvSIG in user home

        themeFile = new File(getAppHomeDir(), "theme" + File.separator

                + "andami-theme.xml");

        logger.info("search andami-theme in user's home {}", themeFile

                .getAbsolutePath());

        if (themeFile.exists()) {

            Theme theme = new Theme(loadProperties(infoFile));

            theme.readTheme(themeFile);

            themes.add(theme);

        }

        // Try to get theme from the instalation dir of gvSIG.

        themeFile = new File(getApplicationDirectory(), "theme"

                + File.separator + "andami-theme.xml");

        logger.info("search andami-theme in installation folder {}", themeFile

                .getAbsolutePath());

        if (themeFile.exists()) {

            Theme theme = new Theme(loadProperties(infoFile));

            theme.readTheme(themeFile);

            themes.add(theme);

        }

        Collections.sort(themes, new Comparator<Theme>() {

            public int compare(Theme t1, Theme t2) {

                return t2.getPriority() - t1.getPriority();

            }

        });

        if (logger.isInfoEnabled()) {

            logger.info("Found andami-themes in:");

            for (Theme theme : themes) {

                logger.info(" - " + theme.getPriority() + ", " + theme.getSource().getAbsolutePath());

            }

        }

        Theme theme = themes.get(0);

        logger.info("Using theme '" + theme.getSource() + "'.");

        return theme;

    }

    /**

     * Establece los datos que tengamos guardados respecto de la configuracion

     * del proxy.

     */

    private void configureProxy() {

        String host = prefs.get("firewall.http.host", "");

        String port = prefs.get("firewall.http.port", "");

        System.getProperties().put("http.proxyHost", host);

        System.getProperties().put("http.proxyPort", port);

        // Ponemos el usuario y clave del proxy, si existe

        String proxyUser = prefs.get("firewall.http.user", null);

        String proxyPassword = prefs.get("firewall.http.password", null);

        if (proxyUser != null) {

            System.getProperties().put("http.proxyUserName", proxyUser);

            System.getProperties().put("http.proxyPassword", proxyPassword);

            Authenticator.setDefault(new ProxyAuth(proxyUser, proxyPassword));

        } else {

            Authenticator.setDefault(new ProxyAuth("", ""));

        }

    }

    /**

     * Recupera la geometr?a (tama?o, posic?n y estado) de la ventana

     * principal de Andami. TODO Pendiente de ver como se asigna un

     * pluginServices para el launcher.

     *

     * @author LWS

     */

    private void restoreMDIStatus(XMLEntity xml) {

        if (xml == null) {

            xml = new XMLEntity();

        }

        // ====================================

        // restore frame size

        Dimension sz = new Dimension(

                MainFrame.MAIN_FRAME_SIZE_DEFAULT[0],

                MainFrame.MAIN_FRAME_SIZE_DEFAULT[1]);

        if (xml.contains(MainFrame.MAIN_FRAME_SIZE)) {

            int[] wh = xml.getIntArrayProperty(MainFrame.MAIN_FRAME_SIZE);

            sz = new Dimension(wh[0], wh[1]);

        }

        frame.setSize(sz);

        // ==========================================

        // restore frame location

        Point pos = new Point(

                MainFrame.MAIN_FRAME_POS_DEFAULT[0],

                MainFrame.MAIN_FRAME_POS_DEFAULT[1]);

        if (xml.contains(MainFrame.MAIN_FRAME_POS)) {

            int[] xy = xml.getIntArrayProperty(MainFrame.MAIN_FRAME_POS);

            pos = new Point(xy[0], xy[1]);

        }

        frame.setLocation(pos);

        // =============================================

        // restore frame state (Maximized, minimized, etc);

        int state = MainFrame.MAIN_FRAME_EXT_STATE_DEFAULT;

        if (xml.contains(MainFrame.MAIN_FRAME_EXT_STATE)) {

            state = xml.getIntProperty(MainFrame.MAIN_FRAME_EXT_STATE);

        }

        frame.setExtendedState(state);

    }

    private XMLEntity saveMDIStatus() {

        XMLEntity xml = new XMLEntity();

        // save frame size

        int[] wh = new int[2];

        wh[0] = frame.getWidth();

        wh[1] = frame.getHeight();

        xml.putProperty(MainFrame.MAIN_FRAME_SIZE, wh);

        // save frame location

        int[] xy = new int[2];

        xy[0] = frame.getX();

        xy[1] = frame.getY();

        xml.putProperty(MainFrame.MAIN_FRAME_POS, xy);

        // save frame status

        xml.putProperty(MainFrame.MAIN_FRAME_EXT_STATE,

                frame.getExtendedState());

        return xml;

    }

    private boolean validJVM() {

        if (!SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_6)) {

            logger.warn("gvSIG requires Java version 1.6 or higher.");

            logger.warn("The Java HOME is '" + SystemUtils.getJavaHome().getAbsolutePath() + "'.");

            return false;

        }

        if (SystemUtils.isJavaAwtHeadless()) {

            logger.warn("The java used by gvSIG does not contain the libraries for access to the graphical interface (AWT-headless)");

            logger.warn("The Java HOME is '" + SystemUtils.getJavaHome().getAbsolutePath() + "'.");

            return false;

        }

        return true;

    }

    private void loadPluginsPersistence() throws ConfigurationException {

        XMLEntity entity = persistenceFromXML();

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

            XMLEntity plugin = entity.getChild(i);

            String pName = plugin

                    .getStringProperty("com.iver.andami.pluginName");

            if (pName.compareToIgnoreCase("com.iver.cit.gvsig") == 0) {

                pName = "org.gvsig.app";

            }

            if (pluginsServices.get(pName) != null) {

                ((PluginServices) pluginsServices.get(pName))

                        .setPersistentXML(plugin);

            } else {

                if (pName.startsWith("Andami.Launcher")) {

                    restoreMDIStatus(plugin);

                }

            }

        }

    }

    /**

     * Salva la persistencia de los plugins.

     *

     * @author LWS

     */

    private void savePluginPersistence() {

        Iterator<String> i = pluginsConfig.keySet().iterator();

        XMLEntity entity = new XMLEntity();

        while (i.hasNext()) {

            String pName = i.next();

            PluginServices ps = (PluginServices) pluginsServices.get(pName);

            XMLEntity ent = ps.getPersistentXML();

            if (ent != null) {

                ent.putProperty("com.iver.andami.pluginName", pName);

                entity.addChild(ent);

            }

        }

        XMLEntity ent = saveMDIStatus();

        if (ent != null) {

            ent.putProperty("com.iver.andami.pluginName", "Andami.Launcher");