Categorías
Rich Client Platform(RCP)

Agregue un selector / selector de archivos para el desarrollo de Eclipse RCP

El selector de archivos o la elección de directorio es un módulo común cuando el procesamiento de archivos está involucrado en una aplicación GUI. Este artículo usa un ejemplo para ilustrar cómo usar el selector de archivos / selector de directorio en Eclipse RCP, y proporciona el código fuente que se puede usar directamente.

Bajo Eclipse RCP, la implementación es simple y el uso es sencillo. Básicamente, un selector de archivos debe ser un compuesto que se puede agregar a un compuesto principal en una vista determinada.

Aquí se muestra dónde necesito el selector de archivos. Cuando se hace clic en el botón, aparece un selector de archivos. Después de elegir un archivo, el campo de texto se completará con el nombre del archivo.

Aquí está el código para la clase de selector de archivos.

import java.io.File;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Text;
 
public class FileChooser extends Composite {
 
	Text mText;
	Button mButton;
	String title = null;
 
	public FileChooser(Composite parent) {
		super(parent, SWT.NULL);
		createContent();
	}
 
	public void createContent() {
		GridLayout layout = new GridLayout(2, false);
		setLayout(layout);
 
		mText = new Text(this, SWT.SINGLE | SWT.BORDER);
		GridData gd = new GridData(GridData.FILL_BOTH);
		gd.grabExcessHorizontalSpace = true;
		gd.horizontalAlignment = GridData.FILL;
		mText.setLayoutData(gd);
 
 
		mButton = new Button(this, SWT.NONE);
		mButton.setText("...");
		mButton.addSelectionListener(new SelectionListener() {
 
			public void widgetDefaultSelected(SelectionEvent e) {
			}
 
			public void widgetSelected(SelectionEvent e) {
				FileDialog dlg = new FileDialog(mButton.getShell(),  SWT.OPEN  );
				dlg.setText("Open");
				String path = dlg.open();
				if (path == null) return;
				mText.setText(path);
			}
		});
	}
 
	public String getText() {
		return mText.getText();
 
	}
 
	public Text getTextControl() {
		return mText;		
	}
 
	public File getFile() {
		String text = mText.getText();
		if (text.length() == 0) return null;
		return new File(text);
	}
 
	public String getTitle() {
		return title;
	}
 
	public void setTitle(String title) {
		this.title = title;
	}
}

Si FileDialog se reemplaza por DirectoryDialog, el selector de directorio está listo.

Aquí está el código del método creatPartControl para una clase View.

public void createPartControl(Composite parent) {
		// Here is the layered layout of the Composite
		// parent -> top -> banner
		// -> text
		Composite top = new Composite(parent, SWT.NONE);// embedded Composite
 
		// setup the layout of top to be GridLayout.
		GridLayout layout = new GridLayout();
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		top.setLayout(layout);
 
		// top banner
		Composite banner = new Composite(top, SWT.NONE);// banner is added to
														// "top"
		banner.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL,
				GridData.VERTICAL_ALIGN_BEGINNING, true, false));
		layout = new GridLayout();
		layout.marginHeight = 5;
		layout.marginWidth = 10;
 
		layout.numColumns = 2;
		banner.setLayout(layout);
 
		// setup bold font
		Font boldFont = JFaceResources.getFontRegistry().getBold(
				JFaceResources.DEFAULT_FONT);
 
		// 1st row
		Label l = new Label(banner, SWT.WRAP);
		l.setText("Regular Expression:");
		l.setFont(boldFont);
 
		final Text reg = new Text(banner, SWT.BORDER | SWT.FILL);
		GridData gridData = new GridData();
		gridData.horizontalAlignment = SWT.FILL;
		gridData.minimumWidth = 400;
		gridData.minimumHeight = 50;
		gridData.grabExcessHorizontalSpace = true;
		reg.setLayoutData(gridData);
		reg.setText("(s*)//(s*).*");
 
		// l = new Label(banner, SWT.WRAP);
		// l.setText("This is a message about the cool Eclipse RCP!");
 
		// 2nd row
		l = new Label(banner, SWT.PUSH);
		l.setText("Author:");
		l.setFont(boldFont);
 
		final Link link = new Link(banner, SWT.NONE);
		link.setText("<a>programcreek.com</a>");
		link.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				MessageDialog
						.openInformation(getSite().getShell(),
								"Not Implemented",
								"Imagine the address book or a new message being created now.");
			}
		});
 
		// 3rd row
		l = new Label(banner, SWT.WRAP);
		l.setText("Source File:");
		l.setFont(boldFont);
 
 
		final FileChooser fileChooser = new FileChooser(banner);
		gridData.heightHint = 25;
		fileChooser.setLayoutData(gridData);
		//fileChooser.setLayout(SWT.WRAP);
 
 
		// 4th row
		l = new Label(banner, SWT.WRAP);
		l.setText("Source File:");
		l.setFont(boldFont);
 
		Button runButton = new Button(banner, SWT.WRAP);
		runButton.setText("Select a File");
 
 
 
		// message contents
		final Text text = new Text(top, SWT.MULTI | SWT.WRAP);
		// here like the banner, text is added to "top".
		text.setText("");
		text.setLayoutData(new GridData(GridData.FILL_BOTH));
 
 
		runButton.addListener(SWT.Selection,  new Listener() {
		      public void handleEvent(Event event) {
 
		    	  ArrayList<String> list = null;
					try {
						list  = FilterText.Filter(fileChooser.getText(), reg.getText());
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
 
					for(String temp : list){
 
						text.append(temp + "n");
 
					}
 
		        }
		      });
 
	}

