| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004-2007 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.andami;

import java.awt.BorderLayout;

import java.awt.Component;

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

import javax.swing.JOptionPane;

import javax.swing.JPopupMenu;

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

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

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

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.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: 38564 $

 */

public class Launcher {

        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 HashMap<String, PluginConfig> pluginsConfig = new HashMap<String, PluginConfig>();

        protected static HashMap<String, PluginServices> pluginsServices = new HashMap<String, PluginServices>();

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

        }

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

                if (args.length < 1) {

                        System.err

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

                }

                initializeApp(args);

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

                // Web Start con este c?digo.

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

                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 aplicaci?n.

                try {

                        logger.info("Initialize andami theme");

                        theme = getTheme(andamiConfig.getPluginsDirectory());

                } catch (Exception ex) {

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

                                        ex);

                }

                // Mostrar la ventana de inicio

                Frame f = new Frame();

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

                // 1. Ponemos los datos del proxy

                splashWindow.process(10, PluginServices.getText(Launcher.class,

                                "SplashWindow.configuring_proxy"));

                logger.info("Configute http proxy");

                configureProxy();

                // 2. TODO Buscar actualizaciones de los plugins

//                splashWindow.process(20, PluginServices.getText(Launcher.class,

//                                "SplashWindow.looking_for_updates"));

//                try {

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

//                } catch (Exception ex) {

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

