Guia del Desarrollador de LibreOffice


Guía del desarrollador de LibreOffice/Openoffice.org

Desarrollo de Office

  • Entorno de aplicación de LibreOffice/Openoffice.org
    • Entorno de escritorio
    • Framework API
      • Paradigma Marco-Controlador-Modelo en LibreOffice/Openoffice.org
      • Marcos (Frames)
      • Controladores
      • Ventanas
      • Marco de Despacho (Dispatch Framework)
    • Uso del escritorio
    • Uso del Marco de Componentes (Component Framework)
      • Obtención de Marcos, Controladores y Modelos entre sí
      • Marcos (Frames)
      • Controladores
      • Modelos
      • Interfaces de ventana
    • Creación de Marcos manualmente
    • Manejo de documentos
      • Cargando Documentos
      • Cerrando Documentos
      • Almacenar Documentos
    • Uso del Marco de Despacho (Dispatch Framework)
      • Comando URL (Uniform Resource Locator)
      • Cadena de Procesamiento
      • Procesos de Despacho
      • Resultados de Despacho
      • Interceptación de Despachos
    • Integración de ventanas Java
  • Características comunes de la aplicación

Entorno de aplicación de LibreOffice/Openoffice.org

El entorno de aplicación de LibreOffice/Openoffice.org se compone del entorno de escritorio y de la API de framework.
El entorno de aplicaciones de OpenOffice.org

El entorno de escritorio consiste en el servicio de escritorio y los objetos auxiliares. Las funciones del entorno de escritorio son llevadas a cabo por la API del framework. El framework API tiene dos partes: el framework de componentes y el framework de expedición. El Marco (Frame) de componentes sigue un paradigma especial de Frame-Controller-Model para gestionar componentes visibles en LibreOffice/Openoffice.org. El Marco (Frame) de Despacho gestiona las solicitudes de comandos enviadas por la GUI.

Entorno de escritorio

El servicio com.sun.star.frame.Desktop es la instancia de administración central del framework de aplicaciones de LibreOffice/Openoffice.org. Todas las ventanas de la aplicación de LibreOffice/Openoffice.org están organizadas en una jerarquía de Marcos que contienen componentes visibles.
El escritorio es el Marco (Frame) raíz de esta jerarquía. Desde el escritorio puede cargar componentes visibles, Marcos (frame) de acceso y componentes, terminar Office, recorrer la jerarquía de Marcos y enviar solicitudes de comandos.
El nombre de este servicio se origina en StarOffice 5.x, donde todas las ventanas de documentos se incrustaron en una ventana de aplicación común que fue ocupada por el escritorio de StarOffice, reflejando el escritorio de Windows.
El Marco (Frame) raíz de esta jerarquía se llamó Marco (Frame) de escritorio. El nombre de este servicio y el nombre de la interfaz com.sun.star.frame.XDesktop se mantuvieron por razones de compatibilidad.
El objeto de escritorio y los objetos de Marco (frame) utilizan servicios auxiliares, como el servicio com.sun.star.document.TypeDetection y otras implementaciones opacas que interactúan con  Office basada en UNO, pero no son accesibles a través de la API de LibreOffice/Openoffice.org. Ejemplos de estos últimos son el manejo de eventos de documentos globales y su interfaz de usuario (Herramientas> Personalizar> Eventos) y las barras de menú que utilizan la API de despacho sin ser los propios servicios de UNO. El servicio de escritorio, junto con estos objetos circundantes, se llama el entorno de escritorio (desktop environment).
El Escritorio termina SOffice y administra componentes y Marcos
Los componentes visibles administrados por el escritorio pueden ser tres tipos diferentes de objetos:
  • Documentos de Office completos con un modelo de documento y controladores.
  • Componentes con un controlador pero sin modelo, como la bibliografía, y
  • El navegador de bases de datos o ventanas sencillas sin Controladores de API habilitada, por ejemplo, ventanas de vista previa.