Categorías
Rich Client Platform(RCP)

Agregar barra de desplazamiento vertical al área de texto en aplicaciones RCP

Agregar una barra de desplazamiento vertical a un área de texto en RCP es sencillo. Debe utilizar el valor de campo estático SWT para establecer el estilo.

Text text = new Text(top, SWT.MULTI | SWT.V_SCROLL | SWT.BORDER);

* Esta respuesta es del libro «Eclipse Rich Client Platform 2nd» que explica detalles como este muy bien.

Categorías
Rich Client Platform(RCP)

Tutorial de Eclipse RCP: aplicación de cliente enriquecido de Eclipse con una vista

Eclipse RCP proporciona una forma sencilla de crear aplicaciones de escritorio con estándares de la industria. Una vez que comprenda cómo funciona el marco, es muy sencillo agregar más vistas, perspectivas, etc.

Este artículo muestra cómo crear una aplicación de cliente enriquecido simple con una vista utilizando el asistente de desarrollo. También explica la función de cada archivo creado. Supongo que ya tiene PDE instalado. Si no lo hace, puede averiguar rápidamente cómo hacerlo en el tutorial «Cómo instalar PDE».

1. Pasos para crear una aplicación RCP simple con una vista

Las siguientes 4 imágenes muestran los 4 pasos para crear una aplicación simple con asistente.

2-set-plugin-nombre-del-proyecto

3-datos-necesarios-para-generar-complemento

La plantilla utilizada es «Aplicación RCP con vista».

2. Archivos creados y sus funciones

Aquí están los archivos creados automáticamente por Eclipse.

Eclipse RCP proporciona el concepto de «puntos de extensión» y «extensiones» para facilitar el desarrollo de aplicaciones de escritorio comerciales. Proporciona una forma de usar todo el marco fácilmente a través del archivo plugin.xml que se encuentra en el directorio raíz de cada directorio.

plugin.xml

<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>
 
   <extension
         id="application"
         point="org.eclipse.core.runtime.applications">
      <application>
         <run
               class="rcpview.Application">
         </run>
      </application>
   </extension>
   <extension
         point="org.eclipse.ui.perspectives">
      <perspective
            name="Perspective"
            class="rcpview.Perspective"
            id="RCPView.perspective">
      </perspective>
   </extension>
   <extension
         point="org.eclipse.ui.views">
      <view
            name="View"
            class="rcpview.View"
            id="RCPView.view">
      </view>
   </extension>
   <extension
         point="org.eclipse.ui.perspectiveExtensions">
      <perspectiveExtension
            targetID="*">
         <view
               standalone="true"
               minimized="false"
               relative="org.eclipse.ui.editorss"
               relationship="left"
               id="RCPView.view">
         </view>
      </perspectiveExtension>
   </extension>
   <extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="menu:org.eclipse.ui.main.menu">
         <menu
               label="File">
            <command
                  commandId="org.eclipse.ui.file.exit"
                  label="Exit">
            </command>
         </menu>
      </menuContribution>
   </extension>
 
