| gvSIG desktop 1

package com.iver.andami;

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.plugins.PluginClassLoader;

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

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

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

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

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

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

import com.iver.andami.ui.SplashWindow;

import com.iver.andami.ui.WaitCursorEventQueue;

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

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

import com.iver.utiles.XMLEntity;

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

import org.apache.log4j.Logger;

import org.apache.log4j.PropertyConfigurator;

import org.exolab.castor.xml.MarshalException;

import org.exolab.castor.xml.ValidationException;

import java.awt.EventQueue;

import java.awt.Toolkit;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.FilenameFilter;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Locale;

import java.util.TreeMap;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

/**

 * DOCUMENT ME!

 *

 * @author $author$

 * @version $Revision: 665 $

 */

public class Launcher {

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

    private static AndamiConfig andamiConfig;

    private static SplashWindow splashWindow;

    private static String userHome = System.getProperty("user.home");

    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;

    /**

     * DOCUMENT ME!

     *

     * @param args DOCUMENT ME!

     *

     * @throws InterruptedException

     * @throws InvocationTargetException

     * @throws ConfigurationException

     * @throws MDIManagerLoadException

     */

    public static void main(String[] args)

        throws InterruptedException, InvocationTargetException, 

            ConfigurationException, MDIManagerLoadException {

        if (args.length != 1) {

            System.err.println("Uso: Launcher appName");

        }

        appName = args[0];

        andamiConfigPath = userHome + File.separator + appName +

            File.separator + "andami-config.xml";

        pluginsPersistencePath = userHome + File.separator + appName +

            File.separator + "plugins-persistence.xml";

        // Configurar el log4j

        PropertyConfigurator.configure(Launcher.class.getClassLoader()

                                                     .getResource("log4j.properties"));

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

        // Configurar el locale

        locale = getLocale(andamiConfig.getLocaleLanguage(),

                andamiConfig.getLocaleCountry(), andamiConfig.getLocaleVariant());

        Locale.setDefault(locale);

        JComponent.setDefaultLocale(locale);

        Messages.init(locale);

        try {

                        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

                        // UIManager.setLookAndFeel("com.iver.WindowsLookAndFeel.WindowsLookAndFeel");

        } catch (Exception e) {

            logger.warn("No se pudo poner el look and feel", e);

        }

        // Mostrar la ventana de inicio

        splashWindow = new SplashWindow(null);

        // TODO Buscar actualizaciones de Andami

        // TODO Buscar actualizaciones de los plugins

        // 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 WaitCursorEventQueue(MDIManagerFactory.createManager(),

                100);

        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

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

                        }

                });

        frame.setClassesExtensions(classesExtensions);

        // Se instalan los bookmarks de los plugins

        splashWindow.close();

        //Se muestra el frame principal

        frame.show();

        SwingUtilities.invokeAndWait(new Runnable() {

                        public void run() {

                                frame.enableControls();

                        }

                });

    }

    /**

     * DOCUMENT ME!

     *

     * @throws ConfigurationException

     */

    private static void loadPluginsPersistence() throws ConfigurationException {

        XMLEntity entity = persistenceFromXML();

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

            XMLEntity plugin = entity.getChild(i);

            String pName = plugin.getStringProperty(

                    "com.iver.andami.pluginName");

            ((PluginServices) pluginsServices.get(pName)).setPresistentXML(plugin);

        }

    }

    /**

     * 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("No se pudo encontrar la clase de la labelset",

                        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.error("Dos skin-extension. Usamos el ?ltimo");

                }

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

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

                Class skinClass;

                try {

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

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

                    classesExtensions.put(skinClass, skinInstance);

                } catch (ClassNotFoundException e) {

                    logger.error("No se pudo instanciar la clase mdi manager", e);

                    throw new MDIManagerLoadException(e);

                } catch (InstantiationException e) {

                    logger.error("No se pudo instanciar la clase mdi manager", e);

                    throw new MDIManagerLoadException(e);

                } catch (IllegalAccessException e) {

                    logger.error("No se pudo instanciar 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.setTitle(pc.getIcon().getText());

            }

        }

    }

    /**

     *

     */

    private static void initializeExtensions() {

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

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

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

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

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

                    logger.error(

                        "Two extensions with the same priority. Only will load one. " +

                        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.Extension extensionInstance;

                try {

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

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

                    classesExtensions.put(extensionClass, extensionInstance);

                    extensionInstance.inicializar();

                } catch (InstantiationException e1) {

                    logger.error("Error instanciando la extension " +

                        extension.getClassName(), e1);

                } catch (IllegalAccessException e1) {

                    logger.error("Error instanciando la extension " +

                        extension.getClassName(), e1);

                } catch (ClassNotFoundException e1) {

                    logger.error("Error instanciando la extension " +

                        extension.getClassName(), e1);

                } catch (NoClassDefFoundError e1) {

                    logger.error("Error localizando la clase de la extension " +

                        extension.getClassName(), e1);

                }

            }

        }

    }

    /**

     * DOCUMENT ME!

     */

    private static void installPluginsMenus() {

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

        while (i.hasNext()) {

            try {

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

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

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

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

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

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

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

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

                        SortableMenu sm = new SortableMenu(exts[j], menu[k]);

                        if (orderedMenus.containsKey(sm)) {

                            logger.error(

                                "Two menus with the same position. Only will load one. " +

                                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(skinExt, menu[k]);

                        if (orderedMenus.containsKey(sm)) {

                            logger.error(

                                "Two menus with the same position. Only will load one. " +

                                skinExt.getClassName());

                        }

                        orderedMenus.put(sm, null);

                    }

                }

                //Se itera por los menus ordenados

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

                // Se ordenan los menues

                while (e.hasNext()) {

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

                    frame.addMenu(ps.getClassLoader(), sm.extension, sm.menu);

                }

            } catch (ClassNotFoundException e) {

                logger.error("No se pudo encontrar la clase de la extension", e);

            }

        }

    }

    /**

     *

     */

    private static void installPluginsControls() {

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

        while (i.hasNext()) {

            try {

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

                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 (orderedExtensions.containsKey(exts[j])) {

                        logger.error(

                            "Two extensions with the same priority. Only will load one. " +

                            exts[j].getClassName());

                    }

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

                }

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

                // Se instalan las extensiones

                while (e.hasNext()) {

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

                    ToolBar[] toolbars = ext.getToolBar();

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

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

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

                            frame.addTool(ps.getClassLoader(), ext,

                                toolbars[k], tools[t]);

                        }

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

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

                            frame.addTool(ps.getClassLoader(), ext,

                                toolbars[k], sTools[t]);

                        }

                    }

                    /*

                       Menu[] menu = ext.getMenu();

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

                           frame.addMenu(ps.getClassLoader(), ext, menu[k]);

                       }

                     */

                }

                // Se instalan las extensiones de MDI

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

                            frame.addTool(ps.getClassLoader(), skinExt,

                                toolbars[k], tools[t]);

                        }

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

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

                            frame.addTool(ps.getClassLoader(), skinExt,

                                toolbars[k], sTools[t]);

                        }

                    }

                    /*

                       Menu[] menu = skinExt.getMenu();

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

                           frame.addMenu(ps.getClassLoader(), skinExt, menu[k]);

                       }

                     */

                }

                //Se instalan los 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]);

                    }

                }

            } catch (ClassNotFoundException e) {

                logger.error("No se pudo encontrar la clase de la extension", e);

            }

        }

    }

    /**

     *

     */

    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("Dependencia no resuelta en plugin " +

                            pluginName + ": " +

                            dependencies[j].getPluginName() +

                            ". Dependencia ignorada");

                        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

                Library[] jars = config.getLibraries().getLibrary();

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

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

                    try {

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

                                andamiConfig.getPluginsDirectory() +

                                File.separator + pluginName + File.separator +

                                jars[j].getFile());

                    } catch (MalformedURLException e) {

                        logger.error("No se puede acceder a " +

                            jars[j].getFile());

                    }

                }

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

                    circle = false;

                } catch (IOException e) {

                    logger.error("Error con las librer?as del plugin", e);

                    pluginsConfig.remove(pluginName);

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

                }

            }

            if (circle) {

                logger.error("Hay dependencias circulares entre los plugins");

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

        //Iteramos por todos los plugins

        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 (config.getResourceBundle() != null) {

                ps.setResourceBundle(config.getResourceBundle().getName(),

                    locale);

            }

        }

    }

    /**

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

                    FileReader xml = new FileReader(configXml);

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

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

                } catch (FileNotFoundException e) {

                    logger.info("Ignorando el directorio " +

                        pluginDirs[i].getAbsolutePath() +

                        " por no encontrar su fichero 'config.xml'");

                } catch (MarshalException e) {

                    logger.info("Ignorando el directorio " +

                        pluginDirs[i].getAbsolutePath() +

                        " por fichero 'config.xml' mal formado", e);

                } catch (ValidationException e) {

                    logger.info("Ignorando el directorio " +

                        pluginDirs[i].getAbsolutePath() +

                        " por fichero 'config.xml' 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);

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

            andamiConfig.setPluginsDirectory(appName + File.separator + "extensiones");

            andamiConfig.setPlugin(new Plugin[0]);

        } else {

            //Se lee la configuraci?n

            FileReader reader;

            try {

                reader = new FileReader(xml);

                andamiConfig = (AndamiConfig) AndamiConfig.unmarshal(reader);

            } catch (FileNotFoundException e) {

                throw new ConfigurationException(e);

            } catch (MarshalException e) {

                throw new ConfigurationException(e);

            } catch (ValidationException e) {

                throw new ConfigurationException(e);

            }

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     *

     * @throws ConfigurationException DOCUMENT ME!

     */

    private static XMLEntity persistenceFromXML() throws ConfigurationException {

        File xml = new File(pluginsPersistencePath);

        if (xml.exists()) {

            FileReader reader;

            try {

                reader = new FileReader(xml);

                XmlTag tag = (XmlTag) XmlTag.unmarshal(reader);

                return new XMLEntity(tag);

            } catch (FileNotFoundException e) {

                throw new ConfigurationException(e);

            } catch (MarshalException e) {

                throw new ConfigurationException(e);

            } catch (ValidationException e) {

                throw new ConfigurationException(e);

            }

        } else {

            return new XMLEntity();

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @param entity DOCUMENT ME!

     *

     * @throws ConfigurationException DOCUMENT ME!

     */

    private static void persistenceToXML(XMLEntity entity)

        throws ConfigurationException {

        File xml = new File(pluginsPersistencePath);

        FileWriter writer;

        try {

            writer = new FileWriter(xml);

            entity.getXmlTag().marshal(writer);

        } catch (FileNotFoundException e) {

            throw new ConfigurationException(e);

        } catch (MarshalException e) {

            throw new ConfigurationException(e);

        } catch (ValidationException e) {

            throw new ConfigurationException(e);

        } catch (IOException e) {

            throw new ConfigurationException(e);

        }

    }

    /**

     * Devuelve un array con los directorios de los plugins

     *

     * @param dirExt Directorio de las extensiones a partir del cual cuelgan

     *        todos los directorios de los plugins

     *

     * @return ArrayList con los directorios

     */

    private String[] getLocales(File dirExt) {

        ArrayList types = new ArrayList();

        File[] files = dirExt.listFiles();

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

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

                File[] textFile = files[i].listFiles(new FilenameFilter() {

                            public boolean accept(File dir, String fileName) {

                                return fileName.toLowerCase().startsWith("text_"); //$NON-NLS-1$

                            }

                        });

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

                    String s = (textFile[j]).getName().replaceAll("text_", "");

                    s = s.replaceAll(".properties", "");

                    s = s.trim();

                    if (!types.contains(s)) {

                        types.add(s);

                    }

                }

            }

        }

        return (String[]) types.toArray(new String[0]);

    }

    /**

     * DOCUMENT ME!

     *

     * @return Returns the frame.

     */

    static MDIFrame getFrame() {

        return frame;

    }

    /**

     * Secuencia de cerrado de Andami

     */

    public static void closeApplication() {

        //Configuraci?n de Andami

        try {

            andamiConfigToXML(andamiConfigPath);

        } catch (MarshalException e) {

            logger.error("No se pudo guardar la configuraci?n de Andami", e);

        } catch (ValidationException e) {

            logger.error("No se pudo guardar la configuraci?n de Andami", e);

        } catch (IOException e) {

            logger.error("No se pudo guardar la configuraci?n de Andami", e);

        }

        //Persistencia de los plugins

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

            }

        }

        try {

            persistenceToXML(entity);

        } catch (ConfigurationException e1) {

            logger.error("Se produjo un error guardando la configuraci?n de los plugins",

                e1);

        }

        System.exit(0);

    }

    /**

     * DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     */

    static HashMap getClassesExtensions() {

        return classesExtensions;

    }

    /**

     * DOCUMENT ME!

     *

     * @author $author$

     * @version $Revision: 665 $

     */

    public static class ExtensionComparator implements Comparator {

        /**

         * DOCUMENT ME!

         *

         * @param o1 DOCUMENT ME!

         * @param o2 DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         */

        public int compare(Object o1, Object o2) {

            Extension e1 = (Extension) o1;

            Extension e2 = (Extension) o2;

            if (!e1.hasPriority() && !e2.hasPriority()) {

                return -1;

            }

            if (e1.hasPriority() && !e2.hasPriority()) {

                return -Integer.MAX_VALUE;

            }

            if (e2.hasPriority() && !e1.hasPriority()) {

                return Integer.MAX_VALUE;

            }

            return e1.getPriority() - e2.getPriority();

        }

    }

    /**

     * DOCUMENT ME!

     */

    public static class MenuComparator implements Comparator {

        private static ExtensionComparator extComp = new ExtensionComparator();

        /**

         * DOCUMENT ME!

         *

         * @param o1 DOCUMENT ME!

         * @param o2 DOCUMENT ME!

         *

         * @return DOCUMENT ME!

         */

        public int compare(Object o1, Object o2) {

            SortableMenu e1 = (SortableMenu) o1;

            SortableMenu e2 = (SortableMenu) o2;

            if (!e1.menu.hasPosition() && !e2.menu.hasPosition()) {

                if (e1.extension instanceof SkinExtensionType) {

                    return 1;

                } else if (e2.extension instanceof SkinExtensionType) {

                    return -1;

                } else {

                    return extComp.compare(e1.extension, e2.extension);

                }

            }

            if (e1.menu.hasPosition() && !e2.menu.hasPosition()) {

                return -Integer.MAX_VALUE;

            }

            if (e2.menu.hasPosition() && !e1.menu.hasPosition()) {

                return Integer.MAX_VALUE;

            }

            return e1.menu.getPosition() - e2.menu.getPosition();

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @author $author$

     * @version $Revision: 665 $

     */

    public static class SortableMenu {

        public Menu menu;

        public SkinExtensionType extension;

        /**

         * DOCUMENT ME!

         *

         * @param skinExt

         * @param menu2

         */

        public SortableMenu(SkinExtensionType skinExt, Menu menu2) {

            extension = skinExt;

            menu = menu2;

        }

    }

}