La similitud entre estos tipos de componentes es la interfaz com.sun.star.lang.XComponent.
Los componentes con controladores también se llaman componentes de Office, mientras que los componentes de ventana simples se llaman componentes triviales.
Los Marcos (Frames) de la API de LibreOffice/Openoffice.org son el vínculo de conexión entre las ventanas, los componentes y el entorno de escritorio. La relación entre Marcos (frame) y componentes se analiza en la siguiente sección Framework API.
Como todos los demás servicios, el servicio com.sun.star.frame.Desktop puede ser intercambiado por otra implementación que amplíe la funcionalidad de LibreOffice/Openoffice.org. Al intercambiar el servicio de escritorio es posible utilizar diferentes tipos de ventanas o hacer que LibreOffice/Openoffice.org utilice MDI en lugar de SDI. Esto no es una cosa fácil de hacer, pero es posible sin cambiar ningún código en otras partes de LibreOffice/Openoffice.org.

Framework API

El framework API no define un Marco (frame) “todo en uno“ con interfaces fuertemente acopladas, sino que define Marcos (frames) especializados que se agrupan mediante la implementación de las interfaces relevantes en los componentes de LibreOffice/Openoffice.org. Cada Marco se concentra en un aspecto particular, de modo que cada componente decida los Marcos en los que desea participar.
En la actualidad, hay dos de estos Marcos:
  • El Marco de Componentes (component framework) que implementa el paradigma Marco-controlador-modelo, y
  • El Marco de Despacho (dispatch framework) que maneja las solicitudes de comandos desde y hacia el entorno de aplicación.
Las implementaciones de controlador y Marco forman el puente entre los dos Marcos, porque los controladores y Marcos implementan interfaces desde el Marco de componentes y el Marco de Despacho.
El framework API es una especificación abstracta. Su implementación actual utiliza el Kit de herramientas de ventana abstracta (AWT - Abstract Window Toolkit) especificado en com.sun.star.awt, que también es una especificación abstracta. La implementación actual del AWT es la Visual Component Library (VCL), un conjunto de herramientas multiplataforma para ventanas y controles escritos en C ++ creado antes de la especificación de com.sun.star.awt y adaptado para soportar com.sun.star.awt.

Uso del escritorio

Servicio de Escritorio (Desktop Service) y Marco de Componentes (Component Framework)
El servicio com.sun.star.frame.Desktop disponible en el gestor de servicios globales incluye el servicio com.sun.star.frame.Frame.
La especificación del servicio de escritorio proporciona tres interfaces:
como se muestra en el siguiente gráfico UML:
Descripción UML del servicio de escritorio
La interfaz com.sun.star.frame.XDesktop proporciona acceso a Marcos y componentes y controla la terminación del proceso de Office. Define los siguientes métodos:
 com::sun::star::frame::XFrame getCurrentFrame()
  com::sun::star::container::XEnumerationAccess getComponents()
  com::sun::star::lang::XComponent getCurrentComponent()
  boolean terminate()
  void addTerminateListener ( [in] com::sun::star::frame::XTerminateListener
xListener)
  void removeTerminateListener ( [in] com::sun::star::frame::XTerminateListener
xListener)
Los métodos getCurrentFrame() y getCurrentComponent() distribuyen el Marco activo y el modelo de documento, mientras que getComponents() devuelve un com.sun.star.container.XEnumerationAccess a todos los documentos cargados. Para los documentos cargados en el entorno de escritorio, los métodos getComponents() y getCurrentComponent() devuelven siempre la interfaz com.sun.star.lang.XComponent del modelo de documento.
🔵  Si se requiere un componente de documento específico, pero no está seguro de si este componente es el componente actual, use getComponents() para obtener una enumeración de todos los componentes del documento, compruebe cada uno por la existencia de la interfaz com.sun.star.frame.XModel y use getURL() en XModel para identificar su documento. Dado que no todos los componentes tienen que soportar XModel, pruebe XModel antes de llamar a getURL().
El proceso de Office normalmente termina cuando el usuario selecciona Archivo - Salir o después de cerrar la última ventana de la aplicación. Los clientes pueden terminar Office mediante una llamada a terminate() y agregar una escucha de terminación, para evitar el proceso de apagado. Mientras el arranque rápido de Windows esté activo, el archivo ejecutable de SOffice no se terminará.
El ejemplo siguiente muestra una implementación com.sun.star.frame.XTerminateListener que impide que se termine Office cuando la clase TerminationTest sigue activa:
 import com.sun.star.frame.TerminationVetoException;
  import com.sun.star.frame.XTerminateListener;
 public class TerminateListener implements XTerminateListener {
     public void notifyTermination (com.sun.star.lang.EventObject eventObject) {
          System.out.println("about to terminate...");
      }
     public void queryTermination (com.sun.star.lang.EventObject eventObject)
         throws TerminationVetoException {
         // test if we can terminate now
          if (TerminationTest.isAtWork()) {
              System.out.println("Terminate while we are at work? No way!");
              throw new TerminationVetoException() ; // this will veto the termination,
                                                // a call to terminate() returns false
          }
      }
     public void disposing (com.sun.star.lang.EventObject eventObject) {
      }
 }