</plugin>
​​ < / menu>

Durante el inicio de una aplicación Eclipse RCP, el tiempo de ejecución de Eclipse detecta la clase de punto de entrada principal a través del punto de extensión definido en plugin.xml. La clase implementa la interfaz IApplication y se carga primero como la función principal en una aplicación Java general.

Application.java

package rcpview;
 
import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
 
/**
 * This class controls all aspects of the application's execution
 */
public class Application implements IApplication {
 
	public Object start(IApplicationContext context) {
		Display display = PlatformUI.createDisplay();
		try {
			int returnCode = PlatformUI.createAndRunWorkbench(display, new ApplicationWorkbenchAdvisor());
			if (returnCode == PlatformUI.RETURN_RESTART) {
				return IApplication.EXIT_RESTART;
			}
			return IApplication.EXIT_OK;
		} finally {
			display.dispose();
		}
	}
 
	public void stop() {
		if (!PlatformUI.isWorkbenchRunning())
			return;
		final IWorkbench workbench = PlatformUI.getWorkbench();
		final Display display = workbench.getDisplay();
		display.syncExec(new Runnable() {
			public void run() {
				if (!display.isDisposed())
					workbench.close();
			}
		});
	}
}

La clase de aplicación crea y ejecuta un Workbench.

¿Qué es un banco de trabajo?
Workbench se basa en Runtime, SWT y JFace para proporcionar un entorno de múltiples ventanas altamente escalable y abierto para administrar vistas, editores, perspectivas (diseños orientados a tareas), acciones, asistentes, páginas de preferencias y más.

Workbench se configura a través de WorkbenchAdvisor. WorkbenchAdvisor le dice a Workbench cómo comportarse, cómo dibujar, qué dibujar, etc. En particular, WorkbenchAdvisor identifica dos cosas (verifique el código a continuación):

1. La perspectiva inicial que se va a mostrar.
2. qué WorkbenchWindowAdvisor utilizar.

ApplicationWorkbenchAdvisor.java

package rcpview;
 
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchAdvisor;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;
 
public class ApplicationWorkbenchAdvisor extends WorkbenchAdvisor {
 
	private static final String PERSPECTIVE_ID = &quot;RCPView.perspective&quot;;
 
	public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(
			IWorkbenchWindowConfigurer configurer) {
		return new ApplicationWorkbenchWindowAdvisor(configurer);
	}
 
	public String getInitialWindowPerspectiveId() {
		return PERSPECTIVE_ID;
	}
 
}

El banco de trabajo inicia WorkbenchWindow, que se configura a través de WorkbenchWindowAdvisor.

ApplicationWorkbenchWindowAdvisor.java

package rcpview;
 
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;
 
public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {
 
	public ApplicationWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
		super(configurer);
	}
 
	public ActionBarAdvisor createActionBarAdvisor(
			IActionBarConfigurer configurer) {
		return new ApplicationActionBarAdvisor(configurer);
	}
 
        //preWindowOpen method configure the initial window size and positions.
	public void preWindowOpen() {
		IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
		configurer.setInitialSize(new Point(400, 300));
		configurer.setShowCoolBar(false);
		configurer.setShowStatusLine(false);
		configurer.setTitle(&quot;RCP Application&quot;);
	}
}

WorkbenchWindowAdvisor crea la barra de herramientas / barra de menú de la aplicación que se configura a través de ActionBarAdvisor. La clase ApplicationActionBarAdvisor a continuación es demasiado simple para implementar cualquier método. Pero generalmente, los siguientes dos métodos se pueden usar para llenar la barra de menú y la barra de herramientas:

protected void fillMenuBar(IMenuManager menuBar) { }
protected void fillCoolBar(ICoolBarManager coolBar) { }

ApplicationActionBarAdvisor.java

