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

import java.awt.Component;

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.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.io.FileUtils;

import org.apache.commons.lang3.JavaVersion;

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.authentication.IAuthentication;

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

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

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

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

        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 ArrayList<String> pluginsOrdered = new ArrayList<String>();

        protected static ArrayList<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 {

                Launcher launcher = getInstance();

                boolean install = false;

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

                        if (args[i].equalsIgnoreCase("--install")) {

                                install = true;

                        }

                }

                try {

                        if (install) {

                                launcher.doInstall(args);

                        } else {

                                launcher.doMain(args);

                        }

                } catch (Exception e) {

                        logger.error("excepci?n 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 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);

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

                // Web Start con este codigo.

                // System.setSecurityManager(null);

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

                }

                validate();

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

                }

                // Initialize andami libraries

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

                File defaultAddonsRepository = PluginsLocator.getManager()

                                .getPluginsFolder();

                InstallerManager installerManager = InstallerLocator

                                .getInstallerManager();

                installerManager.addLocalAddonRepository(defaultAddonsRepository);

                installerManager

                                .setDefaultLocalAddonRepository(defaultAddonsRepository);

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

                // ---------------------------------------------

                // Get the list of installed packages

                PluginsManager pluginmgr = PluginsLocator.getManager();

                InstallerManager installmgr = InstallerLocator.getInstallerManager();

                PackageInfo[] installedPackages = null;

                try {

                        installedPackages = installmgr.getInstalledPackages(pluginmgr

                                        .getPluginsFolder());

                } catch (MakePluginPackageServiceException e) {

                        // Do nothing, ignore errors

                }

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

                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.loadPlugins(andamiConfig.getPluginsDirectory());

                } catch (Exception 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.pluginsClassLoaders();

                } catch (Exception ex) {

                        this.addError("Can't initialize plugin's classloaders  ", ex);

                }

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

                        }

                });

                /* 

                 * Initialize local repository folders of the installer 

                 */

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

                initializeLocalAddOnRepositoryFolders();

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

                                frame.enableControls();

                        }

                });

                splashWindow.close();

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

                                frame.enableControls();

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

                        }

                });

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

                InstallerManager installerManager = InstallerLocator.getInstallerManager();

                File defaultAddonsRepository = PluginsLocator.getManager().getPluginsFolder();

                installerManager.addLocalAddonRepository(defaultAddonsRepository);

                installerManager.setDefaultLocalAddonRepository(defaultAddonsRepository);

                IconThemeManager iconManager = ToolsSwingLocator.getIconThemeManager();

                FolderSet fset = iconManager.getRepository();

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

                while( it.hasNext() ) {

                        FolderEntry entry = it.next();

                        installerManager.addLocalAddonRepository(entry.getFolder());

                }

        }

        /**

     * 

     */

        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) throws IOException, ConfigurationException {

                if( args.length<1 ) {

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

                } else {

                        appName = args[0];

                }

                getOrCreateConfigFolder();

                configureLogging(appName);

                if (!validJVM()) {

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

                    System.exit(-1);

                }

                // Clean temporal files

                Utilities.cleanUpTempFiles();

                if( args.length<2 ) {

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

                } else {

                        loadAndamiConfig(args[1]);

                }

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

                configureLocales(args);

                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 {

                // Leer el fichero de configuraci?n de andami (andami-config.xsd)

                // locale

                // Buscar actualizaci?nes al comenzar

                // Andami

                // Plugins

                // Directorio de las extensiones

                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) throws IOException {

                // Configurar el log4j

                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 %t %C - %m%n");

                RollingFileAppender fa = new RollingFileAppender(l, appHomeDir

                                + File.separator + appName + ".log", false);

                fa.setMaxFileSize("512KB");

                fa.setMaxBackupIndex(3);

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

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

        }

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

                    logger.warn("gvSIG requires Java version 1.4 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");

                        entity.addChild(ent);

                }

                try {

                        persistenceToXML(entity);

                } catch (ConfigurationException e1) {

                        this

                                        .addError(

                                                        Messages

                                                                        .getString("Launcher.Se_produjo_un_error_guardando_la_configuracion_de_los_plugins"),

                                                        e1);

                }

        }

        private void installPluginsLabels() {

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

                while (i.hasNext()) {

                        String name = i.next();

                        PluginConfig pc = pluginsConfig.get(name);

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

                        LabelSet[] ls = pc.getLabelSet();

                        for (int j = 0; j < ls.length; j++) {

                                PluginClassLoader loader = ps.getClassLoader();

                                try {

                                        Class clase = loader.loadClass(ls[j].getClassName());

                                        frame.setStatusBarLabels(clase, ls[j].getLabel());

                                } catch (ClassNotFoundException e) {

                                        this.addError(

                                                        Messages.getString("Launcher.labelset_class"), e);