Application: gvSIG desktop

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

 *

 * Copyright (C) 2004 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 com.iver.andami;

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

import java.io.FilenameFilter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.lang.reflect.InvocationTargetException;

import java.net.Authenticator;

import java.net.MalformedURLException;

import java.net.PasswordAuthentication;

import java.net.URL;

import java.net.URLConnection;

import java.security.AllPermission;

import java.security.CodeSource;

import java.security.PermissionCollection;

import java.security.Permissions;

import java.security.Policy;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Locale;

import java.util.Properties;

import java.util.TreeMap;

import java.util.prefs.Preferences;

import javax.jnlp.BasicService;

import javax.jnlp.ServiceManager;

import javax.jnlp.UnavailableServiceException;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JPopupMenu;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import org.apache.log4j.Logger;

import org.apache.log4j.PatternLayout;

import org.apache.log4j.PropertyConfigurator;

import org.apache.log4j.RollingFileAppender;

import org.exolab.castor.xml.MarshalException;

import org.exolab.castor.xml.ValidationException;

import com.iver.andami.authentication.IAuthentication;

import com.iver.andami.config.generate.Andami;

import com.iver.andami.config.generate.AndamiConfig;

import com.iver.andami.config.generate.Plugin;

import com.iver.andami.messages.Messages;

import com.iver.andami.messages.NotificationManager;

import com.iver.andami.plugins.ExtensionDecorator;

import com.iver.andami.plugins.PluginClassLoader;

import com.iver.andami.plugins.config.generate.ActionTool;

import com.iver.andami.plugins.config.generate.ComboButton;

import com.iver.andami.plugins.config.generate.ComboButtonElement;

import com.iver.andami.plugins.config.generate.ComboScale;

import com.iver.andami.plugins.config.generate.Depends;

import com.iver.andami.plugins.config.generate.Extension;

import com.iver.andami.plugins.config.generate.Extensions;

import com.iver.andami.plugins.config.generate.LabelSet;

import com.iver.andami.plugins.config.generate.Menu;

import com.iver.andami.plugins.config.generate.PluginConfig;

import com.iver.andami.plugins.config.generate.PopupMenu;

import com.iver.andami.plugins.config.generate.PopupMenus;

import com.iver.andami.plugins.config.generate.SelectableTool;

import com.iver.andami.plugins.config.generate.SkinExtension;

import com.iver.andami.plugins.config.generate.SkinExtensionType;

import com.iver.andami.plugins.config.generate.ToolBar;

import com.iver.andami.ui.AndamiEventQueue;

import com.iver.andami.ui.MDIManagerLoadException;

import com.iver.andami.ui.mdiFrame.MDIFrame;

import com.iver.andami.ui.mdiManager.MDIManagerFactory;

import com.iver.andami.ui.splash.MultiSplashWindow;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.xmlEntity.generate.XmlTag;

/**

 * DOCUMENT ME!

 *

 * @author $author$

 * @version $Revision: 9167 $

 */

public class Launcher {

        private static Logger logger = Logger.getLogger(Launcher.class.getName());

        private static Preferences prefs = Preferences.userRoot().node( "gvsig.connection" );

        private static AndamiConfig andamiConfig;

        private static MultiSplashWindow splashWindow;

        private static String appName;

        private static Locale locale;

        private static HashMap pluginsConfig = new HashMap();

        private static HashMap pluginsServices = new HashMap();

        private static MDIFrame frame;

        private static HashMap classesExtensions = new HashMap();

        private static String andamiConfigPath;

        private static String pluginsPersistencePath;

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

    private static ArrayList pluginsOrdered = new ArrayList();

    private static ArrayList extensions=new ArrayList();