package rcpview;
 
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
 
/**
 * An action bar advisor is responsible for creating, adding, and disposing of
 * the actions added to a workbench window. Each window will be populated with
 * new actions.
 */
public class ApplicationActionBarAdvisor extends ActionBarAdvisor {
 
	// Actions - important to allocate these only in makeActions, and then use
	// them
	// in the fill methods. This ensures that the actions aren't recreated
	// when fillActionBars is called with FILL_PROXY.
 
	public ApplicationActionBarAdvisor(IActionBarConfigurer configurer) {
		super(configurer);
	}
 
}

En una aplicación típica, cuando la inicia, aparece una ventana. La perspectiva es como la página de un libro, mientras que el libro es la ventana. Una perspectiva es un contenedor de elementos visuales como vistas, editores y acciones. Cada perspectiva puede contener 0 o varias vistas según el diseño.

Perspective.java

package rcpview;
 
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;
 
public class Perspective implements IPerspectiveFactory {
 
	public void createInitialLayout(IPageLayout layout) {
		layout.setEditorAreaVisible(false);
		layout.setFixed(true);
 
	}
 
}

Una vista es una parte del banco de trabajo para realizar una tarea visual, como navegar por un directorio de árbol, editar un correo electrónico, etc. Proporciona una mejor manera de organizar los componentes visuales en función de sus funciones o propósitos.

View.java

package rcpview;
 
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;
 
public class View extends ViewPart {
	public static final String ID = &quot;RCPView.view&quot;;
 
	private TableViewer viewer;
 
	/**
	 * The content provider class is responsible for providing objects to the
	 * view. It can wrap existing objects in adapters or simply return objects
	 * as-is. These objects may be sensitive to the current input of the view,
	 * or ignore it and always show the same content (like Task List, for
	 * example).
	 */
	class ViewContentProvider implements IStructuredContentProvider {
		public void inputChanged(Viewer v, Object oldInput, Object newInput) {
		}
 
		public void dispose() {
		}
 
		public Object[] getElements(Object parent) {
			if (parent instanceof Object[]) {
				return (Object[]) parent;
			}
	        return new Object[0];
		}
	}
 
	class ViewLabelProvider extends LabelProvider implements
			ITableLabelProvider {
		public String getColumnText(Object obj, int index) {
			return getText(obj);
		}
 
		public Image getColumnImage(Object obj, int index) {
			return getImage(obj);
		}
 
		public Image getImage(Object obj) {
			return PlatformUI.getWorkbench().getSharedImages().getImage(
					ISharedImages.IMG_OBJ_ELEMENT);
		}
	}
 
	/**
	 * This is a callback that will allow us to create the viewer and initialize
	 * it.
	 */
	public void createPartControl(Composite parent) {
		viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
				| SWT.V_SCROLL);
		viewer.setContentProvider(new ViewContentProvider());
		viewer.setLabelProvider(new ViewLabelProvider());
		// Provide the input to the ContentProvider
		viewer.setInput(new String[] {&quot;One&quot;, &quot;Two&quot;, &quot;Three&quot;});
	}
 
	/**
	 * Passing the focus request to the viewer's control.
	 */
	public void setFocus() {
		viewer.getControl().setFocus();
	}
}

Haga clic en Tutoriales de desarrollo de Eclipse RCP para ver temas más avanzados.

Categorías
Rich Client Platform(RCP)

Desarrollo de complementos de Eclipse: agregar un menú mediante el asistente

El siguiente ejemplo es en realidad de eclipse. Simplemente agrega un menú a la barra de menú y un icono a la barra de herramientas. Cuando se hace clic en el elemento de menú del nuevo menú o en el icono de la barra de herramientas, aparece un cuadro de diálogo de mensaje.

Archivo-> Nuevo-> Proyecto-> Proyecto de complemento

Nombre del proyecto: HelloWordMenu

Estructura de archivo:

MANIFEST.MF especifica la dependencia. El menú depende de la interfaz de usuario y el tiempo de ejecución. El archivo se puede generar usando el asistente, así que no se preocupe por esta parte, lo mismo ocurre con plugin.xml.

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: HelloWorldMenu
Bundle-SymbolicName: HelloWorldMenu; singleton:=true
Bundle-Version: 1.0.0.qualifier
Bundle-Activator: helloworldmenu.Activator
Require-Bundle: org.eclipse.ui,
 org.eclipse.core.runtime
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6

