Programación java

1. Aplicaciones basadas en Eclipse Eclipse se originó como una aplicación de ámbito de desarrollo formado modular. En 2004 se lanzó la versión 3.0, la cual soportaba la reutilización de la plataforma Eclipse para desarrollar aplicaciones independientes basadas en la misma tecnología que el ámbito de desarrollo Eclipse. En este punto se acuñó el término Eclipse RCP. RCP implica "Rich Client Platform", e indica que se emplea la plataforma Eclipse para crear aplicaciones independientes con extensas prestaciones incluídas. Las aplicaciones Eclipse se construyen sobre una arquitectura de complementos ('plug-in'). Dichos complementos son componentes de software. Son los componentes más pequeños de Eclipse que pueden desplegarse e instalarse. Un 'plug-in' es una colección de ficheros y un fichero de configuración (MANIFEST.MF) que detalla dicho complemento y sus dependencias. Esta arquitectura de complementos faculta a las aplicaciones basadas en Eclipse el ser ampliadas por terceros. La plataforma Eclipse 4 extiende el concepto de aplicación basada en Eclipse con nuevas tecnologías, por ejemplo con la inyección de dependencias o los estilos declarativos mediante ficheros CSS. 1.2 Ventajas de las aplicaciones basadas en Eclipse La plataforma Eclipse es la fundamento del ámbito de desarrollo en Java más exitoso, y por tanto muy estable, así como ampliamente utilizado. Emplea componentes nativos para el interfaz de usuario tanto como sea posible, para recrear un apariencia y una experiencia de usuario característica; además, dado su enfoque fuertemente modular, faculta el diseño de sistemas basados en componentes. Empresas como IBM o Google emplean el marco de Eclipse en mayor medida yy, por tanto, aseguran que sea flexible, veloz y en constante evolución. La plataforma Eclipse, además, potencia la existencia de una mayor comunidad de individuos que ofrecen apoyo, información y extensiones a marco de Eclipse. El uso de este ecosistema le faculta descubrir los recursos y la información necesarios. 2. Eclipse 3.x frente a Eclipse 4.x A continuación se detalla cómo desarrollar aplicaciones de Eclipse RCP basándose en el modelo de programación de Eclipse 3.x. Eclipse 4 realiza cambios importantes a esta programación, veas el tutorial de Eclipse 4 para una introducción al modelo de programación de Eclipse 4. En la actualidad, el desarrollo con el model de programación de Eclipse 3.x es mucho más estable y tiene mejor apoyo de las dispositivos que el de Eclipse 4. Por otra parte, Eclipse 4.x es mucho más flexible y simple de utilizar. 3. La arquitectura de Eclipse 3.1. El ámbito de desarrollo Eclipse frente a Eclipse RCP Una aplicación Eclipse consiste en componentes de software individuales. El ámbito de desarrollo Eclipse es en sí mismo una colección de componentes de software específicos. Los componentes de Eclipse son principalmente los siguientes. Componentes primarios del ámbito de desarrollo Eclipse Una aplicación basada en Eclipse emplea unicamente una fracción de dichos componentes. Lo tradicional es que una aplicación Eclipse utilice lo siguiente: Componentes típicos de una aplicación Eclipse Para una aplicación basada en Eclipse escencial (sin interfaz de usuario) unicamente es indispensable el componente ejecutable ('Runtime'). El ejecutable OSGi ofrece el marco que faculta ejecutar la aplicación modular. SWT es la biblioteca de componentes normalizada que emplea Eclipse, entretanto que JFace ofrece una conveniente interfaz de programación de aplicaciones sobre SWT. El ámbito de esfuerzo ('Workbench') ofrece el marco para la aplicación. Este ámbito de esfuerzo es el responsable de presentar todos los demás componentes de la interfaz de usuario. 3.2 Componentes de software, complementos, paquetes, OSGi La fundamento de la arquitectura de Eclipse es la especificación OSGi. Felicidad especificación OSGi determina una capa de modularidad. Equinox es la implementación de referencia de OSGi y es la utilizada por la plataforma Eclipse. Un componente de software en Eclipse se designa complemento ('Plug-in'). Un componente de software en OSGi se designa paquete ('Bundle'). Ambos términos se pueden usar indistintamente. Un componente define: Su interfaz de programación - clases públicas a las que pueden alcanzar otros componentes Sus dependencias - bibliotecas o complementos requeridos por el complemento OSGi define, además, servicios. Los servicios son componentes dinámicos. Debido a su compleja configuración, los servicios OSGi no se emplean frecuentemente en las aplicaciones Eclipse 3.x. Esto se ha simplificado enormemente para las aplicaciones de Eclipse 4.x, por tanto los servicios OSGi juegan un papel significativo en las aplicaciones de Eclipse 4. 3.3 Ficheros de configuración Un complemento Eclipse tiene dos ficheros de configuración principales. MANIFEST.MF - contiene la información de configuración de OSGi. plugin.xml - información acerca de las extensiones y lo puntos de extensión. 4. ¿Qué son los puntos de extensión? Sobre OSGi, el marco de Eclipse ofrece asimismo puntos de expansión. Los puntos de expansión determinan interfaces para que otros complementos aporten funcionalidades (con y sin código). Se determinan en el archivo 'plugin.xml', el cual debe situarse en el directorio raíz de su programa de complemento. Este es un archivo XML para el cual se ofrece una interfaz para su edición. Las extensiones existentes (contribuciones) se agrupan mientras el origen de una aplicación Eclipse. La información de los puntos de expansión se convierte en los así llamados descriptores y almacenada en registros. El ámbito de desarrollo Eclipse ofrece un editor para el archivo 'plugin.xml', por recurso del denominado Ámbito de Desarrollo de Complementos ('Plug-in Development Environment'). 5. Componentes principales de una aplicación Eclipse Los componentes minusculos requeridos para crear y ejecutar la aplicación Eclipse RCP más elemental (con interfaz de usuario) son "org.eclipse.core.runtime" y "org.eclipse.ui". Basándose en estos componentes la aplicación debe definir los próximos elementos: Programa principal - la clase principal de una aplicación implementa el interfaz "IApplication". Esta clase pude considerarse como el equivalente al método 'main' de una aplicación Java normal. Eclipse aguarda que la clase de aplicación se defina por recurso del punto de expansión "org.eclipse.core.runtime.application". Una perspectiva - determina el diseño de presentación de su aplicación. Debe declararse por recurso del punto de expansión "org.eclipse.ui.perspective". Asesor del ámbito de esfuerzo ("Workbench Advisor") - componente no visible que controla la aspecto de la aplicación (menús, barras de herramientas, perspectivas etc). La aplicación Eclipse es el equivalente al método Java "main()". Las aplicaciones se determinan por camino del punto de expansión "org.eclipse.core.runtime.application" y debe heredar IApplication. Las aplicaciones se determinan por camino del punto de expansión "org.eclipse.core.runtime.application" y debe heredar IApplication. Lo que Seguid asume que usted ya tiene determinado conocimiento sobre el uso del ámbito de programación Eclipse para el desarrollo usual con Java. Véase el Tutorial de Eclipse IDE si no es así. También se asume que está familiarizado con el gestor de actualizaciones de Eclipse. Véase el tutorial sobre el Gestor de Actualizaciones de Eclipse para aprender a usarlo. ( Eclipse Update Manager A continuación asumiremos que ya tiene Java instalado. Si no afuera así, realice una búsqueda en Google de "Como instalar Jave en mi SO", reemplazando "mi SO" por el sistema operativo que esté usando. Navegue hasta el espacio de descargas de Eclipse y descargue el paquete "Eclipse for RCP and RAP Developers". Extraiga la descarga en su disco duro. Debe eludir los caracteres especiales o los lugares en la ruta de Eclipse. En caso de que debiera descargado la distribución del IDE de Java (o cualquier otra variedad no RCP), puede utilizar el Gestor de Actualización de Eclipse para instalar los complementos necesarios para el desarrollo RCP. Instale "General Purpose Tools"→ "Eclipse Plug-in Development Environment"→ "Eclipse RCP Plug-in Developer Resources" desde el espacio de descarga de actualizaciones correspondiente a su versión instalada. Es probable que deba desmarcar la alternativa "Group items by category" para ver todas las características disponibles. Selección del paquete de desarrollo Eclipse RCP en el gestor de actualizaciones Cuando se enseña a programar se dispone básicamente de dos alternativas opuestas. La primera es explicarlo todo primero y a continuación realizarlo. La segunda es primero realizarlo todo y despues se explica lo que se ha hecho. La descripción que Seguid tiende hacia la esta segunda opción. Vamos a construir una pequeña aplicación RCP, crear un artículo y lanzarlo, antes de aclarar la articula del proyecto, las clases implicadas y lo que es un artículo o una configuración de lanzamiento. Según mi experiencia, es más sencillo comprender una aclaración cuando ya se ha visto crear un ejemplo. El riesgo vinculado con es punto de vista es que si se descubre determinado asunto no sabrá cómo resolverlo. Por tanto, si tiene determinado asunto para ejecutar su producto, le sugiero que lea el capítulo sobre las configuraciones de ejecución y, si eso no ayuda, compruebe el capítulo "Productos e imagen de marca". A continuación se explica cómo crear una simple aplicación RCP. En Eclipse seleccione "File"-> "New Project". En la lista seleccione "Plug-In Project". Selección del asistente para Plug-in Dele a su complemento el nombre "de.vogella.rcp.intro.first". Pulse "Next" y realice los próximos ajustes. Dado que vamos a construir una aplicación RCP, seleccione "Yes" en la pregunta "Would you like to create a rich client application?". Pulse "next" y seleccione la plantilla "Hello RCP". Pulse "next" y seleccione "Add branding", pulse "Finish". Como resultado, se generará la próximo articula de proyecto. Eche un vistazo a los distintos ficheros, en propia a los ficheros Java para una primera impresión acerca de la articula del proyecto. Aunque es probable en Eclipse 3.7 el empezar diretamente la aplicación, lo apropiado es crear un artículo para ejecutar la aplcación. Por tanto no vamos a ejecutar la aplicación directamente sino que crearemos primero un artículo. Esto asimismo es lo adecuado con Eclipse 4.x. En Eclipse 4.x no puede lanzarse directamente una aplicación, siempre es indispensable un producto. Pulse el botón derecho sobre el programa "de.vogella.rcp.intro.first" y seleccione "New"→ "Product Configuration". Creación del archivo de configuración del artículo Llame a su configuración de artículo "de.vogella.rcp.intro.first.product". Seleccione "Create a configuration file with basic settings". Pulse "finish". Selección de la pestaña "Overview" del archivo de artículo Pulse "New" en la fracción denominada "Product Definition" y seleccione la aplicación de su complemento "de.vogella.rcp.intro.first.application". Selección de la aplicación que debería arrojar el artículo Selección de la aplicación que debería arrojar el producto. fracción II Como resultado, el tema "Product Definition" de la pestaña "Overview" debería surgir completada con su selección. El identificador de artículo se almacena como la expansión "org.eclipse.core.runtime.product" en el archivo "plugin.xml". Vaya a la pestaña "Dependencies" y pulse "Add". Añada los complementos de su aplicación. Pulse sobre el botón "Add Required Plug-ins" para agregar todos los complementos dependientes a su producto. Grabe los cambios. Opcionalmente puede crear una imágen "splash.bmp" por recurso de su dispositivo gráfica favorita y guardarla en el programa que contiene su producto. Añada asimismo un mensaje y una barra de progreso a su pantalla de inicio. Cambie el nombre de lanzamiento a "miaplicacion". Sobre la pestaña "Overview" pulse sincronizar (("synchronize") y a continuación pulse "Launch an Eclipse application". Asegúrese de que su artículo se ejecuta. El fruto debería ser como esto: Aplicación de ejemplo ejecutándose Felicidades, ha creado y ejecutado su primera aplicación RCP. En Eclipse, una configuración de ejecución determina el ámbito debajo el cual se ejecutará una aplicación. Por ejemplo, determina alternativas del compilador, dependencias de los complementos (ruta) etc. A veces, una configuración de ejecución se designa "configuración de lanzamiento". Si comienza su aplicación Eclipse por vez primera, se generará una configuración de ejecución automáticamente. Si selecciona felicidad configuración de ejecución y la inicia, se utilizará tal como se haya definido. Los cambios en la configuración del artículo no se tendrán en cuenta. Si comienza la aplicación desde el archivo de definición del producto, una configuración de lanzamiento existente se actualizará a dividir de la nueva configuración del producto. Para ver y editar su configuración de ejecución, seleccione su archivo de configuración del producto, haga click derecho sobre el mismo y selecciona "Run As"→ "Run Configurations" En la pestaña "Main", tema "location" se epecifica dónde creará el IDE Eclipse los ficheros necesarios para empezar su aplicación RCP. Presenta de la configuración de lanzamiento, cabe resaltar el ajuste de ubicación ("Location") La configuración de lanzamiento faculta agregar parámetros adicionales en la pestaña "Arguments". Por defecto se incluye "-consoleLog". Esto escribirá los mensajes de yerro de la instancia de ejecución de Eclipse RCP en la consola del IDE. -consoleLog en la configuración de lanzamiento Si ha traducido su aplicación Eclipse, puede especificar por recurso del parámetro "-nl" el ajuste de idioma para su aplicación, p. ej. "-nl en" iniciará su aplicación en inglés. Esto es provechoso para probar su aplicación con diferentes idiomas. Otros parámetros útiles son "-console" (lo cual le proporcionará una consola OSGi donde puede verificar el estado de su aplicación) y "-noExit" (lo que mantendrá la consola OSGi libre inclusive si la aplicación termina o se bloquea). Las configuraciones de lanzamiento son con frecuencia una fuente de problemas. Si esta comprobación informa que faltan algunos complementos, intente solucionarlo pulsando el botón "Add Required-Plug-Ins" (añadir complementos requeridos). Además, asegúrese de definir todas las dependencias de su producto. La próximo tabla presenta probables dificultades y sus soluciones. Tabla 1. Problemas de lanzamiento habituales Problema Cómo investigar o resolver Durante el origen se producenmensajes como "One or more bundles are not resolved because the following root constraints are not resolved" o "java.lang.RuntimeException: No application id habéis been found." Compruebe que todos los complementos necesarios se incluyen en su configuración de lanzamiento. Asegúrese de que su artículo determina dependencias a todos los complementos o características. Comportamiento raro pero sin mensaje de error. Compruebe si su configuración de lanzamiento incluye el parámetro -consoleLog. Esta alternativa faculta ver los yerros de la aplicación RCP en la vista de consola y es muy provechoso para identificar problemas. La configuración de ejecución con frecuencia carece de complementos necesarios. Asegúrese de que su artículo incluye todas las dependencias requeridas. Un cambio en las depencias del producto, p.ej. se agrega un nuevo complemento, no se incluye en la configuración de lanzamiento. Un artículo actualiza la configuración de lanzamiento existente si lo comienza directamente desde el archivo de definición. Si selecciona directamente la configuración de lanzamiento no se actualizará. 14. Clases Aplicación ("Application") y Asesor ("Advisor") Durante el origen de una aplicación Eclipse RCP el ejecutable Eclipse evaluará qué clase se determina por recurso del punto de expansión "org.eclipse.core.runtime.application" Este es el equivalente a la clase "main" de los proyectos normales Java. Esta clase es la responsable de crear la presentación ("Display") de SWT y de empezar el bucle de eventos de la aplicación. Esta clase usualmente se designa "Application" y debe implementar el interfaz "IApplication" Display display = PlatformUI.createDisplay(); PlatformUI.createAndRunWorkbench(display, new ApplicationWorkbenchAdvisor()); "PlatformUI.createAndRunWorkbench()" crea y ejecuta un ámbito de esfuerzo ( "Workbench" ). Este ámbito de esfuerzo representa el interfaz gráfico de usuario de Eclipse. La fracción visual del ámbito se representa por recurso de la clase "WorkbenchWindow . El "Workbench" puede tener variadas "WorkbenchWindows" abiertas. La fracción interna de "WorkbenchWindow" se representa por recurso de la clase "WorkbenchPage". El ámbito de esfuerzo ( "Workbench" ) se configura por recurso de una clase del tipo "WorkbenchAdvisor". Esta clase determina la perspectiva inicial y determina la clase "WorkbenchWindowAdvisor". "WorkbenchWindowAdvisor" invoca a la clase "ActionBarAdvisor", la cual configura "Actions" (acciones) para el ámbito de esfuerzo ( "Workbench" ) y determina los atributos iniciales para "WorkbenchWindow", tales como el dimensión inicial, título y visibilidad de la barra de estado. public ActionBarAdvisor createActionBarAdvisor(IActionBarConfigurer configurer) { retur new ApplicationActionBarAdvisor(configurer); publi void preWindowOpen() { IWorkbenchWindowConfigurer configurer = getWindowConfigurer(); configurer.setInitialSize new Point( )); configurer.setShowCoolBar(false); configurer.setShowStatusLine(false); configurer.setTitle( "Todo" //$NON-NLS-1$ Por ejemplo, usted podría ajustar la posición inicial de la aplicación por recurso del método "postWindowCreate()" @Override publi void postWindowCreate() { Shell shell = getWindowConfigurer().getWindow().getShell(); shell.setLocation super.postWindowCreate(); La clase "ActionBarAdvisor", desde Eclipse 3.7, irrelevante al haberse reemplazado el marcio de acciones por el mejorado marco de comandos ("Command framework"). Cada clase asesor faculta configurar cierto comportamiento de la aplicación, por ejemplo "WorkbenchAdvisor" faculta hacer ciertas acciones al origen o finalización reemplazando los métodos "preStartUp() y "preShutDown" 15. Productos e Imagen de Marca 15.1. Resultado y aplicación Una configuración de artículo (artículo, para abreviar) determina todos los recursos que van con su aplicación Eclipse, p. ej. iconos, pantalla de inicio, módulos externos, otros complementos, etc. El artículo es un mecanismo de desarrollo que detalla el contenido de su aplicación y que no se necesita en el momento de la ejecución. Un artículo siempre apunta a una clase "Application". Esta clase "Application" debe implementar el interfaz "IApplication". Usted determina su configuración de artículo en un archivo ".product". El archivo de configuración puede crearse pulsando el botón derecho sobre su programa y seleccionando "New" -> "Product Configuration". Este archivo de configuración contiene toda la información sobre complementos requeridos, ficheros de configuración, recursos etc. El archivo de configuración se emplea para exportar / crear su producto. Se recomienda abandonar el tema ID en blanco, porque la exportación del artículo puede tener dificultades si felicidad ID es la misma que la de un complemento. En la pestaña "Overview" de su artículo puede iniciarlo y seleccionar "synchronize". "Synchronize" cotejará los mecanismos de su artículo con la configuración de lanzamiento. Archivo de definición del artículo mostrando la pestaña "Overview" 15.2. Dependencias El archivo de configuración de un artículo puede basarse en complementos o en características ("Features"). Características son agrupaciones de otras características y complementos. Este ajuste se realiza en la pestaña "Overview". En la pestaña de dependenia puede especificar los complementos que forman su artículo. El artículo no realizará la automáticamente la resolución de dependencias por usted. Si agrega un complemento a su artículo y quiere agregar las dependencias, pulse el botón "Dependency". 15.3. Configuración La pestaña "Splash" le faculta especificar el complemento que contiene la pantalla de inicio. Es indispensable colocar el archivo "splash.bmp" en el directorio del proyecto. Tanto el nombre como el formato están fijados en Eclipse y no pueden modificarse. Ejemplo de la pestaña "Splash" en el archivo de configuración del artículo Puede asimismo configurar tanto el lanzador como el icono de su producto. El lanzador es el ejecutable que se crea mientras el despliegue del producto. Por defecto, se crea un lanzador particular para su plataforma. Por ejemplo "eclipse.exe" en la plataforma Windows. El lanzador también tendrá un icono "eclipse. Para cambiar el nombre y el icono seleccione la pestaña del lanzador de su configuración de producto. Aquí puede especificar el nombre de la aplicación y el icono que debería utilizarse. Asegúrese de que el dimensión de los iconos está correctamente ajustado o en otro caso Eclipse no los utilizará. Ejemplo resaltado de la sección donde se especifica el nombre del lanzador y los iconos En la sección del lanzador puede asimismo especificar parámetros para su proyecto Eclipse o argumentos para la máquina virtual de Java (JVM). 16. Despliegue 15.1. Vista común Su archivo de configuración de artículo puede utilizarse para exportar su aplicación para ejecutarla afuera de Eclipse. Al exportar su artículo creará un archivo conteniendo todos los mecanismos necesarios para ejecutar su aplicación. Contendrá asimismo un lanzador particular para cada plataforma, p. ej. Windows o Linux, para la cual exporte. El directorio resultante puede compartirse con otros que podrán ejecutar la aplicación por recurso del lanzador nativo. 16.2. ¿Qué mecanismos se incluyen en la exportación? Los mecanismos incluídos se determinan en el archivo "build.properties". Eclipse por defecto añadirá las clases Java compiladas. Usted deberá gestionar manualmente los otros archivos, p.ej. iconos o imágenes de la pantalla de inicio. Para cambiar al archivo "build.properties" puede utilizar el editor de "plugin.xml". Abra el archivo "plugin.xml" y seleccione la pestaña "Build". Asegúrese de que tanto el directorio "META-INF" como el archivo "plugin.xml y todos los otros ficheros estáticos, p. ej. iconos, "splash.bmp" y (en el caso de Eclipse 4.x) Application.e4xmi y seguramente los ficheros CSS, estén marcados para su incorporación en el artículo exportado. 16.3. Exportando el artículo Para exportar el producto, cambie a la pestaña "Overview" en su archivo de configuración de producto. Pulse sobre "Eclipse Product export wizard" para exportar su producto. En la segunda página del asistente puede especificar el directorio de destino y el directorio raíz de la aplicación exportada. Este directorio raíz será un subdirectorio del de destino y contendrá la aplicación que usted puede iniciar. Las próximos capturas de pantalla muestran el asistente de exportación en acción. Exportación del artículo Eclipse Selección del directorio destino en el diálogo de exportación Tras la exportación, encontrará los ficheros necesarios para la aplicación en la carpeta raíz que se descubre dentro del directorio de destino. Haciendo doble click sobre el lanzador oriundo debería arrancar la aplicación. 16.4. Exportación para múltiples plataformas por recurso del paquete delta El paquete delta es una descarga separada y puede añadirse a su instalación de Eclipse por recurso de los ajustes de la plataforma destino. Si el paquete delta está disponible puede exportar para múltiples plataformas. Véase la descripción de la plataforma destino para más detalles. 16.5. Incluyendo el JRE requerido en la exportación También puede desplegar su aplicación RCP para asegurarse de que cierto JRE se emplea. Una aplicación Eclipse RCP primero busca en el directorio de instalación una carpeta "jre" y por una Java-VM contenida en ella. Si la encuentra, entonces esta JRE se emplea para arrancar la aplicación Eclipse. Para incluir el JRE de su ámbito de ejecución, seleccione la alternativa "Bundle JRE for this environment with the product" en su archivo de configuración del producto. 17. Problemas comunes en la exportación Si la exportación descubre determinado problema, por favor eche un vistazo a lo que se expone a continuación: Tabla 2. Problemas con la exportación del artículo Problema Posible motivo Falla la exportación Intente usar un directorio de destino vacío, a veces la exportación no puede borrar los archivos existentes y por eso falla. No hay archivo ".exe" tras la exportación Compruebe la alternativa "The product includes native launcher artifacts" en su archivo ".product" en la pestaña "Overview". No se pudo descubrir el artículo Verifique que todas las dependencias se incluyen en el artículo. Borre la configuración de lanzamiento existente y reinicie el artículo desde el ámbito de desarrollo (IDE) para ver si todo está correctamente configurado. Faltan la pantalla o otros iconos Compruebe "build.properties" para ver si todos los mecanismos binarios se incluyen en la exportación. Conflictos mientras el arranque Compruebe el archivo de registro (log) en la carpeta del lugar de esfuerzo de su artículo exportado para ver los mensajes de yerro mientras el arranque. Como alternativa, añada "-consoleLog a la carpeta ".ini" del produsto exportado. 18. "WorkbenchParts" (partes del lugar de trabajo) y "Perspectives" (perspectivas) 18.1. "WorkbenchParts" - "Views" (vistas) y "Editors" (editores) Como se describió más encima el "WorkbenchWindow" y el "WorkbenchPage" representan la fracción visual e interna de la interfaz gráfica de usuario. El "WorkbenchPage" contiene "Parts" (partes, piezas), que pueden ser tanto "Views" (vistas) como "Editors" (editores). Las vistas se emplean para presentar información en una aplicación RCP; también pueden usarse para adaptar datos. Las "Views" derivan de la clase abstracta "ViewPart". Los "Editors" derivan de la clase abstracta "EditorPart". Ambos derivan de la clase abstracta "WorkbenchPart". Un editor usualmente requiere que el usuario seleccione "guardar" para aplicar los cambios en los datos, entretanto que una vosta usualmente varía los datos inmediatamente. Todos los editores se abren en la misma área. Por recurso de la perspectiva puede configurar si el área del editor es visible o no. Las "Views" y los "Editors" se determinan por recurso de puntos de expansión en el archivo "plugin.xml", en la pestaña "Extensions". Las "Views" se determinan por el punto de expansión "org.eclipse.ui.views" y los "Editors" por el punto de expansión "org.eclipse.ui.editors". Las "Views" deben implementar los métodos "createPartControl()" y "setFocus()". "createPartControl()" se usa para crear los componentes de la interfaz de usuario de la vista. "createPartControl()" tendrá como parámetro un "Composite" (composición) que puede utilizarse para desarrollar el interfaz de usuario. Esta composición tiene asignado por defecto un gestor de distribución ("layout manager") asignado de tipo "FillLayout". Este gestor de distribución asigna el mismo lugar a todos los componentes de manera igualitaria. "setFocus()" debe otorgar el foco a un componente particular del interfaz de usuario. 18.2. Perspectiva Una "Perspecive" (perspectiva) detalla alguna configuración de vistas y editores. La perspectiva se determina por recurso de "org.eclipse.ui.perspectives". Las fracciónes ("WorkbenchParts") que forman una perspectiva se determinan, bien por recurso de una clase Jave en el punto de expansión "org.eclipse.ui.perspectives" o por recurso de "org.eclipse.ui.perspectiveExtensions". publi class Perspective implements IPerspectiveFactory { publi void createInitialLayout(IPageLayout layout) { layout.addView( "de.vogella.rcp.intro.first.MyView", IPageLayout.TOP, IPageLayout.RATIO_MAX, IPageLayout.ID_EDITOR_AREA); "layout.addView() agrega una vista a la perspectiva. También puede agregar marcadores de posición ("PlaceHolders") por recurso del método "layout.addPlaceHolder()". Este método acepta comodines y cualquier vista con una ID compatible podría abrirse en felicidad área. Además, puede apgrupar las vistas mediante "IFolderLayout", el cual se crea con una llamada "layout.createFolder()", y agregar vistas a felicidad carpeta con el método ".addView(id)" en "IFolderLayout". 19. Convención En este tutorial siempre vamos a crear aplicaciones RCP. Por tanto, si las instruccione son "Crear un programa RCP" debería generar un nuevo programa de complemento con la alternativa "Would you like to create a rich client application" activada. 20. Tutorial: Añadiendo vistas a su aplicación 20.1. Crear una vista A continuación se explicará cómo agregar vistas a su aplicación. Seguiremos usando el programa "de.vogella.rcp.intro.first". Añada la expansión "org.eclipse.ui.views" a su complemento. Seleccione "plugin.xml" y la pestaña "Extensions" Pulse el botón derecho sobre su nueva expansión de vista y seleccione "New"->"View" Mantenga el valor de id como "de.vogella.rcp.intro.view.MyView" y la clase "de.vogella.rcp.intro.view.MyView". Datos para el punto de expansión "org.eclipse.ui.views" Cree la clase "MyView" pulsando sobre el hiperenlace "class" e introduzca el próximo código. Tras esto, su vista está lista para usarse. package de.vogella.rcp.intro.first; import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Text; import org.eclipse.ui.part.ViewPart; publi class MyView extends ViewPart { @Override publi void createPartControl(Composite parent) { Text text = new Text(parent, SWT.BORDER); text.setText( "Imagine a fantastic user interface here" @Override publi void setFocus() { 20.2. Añada la vista a su perspectiva. Debe agregar la vista a su perspectiva. Añada la expansión "org.eclipse,ui,perspectiveExtensions" a su complemento. Añadiendo una vista a su perspectiva con "org.eclipse.ui.perspectiveExtension" Pulse el botón derecho sobre "*(perspectiveExtension)" -> view". Mantenga la id "de.vogella.rcp.intro.first.MyView". Haga la vista relativa a "org.eclipse.ui.editors", el cual es actualmente un área de editor invisible, y que la vista use todo el lugar seleccionando la proporción máxima de "0.95f". 20.3. Efecto Inicie su aplicación para ver el resultado. Aplicación ejecutándose con una nueva vista 20.4. Añadiendo vistas a la perspectiva mediante código Personalmente prefiero puntos de expansión antes que código. Pero, en vez de utilizar el punto de expansión "org.eclipse.ui.perspectiveExtensions", usted podría agregar la nueva vista a la perspectiva mediante código. Para ello, modifique "Perspective.java" de la próximo forma. package de.vogella.rcp.intro.view; import org.eclipse.ui.IPageLayout; import org.eclipse.ui.IPerspectiveFactory; publi class Perspective implements IPerspectiveFactory { publi void createInitialLayout(IPageLayout layout) { layout.addView( "de.vogella.rcp.intro.first.MyView", IPageLayout.TOP, IPageLayout.RATIO_MAX, IPageLayout.ID_EDITOR_AREA); 21. SWT SWT es la bilbioteca del interfaz de usuario de Eclipse. SWT ofrece los mismos componentes de interfaz de usuario en variadas plataformas, utilizando los fundamentos nativos de la plataforma siempre que sea posible. Cuando un fundamento no está disponible en una plataforma, SWT lo emula. La plataforma SWT accede a los fundamentos nativos del sistema operativo mediante JNI. Para una introducción a SWT, por favor véase el Tutorial SWT. 22. Visores (viewers) de JFace JFace también ofrece visores que facultan laborar directamente con objetos de Java para crear un interfaz de usuario. Dichos visores están disponibles para árboles, tablas, listas y cuadros combinados. Por favor, vea el "Tutorial de tablas" de JFace y "Tutorial del visor de árboles JFace" para más detalle. 23. Tutorial: "ControlDecorations" (Decoración de Controles) "Field Assist" puede utilizarse para ofrecer información acerca de probables formatos de introducción de datos y estados de un campo, p. ej. campos de texto o cuadros combinados. La biblioteca "org.eclipse.jface.fieldassist" ofrece asistencia de dos maneras: con "ControlDecoration" y con "Content Proposal" (propuesta de contenido). "Control decoration" faculta situar imágenes en controles SWT para presentar información adicional sobre el control. Estas decoraciones pueden asimismo contener descripciones que se muestran cuando se sitúa el cursor del ratón sobre ellas. En la distribución de los fundamentos de la pantalla, debe asegurarse de que haya suficiente lugar para presentar estas decoraciones. A continuación se presenta cómo crear "ControlDecorations" y cómo asignarle una descripción y un icono. // Create the decoration for the text UI componen final ControlDecoration deco = new ControlDecoration(text, SWT.TOP | SWT.RIGHT); // Re-use an existing image Image image = FieldDecorationRegistry.getDefault().getFieldDecoration(FieldDecorationRegistry.DEC_INFORMATION).getImage(); // Set description and image deco.setDescriptionText( "Use CNTL + SPACE to see possible values" ); deco.setImage(image); // Hide deco if not in focus deco.setShowOnlyOnFocus(false); También puede esconderse y presentar la decoración. deco.hide(); deco.show(); "Content proposal" (propuesta de contenido) ofrece la ayuda para las probables alternativas de acceso de datos en un campo. 24. Tutorial: FieldAssists (asistente para campo) Reutilizamos el programa "de.vogella.rcp.first". En vuestro ejemplo la propuesta de contenido se activaría mediante ciertas teclas ("." y "#") asimismo de por la mezcla "CTRL + Espacio". Modifique View.java como sigue. package de.vogella.rcp.intro.fieldassist; import org.eclipse.jface.bindings.keys.KeyStroke; import org.eclipse.jface.bindings.keys.ParseException; import org.eclipse.jface.fieldassist.ContentProposalAdapter; import org.eclipse.jface.fieldassist.ControlDecoration; import org.eclipse.jface.fieldassist.FieldDecorationRegistry; import org.eclipse.jface.fieldassist.SimpleContentProposalProvider; import org.eclipse.jface.fieldassist.TextContentAdapter; import org.eclipse.swt.SWT; import org.eclipse.swt.events.KeyEvent; import org.eclipse.swt.events.KeyListener; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Text; import org.eclipse.ui.part.ViewPart; publi class View extends ViewPart { public stati final String ID = "de.vogella.rcp.intro.fieldassist.view" publi void createPartControl(Composite parent) { GridLayout layout = new GridLayout(, false); layout.marginWidth = ; parent.setLayout(layout); Label label = new Label(parent, SWT.NONE); label.setText( "Please select a value: " ); Text text = new Text(parent, SWT.BORDER); GridData data = new GridData(GridData.FILL_HORIZONTAL); text.setLayoutData(data); // Create the decoration for the text UI componen final ControlDecoration deco = new ControlDecoration(text, SWT.TOP | SWT.RIGHT); // Re-use an existing image Image image = FieldDecorationRegistry.getDefault() .getFieldDecoration(FieldDecorationRegistry.DEC_INFORMATION) .getImage(); // Set description and image deco.setDescriptionText( "Use CNTL + SPACE to see possible values" ); deco.setImage(image); // Hide deco if not in focus deco.setShowOnlyOnFocus(false); // Also if the text UI componet is not empty hide the decoration text.addKeyListener new KeyListener() { @Override publi void keyReleased(KeyEvent e) { Text text = (Text) e.getSource(); (text.getText().length() > ) { deco.hide(); else { deco.show(); @Override publi void keyPressed(KeyEvent e) { ); // Help the user with the possible inputs // "." and "#" will also activate the content proposal char[] autoActivationCharacters = n char ; KeyStroke keyStroke; try keyStroke = KeyStroke.getInstance( "Ctrl+Space" // assume that myTextControl habéis already been created in some way ContentProposalAdapter adapter = new ContentProposalAdapter(text, new TextContentAdapter(), new SimpleContentProposalProvider new String[] { "ProposalOne" "ProposalTwo" "ProposalThree" ), keyStroke, autoActivationCharacters); catch (ParseException e) { e.printStackTrace(); publi void setFocus() { Ejecute la aplicación y verifique que las decoraciones de los controles y la propuesta de contenido funcionan. 25. Comandos Un comando es una descripción declarativa de un componente y es independiente de los detalles de implementación. Un comando puede categorizarse y se le puede asignar una tecla ("key binding"). Los comandos se pueden utilizar en menús, barras de dispositivos y/o menús contextuales. Vea "Tutorial sobre los Comandos de Eclipse" para una introducción a la plataforma de comandos. 26. Tutorial: Añadiendo una perspectiva Cree un nuevo poryecto llamado "de.vogella.rcp.intro.perspective". Use como plantilla "RCP application with a view". En "plugin.xml" añada un nuevo punto de expansión "org.eclipse.ui.perspectives". Dele a la id de la perspectiva el valor "de.vogella.rcp.intro.perspective.perspective" y el nombre "vogella.de Perspective". Cambie el nombre de la clase a "de.vogella.rcp.intro.perspective.Perspective". Punto de expansión "org.eclipse.ui.perspectives" Pulse sobre el enlace "class" para crear la clase. El método "createInitialLayout()" de la nueva clase es el responsable de crear la nueva perspectiva. Vamos a reutilizar la vista existente para la codificación. Tras este paso, la perspectiva está definida pero aún no es alcanzable por la aplicación. package de.vogella.rcp.intro.perspective; import org.eclipse.ui.IPageLayout; import org.eclipse.ui.IPerspectiveFactory; publi class Perspective implements IPerspectiveFactory { publi void createInitialLayout(IPageLayout layout) { String editorArea = layout.getEditorArea(); layout.setEditorAreaVisible(false); layout.setFixed(true); layout.addStandaloneView(View.ID, false, IPageLayout.LEFT, 1.0f, editorArea); Después de definir su perspectiva necesitará asimismo activar su aplicación para que el usuario pueda seleccionarla. Una opción es permitir que el usuario seleccione la perspectiva por recurso de la barra de dispositivos o la barra de botones. Puede activarse el cambio entre perspectivas con "configurer.setShowPerspectiveBar(true)" en el método "preWindowOpen()" de "ApplicationWorkbenchAdvisor". package de.vogella.rcp.intro.perspective; import org.eclipse.swt.graphics.Point; import org.eclipse.ui.application.ActionBarAdvisor; import org.eclipse.ui.application.IActionBarConfigurer; import org.eclipse.ui.application.IWorkbenchWindowConfigurer; import org.eclipse.ui.application.WorkbenchWindowAdvisor; publi class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor { public ApplicationWorkbenchWindowAdvisor( IWorkbenchWindowConfigurer configurer) { super(configurer); public ActionBarAdvisor createActionBarAdvisor( IActionBarConfigurer configurer) { retur new ApplicationActionBarAdvisor(configurer); publi void preWindowOpen() { IWorkbenchWindowConfigurer configurer = getWindowConfigurer(); configurer.setInitialSize new Point( )); configurer.setShowStatusLine(false); configurer.setTitle( "RCP Application" ); configurer.setShowPerspectiveBar(true); Ahora ya debería ser capaz de selecciona su perspectiva interactivamente. Además, podría reutilizar el comando "org.eclipse.ui.perspectives.showPerspective", el cual le faculta cambiar de perpectivas. Véase "Comandos de Eclipse" 27. Tutorial: Bandeja del Sistema El próximo código añadirá un icono de la aplicación RCP a la bandeja del sistema y un menú a dicho icono. Añadimos la funcionalida de modo que, cuando la ventana se minimice, el proyecto no sea visible en la barra de tareas (solamente por el icono en la bandeja). Cree un nuevo programa llamado "de.vogella.rcp.intro.traytest". Utilice la plantilla "Hello RCP". Abra la clase "ApplicationWorkbenchWindowAdvisor" e introduzca el próximo código. package de.vogella.rcp.intro.traytest; import org.eclipse.swt.SWT; import org.eclipse.swt.events.MenuDetectEvent; import org.eclipse.swt.events.MenuDetectListener; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.events.ShellAdapter; import org.eclipse.swt.events.ShellEvent; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.MenuItem; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Tray; import org.eclipse.swt.widgets.TrayItem; import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.application.ActionBarAdvisor; import org.eclipse.ui.application.IActionBarConfigurer; import org.eclipse.ui.application.IWorkbenchWindowConfigurer; import org.eclipse.ui.application.WorkbenchWindowAdvisor; publi class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor { private IWorkbenchWindow window; private TrayItem trayItem; private Image trayImage; public ApplicationWorkbenchWindowAdvisor( IWorkbenchWindowConfigurer configurer) { super(configurer); public ActionBarAdvisor createActionBarAdvisor( IActionBarConfigurer configurer) { retur new ApplicationActionBarAdvisor(configurer); publi void preWindowOpen() { IWorkbenchWindowConfigurer configurer = getWindowConfigurer(); configurer.setInitialSize new Point( )); configurer.setShowCoolBar(false); configurer.setShowStatusLine(false); configurer.setTitle( "Hello RCP" //$NON-NLS-1$ // As of here is the new stuff @Override publi void postWindowOpen() { super.postWindowOpen(); window = getWindowConfigurer().getWindow(); trayItem = initTaskItem(window); // Some OS might not support tray items (trayItem != null) { minimizeBehavior(); // Create exit and about action on the icon hookPopupMenu(); // Add a listener to the shell privat void minimizeBehavior() { window.getShell().addShellListener new ShellAdapter() { // If the window is minimized hide the window publi void shellIconified(ShellEvent e) { window.getShell().setVisible(false); ); // If user double-clicks on the tray icons the application will be // visible again trayItem.addSelectionListener new SelectionAdapter() { @Override publi void widgetSelected(SelectionEvent e) { Shell shell = window.getShell(); (!shell.isVisible()) { window.getShell().setMinimized(false); shell.setVisible(true); ); // We hook up on menu entry which allows to close the application privat void hookPopupMenu() { trayItem.addMenuDetectListener new MenuDetectListener() { @Override publi void menuDetected(MenuDetectEvent e) { Menu menu = new Menu(window.getShell(), SWT.POP_UP); // Creates a new menu item that terminates the program MenuItem exit = new MenuItem(menu, SWT.NONE); exit.setText( "Goodbye!" ); exit.addSelectionListener new SelectionAdapter() { @Override publi void widgetSelected(SelectionEvent e) { window.getWorkbench().close(); ); // We need to make the menu visible menu.setVisible(true); ); // This methods create the tray item and return a reference private TrayItem initTaskItem(IWorkbenchWindow window) { final Tray tray = window.getShell().getDisplay().getSystemTray(); TrayItem trayItem = new TrayItem(tray, SWT.NONE); trayImage = Activator.getImageDescriptor( "/icons/alt_about.gif" ) .createImage(); trayItem.setImage(trayImage); trayItem.setToolTipText( "TrayItem" return trayItem; // We need to clean-up after ourself @Override publi void dispose() { (trayImage != null) { trayImage.dispose(); (trayItem != null) { trayItem.dispose(); Ejecute la aplicación y verá que tienen un icono en la bandeja del sistema. Pruebe el menú y el comportamiento cuando se minimiza. Cuando la aplicación se minimiza no debería ser visible en la barra de tareas, sino unicamente en la bandeja del sistema. 28. Plataforma de destino 28.1. Programando contra el IDE de Eclipse Cuando desarrolle complementos de Eclipse, usted está reutilizando componentes de la plataforma Eclipse, por ejemplo SWT o JFace. La cuestión es: ¿Cómo puede controlar qué versión de un complemento particular se está utilizando? Por defecto, dichos complentos derivan directamente de su IDE Eclipse. Este no es el enfoque ideal, ya que le hace depender de su versión del IDE. Esto puede ocasionar dificultades si los desarrolladores están usando distintos versiones de Eclipse. Además dificulta la actualización de dichos complementos para todos de forma simultánea. Si Seguid este enfoque, también necesitará instalar cada complemento indispensable para su artículo tanto en su lugar de esfuerzo como en su IDE Eclipse. El último asunto con este enfoque es que sin desear podría agregar complementos desde su IDE a su producto. 28.2. Definiendo su Plataforma Destino Por via de la plataforma destino usted determina el conjunto de complementos que están disponibles para el desarrollo. Por ejemplo, usted determina qué versión de SWT y JFace forman fracción de su plataforma destino. Esto le independiza del IDE Eclipse que usted esté utilizando. Los desarrolladores con distintos versiones de Eclipse compilarán su esfuerzo contra el mismo conjunto de complementos. La plataforma destino se determina en un archivo ".target". Este archivo destino determina la lista de complementos y características. Usualmente se comparte dicho archivo entre distintos desarrolladores para asegurarse de utilizar la misma fundamento para el desarrollo. La forma más efectiva de definir su plataforma destino es emplear los espacios de actualización (Eclipse p2). Estos son el mismo tipo de espacios de actualización que emplea cuando desea instalar un nuevo conjunto de complementos. Si el contenido del espacio de actualización definido por su plataforma destino cambia, el conjunto local de complementos puded también actualizarse. Es probable asimismo definir su plataforma de destino basada en un sistema de archivos, aunque esto no es tan flexible y, por tanto, debereía evitarse. 28.3. Formando la definición de Plataforma Destino Un archivo de definición de destino puede crearse con "File" → "New" → "Other" → "Plug-in Development" → "Target Definition". Archivo de definición de destino Puede agregar nuevas localizaciones por recurso del botón "Add". Para agregar un espacio de Eclipse p2, seleccione "software Site" y especifique la URL. Tras haber definido su archivo de definición de destino, puede activarlo como destino en su IDE Eclipse por recurso del botón "Set as Target Platform". Ajuste de una nueva definición de destino para el desarrollo Puede cambiar la plataforma destino en las preferencias de Eclipse. Seleccione "Window" → "Preferences" → "Plug-in Development" → "Target Platform". Ajustando la definición de destino en las preferencias de Eclipse API del lugar de esfuerzo ("Workbench") Para interactuar con el lugar de trabajo, tiene entrada a la Interfaz de Programación de la Aplicación (API). Por ejemplo, puede alcanzar al editor o la vista activa y abrir o cerrar vistas y editores. La mayoría de llamadas a la API se realizan por recurso de "WorkbenchPage". Un manejador de comandos puede alcanzar a "WorkbenchPage" por recurso de: IWorkbenchPage page = HandlerUtil.getActiveWorkbenchWindow(event).getActivePage(); Una vista ofrece entrada al "Workbench" y al "WorkbenchWindow" con el método "getViewSite()". Un editor ofrece el mismo entrada con "getEditorSite()" IWorkbenchPage page = getViewSite().getPage(); IWorkbenchPage page = getEditorSite().getPage(); Podría asimismo conseguir la página del "Workbench" sobre el "Singleton" de "PlatformUI". IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage() Una vez que tiene entrada a la página, puede invocar su API. A continuación se demuestra cómo cerrar primero todas las vistas de la aplicación y cómo abrir una vista con una ID específica. IViewReference[] views = page.getViewReferences(); for (IViewReference view : views) { page.hideView(view); try { page.showView(View.ID); catch (PartInitException e) { e.printStackTrace(); return null; El próximo pedazo presenta cómo guardar un editor y cómo cerrarlo. IEditorPart editorPart = page.getActiveEditor(); (editorPart != null) { // Save the editor without confirmation page.saveEditor(editorPart, false); // Close the editor and save before saving page.closeEditor(editorPart, true); Puede asimismo agregar un "PartListener" a la página y oir los cambios en vistas y editores. Aquí poseemos un ejemplo de cómo agregarlo en "ApplicationWorkbenchWindowAdvisor". @Override publi void postWindowOpen() { super.postWindowOpen(); IWorkbenchPage page = PlatformUI.getWorkbench() .getActiveWorkbenchWindow().getActivePage(); // Register a part listener for a certain View / Part page.addPartListener new IPartListener2() { @Override publi void partVisible(IWorkbenchPartReference partRef) { System.out.println( "Part visible: " + partRef.getId()); @Override publi void partOpened(IWorkbenchPartReference partRef) { System.out.println( "Part opened: " + partRef.getId()); @Override publi void partInputChanged(IWorkbenchPartReference partRef) { @Override publi void partHidden(IWorkbenchPartReference partRef) { System.out.println( "Part hidden: " + partRef.getId()); @Override publi void partDeactivated(IWorkbenchPartReference partRef) { System.out.println( "Part deactivated:" + partRef.getId()); @Override publi void partClosed(IWorkbenchPartReference partRef) { System.out.println( "Part closed:" + partRef.getId()); @Override publi void partBroughtToTop(IWorkbenchPartReference partRef) { System.out.println( "Part top:" + partRef.getId()); @Override publi void partActivated(IWorkbenchPartReference partRef) { System.out.println( "Part activated: " + partRef.getId()); ); 30. Consejos y Trucos 30.1. Cargue una imagen desde su complemento Para cargar una imagen desde su complemento puede usar "AbstractUIPlugin. AbstractUIPlugin.imageDescriptorFromPlugin(?YourPluginId?,?/icons/your.gif?).createImage(); En otro caso, podría cargar el marco de esfuerzo directamente. Bundle bundle = FrameworkUtil.getBundle this.getClass()); URL url = FileLocator.find(bundle, new Path( "icons/alt_window_32.gif" ), null); Image image = ImageDescriptor.createFromURL(url).createImage(); 30.2. Almacenar la distribución del usuario Para recordar la distribución del usuario y el dimensión de la ventana la próxima vez que se inicie la aplicación, añada al método "initialize" de "ApplicationWorkbenchAdvisor" la instrucción "configurer.SetSaveAndRestore(true);". package addactiontoview; import org.eclipse.ui.application.IWorkbenchConfigurer; import org.eclipse.ui.application.IWorkbenchWindowConfigurer; import org.eclipse.ui.application.WorkbenchAdvisor; import org.eclipse.ui.application.WorkbenchWindowAdvisor; publi class ApplicationWorkbenchAdvisor extends WorkbenchAdvisor { private stati final String PERSPECTIVE_ID = "AddActiontoView.perspective" public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor( IWorkbenchWindowConfigurer configurer) { retur new ApplicationWorkbenchWindowAdvisor(configurer); public String getInitialWindowPerspectiveId() { return PERSPECTIVE_ID; @Override publi void initialize(IWorkbenchConfigurer configurer) { super.initialize(configurer); configurer.setSaveAndRestore(true); Eclipse tiene un comando predefinido para reiniciar la perspectiva. Véase Comandos de Eclipse. 30.3. Accediendo a la barra de estado. La barra de estado de una aplicación RCP puede utilizarse para dar al usuario cierta información acerca de la aplicación que se está ejecutando. Este área compartida pueden utilizarla todas las fracciónes de la aplicación para escribir mensajes. Toda la aplicación RCP tiene entrada a la información en el área compartide de la barra de estado, por lo que la información en felicidad barra de estado podría sobreescribirse. Para presentar la barra de estado en su aplicación RCP utilice "ApplicationWorkbenchWindowAdvisor" y márquela como visible en el método "preWindowOpen()". publi class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor { @Override publi void preWindowOpen() { configurer.setShowStatusLine(false); El próximo código escribe un texto en la barra de estado desde una vista. IStatusLineManager manager = getViewSite().getActionBars().getStatusLineManager(); manager.setMessage( "Information for the status line" Desde un editor, puede accederse a la barra de estado por recurso de: IEditorPart.getEditorSite().getActionBars(); 30.4. Encontrando dependencias no utilizadas Cómo descartar dependencias no utilizadas 30.5. Ajustes Multiusuario Las aplicaciones Eclipse RCP guardan los ficheros de configuración en la carpeta ".metadata". En los ajustes por defecto el directorio de instalación de Eclipse RCP se usará para esta carpeta. Si varios usuarios están utilizando la misma carpeta de instalación, entonces debería añadirse el parámetro "-data" para especificar una ubicación alternativa. Si especifica el valor "@user.home/applicationname" la configuración se guardará en una carpeta específica para el usuario.