    private static String appHomeDir = 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;

                }

        }

        /**

         * DOCUMENT ME!

         *

         * @param args DOCUMENT ME!

         * @throws Exception

         *

         * @throws InterruptedException

         * @throws InvocationTargetException

         * @throws ConfigurationException

         * @throws MDIManagerLoadException

         * @throws IOException

         */

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

            try{

                    if (!validJVM()){

                            System.exit(-1);

                    }

                    if (args.length < 1) {

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

                    }

                    //  Clean temporal files

                    Utilities.cleanUpTempFiles();

                    appName = args[0];

                    //Se crea el directorio de configuraci?n de la aplicaci?n

                    appHomeDir = System.getProperty(args[0]+".home");

                    if (appHomeDir == null)

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

                    //System.err.println("LWS: "+args[0]+".home"+"="+appHomeDir);

                    appHomeDir += File.separator + args[0] + File.separator;

                    File parent = new File( appHomeDir );

                    parent.mkdirs();

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

                    pluginsPersistencePath = appHomeDir +

                    "plugins-persistence.xml";

                    // Configurar el log4j

                    PropertyConfigurator.configure(Launcher.class.getClassLoader()

                                    .getResource("log4j.properties"));

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

                    RollingFileAppender fa = new RollingFileAppender(l,

                                    appHomeDir + args[0] + ".log", false);

                    fa.setMaxFileSize("512KB");

                    fa.setMaxBackupIndex(3);

                    Logger.getRootLogger().addAppender(fa);

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

                    // locale

                    // Buscar actualizaci?nes al comenzar

                    //  Andami

                    //  Plugins

                    // Directorio de las extensiones

                    andamiConfigFromXML(andamiConfigPath);

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

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

                    }

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

             });

                    validate();

                    // Mostrar la ventana de inicio

                    Frame f=new Frame();

                    splashWindow=new MultiSplashWindow(f);

                    validate();

                    // Ponemos los datos del proxy

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

                        }

                    // TODO Buscar actualizaciones de los plugins

                    downloadExtensions(andamiConfig.getPluginsDirectory());

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

                    loadPlugins(andamiConfig.getPluginsDirectory());

                    // Se configura el classloader del plugin

                    pluginsClassLoaders();

                    // Se carga un Skin si alguno de los plugins trae informaci?n para ello

                    skinPlugin();

                    //Se configura la cola de eventos

                    EventQueue waitQueue = new AndamiEventQueue();

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

                    // Se configura la mensajer?a del plugin

                    pluginsMessages();

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

                    updateAndamiConfig();

                    // Se prepara el MainFrame para albergar las extensiones

                    JPopupMenu.setDefaultLightWeightPopupEnabled(false);

                    frame = new MDIFrame();

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

                    frameIcon();

                    SwingUtilities.invokeAndWait(new Runnable() {

                            public void run() {

                                    frame.init();

                            }

                    });

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

                    SwingUtilities.invokeAndWait(new Runnable() {

                            public void run() {

                                    installPluginsControls();

                                    installPluginsMenus();

                                    installPluginsLabels();

                            }

                    });

                    // Leer el fichero de persistencia

                    //  info de los plugins

                    //  bookmarks de los plugins

                    loadPluginsPersistence();

                    // Se instalan los controles del skin

                    // Se inicializan todas las extensiones de todos los plugins

                    SwingUtilities.invokeAndWait(new Runnable() {

                            public void run() {

                                    initializeExtensions();

                                    postInitializeExtensions();

                            }

                    });

                    frame.setClassesExtensions(classesExtensions);

                    // Se instalan los bookmarks de los plugins

                    //Se muestra el frame principal

                    frame.show();

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

                            }

                    });

                    splashWindow.close();

            }catch(Exception e){

                    logger.error("excepci?n al arrancar", e);

                    System.exit(-1);

            }

    }

        /**

         * Recupera la geometr?a (tama?o, posici?n y estado) de la ventana principal de Andami.

         * TODO Pendiente de ver como se asigna un pluginServices para el launcher.

         * @author LWS

         */

        private static void restoreMDIStatus(XMLEntity xml) {

                //System.err.println("Launcher: restoreMDIStatus()");

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

        }

        /**

     * @return

     */

    private static boolean validJVM() {

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

        if (thirdCharacter < '4'){

            return false;

            }else{

                return true;

            }

    }

    /**

         * DOCUMENT ME!

         *

         * @throws ConfigurationException

         */

        private static void loadPluginsPersistence() throws ConfigurationException {

                XMLEntity entity = persistenceFromXML();

                //System.err.println("loadPluginPersistence()");

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

                        XMLEntity plugin = entity.getChild(i);

                        String pName = plugin.getStringProperty(

                                        "com.iver.andami.pluginName");

                        //System.err.println("--> "+pName);

                        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 static void savePluginPersistence() {

                Iterator i = pluginsConfig.keySet().iterator();

                XMLEntity entity = new XMLEntity();

                while (i.hasNext()) {

                        String pName = (String) 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) {

                        logger.error(Messages.getString(

                                        "Launcher.Se_produjo_un_error_guardando_la_configuracion_de_los_plugins"),

                                e1);

                }

        }

        /**

         * DOCUMENT ME!

         */

        private static void installPluginsLabels() {

                Iterator i = pluginsConfig.keySet().iterator();

                while (i.hasNext()) {

                        String name = (String) i.next();

                        PluginConfig pc = (PluginConfig) 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.setLabels(clase, ls[j].getLabel());

                                } catch (ClassNotFoundException e) {

                                        logger.error(Messages.getString("Launcher.labelset_class"),

                                                e);

                                }

                        }

                }

        }

        /**

         * DOCUMENT ME!

         *

         * @throws MDIManagerLoadException

         */

        private static void skinPlugin() throws MDIManagerLoadException {

                Iterator i = pluginsConfig.keySet().iterator();

                while (i.hasNext()) {

                        String name = (String) i.next();

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

                        PluginServices ps = (PluginServices) 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();

                                MDIManagerFactory.setSkinExtension(se, ps.getClassLoader());

                                Class skinClass;

                                try {

                                        skinClass = ps.getClassLoader().loadClass(se.getClassName());

                                        com.iver.andami.plugins.IExtension skinInstance = (com.iver.andami.plugins.IExtension) skinClass.newInstance();

                                        // classesExtensions.put(skinClass, skinInstance);

                                        // jaume

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

                                }

                        }

                }

        }

        /**

         *

         */

        private static void frameIcon() {

                Iterator i = pluginsConfig.keySet().iterator();

                while (i.hasNext()) {

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

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

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

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

                                ImageIcon icon = new ImageIcon(ps.getClassLoader().getResource(pc.getIcon()

                                                                                                                                                                 .getSrc()));

                                frame.setIconImage(icon.getImage());

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

                        }

                }

        }

        /**

         *

         */

        private static void initializeExtensions() {

                Iterator i = pluginsOrdered.iterator();

                while (i.hasNext()) {

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

            logger.debug("Initializing extensions from " + pName);

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

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

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

                        TreeMap orderedExtensions = new TreeMap(new ExtensionComparator());

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

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

                                        continue;

                                }

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

                                        logger.warn(Messages.getString(

                                                        "Launcher.Two_extensions_with_the_same_priority") +

                                                exts[j].getClassName());

                                }

                                orderedExtensions.put(exts[j], null);

                        }

                        Iterator e = orderedExtensions.keySet().iterator();

                        while (e.hasNext()) {

                                Extension extension = (Extension) e.next();

                                com.iver.andami.plugins.IExtension extensionInstance;

                                try {

                                        Class extensionClass = ps.getClassLoader().loadClass(extension.getClassName());

                                        extensionInstance = (com.iver.andami.plugins.IExtension) extensionClass.newInstance();

                                        // CON DECORATOR

                                        // ANTES: classesExtensions.put(extensionClass, extensionInstance);

                                        // AHORA: CREAMOS UNA ExtensionDecorator y asignamos esta instancia para

                                        // poder ampliar con nuevas propiedades (AlwaysVisible, por ejemplo)

                                        // Para crear la nueva clase ExtensionDecorator, le pasamos como par?metro

                                        // la extensi?n original que acabamos de crear

                                        // 0-> Inactivo, controla la extension

                                        // 1-> Siempre visible

                                        // 2-> Invisible

                                        ExtensionDecorator newExtensionDecorator = new ExtensionDecorator(extensionInstance, ExtensionDecorator.INACTIVE);

                                        classesExtensions.put(extensionClass, newExtensionDecorator);

                                        System.err.println("Loading "+extension.getClassName()+"...");

                    // logger.debug("Initializing " + extension.getClassName());

                    extensionInstance.initialize();

                    extensions.add(extensionInstance);

                    // logger.debug(extension.getClassName() + " initialized.");

                                } catch (InstantiationException e1) {

                                        logger.error(Messages.getString(

                                                        "Launcher.Error_instanciando_la_extension") +

                                                extension.getClassName(), e1);

                                } catch (IllegalAccessException e1) {

                                        logger.error(Messages.getString(

                                                        "Launcher.Error_instanciando_la_extension") +

                                                extension.getClassName(), e1);

                                } catch (ClassNotFoundException e1) {

                                        logger.error(Messages.getString(

                                                        "Launcher.No_se_encontro_la_clase_de_la_extension") +

                                                extension.getClassName(), e1);

                                } catch (NoClassDefFoundError e1) {

                                        logger.error(Messages.getString(

                                                        "Launcher.Error_localizando_la_clase_de_la_extension") +

                                                extension.getClassName(), e1);

                                }

                        }

                }

        }

        private static void postInitializeExtensions() {

                for (int i=0;i<extensions.size();i++) {

                        com.iver.andami.plugins.IExtension extensionInstance=(com.iver.andami.plugins.IExtension)extensions.get(i);

                        extensionInstance.postInitialize();

                }

        }

        /**

         * DOCUMENT ME!

         */

        private static void installPluginsMenus() {

                TreeMap orderedMenus = new TreeMap(new MenuComparator());

                Iterator i = pluginsConfig.keySet().iterator();

                while (i.hasNext()) {

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

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

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

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

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

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

                                        continue;

                                }

                                Menu[] menus = exts[j].getMenu();

                                for (int k = 0; k < menus.length; k++) {

                                        SortableMenu sm = new SortableMenu(ps.getClassLoader(),

                                                        exts[j], menus[k]);

                                        if (orderedMenus.containsKey(sm)) {

                                                logger.error(Messages.getString(

                                                                "Launcher.Two_menus_with_the_same_position") + " - " +

                                                        menus[k].getText()+ " - " + exts[j].getClassName());

                                        }

                                        orderedMenus.put(sm, null);

                                }

                        }

                        // Se instalan las extensiones de MDI

                        SkinExtension skinExt = pc.getExtensions().getSkinExtension();

                        if (skinExt != null) {

                                Menu[] menu = skinExt.getMenu();

                                for (int k = 0; k < menu.length; k++) {

                                        SortableMenu sm = new SortableMenu(ps.getClassLoader(),

                                                        skinExt, menu[k]);

                                        if (orderedMenus.containsKey(sm)) {

                                                logger.error(Messages.getString(

                                                                "Launcher.Two_menus_with_the_same_position") +

                                                        skinExt.getClassName());

                                        }

                                        orderedMenus.put(sm, null);

                                }

                        }

                }

                //Se itera por los menus ordenados

                Iterator e = orderedMenus.keySet().iterator();

                // Se ordenan los menues

                while (e.hasNext()) {

                        try {

                                SortableMenu sm = (SortableMenu) e.next();

                                frame.addMenu(sm.loader, sm.extension, sm.menu);

                        } catch (ClassNotFoundException ex) {

                                logger.error(Messages.getString(

                                                "Launcher.No_se_encontro_la_clase_de_la_extension"), ex);

                        }

                }

        }

        /**

         * Installs the menus, toolbars, actiontools, selectable toolbars and combos.

         * The order in which they are shown is determined here.

         */

        private static void installPluginsControls() {

                Iterator i = pluginsConfig.keySet().iterator();

                HashMap extensionPluginServices = new HashMap();

                HashMap extensionPluginConfig = new HashMap();

                TreeMap orderedExtensions = new TreeMap(new ExtensionComparator());

                // First of all, sort the extensions.

                // We need to iterate on the plugins, and iterate on each plugin's extensions

                // (each plugin may contain one or more extensions)

                while (i.hasNext()) { // iterate on the plugins

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

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

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

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

                        for (int j = 0; j < exts.length; j++) { // iterate on the extensions

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

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

                                                logger.error(Messages.getString(

                                                "Launcher.Two_extensions_with_the_same_priority") +

                                                exts[j].getClassName());

                                        }

                                        orderedExtensions.put(exts[j], null);

                                        extensionPluginServices.put(exts[j], ps);

                                        extensionPluginConfig.put(exts[j], pc);

                                }

                        }

                }

                TreeMap orderedTools = new TreeMap(new ToolComparator());

                Iterator e = orderedExtensions.keySet().iterator();

                // sort the toolbars and tools from 'normal' extensions (actiontools, selectabletools)

                // and load the  combo-scales and combo-buttons for the status bar

                while (e.hasNext()) {

                        Extension ext = (Extension) e.next();

                        ToolBar[] toolbars = ext.getToolBar();

                        // get tools from toolbars

                        for (int k = 0; k < toolbars.length; k++) {

                                ActionTool[] tools = toolbars[k].getActionTool();

                                for (int t = 0; t < tools.length; t++) {

                                        SortableTool sm = new SortableTool(((PluginServices)extensionPluginServices.get(ext)).getClassLoader(), ext,

                                                        toolbars[k], tools[t]);

                                        orderedTools.put(sm, null);

                                }

                                SelectableTool[] sTools = toolbars[k].getSelectableTool();

                                for (int t = 0; t < sTools.length; t++) {

                                        SortableTool sm=new SortableTool(((PluginServices)extensionPluginServices.get(ext)).getClassLoader(), ext,

                                                        toolbars[k], sTools[t]);

                                        orderedTools.put(sm, null);

                                }

                        }

                        // get controls for statusBar

                        PluginServices ps = (PluginServices) extensionPluginServices.get(ext);

                        PluginClassLoader loader = ps.getClassLoader();

                        //ArrayList componentList = new ArrayList();

                        ComboScale[] comboScaleArray = ext.getComboScale();

                        for (int k=0; k < comboScaleArray.length; k++) {

                                org.gvsig.gui.beans.controls.comboscale.ComboScale combo = new org.gvsig.gui.beans.controls.comboscale.ComboScale();

                                String label = comboScaleArray[k].getLabel();

                                if (label!=null)

                                        combo.setLabel(label);

                                String name = comboScaleArray[k].getName();

                                if (name!=null)

                                        combo.setName(name);

                                String[] elementsString = ((String)comboScaleArray[k].getElements()).split(";");

                                long[] elements = new long[elementsString.length];

                                for (int currentElem=0; currentElem<elementsString.length; currentElem++) {

                                        try {

                                                elements[currentElem] = Long.parseLong(elementsString[currentElem]);

                                        }

                                        catch (NumberFormatException nfex1) {

                                                logger.error(ext.getClassName()+" -- "+Messages.getString( "error_parsing_comboscale_elements"));

                                                elements[currentElem] = 0;

                                        }

                                }

                                combo.setItems(elements);

                                try {

                                        long value = Long.parseLong((String)comboScaleArray[k].getValue());

                                        combo.setScale(value);

                                }

                                catch (NumberFormatException nfex2) {

                                        logger.error(ext.getClassName()+" -- "+Messages.getString( "error_parsing_comboscale_value"));

                                }

                                try {

                                        frame.addStatusBarControl(loader.loadClass(ext.getClassName()),combo);

                                } catch (ClassNotFoundException e1) {

                                        logger.error(Messages.getString("Launcher.error_getting_class_loader_for_status_bar_control"), e1);

                                }

                        }

                        ComboButton[] comboButtonArray = ext.getComboButton();

                        for (int k=0; k < comboButtonArray.length; k++) {

                                ComboButtonElement[] elementList = comboButtonArray[k].getComboButtonElement();

                                org.gvsig.gui.beans.controls.combobutton.ComboButton combo = new org.gvsig.gui.beans.controls.combobutton.ComboButton();

                                String name = comboButtonArray[k].getName();

                                if (name!=null)

                                        combo.setName(name);

                                for (int currentElement=0; currentElement<elementList.length; currentElement++) {

                                        ComboButtonElement element = elementList[currentElement];

                                        ImageIcon icon;

                                        URL iconLocation = loader.getResource(element.getIcon());

                                        if (iconLocation==null)

                                                logger.error(Messages.getString("Icon_not_found_")+element.getIcon());

                                        else {

                                                icon = new ImageIcon(iconLocation);

                                                JButton button = new JButton(icon);

                                                combo.addButton(button);

                                                button.setActionCommand(element.getActionCommand());

                                        }

                                }

                                try {

                                        frame.addStatusBarControl(loader.loadClass(ext.getClassName()), combo);

                                } catch (ClassNotFoundException e1) {

                                        logger.error(Messages.getString("Launcher.error_getting_class_loader_for_status_bar_control"), e1);

                                }

                        }

                }

                // Add the tools from MDI extensions to the ordered tool-list, so that we get a sorted list containing all the tools

                i = pluginsConfig.keySet().iterator();

                while (i.hasNext()) {

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

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

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

                        SkinExtension skinExt = pc.getExtensions().getSkinExtension();

                        if (skinExt != null) {

                                ToolBar[] toolbars = skinExt.getToolBar();

                                for (int k = 0; k < toolbars.length; k++) {

                                        ActionTool[] tools = toolbars[k].getActionTool();

                                        for (int t = 0; t < tools.length; t++) {

                                                SortableTool stb=new SortableTool(ps.getClassLoader(), skinExt,

                                                                toolbars[k], tools[t]);

                                                orderedTools.put(stb,null);

                                        }

                                        SelectableTool[] sTools = toolbars[k].getSelectableTool();

                                        for (int t = 0; t < sTools.length; t++) {

                                                SortableTool stb=new SortableTool(ps.getClassLoader(), skinExt,

                                                                toolbars[k], sTools[t]);

                                                orderedTools.put(stb,null);

                                        }

                                }

                        }

                        // Install popup menus

                        PopupMenus pus = pc.getPopupMenus();

                        if (pus != null) {

                                PopupMenu[] menus = pus.getPopupMenu();

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

                                        frame.addPopupMenu(ps.getClassLoader(), menus[j]);

                                }

                        }

                }

                // loop on the ordered extension list, to add them to the interface in an ordered way

                Iterator t = orderedTools.keySet().iterator();

                while (t.hasNext()) {

                        try {

                                SortableTool stb = (SortableTool) t.next();

                                if (stb.actiontool!=null)

                                        frame.addTool(stb.loader, stb.extension,stb.toolbar, stb.actiontool);

                                else

                                        frame.addTool(stb.loader, stb.extension,stb.toolbar, stb.selectabletool);

                        } catch (ClassNotFoundException ex) {

                                logger.error(Messages.getString(

                                "Launcher.No_se_encontro_la_clase_de_la_extension"), ex);

                        }

                }

        }

        /**

         * Adds new plugins to the the andami-config file.

         */

        private static void updateAndamiConfig() {

                HashSet olds = new HashSet();

                Plugin[] plugins = andamiConfig.getPlugin();

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

                        olds.add(plugins[i].getName());

                }

                Iterator i = pluginsServices.values().iterator();

                while (i.hasNext()) {

                        PluginServices ps = (PluginServices) i.next();

                        if (!olds.contains(ps.getPluginName())) {

                                Plugin p = new Plugin();

                                p.setName(ps.getPluginName());

                                p.setUpdate(false);

                                andamiConfig.addPlugin(p);

                        }

                }

        }

        /**

         * DOCUMENT ME!

         */

        private static void pluginsClassLoaders() {

                HashSet instalados = new HashSet();

                // Se itera hasta que est?n todos instalados

                while (instalados.size() != pluginsConfig.size()) {

                        boolean circle = true;

                        //Hacemos una pasada por todos los plugins

                        Iterator i = pluginsConfig.keySet().iterator();

                        while (i.hasNext()) {

                                String pluginName = (String) i.next();

                                PluginConfig config = (PluginConfig) pluginsConfig.get(pluginName);

                                if (instalados.contains(pluginName)) {

                                        continue;

                                }

                                //Se obtienen las dependencias y sus class loaders

                                boolean ready = true;

                                Depends[] dependencies = config.getDepends();

                                PluginClassLoader[] loaders = new PluginClassLoader[dependencies.length];

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

                                        if (pluginsConfig.get(dependencies[j].getPluginName()) == null) {

                                                logger.error(Messages.getString(

                                                                "Launcher.Dependencia_no_resuelta_en_plugin") +

                                                        pluginName + ": " +

                                                        dependencies[j].getPluginName());

                                                continue;

                                        }

                                        if (!instalados.contains(dependencies[j].getPluginName())) {

                                                ready = false;

                                        } else {

                                                loaders[j] = ((PluginServices) pluginsServices.get(dependencies[j].getPluginName())).getClassLoader();

                                        }

                                }

                                //Si no est?n sus dependencias satisfechas se aborta la instalaci?n

                                if (!ready) {

                                        continue;

                                }

                                //Se genera el class loader

                                String jardir = config.getLibraries().getLibraryDir();

                                File jarDir = new File(andamiConfig.getPluginsDirectory() +

                                                File.separator + pluginName + File.separator + jardir);

                                File[] jarFiles = jarDir.listFiles(new FileFilter() {

                                                        public boolean accept(File pathname) {

                                                                return (pathname.getName().toUpperCase()

                                                                                                .endsWith(".JAR")) ||

                                                                (pathname.getName().toUpperCase().endsWith(".ZIP"));

                                                        }

                                                });

                                URL[] urls = new URL[jarFiles.length];

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

                                        try {

                                                urls[j] = new URL("file:" + jarFiles[j]);

                                        } catch (MalformedURLException e) {

                                                logger.error(Messages.getString(

                                                                "Launcher.No_se_puede_acceder_a") +

                                                        jarFiles[j]);

                                        }

                                }

                                PluginClassLoader loader;

                                try {

                                        loader = new PluginClassLoader(urls,

                                                        andamiConfig.getPluginsDirectory() +

                                                        File.separator + pluginName,

                                                        Launcher.class.getClassLoader(), loaders);

                                        PluginServices ps = new PluginServices(loader);

                                        pluginsServices.put(ps.getPluginName(), ps);

                                        instalados.add(pluginName);

                    // FJP: Los metemos ordenados para luego no cargar uno que necesita de otro antes de tiempo. Esto lo usaremos al

                    // inicializar los plugins

                    pluginsOrdered.add(pluginName);

                                        circle = false;

                                } catch (IOException e) {

                                        logger.error(Messages.getString(

                                                        "Launcher.Error_con_las_librerias_del_plugin"), e);

                                        pluginsConfig.remove(pluginName);

                                        i = pluginsConfig.keySet().iterator();

                                }

                        }

                        if (circle) {

                                logger.error(Messages.getString(

                                                "Launcher.Hay_dependencias_circulares"));

                                break;

                        }

                }

                //Se eliminan los plugins que no fueron instalados

                Iterator i = pluginsConfig.keySet().iterator();

                while (i.hasNext()) {

                        String pluginName = (String) i.next();

                        PluginConfig config = (PluginConfig) pluginsConfig.get(pluginName);

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

                        if (ps == null) {

                                pluginsConfig.remove(pluginName);

                                i = pluginsConfig.keySet().iterator();

                        }

                }

        }

        /**

         * DOCUMENT ME!

         */

        private static void pluginsMessages() {

                /* add gvsig translations first. This should be done using a generic "appPlugin" variable, instead

                 * of using "com.iver.cit.gvsig" directly, but I'll do it when we use the new appgvSIG launcher.

                 * I keep this workaround for the moment.

                 */

                PluginConfig config = (PluginConfig) pluginsConfig.get("com.iver.cit.gvsig");

                PluginServices ps = (PluginServices) pluginsServices.get("com.iver.cit.gvsig");

                if (config.getResourceBundle() != null) {

                        org.gvsig.i18n.Messages.addResourceFamily(config.getResourceBundle().getName(), ps.getClassLoader(), "com.iver.cit.gvsig");

                }

                //Iteramos por todos los plugins

                Iterator i = pluginsConfig.keySet().iterator();

                while (i.hasNext()) {

                        String pluginName = (String) i.next();

                        if (!pluginName.equals("com.iver.cit.gvsig")) { // we've already loaded com.iver.cit.gvsig

                                config = (PluginConfig) pluginsConfig.get(pluginName);

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

                                if (config.getResourceBundle() != null && !config.getResourceBundle().getName().equals("")) {

                                        // add the locale files associated with the plugin

                                        org.gvsig.i18n.Messages.addResourceFamily(config.getResourceBundle().getName(), ps.getClassLoader(), pluginName);

                                }

                        }

                }

        }

        /**

         * DOCUMENT ME!

         *

         * @param name DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         */

        static PluginServices getPluginServices(String name) {

                return (PluginServices) pluginsServices.get(name);

        }

        /**

         * DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         */

        static String getPluginsDir() {

                return andamiConfig.getPluginsDirectory();

        }

        /**

         * DOCUMENT ME!

         *

         * @param s DOCUMENT ME!

         */

        static void setPluginsDir(String s) {

                andamiConfig.setPluginsDirectory(s);

        }

        /**

         * DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         */

        static MDIFrame getMDIFrame() {

                return frame;

        }

        /**

         * DOCUMENT ME!

         *

         * @param pluginsDirectory

         */

        private static void loadPlugins(String pluginsDirectory) {

                File pDir = new File(pluginsDirectory);

                if (!pDir.exists()) {

                        return;

                }

                File[] pluginDirs = pDir.listFiles();

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

                        if (pluginDirs[i].isDirectory()) {

                                File configXml = new File(pluginDirs[i].getAbsolutePath() +

                                                File.separator + "config.xml");

                                try {

                                        FileInputStream is = new FileInputStream(configXml);

                                        Reader xml = com.iver.utiles.xml.XMLEncodingUtils.getReader(is);

                                        if (xml==null) {

                                                // the encoding was not correctly detected, use system default

                                                xml = new FileReader(configXml);

                                        }

                                        else {

                                                // use a buffered reader to improve performance

                                                xml = new BufferedReader(xml);

                                        }

                                        PluginConfig pConfig = (PluginConfig) PluginConfig.unmarshal(xml);

                                        pluginsConfig.put(pluginDirs[i].getName(), pConfig);

                                } catch (FileNotFoundException e) {

                                        logger.info(Messages.getString(

                                                        "Launcher.Ignorando_el_directorio") +

                                                pluginDirs[i].getAbsolutePath() +

                                                Messages.getString("Launcher.config_no_encontrado"));

                                } catch (MarshalException e) {

                                        logger.info(Messages.getString(

                                                        "Launcher.Ignorando_el_directorio") +

                                                pluginDirs[i].getAbsolutePath() +

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

                                } catch (ValidationException e) {

                                        logger.info(Messages.getString(

                                                        "Launcher.Ignorando_el_directorio") +

                                                pluginDirs[i].getAbsolutePath() +

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

                                }

                        }

                }

        }

        /**

         * DOCUMENT ME!

         *

         * @param language

         * @param country

         * @param variant

         *

         * @return DOCUMENT ME!

         */

        private static Locale getLocale(String language, String country,

                String variant) {

                if (variant != null) {

                        return new Locale(language, country, variant);

                } else if (country != null) {

                        return new Locale(language, country);

                } else if (language != null) {

                        return new Locale(language);

                } else {

                        return new Locale("es");

                }

        }

        /**

         * DOCUMENT ME!

         *

         * @param file DOCUMENT ME!

         *

         * @throws IOException DOCUMENT ME!

         * @throws MarshalException DOCUMENT ME!

         * @throws ValidationException DOCUMENT ME!

         */

        private static void andamiConfigToXML(String file)

                throws IOException, MarshalException, ValidationException {

                File xml = new File(file);

                File parent = xml.getParentFile();

                parent.mkdirs();

                FileWriter writer = new FileWriter(xml);

                andamiConfig.marshal(writer);

        }

        /**

         * DOCUMENT ME!

         *

         * @param file DOCUMENT ME!

         *

         * @throws ConfigurationException DOCUMENT ME!

         */

        private static void andamiConfigFromXML(String file)

                throws ConfigurationException {

                File xml = new File(file);

                //Si no existe se ponen los valores por defecto

                if (!xml.exists()) {

                        andamiConfig = new AndamiConfig();

                        Andami andami = new Andami();

                        andami.setUpdate(true);

                        andamiConfig.setAndami(andami);

                        andamiConfig.setLocaleCountry(Locale.getDefault().getCountry());

                        andamiConfig.setLocaleLanguage(Locale.getDefault().getLanguage());

                        andamiConfig.setLocaleVariant(Locale.getDefault().getVariant());

                        if (System.getProperty("javawebstart.version") != null) // Es java web start)

                         {

                                andamiConfig.setPluginsDirectory(new File(appHomeDir

                                                + "extensiones").getAbsolutePath());

                        } else {

                                andamiConfig.setPluginsDirectory(new File(appName +

                                                File.separator + "extensiones").getAbsolutePath());

                        }