plugin.xml especifica la extensión. Es el lugar central para configurar el complemento que se está desarrollando. El punto de extensión de este complemento de muestra es org.eclipse.ui.actionSets.

<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>
   <extension
         point="org.eclipse.ui.actionSets">
      <actionSet
            id="SampleView.actionSet"
            label="Sample Action Set"
            visible="true">
         <menu
               id="sampleMenu"
               label="Sample Menu">
            <separator
                  name="sampleGroup">
            </separator>
         </menu>
         <action
               class="sampleview.actions.SampleAction"
               icon="icons/sample.gif"
               id="sampleview.actions.SampleAction"
               label="Sample Action"
               menubarPath="sampleMenu/sampleGroup"
               toolbarPath="sampleGroup"
               tooltip="Hello, Eclipse world">
         </action>
      </actionSet>
   </extension>
</plugin>

La GUI para la extensión es la siguiente:

Como se muestra arriba, en este ejemplo se requiere la extensión actionSets. (Más adelante se explicará cómo decidir cuál se requiere)

El código Java en SampleAction.java y Activator.java es sencillo si no pregunta más sobre cómo funciona el marco.

Aquí está el método de ejecución del archivo SampleAction.java. La clase SampleAction implementa la interfaz IWorkbenchWindowActionDelegate. Es el llamar de vuelta método llamado por el complemento de host. El banco de trabajo creará el proxy de acción y se mostrará en la interfaz de usuario. Cuando el usuario intente utilizar la acción, se creará este delegado y se le delegará la ejecución.

public void run(IAction action) {
		MessageDialog.openInformation(
			window.getShell(),
			&quot;HelloWorldMenu&quot;,
			&quot;Hello, Eclipse world&quot;);
	}

Complete SampleAction.java

package sampleview.actions;
 
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.PlatformUI;
import org.eclipse.jface.dialogs.MessageDialog;
 
/**
 * Our sample action implements workbench action delegate.
 * The action proxy will be created by the workbench and
 * shown in the UI. When the user tries to use the action,
 * this delegate will be created and execution will be 
 * delegated to it.
 * @see IWorkbenchWindowActionDelegate
 */
public class SampleAction implements IWorkbenchWindowActionDelegate {
	private IWorkbenchWindow window;
	/**
	 * The constructor.
	 */
	public SampleAction() {
	}
 
	/**
	 * The action has been activated. The argument of the
	 * method represents the 'real' action sitting
	 * in the workbench UI.
	 * @see IWorkbenchWindowActionDelegate#run
	 */
	public void run(IAction action) {
		MessageDialog.openInformation(
			window.getShell(),
			"SampleView",
			"Hello, Eclipse world");
	}
 
	/**
	 * Selection in the workbench has been changed. We 
	 * can change the state of the 'real' action here
	 * if we want, but this can only happen after 
	 * the delegate has been created.
	 * @see IWorkbenchWindowActionDelegate#selectionChanged
	 */
	public void selectionChanged(IAction action, ISelection selection) {
	}
 
	/**
	 * We can use this method to dispose of any system
	 * resources we previously allocated.
	 * @see IWorkbenchWindowActionDelegate#dispose
	 */
	public void dispose() {
	}
 
	/**
	 * We will cache window object in order to
	 * be able to provide parent shell for the message dialog.
	 * @see IWorkbenchWindowActionDelegate#init
	 */
	public void init(IWorkbenchWindow window) {
		this.window = window;
	}
}

Ejecute este complemento como «Aplicación Eclipse».

Este es un ejemplo muy simple. Un trabajo de desarrollo real normalmente relacionado con el análisis de programas, como el uso de JDT Java Model, ASTParser, etc.

Categorías
Rich Client Platform(RCP)

Eclipse RCP: Relación entre ventana, perspectiva, vista, etc.

Este diagrama es de «Eclipse Rich Client Platform 2nd Edition» de Addison Wesley. Demuestra las relaciones entre ventana, menú, perspectiva, vistas, etc.