La siguiente clase TerminationTest prueba el TerminateListener anterior.
anterior.
 import com.sun.star.bridge.XUnoUrlResolver;
  import com.sun.star.uno.UnoRuntime;
  import com.sun.star.uno.XComponentContext;
  import com.sun.star.lang.XMultiComponentFactory;
  import com.sun.star.beans.XPropertySet;
  import com.sun.star.beans.PropertyValue;
 import com.sun.star.frame.XDesktop;
  import com.sun.star.frame.TerminationVetoException;
  import com.sun.star.frame.XTerminateListener;
 public class TerminationTest extends java.lang.Object {
     private static boolean atWork = false;
     public static void main(String[] args) {
         XComponentContext xRemoteContext = null;
          XMultiComponentFactory xRemoteServiceManager = null;
          XDesktop xDesktop = null;
         try {
             // connect and retrieve a remote service manager and component context
              XComponentContext xLocalContext = com.sun.star.comp.helper.Bootstrap.
                                               createInitialComponentContext(null);
              XMultiComponentFactory xLocalServiceManager =
                                                 xLocalContext.getServiceManager();
              Object urlResolver = xLocalServiceManager.createInstanceWithContext(
                              "com.sun.star.bridge.UnoUrlResolver", xLocalContext );
              XUnoUrlResolver xUnoUrlResolver = (XUnoUrlResolver)
                    UnoRuntime.queryInterface( XUnoUrlResolver.class, urlResolver );
              Object initialObject = xUnoUrlResolver.resolve(
                 "uno:socket,host=localhost,port=2083;urp;StarOffice.ServiceManager" );
              XPropertySet xPropertySet = (XPropertySet)UnoRuntime.queryInterface(
                                                 XPropertySet.class, initialObject);
              Object context = xPropertySet.getPropertyValue("DefaultContext");
             xRemoteContext = (XComponentContext)UnoRuntime.queryInterface(
                                                   XComponentContext.class, context);
              xRemoteServiceManager = xRemoteContext.getServiceManager();
             // get Desktop instance
              Object desktop = xRemoteServiceManager.createInstanceWithContext (
                                        "com.sun.star.frame.Desktop", xRemoteContext);
              xDesktop = (XDesktop)UnoRuntime.queryInterface(XDesktop.class, desktop);

              TerminateListener terminateListener = new TerminateListener();
              xDesktop.addTerminateListener (terminateListener);
             // try to terminate while we are at work
              atWork = true;
              boolean terminated = xDesktop.terminate();
              System.out.println("The Office " +
            (terminated ? "has been terminated" : "is still running, we are at work"));
             // no longer at work
              atWork = false;
              // once more: try to terminate
             terminated = xDesktop.terminate();
              System.out.println("The Office " + (terminated ? "has been terminated" :
                                              "is still running. Someone else prevents
                                                termination, e.g. the quickstarter"));
          }
          catch (java.lang.Exception e){
              e.printStackTrace();
          }
          finally {
              System.exit(0);
          }
     }
      public static boolean isAtWork() {
          return atWork;
      }
 }
Cuando hay cambios sin guardar y se llama a terminate(), Office se estanca. Como solución, establezca todos los documentos en un estado de no modificado a través de su interfaz com.sun.star.util.XModifiable o guárdelos utilizando com.sun.star.frame.XStorable.
El Escritorio ofrece la posibilidad de cargar componentes a través de su interfaz com.sun.star.frame.XComponentLoader. Tiene un método:
com::sun::star::lang::XComponent loadComponentFromURL ( [in] string aURL,
                  [in] string aTargetFrameName,
                  [in] long nSearchFlags,
                  [in] sequence < com::sun::star::beans::PropertyValue aArgs > )
Consulte el capítulo Manejo de documentos para obtener detalles sobre el proceso de carga.
Para versiones más allá de 6.41, el escritorio también proporciona una interfaz que permite a los procesos que escuchan, ser notificados sobre ciertos eventos del documento a través de su interfaz com.sun.star.document.XEventBroadcaster.
 void addEventListener ( [in] com::sun::star::document::XEventListener
xListener)
  void removeEventListener ( [in] com::sun::star::document::XEventListener
xListener)
El XEventListener debe implementar un solo método (además de disposing()):
[oneway] void notifyEvent ( [in] com::sun::star::document::EventObject Event )
La estructura com.sun.star.document.EventObject tiene un miembro de cadena EventName que asume uno de los valores especificados en com.sun.star.document.Events. Los eventos correspondientes se encuentran en el tab Eventos del diálogo Herramientas - Configurar cuando se selecciona la opción LibreOffice/Openoffice.org.
El escritorio transmite estos eventos para todos los documentos cargados.
La versión actual de LibreOffice/Openoffice.org no tiene un elemento GUI como escritorio. El rediseño de la GUI de LibreOffice/Openoffice.org en StarOffice 5.x y posterior resultó en que la parte de servicio com.sun.star.frame.Frame del servicio de escritorio ya no es funcional. Aunque la interfaz XFrame todavía se puede consultar desde el escritorio, casi todos sus métodos son implementaciones ficticias.
La implementación por defecto del objeto de escritorio en LibreOffice/Openoffice.org no puede contener un componente y se niega a adjuntarlo, ya que el escritorio sigue siendo un Marco que es la raíz de la jerarquía común de todos los Marcos de LibreOffice/Openoffice.org. El escritorio tiene que ser un Marco porque su interfaz com.sun.star.frame.XFramesSupplier debe pasar a com.sun.star.frame.XFrame:setCreator() en los Marcos hijos, por lo tanto, el escritorio se convierte en el Marco padre. Sin embargo, la siguiente funcionalidad de com.sun.star.frame.Frame todavía está en su lugar:
La interfaz de escritorio com.sun.star.frame.XFramesSupplier ofrece métodos para acceder a Marcos. Esta interfaz hereda de com.sun.star.frame.XFrame, e introduce los siguientes métodos:
 com::sun::star::frame::XFrames getFrames()
  com::sun::star::frame::XFrame getActiveFrame()
  void setActiveFrame ( [in] com::sun::star::frame::XFrame xFrame)
El método getFrames() devuelve un contenedor com.sun.star.frame.XFrames, que es un com.sun.star.container.XIndexAccess, con métodos adicionales para agregar y quitar Marcos:
 void append ( [in] com::sun::star::frame::XFrame xFrame )
  sequence < com::sun::star::frame::XFrame > queryFrames([in] long nSearchFlags )
  void remove ( [in] com::sun::star::frame::XFrame xFrame )
Esta colección XFrames se utiliza cuando se agregan Marcos (frames) al escritorio para convertirse en ventanas de la aplicación.
A través de getActiveFrame(), se accede al sub-frame activo del Marco de escritorio, mientras que setActiveFrame() es llamado por un sub-frame para informar al escritorio acerca del sub-frame activo.
El objeto devuelto por getFrames() no admite XTypeProvider, por lo tanto, no se puede utilizar con LibreOffice/Openoffice.org Basic.
La interfaz principal de XFramesSupplier, com.sun.star.frame.XFrame es funcional al tener acceso a la jerarquía Frame debajo del escritorio. Estos métodos se analizan en la siguiente sección Marcos:
com::sun::star::frame::XFrame findFrame([in]string aTargetFrameName,
[in]long nSearchFlags );
boolean isTop();
La interfaz de Despacho genérica com.sun.star.frame.XDispatchProvider ejecuta funciones de la implementación interna de Escritorio que no son accesibles a través de interfaces especializadas. Las funciones de envío se describen mediante una URL de comando. El XDispatchProvider devuelve un objeto de despacho que distribuye una URL de comando dada. Una referencia de direcciones URL de comandos compatibles con el escritorio está disponible en LibreOffice/Openoffice. A través del com.sun.star.frame.XDispatchProviderInterception, el código de cliente intercepta los envíos de comando en el escritorio. El proceso de despacho se describe en la sección Utilización del Marco de Despacho (Dispatch Framework).

Uso del Marco de Componentes (Component Framework)

El Marco de Componentes (Component Framework) incluye las interfaces de Marcos (frames), controladores y modelos utilizados para administrar componentes en el entorno de escritorio de LibreOffice/Openoffice.org. En nuestro contexto, todo lo que "habita" en un Marco del entorno de escritorio se llama componente, porque la interfaz com.sun.star.lang.XComponent es el denominador común de los objetos que se cargan en Marcos (frames).
Marcos (Frames), controladores y modelos mantienen referencias entre sí. El Marco es, por definición, el propietario predeterminado del controlador y el modelo, es decir, es responsable de llamar a dispose() en el controlador y el modelo cuando se destruye por sí mismo. Otros objetos que deben contener referencias al Marco (frame), controlador o modelo deben registrarse como oyentes (procesos que escuchan) para ser informados cuando estas referencias resultan inválidas. Por lo tanto XModel, XController y XFrame heredan de XComponent:
 void dispose()
  void addEventListener ( [in] com::sun::star::lang::XEventListener xListener)
  void removeEventListener ( [in] com::sun::star::lang::XEventListener aListener)
El proceso para resolver las dependencias circulares del Marco de componentes es complejo. Por ejemplo, los objetos involucrados en el proceso pueden estar en una condición en la que no se pueden eliminar. Consulte la sección Cierre de documentos para obtener más detalles.
Teóricamente, cada objeto UNO podría existir en un Marco, siempre y cuando esté dispuesto a permitir que el Marco controle su existencia cuando termina.
Un componente trivial (sólo XWindow) es suficiente para fines de visualización sencilla, donde no es necesaria la activación de un componente y acciones relacionadas como el posicionamiento del cursor o las interacciones del usuario.
Si el componente participa en interacciones más complejas, debe implementar el servicio del controlador.
Muchas características del entorno de escritorio sólo están disponibles si se conoce la URL de un componente. Por ejemplo:
  • Presentando la URL o el título del documento.
  • Insertar el documento en la cola de autoguardado.
  • Evitar que el entorno de escritorio cargue documentos dos veces.
  • Permitir la participación en el manejo de eventos de documentos globales.
En este caso, com.sun.star.frame.XModel entra en funcionamiento, ya que tiene métodos para manejar URLs, entre otros.
Así que un componente completo de Office se compone de:

No hay comentarios:

Publicar un comentario

Gracias por participar

Suscribirse a: Entradas (Atom)

GIMP: Trabajando con Python en GIMP

Vamos a trabajar con python desde gimp, para esto vamos a abrir algun archivo XCF con imagenes. Luego abrir la consola en el menu Filtros -...