//                }

                // 2.5. Initialize andami libraries

                splashWindow.process(25, PluginServices.getText(Launcher.class,

                                "SplashWindow.initialize_andami_libraries"));

                new DefaultLibrariesInitializer().fullInitialize(true);

                File defaultAddonsRepository = PluginsLocator.getManager()

                                .getPluginsFolder();

                InstallerManager installerManager = InstallerLocator

                                .getInstallerManager();

                installerManager.addLocalAddonRepository(defaultAddonsRepository);

                installerManager

                                .setDefaultLocalAddonRepository(defaultAddonsRepository);

                logger.info("Dump system information");

                logger_info(getInformation());

                // 3. Se leen los config.xml de los plugins -----++++

                splashWindow.process(30, PluginServices.getText(Launcher.class,

                                "SplashWindow.reading_plugins_config.xml"));

                try {

                        logger.info("Load plugins information");

                        this.loadPlugins(andamiConfig.getPluginsDirectory());

                } catch (Exception ex) {

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

                }

                // 4. Se configura el classloader del plugin

                splashWindow.process(40, PluginServices.getText(Launcher.class,

                                "SplashWindow.setting_up_class_loaders"));

                try {

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

                        this.pluginsClassLoaders();

                } catch (Exception ex) {

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

                }

                // 5. Initialize libraries

                splashWindow.process(50, PluginServices.getText(Launcher.class,

                                "SplashWindow.initialize_libraries"));

                initializeLibraries();

                // 6. Se carga un Skin si alguno ide los plugins trae informaci?n

                // para ello

                splashWindow.process(60, PluginServices.getText(Launcher.class,

                                "SplashWindow.looking_for_a_skin"));

                // skinPlugin( "com.iver.core.mdiManager.NewSkin");

                logger.info("Initialize skin");

                skinPlugin(null);

                // 7. Se configura la cola de eventos

                splashWindow.process(70, PluginServices.getText(Launcher.class,

                                "setting_up_event_queue"));

                EventQueue waitQueue = new AndamiEventQueue();

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

                // 8. Se configura la mensajer?a del plugin

                splashWindow.process(80, PluginServices.getText(Launcher.class,

                                "SplashWindow.starting_plugin_internationalization_system"));

                pluginsMessages();

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

                splashWindow.process(90, PluginServices.getText(Launcher.class,

                                "SplashWindow.looking_for_a_skin"));

                updateAndamiConfig();

                frame = new MDIFrame();

                // 10. Se configura el nombre e icono de la aplicaci?n

                splashWindow.process(100, PluginServices.getText(Launcher.class,

                                "SplashWindow.setting_up_applications_name_and_icons"));

                frameIcon(theme);

                // 11. Se prepara el MainFrame para albergar las extensiones

                splashWindow.process(110, PluginServices.getText(Launcher.class,

                                "SplashWindow.preparing_workbench"));

                JPopupMenu.setDefaultLightWeightPopupEnabled(false);

                SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                frame.init();

                        }

                });

                ToolsSwingLocator.registerWindowManager(ToolsWindowManager.class);

                // 12. Leer el fichero de persistencia

                // info de los plugins

                // bookmarks de los plugins

                splashWindow.process(120, PluginServices.getText(Launcher.class,

                                "SplashWindow.loading_plugin_settings"));

                loadPluginsPersistence();

                // Se instalan los controles del skin

                // 13. Se inicializan todas las extensiones de todos los plugins

                splashWindow.process(130, PluginServices.getText(Launcher.class,

                                "SplashWindow.initializing_extensions"));

                SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                initializeExtensions();

                        }

                });

                // 14. Se inicializan la extensi?n exclusiva

                splashWindow.process(140, PluginServices.getText(Launcher.class,

                                "SplashWindow.setting_up_master_extension"));

                SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                initializeExclusiveUIExtension();

                        }

                });

                frame.setClassesExtensions(classesExtensions);

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

                splashWindow.process(150, PluginServices.getText(Launcher.class,

                                "SplashWindow.installing_extensions_controls"));

                SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                installPluginsControls();

                        }

                });

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

                splashWindow.process(160, PluginServices.getText(Launcher.class,

                                "SplashWindow.installing_extensions_menus"));

                SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                installPluginsMenus();

                        }

                });

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

                splashWindow.process(170, PluginServices.getText(Launcher.class,

                                "SplashWindow.installing_extensions_labels"));

                SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                installPluginsLabels();

                        }

                });

                // 18. Se instalan los bookmarks de los plugins

                // 19. Se muestra el frame principal

                splashWindow.process(180, PluginServices.getText(Launcher.class,

                                "creating_main_window"));

                frame.setVisible(true);

                /* 

                 * Initialize installer local repository folders 

                 */

                initializeLocalAddOnRepositoryFolders();

                // 19. Se ejecuta el postInitialize

                splashWindow.process(190, PluginServices.getText(Launcher.class,

                                "SplashWindow.post_initializing_extensions"));

                SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                postInitializeExtensions();

                        }

                });

                // Definimos un KeyEventDispatcher global para que las extensiones

                // puedan registrar sus "teclas r?pidas".

                GlobalKeyEventDispatcher keyDispatcher = GlobalKeyEventDispatcher.getInstance();

                KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(keyDispatcher);

                SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                frame.enableControls();

                        }

                });

                createDefaultIconTheme();

                splashWindow.close();

                if (launcherrors != null) {

                        NotificationManager.addError(launcherrors);

                }

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

                                new NotificationAppender());

        }

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

                PluginsManager pluginsManager = PluginsLocator.getManager();

                IconThemeManager iconManager = ToolsSwingLocator.getIconThemeManager();

                File f = new File(pluginsManager.getApplicationHomeFolder(),"icon-theme");

                if( !f.exists() ) {

                        f.mkdir();

                }

                IconTheme theme = iconManager.getDefault();

                File f2 = new File(f,theme.getID()) ;

                if( !f2.exists() ) {

                        logger.info("Creating default icon theme in "+f.getAbsolutePath());

                        theme.export(f);

                }

        }

        /**

     * 

     */

        private void initializeLibraries() {

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

                                pluginsOrdered.size() + 1);

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

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

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

                while (iter.hasNext()) {

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

                        PluginServices ps = (PluginServices) pluginsServices.get(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 (!validJVM()) {

                        System.exit(-1);

                }

                // Clean temporal files

                Utilities.cleanUpTempFiles();

                appName = args[0];

                getOrCreateConfigFolder();

                configureLogging(appName);

                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("Load and initialize andami and plugins libraries");

                // LibrariesInitializer libsInitializer =

                // new DefaultLibrariesInitializer();

                // libsInitializer.initialize(true);

                // libsInitializer.postInitialize(true);

                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

                Launcher.class.getClassLoader().getResource(".");

                PropertyConfigurator.configure("log4j.properties");

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

        }

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

                                NotificationManager.dispatchError(event.getRenderedMessage(),

                                                null);

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

        }

        /**

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

         * aplicaci?n.

         * 

         * @return Theme

         */

        private Theme getTheme(String pluginsDirectory) {

                File themeFile = null;

                Theme theme = new 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.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(System.getProperty("user.dir"),

                                        pluginsDirectory);

                }

                if (pluginsDir.exists()) {

                        logger.info("search andami-theme in plugins folder.");

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

                                                themeFile = pluginThemeFile;

                                                // This if is a hack to allow more themes than the

                                                // one available in org.gvsig.app. Remove this

                                                // when a the theme format is changed to allow for

                                                // priorities

                                                if (!"org.gvsig.app".equals(pluginDirs[i].getName())) {

                                                        break;

                                                }

                                        }

                                }

                        }

                }

                // The theme file will be the one into a plugin or by default the one

                // in the org.gvsig.app plugin

                if (themeFile != null && themeFile.exists()) {

                        theme.readTheme(themeFile);

                        logger.info("andami-theme found in plugin {}", themeFile

                                        .getAbsolutePath());

                        return 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.readTheme(themeFile);

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

                                        .getAbsolutePath());

                        return 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.readTheme(themeFile);

                        logger.info("andami-theme found in instalation folder {}",

                                        themeFile.getAbsolutePath());

                        return theme;

                }

                logger.info("Apply default andami-theme.");

                return theme;

        }

        /**

         * Establece los datos que ten?amos guardados respecto de la configuraci?n

         * 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(700, 580);

                if (xml.contains("MDIFrameSize")) {

                        int[] wh = xml.getIntArrayProperty("MDIFrameSize");

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

                }

                frame.setSize(sz);

                // restore frame location

                Point pos = new Point(10, 10);

                if (xml.contains("MDIFramePos")) {

                        int[] xy = xml.getIntArrayProperty("MDIFramePos");

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

                }

                frame.setLocation(pos);

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

                int state = java.awt.Frame.MAXIMIZED_BOTH;

                if (xml.contains("MDIFrameState")) {

                        state = xml.getIntProperty("MDIFrameState");

                }

                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("MDIFrameSize", wh);

                // save frame location

                int[] xy = new int[2];

                xy[0] = frame.getX();

                xy[1] = frame.getY();

                xml.putProperty("MDIFramePos", xy);

                // save frame status

                xml.putProperty("MDIFrameState", frame.getExtendedState());

                return xml;

        }

        private boolean validJVM() {

                char thirdCharacter = System.getProperty("java.version").charAt(2);

                if (thirdCharacter < '4') {

                        return false;

                } else {

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

                                }

                        }

                }

        }

        private String configureSkin(XMLEntity xml, String defaultSkin) {

                if (defaultSkin == null) {

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

                                if (xml.getChild(i).contains("Skin-Selected")) {

                                        String className = xml.getChild(i).getStringProperty(

                                                        "Skin-Selected");

                                        return className;

                                }

                        }

                }

                // return "com.iver.core.mdiManager.NewSkin";

                return defaultSkin;

        }

        private void fixSkin(SkinExtension skinExtension,

                        PluginClassLoader pluginClassLoader) throws MDIManagerLoadException {

                // now insert the skin selected.

                MDIManagerFactory.setSkinExtension(skinExtension, pluginClassLoader);

                // MDIManagerFactory.setSkinExtension(se,

                // ps.getClassLoader());

                Class<? extends IExtension> skinClass;

                try {

                        skinClass = (Class<? extends IExtension>) pluginClassLoader

                                        .loadClass(skinExtension.getClassName());

                        IExtension skinInstance = skinClass.newInstance();

                        ExtensionDecorator newExtensionDecorator = new ExtensionDecorator(

                                        skinInstance, ExtensionDecorator.INACTIVE);

                        classesExtensions.put(skinClass, newExtensionDecorator);

                } catch (ClassNotFoundException e) {

                        logger.error(Messages

                                        .getString("Launcher.No_se_encontro_la_clase_mdi_manager"),

                                        e);

                        throw new MDIManagerLoadException(e);

                } catch (InstantiationException e) {

                        logger

                                        .error(

                                                        Messages

                                                                        .getString("Launcher.No_se_pudo_instanciar_la_clase_mdi_manager"),

                                                        e);

                        throw new MDIManagerLoadException(e);

                } catch (IllegalAccessException e) {

                        logger

                                        .error(

                                                        Messages

                                                                        .getString("Launcher.No_se_pudo_acceder_a_la_clase_mdi_manager"),

                                                        e);

                        throw new MDIManagerLoadException(e);

                }

        }

        /**

         * DOCUMENT ME!

         * 

         * @throws MDIManagerLoadException

         */

        private void skinPlugin(String defaultSkin) throws MDIManagerLoadException {

                XMLEntity entity = null;

                try {

                        entity = persistenceFromXML();

                } catch (ConfigurationException e1) {

                        // TODO Auto-generated catch block

                        e1.printStackTrace();

                }

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

                SkinExtension skinExtension = null;

                PluginClassLoader pluginClassLoader = null;

                List<SkinExtension> skinExtensions = new ArrayList<SkinExtension>();

                while (i.hasNext()) {

                        String name = i.next();

                        PluginConfig pc = pluginsConfig.get(name);

                        PluginServices ps = pluginsServices.get(name);

                        if (pc.getExtensions().getSkinExtension() != null) {

                                // if (MDIManagerFactory.getSkinExtension() != null) {

                                // logger.warn(Messages.getString(

                                // "Launcher.Dos_skin_extension"));

                                // }

                                SkinExtension[] se = pc.getExtensions().getSkinExtension();

                                for (int numExten = 0; numExten < se.length; numExten++) {

                                        skinExtensions.add(se[numExten]);

                                }

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

                                        String configuredSkin = this.configureSkin(entity,

                                                        defaultSkin);

                                        if ((configuredSkin != null)

                                                        && configuredSkin.equals(se[j].getClassName())) {

                                                skinExtension = se[j];

                                                pluginClassLoader = ps.getClassLoader();

                                        }

                                }

                        }

                }

                if ((skinExtension != null) && (pluginClassLoader != null)) {

                        // configured skin was found

                        fixSkin(skinExtension, pluginClassLoader);

                } else {

                        if (skinExtensions.contains("com.iver.core.mdiManager.NewSkin")) {

                                // try first NewSkin (from CorePlugin)

                                skinPlugin("com.iver.core.mdiManager.NewSkin");

                        } else if (skinExtensions.size() > 0) {

                                // try to load the first skin found

                                SkinExtension se = (SkinExtension) skinExtensions.get(0);

                                skinPlugin((String) se.getClassName());

                        } else {

                                throw new MDIManagerLoadException("No Skin-Extension installed");

                        }

                }

        }

        private static void frameIcon(Theme theme) {

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

                while (i.hasNext()) {

                        String pName = i.next();

                        PluginConfig pc = pluginsConfig.get(pName);

                        if (pc.getIcon() != null) {

                                if (theme.getIcon() != null) {

                                        frame.setIconImage(theme.getIcon().getImage());

                                } else {

                                        ImageIcon icon = PluginServices.getIconTheme().get(

                                                        pc.getIcon().getSrc());

                                        frame.setIconImage(icon.getImage());

                                }

                                if (theme.getName() != null) {

                                        frame.setTitlePrefix(theme.getName());

                                } else {

                                        frame.setTitlePrefix(pc.getIcon().getText());

                                }

                                if (theme.getBackgroundImage() != null) {

                                        PluginServices.getMDIManager().setBackgroundImage(

                                                        theme.getBackgroundImage(), theme.getTypeDesktop());

                                }

                        }

                }

        }

        private void initializeExtensions() {

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

                                pluginsOrdered.size());

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

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

                // logger.debug("Initializing plugins libraries: ");

                // while (iter.hasNext()) {

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

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

                // classLoaders.add(ps.getClassLoader());

                // }

                //

                // // Create the libraries initializer and

                // // initialize the plugin libraries

                // new DefaultLibrariesInitializer(

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

                // .fullInitialize();

                //

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

                // classLoaders.clear();

                // classLoaders = null;

                logger.info("Initializing plugins: ");

                // iter = pluginsOrdered.iterator();

                while (iter.hasNext()) {

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

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

                        PluginConfig pc = (PluginConfig) pluginsConfig.get(pName);

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

                        Extension[] exts = pc.getExtensions().getExtension();

                        TreeSet<Extension> orderedExtensions = new TreeSet<Extension>(

                                        new ExtensionComparator());

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

                                if (!exts[j].getActive()) {

                                        continue;

                                }

                                if (orderedExtensions.contains(exts[j])) {

                                        logger.warn("Two extensions with the same priority ("

                                                        + exts[j].getClassName() + ")");

                                }

                                orderedExtensions.add(exts[j]);

                        }

                        Iterator<Extension> e = orderedExtensions.iterator();

                        logger.info("Initializing extensions of plugin " + pName + ": ");

                        while (e.hasNext()) {

                                Extension extension = e.next();

                                org.gvsig.andami.plugins.IExtension extensionInstance;

                                try {

                                        logger.info("Initializing " + extension.getClassName()

                                                        + "...");

                                        Class<? extends IExtension> extensionClass = (Class<? extends IExtension>) ps

                                                        .getClassLoader().loadClass(