En resumen, la ventana es la vista completa de la aplicación y tiene una página. La página tiene su propio editor e instancias de vista, y utiliza la perspectiva para determinar su diseño. Una vista se utiliza como contenedor para contener diferentes tipos de widgets. Cada widget puede ser una etiqueta, un botón, un selector de archivos, etc.

Categorías
Rich Client Platform(RCP)

Referencias de los widgets de Eclipse SWT y JFace

Si desea desarrollar la aplicación Java Desktop, probablemente tenga dos opciones de bibliotecas: SWT o Swing. Donde hay pros y contras para ambos, aquí es una comparación entre ellos.

Recuerde el papel de Standard Widget Tootlkit (SWT) en la plataforma eclipse a continuación.

JFace es una biblioteca de widgets de interfaz de usuario (UI) de alto nivel construida sobre SWT. Al programar con la plataforma Eclipse, se requerirán varios widgets. Esta publicación resume una lista de referencia de widgets de JFace y SWT.

Lista de widgets SWT:



JFace

Sitio de Eclipse.

Referencias:
1. Widgets SWT
2. FIT y Eclipse: desarrollo del complemento Extended FIT Eclipse
3. Clientes ricos con SWT y JFace
4. Uso de la GUI de Eclipse fuera de Eclipse Workbench

Categorías
Rich Client Platform(RCP)

Pasos para realizar una solicitud de RCP

Eclipse RCP es una buena plataforma para desarrollar aplicaciones de escritorio GUI. Existe un cuello de botella para que los programadores aprendan a crear una aplicación cliente enriquecida. Siempre tengo mucha curiosidad por saber si existe una forma más eficaz. Esto puede considerarse como un problema de ingeniería de software. El problema es cómo las técnicas de SE pueden ayudar con este cuello de botella.

Para resolver el problema, resumo los siguientes pasos para hacer una aplicación RCP.

1. Utilizando el asistente para crear una aplicación de muestra.

1) Es sencillo crear una aplicación GUI con una vista simple usando el asistente.
2) Sabiendo que el método de devolución de llamada necesario para implementar es createPartControl (padre compuesto), podemos echar un vistazo a lo que otros han hecho por sus proyectos.
3) Usando koders.com (anteriormente usaba Google Code Search hasta que se cerró) para buscar este método.

2. Utilice el diseño adecuado y agregue los widgets necesarios.

Aquí se necesita una referencia sobre lo que está disponible para agregar a una aplicación GUI.

3. Mejore la interfaz de forma creativa y conviértala en un producto comercial.

Por ejemplo, logotipos, información de producción, barra de estado, etc.

4. Optimización sobre otros, como pensamientos, ideas, usabilidad, accesibilidad, etc.

Categorías
Rich Client Platform(RCP)

Tutorial de Eclipse RCP: Exportar la aplicación Eclipse RCP para convertirla en un producto

Para desarrollar una aplicación GUI de escritorio independiente mediante eclipse RCP, es necesario exportarla para que sea un producto. Este tutorial trata sobre cómo utilizar el asistente de exportación de productos Eclipse para generar una aplicación de escritorio independiente ejecutable.

Este artículo asume que sabe cómo crear un proyecto de complemento mediante el asistente de eclipse RCP. Aquí hay una publicación sobre cómo hacerlo y cómo cada parte juega un papel.

Pasos:

1. Haga clic derecho en el proyecto.

Nuevo -> Configuración del producto
Deje que el nombre del producto sea: myFirstProductName (de esta manera podemos rastrear fácilmente dónde irá este nombre en el archivo xml)

2. Ahora tiene una configuración de producto y aparece la página de descripción general.

En la parte inferior, hay pestañas como Descripción general, Dependencias, Configuración, Lanzamiento, Presentación, Marca, Licencia. Cada uno de ellos se explicará individualmente a continuación.

3. Resumen

En la sección «Definición de producto», haga clic en el botón «nuevo» y llene la ventana emergente:

4. Dependencias

En la pestaña de dependencias, primero agregue «RCPView», que es el complemento creado, y luego haga clic en «Agregar complementos requeridos».

