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

import java.awt.KeyEventDispatcher;

import java.awt.Toolkit;

import java.awt.datatransfer.DataFlavor;

import java.awt.datatransfer.StringSelection;

import java.awt.datatransfer.UnsupportedFlavorException;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.util.HashMap;

import java.util.Iterator;

import javax.swing.KeyStroke;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import org.apache.log4j.Logger;

import com.iver.andami.authentication.IAuthentication;

import com.iver.andami.messages.Messages;

import com.iver.andami.messages.NotificationManager;

import com.iver.andami.plugins.ExtensionDecorator;

import com.iver.andami.plugins.IExtension;

import com.iver.andami.plugins.PluginClassLoader;

import com.iver.andami.preferences.DlgPreferences;

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

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

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

import com.iver.utiles.XMLEntity;

import com.iver.utiles.swing.threads.IMonitorableTask;

import com.iver.utiles.swing.threads.IProgressMonitorIF;

import com.iver.utiles.swing.threads.TaskMonitorTimerListener;

import com.iver.utiles.swing.threads.UndefinedProgressMonitor;

/**

 * Clase que proporciona servicios a los plugins.

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class PluginServices {

        private static Logger logger = Logger.getLogger(PluginServices.class

                        .getName());

        private static String[] arguments;

        private static IAuthentication authentication;

        private static IExtension exclusiveUIExtension = null;

        private PluginClassLoader loader;

        private XMLEntity persistentXML;

        /**

         * Crea un nuevo PluginServices

         *

         * @param loader

         *            ClassLoader del plugin

         */

        public PluginServices(PluginClassLoader loader) {

                this.loader = loader;

        }

        /**

         * Devuelve el mensaje en el idioma del locale actual del texto

         * correspondiente a la clave que se pasa como par?metro

         *

         * @param key

         *            Clave del texto que se quiere obtener

         *

         * @return Texto en el idioma que toca o la propia clave si no se encuentra

         *         en el fichero

         */

        public String getText(String key) {

                if (key == null) return null;

                String translation = org.gvsig.i18n.Messages.getText(key, false);

                if (translation != null)

                        return translation;

                else

                {

                        logger.warn("Plugin "+getPluginName()+" -- "+org.gvsig.i18n.Messages.getText("No_se_encontro_la_traduccion_para", false)+ " " + key);

                        return key;

                }

        }

        /**

         * Obtiene el classloader del plugin

         *

         * @return Returns the loader.

         */

        public PluginClassLoader getClassLoader() {

                return loader;

        }

        /**

         * Obtiene el nombre del plugin

         *

         * @return String

         */

        String getPluginName() {

                return loader.getPluginName();

        }

        /**

         * Obtienen una referencia al PluginServices del plugin cuyo nombre se pasa

         * como par?metro

         *

         * @param pluginClassInstance

         *            Instancia de una clase propia del plugin a cuyos servicios se

         *            quiere acceder

         *

         * @return Objeto PluginServices asociado al plugin

         *

         * @throws RuntimeException

         *             Si el par?metro no es un objeto cargado desde un plugin

         */

        public static PluginServices getPluginServices(Object pluginClassInstance) {

                try {

                        PluginClassLoader loader = (PluginClassLoader) pluginClassInstance

                                        .getClass().getClassLoader();

                        return Launcher.getPluginServices(loader.getPluginName());

                } catch (ClassCastException e) {

                        /*

                         * throw new RuntimeException( "Parameter is not a plugin class

                         * instance");

                         */

                        return null;

                }

        }

        /**

         * Obtienen una referencia al PluginServices del plugin cuyo nombre se pasa

         * como par?metro

         *

         * @param pluginName

         *            Instancia de una clase propia del plugin a cuyos servicios se

         *            quiere acceder

         *

         * @return Objeto PluginServices asociado al plugin

         */

        public static PluginServices getPluginServices(String pluginName) {

                return Launcher.getPluginServices(pluginName);

        }

        /**

         * Obtiene una referencia al gestor de ventanas

         *

         * @return MDIManager

         */

        public static MDIManager getMDIManager() {

                return Launcher.getFrame().getMDIManager();

        }

        /**

         * Obtiene una referencia al marco principal de la aplicaci?n

         *

         * @return MainFrame

         */

        public static MainFrame getMainFrame() {

                return Launcher.getFrame();

        }

        public static void registerKeyStroke(KeyStroke key, KeyEventDispatcher a)

        {

                GlobalKeyEventDispatcher.getInstance().registerKeyStroke(key, a);

        }

        public static void unRegisterKeyStroke(KeyStroke key)

        {

                GlobalKeyEventDispatcher.getInstance().removeKeyStrokeBinding(key);

        }

        /**

         * Obtiene una referencia a la instancia de la extensi?n cuya clase se pasa

         * como par?metro

         *

         * @param extensionClass

         *            Clase de la extensi?n cuya instancia se quiere obtener

         *

         * @return Instancia de la extensi?n o null en caso de que no haya una

         *         extensi?n con esa clase

         */

        public static IExtension getExtension(Class extensionClass) {

                ExtensionDecorator extAux = (ExtensionDecorator) Launcher

                                .getClassesExtensions().get(extensionClass);

                return extAux.getExtension();

                // return (Extension)

                // Launcher.getClassesExtensions().get(extensionClass);

        }

        /**

         * Gets a reference to the Extension Decorator with support for several more

         * options

         *

         * @param extensionClass

         * @return

         */

        public static ExtensionDecorator getDecoratedExtension(Class extensionClass) {

                return (ExtensionDecorator) Launcher.getClassesExtensions().get(

                                extensionClass);

        }

        /**

         * Returns an array containing references to all the loaded extensions.

         * @return ExtensionDecorator[]

         */

        public static ExtensionDecorator[] getDecoratedExtensions() {

                HashMap map = Launcher.getClassesExtensions();

                ExtensionDecorator[] extensions = (ExtensionDecorator[]) map.

                                values().toArray(new ExtensionDecorator[0]);

                return extensions;

        }

        /**

         * Obtiene un iterador sobre las extensiones

         *

         * @return Iterator

         */

        public static Iterator getExtensions() {

                return Launcher.getClassesExtensions().values().iterator();

        }

        /**

         * Obtiene una traducci?n de un plugin

         *

         * @param pluginObject

         *            Objeto cargado desde un plugin

         * @param key

         *            Nombre de la clave cuyo valor se quiere obtener

         *

         * @return El valor, si existe. La clave si no existe. Si el objeto que se

         *         pasa como par?metro no ha sido cargado desde un plugin se

         *         devuelve la clave.

         */

        public static String getText(Object pluginObject, String key) {

                if (key == null) return null;

                String translation = org.gvsig.i18n.Messages.getText(key, false);

                if (translation != null)

                        return translation;

                else

                {

                        logger.warn(org.gvsig.i18n.Messages.getText("No_se_encontro_la_traduccion_para",false) + " "+ key);

                        return key;

                }

        }

        /**

         * Establece los datos del plugin que deber?n persistir entre ejecuciones en

         * formato xml

         *

         * @param entity

         *            DOCUMENT ME!

         */

        public void setPersistentXML(XMLEntity entity) {

                persistentXML = entity;

        }

        /**

         * Obtiene un objeto que representa la persistencia del plugin en formato

         * xml.

         *

         * @return Devuelve null hasta que se invoca el m?todo setPersistentXML

         */

        public XMLEntity getPersistentXML() {

                if (persistentXML == null) {

                        persistentXML = new XMLEntity();

                }

                return persistentXML;

        }

        /**

         * A?ade un listener a un popup menu registrado en el config.xml de alg?n

         * plugin

         *

         * @param name

         *            Nombre del men? contextual

         * @param c

         *            Componente que desplegar? el men? cuando se haga click con el

         *            bot?n derecho

         * @param listener

         *            Listener que se ejecutar? cuando se seleccione cualquier

         *            entrada del men?

         *

         * @throws RuntimeException

         *             Si la interfaz no est? preparada todav?a. S?lo puede darse

         *             durante el arranque

         */

        public void addPopupMenuListener(String name, Component c,

                        ActionListener listener) {

                MDIFrame frame = Launcher.getFrame();

                if (frame == null) {

                        throw new RuntimeException("MDIFrame not loaded yet");

                }

                frame.addPopupMenuListener(name, c, listener, loader);

        }

        /**

         * Obtiene una referencia al directorio del plugin

         *

         * @return File

         */

        public File getPluginDirectory() {

                return new File(Launcher.getPluginsDir() + File.separator

                                + getPluginName());

        }

        /**

         * Ejecuta una tarea en segundo plano, dejando a la interfaz responder pero

         * inhibiendo los eventos

         *

         * @param r

         *            Tarea a ejecutar

         *

         * @return Thread en el que se ejecuta la tarea

         */

        public static Thread backgroundExecution(Runnable r) {

                Thread t = new Thread(new RunnableDecorator(r));

                t.start();

                return t;

        }

        /**

         * Runs a task in background. This task could be monitored and canceled, and

         * doesnt inhibed any event.

         *

         * @param task

         *            IMonitorableTask

         */

        public static void cancelableBackgroundExecution(final IMonitorableTask task) {

                final com.iver.utiles.swing.threads.SwingWorker worker = new com.iver.utiles.swing.threads.SwingWorker() {

                        public Object construct() {

                                try {

                                        task.run();

                                        return task;

                                } catch (Exception e) {

                                        NotificationManager.addError(null, e);

                                }

                                return null;

                        }

                };

                Component mainFrame = (Component) PluginServices.getMainFrame();

                IProgressMonitorIF progressMonitor = null;

                String title = getText(null, "PluginServices.Procesando");

                progressMonitor = new UndefinedProgressMonitor((Frame) mainFrame, title);

                progressMonitor.setIndeterminated(!task.isDefined());

                progressMonitor.setInitialStep(task.getInitialStep());

                progressMonitor.setLastStep(task.getFinishStep());

                progressMonitor.setCurrentStep(task.getCurrentStep());

                progressMonitor.setMainTitleLabel(task.getStatusMessage());

                progressMonitor.setNote(task.getNote());

                progressMonitor.open();

                int delay = 500;

                TaskMonitorTimerListener timerListener = new TaskMonitorTimerListener(

                                progressMonitor, task);

                Timer timer = new Timer(delay, timerListener);

                timerListener.setTimer(timer);

                timer.start();

                worker.start();

        }

        public static void closeApplication() {

                Launcher.closeApplication();

        }

        /**

         * DOCUMENT ME!

         *

         * @author Fernando Gonz?lez Cort?s

         */

        private static class RunnableDecorator implements Runnable {

                private Runnable r;

                /**

                 * Crea un nuevo RunnableDecorator.

                 *

                 * @param r

                 *            DOCUMENT ME!

                 */

                public RunnableDecorator(Runnable r) {

                        this.r = r;

                }

                /**

                 * @see java.lang.Runnable#run()

                 */

                public void run() {

                        /*

                         * try { SwingUtilities.invokeAndWait(new Runnable() { public void

                         * run() { getMDIManager().setWaitCursor(); } }); } catch

                         * (InterruptedException e) {

                         * NotificationManager.addWarning(Messages.getString("PluginServices.No_se_pudo_poner_el_reloj_de_arena"),

                         * e); } catch (InvocationTargetException e) {

                         * NotificationManager.addWarning(Messages.getString("PluginServices.No_se_pudo_poner_el_reloj_de_arena"),

                         * e); }

                         */

                        try {

                                SwingUtilities.invokeAndWait(new Runnable() {

                                        public void run() {

                                                try {

                                                        r.run();

                                                } catch (RuntimeException e) {

                                                        NotificationManager

                                                                        .addError(

                                                                                        Messages

                                                                                                        .getString("PluginServices.Bug_en_el_codigo"),

                                                                                        e);

                                                } catch (Error e) {

                                                        NotificationManager

                                                                        .addError(

                                                                                        Messages

                                                                                                        .getString("PluginServices.Error_grave_de_la_aplicaci?n"),

                                                                                        e);

                                                }

                                        }

                                });

                        } catch (InterruptedException e) {

                                NotificationManager

                                                .addWarning(

                                                                Messages

                                                                                .getString("PluginServices.No_se_pudo_poner_el_reloj_de_arena"),

                                                                e);

                        } catch (InvocationTargetException e) {

                                NotificationManager

                                                .addWarning(

                                                                Messages

                                                                                .getString("PluginServices.No_se_pudo_poner_el_reloj_de_arena"),

                                                                e);

                        }

                        /*

                         * try { SwingUtilities.invokeAndWait(new Runnable() { public void

                         * run() { getMDIManager().restoreCursor(); } }); } catch

                         * (InterruptedException e) {

                         * NotificationManager.addWarning(Messages.getString("PluginServices.No_se_pudo_restaurar_el_cursor_del_raton"),

                         * e); } catch (InvocationTargetException e) {

                         * NotificationManager.addWarning(Messages.getString("PluginServices.No_se_pudo_restaurar_el_cursor_del_raton"),

                         * e); }

                         */

                }

        }

        /**

         * Usually appName plugins-directory [locale] [other args]

         *

         * @return the original arguments that Andami received. (app-name

         *         plugins-directory, locale, etc)

         */

        public static String[] getArguments() {

                return arguments;

        }

        public static void setArguments(String[] arguments) {

                PluginServices.arguments = arguments;

        }

        /**

         * Return the value of a command line named argument.

         *<br>

         *<br>

         * The argument format is:

         *<br>

         * -{argumentName}={argumentValue}

         *<br>

         *<br>

         *example:

         * <br>

         * ' -language=en '

         * @return String value

         */

        public static String getArgumentByName(String name) {

        for (int i=2; i < PluginServices.arguments.length; i++)

        {

                int index = PluginServices.arguments[i].indexOf(name +"=");

                if (index != -1)

                        return PluginServices.arguments[i].substring(index+name.length()+1);

        }

        return null;

        }

        public static Logger getLogger() {

                return logger;

        }

        public static IAuthentication getAuthentication() {

                return authentication;

        }

        public static void setAuthentication(IAuthentication authen) {

                authentication = authen;

        }

        public static DlgPreferences getDlgPreferences() {

                return DlgPreferences.getInstance();

        }

        public static void putInClipboard(String data) {

                StringSelection ss = new StringSelection(data);

                Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss,ss);

        }

        public static String getFromClipboard() {

                 try {

                        return (String)Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null).getTransferData(DataFlavor.stringFlavor);

                } catch (UnsupportedFlavorException e) {

                        return null;

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        return null;

                }

        }

        /**

         * Gets the extesion that have to take the control

         *  of the state of action controls of the UI of all extensions.

         * <br>

         * <br>

         * -exclusiveUI={pathToExtensionClass}

         * <br>

         *  @see com.iver.andami.Launcher#initializeExclusiveUIExtension()

         *  @see com.iver.andami.plugins.IExtension#isEnabled(IExtension extension)

         *  @see com.iver.andami.plugins.IExtension#isVisible(IExtension extension)

         */

        public static IExtension getExclusiveUIExtension() {

                return PluginServices.exclusiveUIExtension;

        }

        public static void setExclusiveUIExtension(IExtension extension) {

                PluginServices.exclusiveUIExtension = extension;

        }

}