Application: gvSIG desktop

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

 * the terms of the GNU General Public License as published by the Free Software

 * Foundation; either version 3 of the License, or (at your option) any later

 * version.

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

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

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

 * this program; if not, write to the Free Software Foundation, Inc., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

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

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

        public abstract String[] getAliases(Item item);

        public boolean isAlias(String key) {

            return aliases.get(key) != null;

        }

        public String getMainKey(String key) {

            Item item = super.get(key);

            if (item != null) {

                return key;

            }

            String alias = aliases.get(key);

            if (alias != null) {

                return alias;

            }

            return null;

        }

        public Item get(Object key) {

            Item item = super.get(key);

            if (item != null) {

                return item;

            }

            String alias = aliases.get(key);

            if (alias != null) {

                return super.get(alias);

            }

            return null;

        }

        public boolean containsKey(Object key) {

            boolean contains = super.containsKey(key);

            if (contains) {

                return true;

            }

            String alias = aliases.get(key);

            return super.containsKey(alias);

        }

        public Item put(String key, Item value) {

            super.put(key, value);

            String[] aliases = getAliases(value);

            if (aliases == null) {

                return value;

            }

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

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

            }

            return value;

        }

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

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

            while (it.hasNext()) {

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

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

            }

        }

        public Item remove(Object key) {

            Item item = super.get(key);

            if (item == null) {

                String alias = aliases.get(key);

                if (alias == null) {

                    return null;

                }

                item = super.get(alias);

                super.remove(alias);

            } else {

                super.remove(key);

            }

            String[] aliases = getAliases(item);

            if (aliases == null) {

                return item;

            }

            // Rebuild the alias list

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

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

            while (it.hasNext()) {

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

                aliases = getAliases(entry.getValue());

                if (aliases == null) {

                    continue;

                }

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

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

                }

            }

            return item;

        }

    }

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

        public String[] getAliases(

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

            return getAlternativeNames(item);

        }

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

            AlternativeNames[] x = item.getAlternativeNames();

            if (x == null) {

                return null;

            }

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

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

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

            }

            return r;

        }

    }

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

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

            return item.getAlternativeNames();

        }

    }

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

            .getName());

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

            "gvsig.connection");

    protected static AndamiConfig andamiConfig;

    protected static MultiSplashWindow splashWindow;

    protected static String appName;

    protected static Locale locale;

    protected static PluginsConfig pluginsConfig = new PluginsConfig();

    protected static PluginsServices pluginsServices = new PluginsServices();

    protected static MDIFrame frame;

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

    protected static String andamiConfigPath;

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

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

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

    protected static String appHomeDir = null;

    // it seems castor uses this encoding

    protected static final String CASTORENCODING = "UTF8";

    protected static ListBaseException launcherrors = null;

    protected static Theme theme = null;

    private List<String> deprecatedPluginNames = null;

    private static final class ProxyAuth extends Authenticator {

        private PasswordAuthentication auth;

        private ProxyAuth(String user, String pass) {

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

        }

        protected PasswordAuthentication getPasswordAuthentication() {

            return auth;

        }

    }

    private static Launcher launcherInstance;

    public static Launcher getInstance() {

        if (launcherInstance == null) {

            launcherInstance = new Launcher();

        }

        return launcherInstance;

    }

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

        Launcher launcher = getInstance();

        boolean install = false;

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

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

                install = true;

            }

        }

        try {

            if (install) {

                launcher.doInstall(args);

            } else {

                launcher.doMain(args);

            }

        } catch (Exception e) {

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

            System.exit(-1);

        }

    }

    protected void downloadExtensions(String extDir) {

        // do nothing

    }

    public static class LaunchException extends ListBaseException {

        private static final long serialVersionUID = 4541192746962684705L;

        public LaunchException() {

            super("Errors in initialization of application.",

                    "_errors_in_initialization_of_application",

                    serialVersionUID);

        }

    }

    protected void addError(Throwable ex) {

        if (launcherrors == null) {

            launcherrors = new LaunchException();

        }

        launcherrors.add(ex);

    }

    protected void addError(String msg, Throwable cause) {

        logger.error(msg, cause);

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

    }

    protected void addError(String msg) {

        this.addError(msg, null);

    }

    private String translate(String msg) {

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

    }

    private List<String> getDeprecatedPluginNames() {

        if (deprecatedPluginNames == null) {

            String[] ss = new String[]{

                "org.gvsig.app",

                "org.gvsig.coreplugin",

                "org.gvsig.editing",

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

                "org.gvsig.exportto.app.extension"

            };

            deprecatedPluginNames = Arrays.asList(ss);

        }

        return deprecatedPluginNames;

    }

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

        if (args.length < 1) {

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

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

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

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

        }

        initializeApp(args, null);

        // Web Start con este codigo.

        // System.setSecurityManager(null);

        Policy.setPolicy(new Policy() {

            public PermissionCollection getPermissions(CodeSource codesource) {

                Permissions perms = new Permissions();

                perms.add(new AllPermission());

                return (perms);

            }

            public void refresh() {

            }

        });

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

        try {

            initIconThemes();

        } catch (Exception ex) {

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

        }

        // Registramos los iconos base

        try {

            registerIcons();

        } catch (Exception ex) {

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

        }

        // Obtener la personalizaci�n de la aplicacion.

        try {

            logger.info("Initialize andami theme");

            theme = getTheme(andamiConfig.getPluginsDirectory());

        } catch (Exception ex) {

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

                    ex);

        }

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

        // Mostrar la ventana de inicio

        Frame f = new Frame();

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

        // Ponemos los datos del proxy

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

        logger.info("Configute http proxy");

        configureProxy();

        // Buscar actualizaciones de los plugins

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

        try {

        } catch (Exception ex) {

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

        }

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

        initializeInstallerManager();

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

        PackageInfo[] installedPackages = null;

        try {

            installedPackages = installerManager.getInstalledPackages();

        } catch (MakePluginPackageServiceException e) {

            // Do nothing, ignore errors

        }

        logger.info("Dump system information");

        logger_info(getInformation(installedPackages));

        saveEnvironInformation(installedPackages);

        // Se leen los config.xml de los plugins

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

        try {

            logger.info("Load plugins information");

            this.loadPluginConfigs();

            if (pluginsConfig.isEmpty()) {

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

                System.exit(-1);

            }

        } catch (Throwable ex) {

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

        }

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

        fixIncompatiblePlugins(installedPackages);

        // Se configura el classloader del plugin

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

        try {

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

            this.loadPluginServices();

        } catch (Throwable ex) {

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

        }

        try {

            registerActions();

        } catch (Throwable ex) {

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

        }

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

        // Initialize libraries

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

        initializeLibraries();

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

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

        logger.info("Initialize skin");

        skinPlugin(null);

        // Se configura la cola de eventos

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

        EventQueue waitQueue = new AndamiEventQueue();

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

        // Se configura la internacionalizacion del plugin

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

        pluginsMessages();

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

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

        updateAndamiConfig();

        frame = MDIFrame.getInstance();

        // Se configura el nombre e icono de la aplicacion

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

        frameIcon(theme);

        // Se prepara el MainFrame para albergar las extensiones

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

        JPopupMenu.setDefaultLightWeightPopupEnabled(false);

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                frame.init();

            }

        });

        ToolsSwingLocator.registerWindowManager(ToolsWindowManager.class);

        // Leer el fichero de persistencia de los plugins

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

        loadPluginsPersistence();

        // Se inicializan todas las extensiones de todos los plugins

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

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                initializeExtensions();

            }

        });

        // Se inicializan la extension exclusiva

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

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                initializeExclusiveUIExtension();

            }

        });

        frame.setClassesExtensions(classesExtensions);

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

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

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                installPluginsControls();

            }

        });

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

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

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                installPluginsMenus();

            }

        });

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

        ServerDataPersistence.registerPersistence();

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

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

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                installPluginsLabels();

            }

        });

        // Se muestra el frame principal

        message(translate("creating_main_window"));

        frame.setVisible(true);

        frame.setCursor(Cursor.WAIT_CURSOR);

        // puedan registrar sus "teclas rapidas".

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

        GlobalKeyEventDispatcher keyDispatcher = GlobalKeyEventDispatcher.getInstance();

        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(keyDispatcher);

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

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                try {

                    frame.enableControls();

                } catch (Throwable th) {

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

                }

            }

        });

        // Se ejecuta el postInitialize

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

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                postInitializeExtensions();

            }

        });

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

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                try {

                    frame.enableControls();

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

                } catch (Throwable th) {

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

                }

            }

        });

        splashWindow.close();

        frame.setCursor(Cursor.DEFAULT_CURSOR);

        if (launcherrors != null) {

            NotificationManager.addError(launcherrors);

        }

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

                new NotificationAppender());

        /*

         * Executes additional tasks required by plugins

         */

        PluginsLocator.getManager().executeStartupTasks();

    }

    private void initializeInstallerManager() {

        PluginsManager pluginmgr = PluginsLocator.getManager();

        InstallerManager installerManager = InstallerLocator.getInstallerManager();

        // Configure repository of plugins

        //

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

        for (File folder : folders) {

            installerManager.addLocalAddonRepository(folder, "plugin");

        }

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

        // Configure repository of iconsets

        //

        IconThemeManager iconManager = ToolsSwingLocator.getIconThemeManager();

        FolderSet fset = iconManager.getRepository();

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

        boolean first = true;

        while (it.hasNext()) {

            FolderEntry entry = it.next();

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

            if (first) {

                first = false;

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

        }

    }

    private void message(final String msg) {

        if (!SwingUtilities.isEventDispatchThread()) {

            try {

                SwingUtilities.invokeAndWait(new Runnable() {

                    public void run() {

                        message(msg);

                });

            } catch (Exception e) {

                logger.info(msg);

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

            return;

        if (splashWindow.isVisible()) {

            splashWindow.process(msg);

        }

        if (frame.isVisible()) {

            frame.message(msg, JOptionPane.INFORMATION_MESSAGE);

        }

    }

    private void initializeLibraries() {

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

                pluginsOrdered.size() + 1);

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

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

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

        while (iter.hasNext()) {

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

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

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

            classLoaders.add(ps.getClassLoader());

        }

        // initialize the plugin libraries

        new DefaultLibrariesInitializer(classLoaders

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

                .fullInitialize(true);

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

        classLoaders.clear();

        classLoaders = null;

    }

    /**

     * @param args

     * @throws IOException

     * @throws ConfigurationException

     */

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

        if (args.length < 1) {

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

        } else {

            appName = args[0];

        }

        getOrCreateConfigFolder();

        configureLogging(appName, applicationClasifier);

        if (!validJVM()) {

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

            System.exit(-1);

        }

        // Clean temporal files

        Utilities.cleanUpTempFiles();

        if (args.length < 2) {

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

        } else {

            loadAndamiConfig(args[1]);

        }

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

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

        PluginServices.setArguments(args);

        configureLocales(args);

        logger.info("Configure LookAndFeel");

        configureLookAndFeel();

    }

    /**

    private void configureLookAndFeel() {

        // Se pone el lookAndFeel

        try {

            String lookAndFeel = getAndamiConfig().getLookAndFeel();

            if (lookAndFeel == null) {

                lookAndFeel = getDefaultLookAndFeel();

            }

            UIManager.setLookAndFeel(lookAndFeel);

        } catch (Exception e) {

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

        }

        FontUtils.initFonts();

    }

    /**

     * @param args

     * @throws ConfigurationException

     */

    private void loadAndamiConfig(String pluginFolder)

            throws ConfigurationException {

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

        andamiConfigFromXML(andamiConfigPath);

        andamiConfig.setPluginsDirectory(pluginFolder);

    }

    /**

    private void getOrCreateConfigFolder() {

        // Create application configuration folder

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

        if (appHomeDir == null) {

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

        }

        appHomeDir += File.separator + appName;

        File parent = new File(appHomeDir);

        parent.mkdirs();

    }

    /**

     * @param args

     * @throws IOException

     */

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

        // Configurar el log4j

        String pathname;

        if (StringUtils.isBlank(applicationClasifier)) {

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

        } else {

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

        }

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

        if (config == null) {

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

        }

        PropertyConfigurator.configure(config);

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

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

        fa.setMaxFileSize("512KB");

        fa.setMaxBackupIndex(3);

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

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

        if (StringUtils.isBlank(applicationClasifier)) {

            logger.info("Application " + appName);

        } else {

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

        }

    }

    private class NotificationAppender extends AppenderSkeleton {

        @Override

        protected void append(LoggingEvent event) {

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

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

                Throwable th = null;

                ThrowableInformation thi = event.getThrowableInformation();

                if (thi != null) {

                    th = thi.getThrowable();

                }

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

                return;

            }

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

            // null);

            // return;

            // }

        }

        @Override

        public void close() {

            // TODO Auto-generated method stub

        }

        @Override

        public boolean requiresLayout() {

            // TODO Auto-generated method stub

            return false;

        }

    }

    /**

     * Return the directory applicaction is installed.

     */

    public static String getApplicationDirectory() {

        return getApplicationFolder().getAbsolutePath();

    }

    private void registerIcons() {

        IconTheme theme = PluginServices.getIconTheme();

        ClassLoader loader = Launcher.class.getClassLoader();

        String[][] icons = {

            // MultiSplashWindow

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

            // NewStatusBar

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

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

            {"main", "statusbar-error"}

        };

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

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

            } catch (Exception e) {

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

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

    }

    private Properties loadProperties(File f) {

        FileInputStream fin = null;

        Properties p = null;

        try {

            fin = new FileInputStream(f);

            p = new Properties();

            p.load(fin);