5. Prueba lo que hasta ahora

En la pestaña Descripción general, haga clic en el enlace «Asistente de exportación de productos Eclipse» en «Sección de exportación».

Posible problema:
Este archivo exe generado no se ejecuta correctamente, una posible razón es que el entorno de ejecución puede no ser correcto. Vaya al paso siguiente.

6. Lanzamiento

Haga clic en el botón «Entorno» y encuentre la mejor opción para su desarrollo. El problema del paso 5 anterior debería desaparecer.

Las 6 imágenes BMP separadas o un solo archivo ICO son para el logotipo del archivo ejecutable que finalmente se genera.

7. Salpicaduras

La pantalla de bienvenida aparece cuando se lanza el producto. Si no se especifica su ubicación, se asume que el archivo ‘splash.bmp’ está en el complemento de definición del producto.

Tenga en cuenta que splash.bmp debe estar en el directorio raíz como el siguiente:

Se cargará automáticamente cuando se inicie la aplicación.

8. Marca

Las imágenes para la ventana de la aplicación se configuran en esta sección. Estas imágenes deben estar en formato GIF. La imagen de 16×16 aparece en la esquina superior izquierda de la ventana y la barra de tareas y la imagen de 32×32 aparece en el conmutador de aplicaciones Alt + Tab.

9. Licencias

Solución de problemas

1. Si el ejecutable generado no tiene una pantalla de bienvenida, vaya a plugin.xml -> Compilación binaria -> marque todos los recursos necesarios.

Categorías
Rich Client Platform(RCP)

Tutorial de Eclipse RCP: recopilación de recursos

Para aprender Eclipse RCP, leer un libro no es la forma más eficiente. Podemos encontrar muchos recursos gratuitos en línea. Aparte de programcreek.com, hay muchos tutoriales escritos por desarrolladores experimentados de Eclipse RCP. Aquí hay algunos recursos de aprendizaje que me han resultado útiles.

1. Sitio web del documento oficial de Eclipse: Documentación de Eclipse RCP

Este sitio web tiene documentación Java para usar la plataforma Eclipse y también algunos tutoriales escritos por esos escritores de documentos.

2. Referencia de puntos de extensión

Una lista de puntos de extensión disponibles en la plataforma.

3. Artículos de Eclipse Corner

Algunos artículos que sirven como ejemplo de «hola mundo».

4. Código de Google

Aprenda Eclipse leyendo el código fuente.

Categorías
Rich Client Platform(RCP)

Tutorial de Eclipse RCP: Cómo agregar una barra de progreso

Este tutorial trata sobre eclipse Job y consta de dos partes. La primera parte presenta cómo hacer una barra de progreso usando un ejemplo simple. La segunda parte ilustra brevemente el trabajo de Eclipse para el procesamiento en segundo plano.

1. Un ejemplo simple de barra de progreso en Eclipse

Suponga que tiene una aplicación RCP en funcionamiento con un menú «Hola mundo» de muestra y la acción correspondiente. (Esto se puede hacer en poco tiempo utilizando el asistente de extensión de eclipse)

Para informar el progreso de alguna tarea ejecutable, se requieren las siguientes clases:

1. org.eclipse.core.runtime.jobs.Job
(Los trabajos son unidades de trabajo ejecutables que se pueden programar para que se ejecuten con el administrador de trabajos. Una vez que se ha completado un trabajo, se puede programar para que se ejecute nuevamente)
2. org.eclipse.core.runtime.IProgressMonitor

Para tener una idea de cómo se ve una barra de progreso, simplemente reemplace el método de ejecución con el siguiente código. No hace un trabajo real, solo imita una tarea real.

	public void run(IAction action) {
		Job job = new Job("Test Job") {
			@Override
			protected IStatus run(IProgressMonitor monitor) {
				// Set total number of work units
				monitor.beginTask("start task", 100);
 
				for (int i = 0; i < 10; i++) {
					try {
						Thread.sleep(1000);
						monitor.subTask("doing " + i);
						// Report that 10 units are done
						monitor.worked(10);
					} catch (InterruptedException e1) {
						e1.printStackTrace();
					}
				}
				return Status.OK_STATUS;
			}
		};
 
		job.schedule();
	}

Agregue la siguiente declaración al método preWindowOpen de la clase ApplicationWorkbenchWindowAdvisor.

public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {
 
	public ApplicationWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
		super(configurer);
	}
 
	public ActionBarAdvisor createActionBarAdvisor(
			IActionBarConfigurer configurer) {
		return new ApplicationActionBarAdvisor(configurer);
	}
 
	public void preWindowOpen() {
		IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
		configurer.setInitialSize(new Point(400, 300));
		configurer.setShowCoolBar(false);
		configurer.setShowStatusLine(false);
		configurer.setTitle("RCP Application");
 
		configurer.setShowProgressIndicator(true);
	}
}

2. Habilitar el procesamiento en segundo plano

Suponga que tiene una aplicación cliente enriquecida con una vista y un botón. Cuando se hace clic en el botón, se inicia un trabajo que requiere mucho tiempo.

Si este costoso trabajo se implementa de una manera sencilla, es decir, se implementa en el hilo principal, la vista de la aplicación no responderá. Si hace clic en otro menú o botón, nadie responderá. Esto podría ser molesto para muchos usuarios y hacerles creer que necesitan terminar el proceso.

public void createPartControl(Composite parent) {
		Composite top = new Composite(parent, SWT.NONE);
 
		// setup the layout of top to be GridLayout.
		GridLayout layout = new GridLayout();
		layout.marginHeight = 0;
		layout.marginWidth = 0;
 
		top.setLayout(layout);
		Button button = new Button(top, SWT.PUSH);
 
		button.setText("test button");
 
		Listener listener = new Listener() {
		      public void handleEvent(Event event) { //expensive job below
		    	  for (int i = 0; i < 10; i++) {
		  			try {		  				
		  				Thread.sleep(2000);
		  				System.out.println(i);
		  			} catch (InterruptedException e) {
		  				e.printStackTrace();
		  			}
		    	  }
		      }
		    };
 
		button.addListener(SWT.Selection, listener); 
	}

Una posible solución es crear varios subprocesos y luego sincronizarlos entre sí. Esto debería funcionar, pero la plataforma Eclipse proporciona una forma sencilla.

Con Eclipse, podemos dedicar mucho tiempo a un trabajo. La clase Job, que se proporciona en el complemento org.eclipse.core.runtime, permite a los clientes ejecutar fácilmente el código en un subproceso separado. Además, se puede agregar fácilmente una barra de control de progreso.

 Listener listener = new Listener() {
		      public void handleEvent(Event event) {
 
		    	  Job job = new Job("test") {
		  			@Override
		  			protected IStatus run(IProgressMonitor monitor) {
		  				monitor.beginTask("start task", 100);
 
		  				//time consuming work here
		  				doExpensiveWork(monitor);
		  				//sync with UI				
		  				syncWithUI();
 
		  				return Status.OK_STATUS;
		  			}
 
		  		};
		  		job.setUser(true);
		  		job.schedule();  	  
		      }
		    };

doExpensiveWork y syncWithUI se definen de la siguiente manera:

	private void doExpensiveWork(IProgressMonitor monitor) {
		// mimic a long time job here
		for (int i = 0; i < 10; i++) {
			try {
				//give a progress bar to indicate progress
				monitor.worked(10);
 
				Thread.sleep(2000);
				System.out.println("step: " + i);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
 
	private void syncWithUI() {
		Display.getDefault().asyncExec(new Runnable() {
			public void run() {
				MessageDialog.openInformation(getSite().getShell(), "message",
						"completed!");
			}
		});
	}

asyncExec permite que el hilo de llamada sea asincrónico con el hilo de llamada. El autor de la llamada de este método continúa ejecutándose en paralelo y no se le notifica cuando se completa el ejecutable.

En su lugar, podemos usar syncExec, en cuyo caso el hilo que llama a este método se suspende hasta que se completa el ejecutable.

La diferencia es evidente en esta demostración. syncExec tiene que esperar que el usuario haga clic en el botón «Aceptar» para completar, mientras que asyncExec no lo hace.

Referencia

En el trabajo