Eclipse RCP Tutorials - beta

Using Simple JFace Message Boxes in an Eclipse RCP Application

2009-05-28T11:27:00.000-07:00

This article shows how to use JFace messages boxes in an RCP application and builds off of a clean RCP Application with a View. The full source code is found at the end of the article. Most if not all GUI applications frequently use message boxes to give or get information to or from the user. Jface provides us with 5 commonly used message boxes which can be conveniently used via a single static method. The available message boxes are:

MessageDialog.openQuestion()
MessageDialog.openInformation()
MessageDialog.openWarning()
MessageDialog.openConfirm()
MessageDialog.openError()

Each method takes as arguments a Shell that the message box belongs to, the title of the message box, and the message to be displayed in the message box. They each display an icon such as a question mark or a exclamation mark, etc. (For some reason the openQuestion message box displayes an exclamation point on a Mac?!?) and a button or buttons for the user to close the box or respond to a question. The openQuestion and openConfirm message boxes return a boolean corresponding to the users selection.

To demonstrate the JFace Message Boxes used in an Eclipse RCP application, a view containing a single button is created. When the button is clicked, a Question message box pops up, and depending on the boolean value returned, opens up either a Warning or an Information message box.

Step 0: Create a Hello World Eclipse RCP Application and add a View to it.

Step 1: Add code to the createPartControl() method in the application's view to add a button and set its action listener, coding the calls to the JFace message box static methods.


package com.eclipsercptutorials.jfacemessageboxes;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;

public class MainView extends ViewPart {

 public static final String ID = "com.eclipsercptutorials.JFaceMessageBoxes.MainView"; // the ID needs to match the id set in the view's properties

 public MainView() {}

 public void createPartControl(Composite parent) {

   Composite lMainViewComposite = new Composite(parent, SWT.NONE);

   Button lButton = new Button(lMainViewComposite, SWT.PUSH);
   lButton.setText("Question");
   lButton.addSelectionListener(new SelectionAdapter(){
     public void widgetSelected(SelectionEvent event){

     Shell lShell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();

     boolean isHavingFun = MessageDialog.openQuestion(lShell, "Information", "Are you having fun?");

       if(isHavingFun){

      MessageDialog.openInformation(lShell, "Information", "You are having fun! Java is awesome.");

       }else{

      MessageDialog.openWarning(lShell, "Warning", "You are NOT having fun! Go for a walk and get some fresh air.");

       }
     }
   });

   lMainViewComposite.setLayout(new RowLayout()); // this sets a Layout for the view's Composite

 }

 public void setFocus() {}

}

Step 2. Run the application and test if everything worked. Your application should now have a view with a single button that triggers a JFace question message box to pop up, and depending on the boolean value returned, opens up either a Warning or an Information message box:

Piece of Cake!!

Get the code: com.eclipsercptutorials.JFaceMessageBoxes.zip
<--- Previous - Add a Menu to a View in an Eclipse RCP Application
Also see: Eclipse RCP Tutorial Table of Contents

Add a Menu to a View in an Eclipse RCP Application

2009-05-20T22:59:00.000-07:00

This article shows how to add a menu to a View and builds off of a clean RCP Application with a View. The full source code is found at the end of the article. Eclipse RCP applications such as the Eclipse IDE, can have a toolbar and/or, as demonstrated here, a drop down menu located at the top of any View. With just a few lines of code you can easily add a menu to a View. By the way, see the article for adding a Toolbar to a View with this link.

Step 0: Create a Hello World Eclipse RCP Application and add a View to it.

Step 1: Create an Action that defines what will happen when the action in the menu is clicked. Make a new class that extends org.eclipse.jface.action.Action and implements IWorkbenchAction. The class needs a private static final String property used to set the ID in the constructor. Inside the run() method is where you put your custom code. In this "CustomAction" example, code is added to the run() method that opens up a JFace MessageDialog box using a handy static convenience method of the MessageDialog class.


package com.eclipsercptutorials.addviewmenu;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;

public class CustomAction extends Action implements IWorkbenchAction{

  private static final String ID = "com.timmolter.helloWorld.CustomAction";

  public CustomAction(){
    setId(ID);
  }

  public void run() {

    Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
    String dialogBoxTitle = "Message";
    String message = "You clicked the custom action from the menu!";
    MessageDialog.openInformation(shell, dialogBoxTitle, message);
  }

  public void dispose() {}

}

Step 2: Add the menu with its Action and icon to the View. In the View's createPartControl method new-up the CustomAction, and set the Action's tool-tip text and icon. In this example, a .png icon image called "bomb.png" was added to the icons folder in the plugin project. To find out where to find nice icons for Eclipse RCP projects see: Add an Icon to an Eclipse RCP Application View. Add the Action to the View's ToolBarManager using the getViewSite().getActionBars().getMenuManager().add(lCustomAction) method. Here the CustomAction was added to the same menu three times just to fill out the menu a bit, but you would of course add a set of several different Actions. Use a Separator in the menu to organize the Actions.


package com.eclipsercptutorials.addviewmenu;

import org.eclipse.jface.action.Separator;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;

public class MainView extends ViewPart {

  public static final String ID = "com.eclipsercptutorials.addViewMenu.MainView"; // the ID needs to match the id set in the view's properties

  public MainView() { }

  public void createPartControl(Composite parent) {

   // Custom Action for the View's Menu
   CustomAction lCustomAction = new CustomAction();
   lCustomAction.setText("Open Dialog Box");
   lCustomAction.setImageDescriptor(Activator.getImageDescriptor("icons/bomb.png"));
   getViewSite().getActionBars().getMenuManager().add(lCustomAction);
   getViewSite().getActionBars().getMenuManager().add(new Separator()); //Add a horizontal separator
   getViewSite().getActionBars().getMenuManager().add(lCustomAction);
   getViewSite().getActionBars().getMenuManager().add(lCustomAction);

  }

  public void setFocus() { }

}

Step 3: Run the application and test if everything worked. Your application should now have a View with a menu containing several Actions with a Separator. Clicking on one of the Actions opens up a MessageDialog. If you're not seeing it, nor the View's tab and title for that matter, make sure you specify that the title of the View should be shown in the layout.addStandaloneView() method of the Perspective's createInitialLayout() method - the second argument of the addStandaloneView() should be set to true.


package com.eclipsercptutorials.addviewmenu;

import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;

import com.eclipsercptutorials.addviewmenu.MainView;

public class Perspective implements IPerspectiveFactory {

  public void createInitialLayout(IPageLayout layout) {

   layout.addStandaloneView(MainView.ID, true, IPageLayout.LEFT, 1.0f, layout.getEditorArea());
   layout.setEditorAreaVisible(false); //hide the editor in the perspective
  }

}

Piece of Cake!!

Get the code: com.eclipsercptutorials.addViewMenu.zip
<--- Previous - Add a Toolbar to a View in an Eclipse RCP Application
---> Next - Using Simple JFace Message Boxes in an Eclipse RCP Application
Also see: Eclipse RCP Tutorial Table of Contents

Add a Toolbar to a View in an Eclipse RCP Application

2009-05-16T06:56:00.000-07:00

This article shows how to add a toolbar to a View and builds off of a clean RCP Application with a View. The full source code is found at the end of the article. Eclipse RCP applications such as the Eclipse IDE, can have a drop down menu and/or, as demonstrated here, a toolbar located at the top of any View. With just a few lines of code you can easily add an icon to a View's toolbar and have it activate an Action when clicked. By the way, see the article for adding a Menu to a View with this link.

Step 0: Create a Hello World Eclipse RCP Application and add a View to it.

Step 1: Create an Action that defines what will happen when the icon in the toolbar is clicked. Make a new class that extends org.eclipse.jface.action.Action and implements IWorkbenchAction. The class needs a private static final String property used to set the ID in the constructor. Inside the run() method is where you put your custom code. In this "CustomAction" example, code is added to the run() method that opens up a JFace MessageDialog box using a handy static convenience method of the MessageDialog class.


package com.eclipsercptutorials.addviewtoolbar;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;

public class CustomAction extends Action implements IWorkbenchAction{

private static final String ID = "com.timmolter.helloWorld.CustomAction";

public CustomAction(){
setId(ID);
}

public void run() {

Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
String dialogBoxTitle = "Message";
String message = "You clicked something!";
MessageDialog.openInformation(shell, dialogBoxTitle, message);

}

public void dispose() {}

}

Step 2:Add the toolbar with its Action and icon to the View. In the View's createPartControl method new-up the Action, and set the Action's tool-tip text and icon. In this example, a .png icon image called "bomb.png" was added to the icons folder in the plugin project. To find out where to find nice icons for Eclipse RCP projects see: Add an Icon to an Eclipse RCP Application View. Add the Action to the View's ToolBarManager using the getViewSite().getActionBars().getToolBarManager().add(lCustomAction) method.


package com.eclipsercptutorials.addviewtoolbar;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;

public class MainView extends ViewPart {

public static final String ID = "com.eclipsercptutorials.addViewToolBar.MainView"; // the ID needs to match the id set in the view's properties

public MainView() { }

public void createPartControl(Composite parent) {

 // Custom Action for the View's Menu
 CustomAction lCustomAction = new CustomAction();
 lCustomAction.setText("Open Dialog Box");
 lCustomAction.setImageDescriptor(Activator.getImageDescriptor("icons/bomb.png"));
 getViewSite().getActionBars().getToolBarManager().add(lCustomAction);

}

public void setFocus() { }

}

Step 3: Run the application and test if everything worked. Your application should now have a View with an icon in the View's toolbar, which opens up a MessageDialog when clicked. If you're not seeing it, nor the View's tab and title for that matter, make sure you specify that the title of the View should be shown in the layout.addStandaloneView() method of the Perspective's createInitialLayout() method - the second argument of the addStandaloneView() should be set to true.


package com.eclipsercptutorials.addviewtoolbar;

import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;

public class Perspective implements IPerspectiveFactory {

public void createInitialLayout(IPageLayout layout) {

 layout.addStandaloneView(MainView.ID, true, IPageLayout.LEFT, 1.0f, layout.getEditorArea());
 layout.setEditorAreaVisible(false); //hide the editor in the perspective

}
}

Piece of Cake!!

Get the code: com.eclipsercptutorials.addViewToolBar.zip
---> Next - Add a Menu to a View in an Eclipse RCP Application
<--- Previous - Animation in Eclipse RCP Applications - A Bouncing Ball
Also see: Eclipse RCP Tutorial Table of Contents

Animation in Eclipse RCP Applications - A Bouncing Ball

2009-04-21T12:09:00.000-07:00

This article shows how to add animation to an Eclipse RCP Application and builds off of a clean RCP Application with a View. The full source code is found at the end of the article. To demonstrate the animation, code is created that makes an image of the moon bounce around the view, using real physics equations to control the acceleration and spin. If you want a more in depth explanation of adding an image or updating the GUI from a worker thread please see the previous articles: Add an Image to an Eclipse RCP Application and Updating a Widget in an Eclipse RCP Application from a Worker Thread.

Step 0: Create a Hello World Eclipse RCP Application and add a View to it.

Step 1: Add an Image to the view . For this tutorial, an image of the moon with a transparent background called moon.png was prepared and added to the project.

Step 2: Create an inner class that implements Runnable, that updates the contents of the view at a regular interval. Later, during the initialization of the view, this worker thread is started, which calls the update() method of the view every ~15 milliseconds. The speed of the animation can be controlled by the TIMER_INTERVAL variable, which defines how long the thread should sleep before waking up and calling the update() method again.



class AnimatorThread implements Runnable{

  // The timer interval in milliseconds
  private static final int   TIMER_INTERVAL = 14;
  
  public void go(){
   
   Thread t = new Thread(this);
   t.start();
   
  }
  
  public void run() {
   try {
    while(true){
     animate();
     Thread.sleep(TIMER_INTERVAL);
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }

Step 3: Create the view's contents and start the worker thread. In the createPartControl() method of the view, create a Canvas where the image will be painted. Set the canvas's background color and add a paintListener to it with code defining where the image of the moon should be painted. Finally, new up the worker thread class and start it.


public void createPartControl(Composite parent) {
  
  parent.setBackground(new Color(parent.getDisplay(), 205, 38, 38));

  // Create the canvas for drawing
  canvas = new Canvas(parent, SWT.DOUBLE_BUFFERED);
  canvas.setBackground(new Color(parent.getDisplay(), 0,0,0));
     canvas.addPaintListener( new PaintListener() {

   public void paintControl(PaintEvent e) {
    
          GC gc = e.gc;
          Transform trans = new Transform(e.display );
          gc.getTransform( trans );
          trans.translate( x, y );
          trans.translate( IMAGE_WIDTH / 2f, IMAGE_WIDTH / 2f );
          trans.rotate( a );
          trans.translate( -IMAGE_WIDTH / 2f, -IMAGE_WIDTH / 2f );
          gc.setTransform( trans );
          trans.dispose();

          gc.drawImage( moon, 0, 0, moon.getBounds().width, moon.getBounds().height, 0, 0, IMAGE_WIDTH, IMAGE_WIDTH); // Draw the moon

   }
  });
 
     AnimatorThread at = new AnimatorThread();
     at.go();
 }

Step 4: Create the physics for the bouncing of the ball. Add some constants and variables as private members of the view class and an animate() method which calculates the next position of the moon. Last but not least, force a redraw of the canvas at the end of the animate() method. This invokes the code that was defined in the canvas's PaintListener.


 public void animate() {
    
  Display.getDefault().asyncExec(new Runnable(){
   
   public void run(){
    
    try{
     
     float left = x;
        float top = y;

        // Determine the ball's location
        directionY += GRAVITY;
        x += directionX;
        y += directionY;
        a += directionA;

        // Determine out of bounds
        Rectangle rect = canvas.getClientArea();
        if ( x > rect.width - IMAGE_WIDTH ) {
          x = rect.width - IMAGE_WIDTH;
          directionX = -directionX;
          directionA -= ( directionY - directionA ) * FRICTION_WALL;
        }
        if ( x < 0 ) {
          x = 0;
          directionX = -directionX;
          directionA += ( directionY - directionA ) * FRICTION_WALL;
        }

        if ( y > rect.height - IMAGE_WIDTH ) {
          directionY = (int) ( -GRAVITY * Math.sqrt( ( 1 + 8 * ( rect.height - IMAGE_WIDTH ) / GRAVITY ) ) / 2 );
          y = rect.height - IMAGE_WIDTH;
          directionA += ( directionX - directionA ) * FRICTION_FLOOR;
        }

        float right = left + IMAGE_WIDTH;
        float bottom = top + IMAGE_WIDTH;
        if ( x < left )
          left = x;
        else
          right = x + IMAGE_WIDTH;
        if ( y < top )
          top = y;
        else
          bottom = y + IMAGE_WIDTH;
        
        // Force a redraw
        canvas.redraw( (int) Math.floor( left ) - 1, (int) Math.floor( top ) - 1, (int) ( Math.ceil( right ) - Math.floor( left ) ) + 2, (int) ( Math.ceil( bottom ) - Math.floor( top ) ) + 2, false );
        
    }catch(SWTException e){
     //eat it!
    }
   }
  });

   }

Step 5: Run the application and test if everything worked. Your application should now have an image of the moon in the view that bounces back and forth across the view. As you resize the view, the moon's boundaries are recalculated.

Here's the full code of the view:


package com.eclipsercptutorials.animation;

import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.graphics.Transform;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.part.ViewPart;

public class MainView extends ViewPart {
 
 public static final String ID = "com.eclipsercptutorials.animation.mainView"; // the ID needs to match the id set in the view's properties
 
 // The image
 private Image moon;
 
 // The image width
 private static int IMAGE_WIDTH = 85;

 // Rate of downward acceleration per frame
 private static final float GRAVITY        = .25f;
 
 // Coefficient of friction
 private static final float FRICTION_FLOOR = 5f / 9f;
 private static final float FRICTION_WALL  = 5f / 11f;
 
 // The location of the "ball"
 private float              x              = 0;
 private float              y              = 0;
 private float              a              = 0;
 
 // The direction the "ball" is moving
 private float              directionX     = 4;
 private float              directionY     = 0;
 private float              directionA     = 0;
 
 // We draw everything on this canvas
 private Canvas             canvas;
 
 public MainView() {
  
  moon = Activator.getImageDescriptor("icons/moon.png").createImage();
  
 }

 public void createPartControl(Composite parent) {
  
  parent.setBackground(new Color(parent.getDisplay(), 205, 38, 38));

  // Create the canvas for drawing
  canvas = new Canvas(parent, SWT.DOUBLE_BUFFERED);
  canvas.setBackground(new Color(parent.getDisplay(), 0,0,0));
     canvas.addPaintListener( new PaintListener() {

   public void paintControl(PaintEvent e) {
    
          GC gc = e.gc;
          Transform trans = new Transform(e.display );
          gc.getTransform( trans );
          trans.translate( x, y );
          trans.translate( IMAGE_WIDTH / 2f, IMAGE_WIDTH / 2f );
          trans.rotate( a );
          trans.translate( -IMAGE_WIDTH / 2f, -IMAGE_WIDTH / 2f );
          gc.setTransform( trans );
          trans.dispose();

          gc.drawImage( moon, 0, 0, moon.getBounds().width, moon.getBounds().height, 0, 0, IMAGE_WIDTH, IMAGE_WIDTH); // Draw the moon

   }
  });
     
     AnimatorThread at = new AnimatorThread();
     at.go();
 }
     
   public void animate() {
    
  Display.getDefault().asyncExec(new Runnable(){
   
   public void run(){
    
    try{
     
     float left = x;
        float top = y;

        // Determine the ball's location
        directionY += GRAVITY;
        x += directionX;
        y += directionY;
        a += directionA;

        // Determine out of bounds
        Rectangle rect = canvas.getClientArea();
        if ( x > rect.width - IMAGE_WIDTH ) {
          x = rect.width - IMAGE_WIDTH;
          directionX = -directionX;
          directionA -= ( directionY - directionA ) * FRICTION_WALL;
        }
        if ( x < 0 ) {
          x = 0;
          directionX = -directionX;
          directionA += ( directionY - directionA ) * FRICTION_WALL;
        }

        if ( y > rect.height - IMAGE_WIDTH ) {
          directionY = (int) ( -GRAVITY * Math.sqrt( ( 1 + 8 * ( rect.height - IMAGE_WIDTH ) / GRAVITY ) ) / 2 );
          y = rect.height - IMAGE_WIDTH;
          directionA += ( directionX - directionA ) * FRICTION_FLOOR;
        }

        float right = left + IMAGE_WIDTH;
        float bottom = top + IMAGE_WIDTH;
        if ( x < left )
          left = x;
        else
          right = x + IMAGE_WIDTH;
        if ( y < top )
          top = y;
        else
          bottom = y + IMAGE_WIDTH;
        
        // Force a redraw
        canvas.redraw( (int) Math.floor( left ) - 1, (int) Math.floor( top ) - 1, (int) ( Math.ceil( right ) - Math.floor( left ) ) + 2, (int) ( Math.ceil( bottom ) - Math.floor( top ) ) + 2, false );
        
    }catch(SWTException e){
     //eat it!
    }
   }
  });

   }
   

 public void setFocus() {}
 
 class AnimatorThread implements Runnable{

  // The timer interval in milliseconds
  private static final int   TIMER_INTERVAL = 14;
  
  public void go(){
   
   Thread t = new Thread(this);
   t.start();
   
  }
  
  public void run() {
   try {
    while(true){
     animate();
     Thread.sleep(TIMER_INTERVAL);
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}

Piece of Cake!!

Get the code: com.eclipsercptutorials.animation.zip
<--- Previous - Updating a Widget in an Eclipse RCP Application from a Worker Thread
---> Next - Add a Toolbar to a View in an Eclipse RCP Application
Also see: Eclipse RCP Tutorial Table of Contents

Updating a Widget in an Eclipse RCP Application from a Worker Thread

2009-04-04T10:37:00.000-07:00

This article shows how to update an Eclipse RCP Application widget from a worker thread and builds off of a clean RCP Application with a View. When programming GUI applications, it's often necessary to run a background processes to do some calculations or coordinate timed events. If these processes run on the main (GUI) thread, the GUI will be unresponsive to users' clicks during the process, leading to a bad user experience. To get around this problem, worker threads can be created to do the processing, leaving the GUI thread responsive to user input. The catch though is that you can't update any GUI components (SWT or JFace widgets in this case) from the worker thread. If you try to you get an exception such as: Exception in thread "Thread-3" org.eclipse.swt.SWTException: Invalid thread access. And worse, the compiler won't warn you of this pitfall. In this tutorial an Eclipse RCP application with a view is created, and a label is updated every second from a worker thread.

Step 0: Create a Hello World Eclipse RCP Application and add a View to it.

Step 1: Create a worker thread class. The following class called WorkerThread implements Runnable and is passed a reference to the MainView class. In its run method, which must be implemented, a counter is initialized to zero and is incremented by one followed by a one second pause. Right before the incrementation the updateLabelText method in the MainView is called. A go() method is added to the class to create the thread and call the run method.


package com.eclipsercptutorials.workerthread;

class WorkerThread implements Runnable{

// The timer interval in milliseconds
private static final int   TIMER_INTERVAL = 1000;

private MainView mainView;

public WorkerThread(MainView mainView){
this.mainView = mainView;
}

public void go(){

Thread t = new Thread(this);
t.start();

}

public void run() {
int counter = 0;
try {
while(mainView != null){
mainView.updateLabelText("Counter = " + counter);
counter++;
Thread.sleep(TIMER_INTERVAL);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

Step 2: Add a label to the MainView and start the worker thread in the createPartControl method.


public void createPartControl(Composite parent) {

label = new Label(parent, SWT.None); //new up a Label widget
WorkerThread workerThread = new WorkerThread(this);
workerThread.go();
}

Step 3: Add a method in the MainView class that updates the label's text and is called by the worker thread. The method called updateLabelText in MainView uses the Display's asyncExec method to post a Runnable that is executed in the main thread enabling the update of the Label widget from the worker thread. In the Runnable's run method make sure the widget isn't null or disposed first.


package com.eclipsercptutorials.workerthread;

import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.part.ViewPart;

public class MainView extends ViewPart {

public static final String ID = "com.eclipsercptutorials.workerThread.mainView"; // the ID needs to match the id set in the view's properties

public Label label;

public MainView() {}

public void createPartControl(Composite parent) {

label = new Label(parent, SWT.None); //new up a Label widget
WorkerThread workerThread = new WorkerThread(this);
workerThread.go();
}

public void setFocus() {}

public void updateLabelText(final String labelText){

try{
Display.getDefault().asyncExec(new Runnable(){
public void run(){
if(!label.isDisposed() && label !=null){
label.setText(labelText);
}
}
});
}catch(SWTException e){
//eat it!
}
}
}

Step 3: Run the application and test if everything worked. Your application should now have a label in the view that updates its value each second and look something like this:
Piece of cake!!

Get the code: com.eclipsercptutorials.workerThread.zip
<--- Previous - Add an Image to an Eclipse RCP Application
---> Next - Animation in Eclipse RCP Applications - A Bouncing Ball
Also see: Eclipse RCP Tutorial Table of Contents

Add an Image to an Eclipse RCP Application

2009-03-29T08:00:00.000-07:00

This article shows how to add an image to a view in an Eclipse RCP application and builds off of a clean RCP Application with a View. Images used in an RCP application are managed by an ImageRegistry that is global to the scope of a plugin. If your project has a class that extends AbstractUIPlugin, then there is a static method you can use called getImageDescriptor() to access ImageDescriptors given a path to the image. The Activator class ectending AbstractUIPlugin is automatically generated if you used the wizard to create a Hello World Eclipse RCP Application. The ImageRegistery is the preferred means of handling images in your application because it handles the lazy loading of the images and disposes of them properly when needed. The image is added to a view by adding a canvas to the view's parent composite and adding the image from the image descriptor to the canvas through its addPaintListener method. It may sound confusing, but in practice it's really simple.

Step 0: Create a Hello World Eclipse RCP Application and add a View to it.

Step 1: Add the image into the RCP plugin project. In this example an image called moon.png is added to the "icons" folder inside the plugin project. Whether you use this folder or not is really not important - you can organize your images any way you want. In the next step, the path to the image's location is used to get the image.

Step 2: Add the image to the view. In the view's class where you want the image to appear, add a global Image field and set it in the view's constructor calling the Activator.getImageDescriptor("icons/moon.png").createImage(); method. Adjust the path accordingly to locate your image. The path is relative to the plugin. In the createPartControl method, add a Canvas to the view's parent Composite and define its PaintEvent to draw the image. In the drawImage method, give it the image and the x and y coordinates where it should be drawn.


package com.eclipsercptutorials.addimagetoview;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;

public class MainView extends ViewPart {

public static final String ID = "com.eclipsercptutorials.addimagetoview.mainView"; // the ID needs to match the id set in the view's properties

private Image image;

public MainView() {

image = Activator.getImageDescriptor("icons/moon.png").createImage();
}

@Override
public void createPartControl(Composite parent) {

// Create the canvas for drawing
Canvas canvas = new Canvas( parent, SWT.NONE);
canvas.addPaintListener( new PaintListener() {
public void paintControl(PaintEvent e) {
     GC gc = e.gc;
     gc.drawImage( image,10,10); // Draw the moon
}
});
}


public void setFocus() {}

}

Step 3: Run the application and test if everything worked. Your application should now have an image in the view and look something like this:

Piece of cake!!

Get the code: com.eclipsercptutorials.addimagetoview.zip
<--- Previous - Import and Export an Eclipse RCP Application Project
---> Next - Updating a Widget in an Eclipse RCP Application from a Worker Thread
Also see: Eclipse RCP Tutorial Table of Contents

Import and Export an Eclipse RCP Application Project

2009-03-23T11:46:00.000-07:00

This article shows how to import and export an Eclipse RCP application to and from the Eclipse IDE workbench. Importing is necessary for example, when you want to download a sample RCP project from the internet and run it yourself. Also, you may need to export your RCP project if you are working on a team of developers and you need to get your code to someone. Importing and exporting an RCP project is easily done by following these steps.

Import

Step 0: Download, transfer and/or locate the RCP project. If you need a practice RCP project, here's on for you: com.eclipsercptutorials.addMenu.zip. If you download this, you'll need to unzip it. Or you can download any of the projects found at the end of most of the tutorials on this website.

Step 1: Choose File ---> Import. Or right click somewhere in the package explorer to find the import action.

Step 2: On the first page of the Import wizard choose "Existing Projects into Workspace" in the "General" folder. Click Next.
Step 3: On the second page of the Import wizard choose browse for and select the project folder you want to import. Check "Copy projects into workspace". Click Finish. The project now appears in the package explorer!
Export

Step 0: Right-click on the project you'd like to export and choose "Export".

Step 1: On the first page of the Export wizard choose "File System" in the "General" folder. Click Next.
Step 2: On the second page of the Export wizard click on "Browse..." and select the location where you want to export the project. Click Finish. The project is now exported! Now you can zip up the project folder and email it or archive it for example.

Piece of cake!!

<--- Previous - Verify User Intent Before Closing an Eclipse RCP Application
---> Next - Add an Image to an Eclipse RCP Application
Also see: Eclipse RCP Tutorial Table of Contents

Verify User Intent Before Closing an Eclipse RCP Application

2009-03-22T07:26:00.000-07:00

This article shows how ask the user if s/he really intends to close a RCP application and builds off of a clean Hello World Eclipse RCP Application. Use this feature sparingly with your applications because it can be an annoying "feature". The best solution would be to add a preference to the application where the user could decide if s/he wanted the reminder or not. Look for a tutorial on how to ad the preferences soon.

Step 0: Create a HelloWorld RCP application.

Step 1: Add code to create the dialog box when the close application action is triggered. In the ApplicationWorkbenchAdvisor class that was automatically generated during step 0, you need to override the preShutdown() method. The method returns a boolean where, if true, the application will shut down, and if false, the application will continue running. You need to add code in that method that opens up a dialog box, gets user input, and returns what the user selected. Eclipse's JFace library contains a nice little class called MessageDialog where we can easily make a dialog box pop up, ask a question, and get the yes/no answer. We use the MessageDialog.openQuestion() method and pass it three parameters: a Shell, the dialog box's title, and the question we want to ask.


package com.eclipsercptutorials.verifyintent;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
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 = "com.eclipsercptutorials.verifyIntent.perspective";

public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
 return new ApplicationWorkbenchWindowAdvisor(configurer);
}

public String getInitialWindowPerspectiveId() {
return PERSPECTIVE_ID;
}


public boolean preShutdown(){

Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
String dialogBoxTitle = "Question";
String question = "Are you sure you want to close this application?";
return MessageDialog.openQuestion(shell, dialogBoxTitle, question);

}

}

Step 2: Run the application and test if everything worked. Your application should now have a dialog box that verifies user intent when the application is closed and look something like this:

Piece of Cake!

Get the code: com.eclipsercptutorials.verifyIntent.zip
---> Next - Import and Export an Eclipse RCP Application Project
<--- Previous - Add a Custom Menu Action to an Eclipse RCP Application
Also see: Eclipse RCP Tutorial Table of Contents

Add a Custom Menu Action to an Eclipse RCP Application

2009-03-22T06:12:00.000-07:00

This article shows how to add a custom menu item to a menu in an Eclipse RCP application and builds off of a clean Hello World Eclipse RCP Application. As shown in the article Add a Menu to an Eclipse RCP Application, it is very easy to add a File menu containing the Exit action. Here a custom menu action is added to the File menu that opens a dialog box when clicked.

Step 0: Create a HelloWorld RCP application.

Step 1: Make the custom action. Create a new class that extends org.eclipse.jface.action.Action and implements IWorkbenchAction. The class needs a private static final String property used to set the ID in the constructor. Inside the run() method is where you put your custom code. In this example, code is added that opens up a message dialog box.


package com.eclipsercptutorials.customaction;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;

public class CustomAction extends Action implements IWorkbenchAction{

private static final String ID = "com.timmolter.helloWorld.CustomAction";

public CustomAction(){
setId(ID);
}

public void run() {

Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
String dialogBoxTitle = "Message";
String message = "You clicked the custom action from the menu!";
MessageDialog.openInformation(shell, dialogBoxTitle, message);
}

public void dispose() {}

}

Step 2: In the ApplicationActionBarAdvisor class add the CustomAction as a private field. In the makeActions() method, new up the custom action, set its text and accelerator and register it. The accelerator is of course optional and it simply adds a keyboard shortcut, in this case CTRL+T. In the fillMenuBar() method, add the action to a File Menu.


package com.eclipsercptutorials.customaction;

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;

public class ApplicationActionBarAdvisor extends ActionBarAdvisor {

private CustomAction customAction;

public ApplicationActionBarAdvisor(IActionBarConfigurer configurer) {
 super(configurer);
}

protected void makeActions(IWorkbenchWindow window) {

//Custom action
 customAction = new CustomAction();
 customAction.setText("Do custom action!");
 customAction.setAccelerator(SWT.CTRL + 'T');
 register(customAction);
}

protected void fillMenuBar(IMenuManager menuBar) {

 MenuManager fileMenu = new MenuManager("&File", "file"); //create a menuManager to take care of all submenus in "File"
 fileMenu.add(customAction); //Add the "customAction" action
 menuBar.add(fileMenu); //Add the "File" menu to the menuBar
}

}

Step 3: Run the application and test if everything worked. Your application should now have a File Menu containing a custom action:

When the custom action is clicked or CTRL+T is entered, a messaage box should come up:
Piece of cake!

Get the code: com.eclipsercptutorials.customAction.zip
---> Next - Verify User Intent Before Closing an Eclipse RCP Application
<--- Previous - Add Nested Menu Items to an Eclipse RCP Application
Also see: Eclipse RCP Tutorial Table of Contents

Add Nested Menu Items to an Eclipse RCP Application

2009-03-21T05:42:00.000-07:00

This article shows how to add nested menu items to a menu in an Eclipse RCP application and builds off of a clean Hello World Eclipse RCP Application. As shown in the article Add a Menu to an Eclipse RCP Application, it is very easy to add a File menu containing the Exit action. Here the Exit action as well as About and Preferences are added to a submenu called Expand in the File menu to demonstrate nested menu items.

Step 0: Create a HelloWorld RCP application.

Step 1: Add the nested menu actions. Open up the ApplicationActionBarAdvisor class and add the three About, Preferences, and Exit actions as private fields. In makeactions(), define the actions and register them. In the fillMenuBar() method, create two instances of MenuManager, one for the File and one for Expand. Add the three actions to the Expand MenuManager. A Separator is added before the Exit action for the sake of demonstrating this nice menu organizing feature. Next add the Expand MenuManager to the File MenuManager. Finally add the File MenuManager to the menubar.

package com.eclipsercptutorials.nestedmenu;

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;

public class ApplicationActionBarAdvisor extends ActionBarAdvisor {

private IWorkbenchAction aboutAction;
private IWorkbenchAction preferencesAction;
private IWorkbenchAction exitAction;

public ApplicationActionBarAdvisor(IActionBarConfigurer configurer) {
 super(configurer);
}

protected void makeActions(IWorkbenchWindow window) {

 //ActionFactory Actions, the ActionFactory defines a set of common actions and can be used in our application.
 aboutAction = ActionFactory.ABOUT.create(window);
 register(aboutAction); //register the action so it is deleted when the Workbench window is closed
 preferencesAction = ActionFactory.PREFERENCES.create(window);
 register(preferencesAction);
 exitAction = ActionFactory.QUIT.create(window);
 register(exitAction);
}

protected void fillMenuBar(IMenuManager menuBar) {

 MenuManager fileMenu = new MenuManager("&File", "file"); //create a menuManager to take care of all submenus in "File"

 MenuManager expandingMenu = new MenuManager("&Expand", "expand");
      expandingMenu.add(aboutAction); //Add the "about" action
      expandingMenu.add(preferencesAction); //Add the "preferences" action
      expandingMenu.add(new Separator()); //Add a horizontal separator
      expandingMenu.add(exitAction); //Add the "exit" action

 fileMenu.add(expandingMenu); //Add the expanding menu to the "File" menu
 menuBar.add(fileMenu); //Add the "File" menu to the menuBar
}

}

Step 2: Run the application and test if everything worked. Your application should now have a new menu containing a group of actions nested in a parent menu:

Piece of cake!

Get the code: com.eclipsercptutorials.nestedmenu.zip
---> Next - Add a custom Menu Action to an Eclipse RCP Application
<--- Previous - Add a Menu to an Eclipse RCP Application
Also see: Eclipse RCP Tutorial Table of Contents

Add a Menu to an Eclipse RCP Application

2009-03-20T12:53:00.000-07:00

This article shows how to add a menu containing an action to an Eclipse RCP application and builds off of a clean Hello World Eclipse RCP Application. In particular, the "Exit" action will be added to a "File" menu. Doing so is very simple, requiring only a few lines of code in one class. The application's menu is used to provide the user with a logical and organized interface to access all the global functions of the application. For example, almost all applications have a File--->Exit or a Help---> About menu. An Eclipse RCP application menu can be as simple or elaborate as needed, and it can contain icons, dividers, and expanding submenus. The following steps demonstrate how to add the Exit action to a File menu to an Eclipse RCP application.

Step 0: Create a HelloWorld RCP application.

Step 1: Add code to create the File menu and the Exit action. When you created a hello world application using the new RCP application wizard in Eclipse, it created a ApplicationActionBarAdvisor class that extends ActionBarAdvisor. You need to override 2 of the methods to configure the application's menu to suit the needs of the particular application. During certain strategic points in the workbench's lifecycle, these methods are called and the menu is created. In makeActions(), the Exit action is created and registered. In fillMenuBar() the File menu is created, the Exit action is added to the File menu, and the File menu is added to the application's menu bar.


package com.eclipsercptutorials.addmenu;

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;

public class ApplicationActionBarAdvisor extends ActionBarAdvisor {

IWorkbenchAction exitAction;

public ApplicationActionBarAdvisor(IActionBarConfigurer configurer) {
   super(configurer);
}

protected void makeActions(IWorkbenchWindow window) {

   exitAction = ActionFactory.QUIT.create(window); //the ActionFactory defines a set of common actions and can be used in the application.
   register(exitAction);  //register the action so they are deleted when the Workbench window is closed

}

protected void fillMenuBar(IMenuManager menuBar) {

   MenuManager fileMenu = new MenuManager("&File", "file"); //create a menuManager to take care of all submenus in "File"
   fileMenu.add(exitAction); //Add the "exit" action
   menuBar.add(fileMenu);//Add the "File" menu to the menuBar

}

}

Step 2: Run the application and test if everything worked. Your application should now have a File menu with an Exit action and look something like this:

Piece of Cake!

Get the code: com.eclipsercptutorials.addMenu.zip
---> Next - Add Nested Menu Items to an Eclipse RCP Application
<--- Previous - Add an Icon to an Eclipse RCP Application View
Also see: Eclipse RCP Tutorial Table of Contents

Add an Icon to an Eclipse RCP Application View

2009-03-15T02:45:00.000-07:00

This article shows how to add an icon to a view in an Eclipse RCP application and builds off of a clean Hello World Eclipse RCP Application. In RCP applications, views are where you put things like tables, buttons, combo boxes, labels, charts, etc. - all the graphical interfaces that a user will interact with when using your application.

Step 0: Create a HelloWorld RCP application.

Step 1: Get some icons. Mark James at www.famfamfam.com has graciously created and made available over 1000 icons suitable for Eclipse RCP applications. His work is licensed under a Creative Commons Attribution 2.5 License, so you can use the icons any way you like. Download the icons, browse through them, and choose one that you'd like to use for your view.

Step 2: Add the icon to your RCP application. With Eclipse open and the Package Explorer showing the contents of your project, drag and drop an icon into the "icons" folder. For this example, I put the bomb.png icon into the icons folder.

Step 3: Add a View to the Eclipse RCP Application

Step 4: Add the icon to a view. Make sure the View is highlighted in the All Extensions list. To the right are the properties of the view. To the right of the icon property, click on the "Browse..." button. In the dialog box that pops up, choose the icon that you just added. The icon should show up next to the view's name in the "All Extensions" list.

Collapse and re-expand the org.eclipse.ui.views extension point and the icon should be visible next to the view.

Step 5: Specify that the view's title should be shown. Now that the icon is added to the application project and associated with the view, some code is needed to tie everything together. In Perspective.java set the boolean flag for the second argument in the "addStandAloneView" method to true (line 10). This is the "showTitle" flag which tells the RCP application to show a tab for the view containing the icon and a title for the view.


package com.blogspot.eclipsercptutorials.addicon;

import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;

public class Perspective implements IPerspectiveFactory {

public void createInitialLayout(IPageLayout layout) {

layout.addStandaloneView(MainView.ID, true, IPageLayout.LEFT, 1.0f, layout.getEditorArea());
layout.setEditorAreaVisible(false); //hide the editor in the perspective

}
}

Step 6: Give the view's tab a name. In the view's class, add the line "this.setPartName("Hello!");" to the createPartControl method (line 16). Change the "Hello!" String to whatever you want.


package com.blogspot.eclipsercptutorials.addicon;

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.part.ViewPart;

public class MainView extends ViewPart {

public static final String ID = "com.blogspot.eclipsercptutorials.addicon.mainView"; //the ID needs to match the id set in the view's properties

public MainView() {    }

public void createPartControl(Composite parent) {

this.setPartName("Hello!");

Label label = new Label(parent, SWT.None); //new up a Label widget
label.setText("  All this program does is display this text in a view."); //set the label's text

}

public void setFocus() { }

}

Step 7: Run the application and test if everything worked. Your application should now look something like this:

Step 8: If you want the view to be non-closeable, add layout.getViewLayout(MainView.ID).setCloseable(false);" to the createInitialLayout" method (line 12). This will hide the little "X" on the tab and not allow the tab to be closed, which you probably want to do if your program only has one view.



package com.blogspot.eclipsercptutorials.addicon;

import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;

 public class Perspective implements IPerspectiveFactory {

 public void createInitialLayout(IPageLayout layout) {

  layout.addStandaloneView(MainView.ID, true, IPageLayout.LEFT, 1.0f,   layout.getEditorArea());
  layout.setEditorAreaVisible(false); //hide the editor in the perspective
  layout.getViewLayout(MainView.ID).setCloseable(false);
 }
}

Piece of cake!

Get the code: com.blogspot.eclipsercptutorials.addicon.zip
<--- Previous - Adding a View to an Eclipse RCP Application
Next ---> Add a Menu to an Eclipse RCP Application
Also see: Eclipse RCP Tutorial Table of Contents

Adding a View to an Eclipse RCP Application

2009-03-13T14:52:00.000-07:00

As shown in the article Hello World with Eclipse RCP - Your First Application, it is quite simple to create and run your own very basic Java RCP application using Eclipse. This article shows you how to add a "View" to your application. Part of learning how to create RCP applications using Eclipse is to learn the terminology people use. A view is the part of your application where you put things like tables, buttons, combo boxes, labels, charts, etc. - all the graphical interfaces that a user will interact with when using your application. These visible units of interaction are called "widgets" and Eclipse provides us with many customizable widgets in the SWT and JFACE libraries.

When an RCP application starts up, a string of events occurs under the hood that generates a stand-alone window containing all your customized widgets that give your program its unique look and functionality. At the top of the hierarchy is the Application class and contains the application's main method (actually called "start()"). In the start() method, a single Workbench object is created, which is a behind-the-scenes class controlling your RCP application. The Workbench in turn contains one or more WorkbenchWindow objects, which are the visible windows making up your program. In most cases you just have one WorkbenchWindow. A WorkbenchWindow in turn contains a menu (optional), a toolbar (optional), and/or one or more Perspective objects. In most cases you just have one Perspective. A Perspective in turn contains one Editor object and/or one or more View objects. View objects in turn contain one or more Widgets, which are the finest grain visible units of the RCP application. As a visual example of all this, look at the following BitTorrent application called Vuze (aka Azureus). You see a WorkbenchWindow with a menu, a toolbar, and two views called "My Torrents" and "Statistics". The "Statistics" view contains Tab widgets which in turn contain other widgets.

As a review, the hierarchy is like this:

Application
|
Workbench
|
WorkbenchWindow(s)
|
Perspective(s) Menu Toolbar
|
View(s) Editor
|
SWT and/or JFace Widget(s)

When Eclipse set up a HelloWorld RCP application for you with a wizard described here, it generated an Application, a Workbench, and a WorkbenchWindow with a Perspective. This article shows how to build off of that, by adding a View with a Label widget containing some text to the View. Let's get to it...

Step 0: Create a HelloWorld RCP application.

Step 1: Add the "views" extension point to your RCP project. Click on the "Extensions" tab along the bottom of the view in Eclipse that shows all the properties for your RCP project. If you don't see that view, double-click on "MANIFEST.MF" in the "META-INF" folder in your project folder in the Package Explorer. Here, you need to add an extension point to your application. Click "Add..." and a dialog box will pop up for selecting a new extension point. Scroll down and find the extension point called "org.eclipse.ui.views", select it and click "Finish".

Step 2: Add a View to your RCP project. You should now see the org.eclispe.ui.views extension added to the "All Extensions" list for your project. Right-click on "org.eclispe.ui.views" and select New --> view.

Step 3: Set the properties of the View. Make sure the View is highlighted in the All Extensions list. To the right you will be able to set some properties of the view. For right now, just the first two properties need to be set. In this example an id of com.blogspot.eclipsercptutorials.mainView and a name of MainView.

Step 4: Generate the view's class. In the properties list click on the "class" link. This will bring up a wizard. Leave everything at the default values but give it a name that matches the name you entered in the name property before. Click "Finish".

Step 5: Add some code to the MainView class that you generated earlier. You need to make sure a "public static final String" field called ID is defined and set equal to the id that you set in the view's properties editor. Also, in createPartControl() add two lines of code that creates a Label widget and set it's text. You may find that when you add the Label code you get an error "Label cannot be resolved to a type". This is because you haven't added an import statement yet above the class definition. The import statements tell the compiler what classes your class will be using. If you ever get an error like that, you can click on the class name, i.e. "Label", in your code and type ctrl+m (windows or Linux) or command+m (Mac). Make sure to always choose the SWT version of the widget and not the Swing or other type of class with the same name.


package com.blogspot.eclipsercptutorials.addview;

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.part.ViewPart;

public class MainView extends ViewPart {

  public static final String ID = "com.blogspot.eclipsercptutorials.mainView"; // the ID needs to match the id set in the view's properties

  public MainView() { }

  public void createPartControl(Composite parent) {

    Label label = new Label(parent, SWT.None); //new up a Label widget
    label.setText("  All this program does is display this text in a view."); //set the label's text

  }

  public void setFocus() { }

}

Step 6: Add the view to the application's perspective. Remember how when you used the wizard in Eclipse to create a standalone HelloWrold application and it generated a perspective for you automatically? And remember that views are children of perspectives? The Perspective class in your project should look similar to the following if you want it to add your new view. Open Perspective.java and add the two lines of code shown below in the createInitialLayout method.


package com.blogspot.eclipsercptutorials.addview;

import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPerspectiveFactory;

public class Perspective implements IPerspectiveFactory {

  public void createInitialLayout(IPageLayout layout) {

    layout.addStandaloneView(MainView.ID, false, IPageLayout.LEFT, 1.0f, layout.getEditorArea());
    layout.setEditorAreaVisible(false); //hide the editor in the perspective
  }
}

Step 7: Run your application. Congrats, you now have an Eclipse RCP application with a view! The view gives you a place to add more widgets and add funtionality to your program. The next things you'll want to add to your program are things like a menu, an editor, more views, status bars, a toolbar, and widgets.

Get the code: com.blogspot.eclipsercptutorials.addView.zip
Next --->Add an Icon to an Eclipse RCP Application View
<--- Previous - Hello World with Eclipse RCP - Your First Application
Also see: Eclipse RCP Tutorial Table of Contents

Hello World with Eclipse RCP - Your First Application

2009-03-10T13:27:00.000-07:00

As discussed in the article Using Eclipse for RCP Application Development, Eclipse is free and open-source software that people use to develop Java-based applications called Rich Client Platform (RCP) applications. Using a computer with any operating system (in this tutorial Mac OS X), you can use Eclipse to create an advanced program that can be deployed on Mac, Linux, and/or Windows OS. This article shows how easy it is to get started using Eclipse and make your very own application even if you never wrote a line of code in your life. The program is going to be the classic "Hello World" application that programmers often write as their first program when trying out a new coding language or Integrated Development Environment (IDE). Before following along you'll need to have Eclipse and the Java Runtime Environment (JRE) installed as described here.

Step 0: Launch Eclipse and choose a "workspace". The workspace is where all the files needed for the application, either generated by Eclipse or written by you, will be located. The location I chose for my workspace is in a folder called "workspace" located in the directory that my Eclipse IDE folder resides. Once your application is created, you can navigate to that folder on your hard drive and actually find the files there.
Step 1: Launch the new project wizard in Eclipse. Select "File" from the menu, choose "New" and click "Project".

Step 2: When the new project wizard launches, select "Plugin Project" and click "Next".

Step 3: Enter a Project name and click "Next". The nomenclature that Java developers use is [top-level domain.secondary-level domain (if any).your personal or organization's domain name.project name], in this example com.blogspot.eclipsercptutorials.helloWorld. The reason for this is to avoid projects with the same name existing elsewhere in the world. If you named your project HelloWorld, there is a chance that there will be other projects out there named the exact same thing. Often people share their projects and source code, and having a consistent project naming system keeps things in order. The point is to have a unique name that no one else will use.

Step 4: Choose "Yes" for "Would you like to create a rich client application?" and click "Next".

Step 5: Select the "Hello RCP" template and click "Finish".

Step 6: You may be asked if you want to use the Plug-in Development perspective. Choose "Yes". This just specifies how you want the Eclipse IDE to be laid out when working on RCP applications.

Step 7: The new project wizard has created a project for you with all the necessary files and settings to make it an RCP Application. On the left side of the IDE you will see a view called "Package Explorer" which contains your new Hello World application files. These files shown in the view match what is found in your workspace folder, which you set up earlier. Navigate to your workspace folder and you should see your new project there.

Step 8: Launch your Hello World application. To do this, you need to be looking at the "Overview" shown in the center view above. This should have been the default thing displayed, but if it is not, just double-click on "MANIFEST.MF" in the "META-INF" folder in your new project folder in the Package Explorer view. On the "Overview" tab, click on the link called "Launch an Eclipse Application" in the "Testing" area. A small window should pop up with "Hello RCP" written at the top. Congrats, you just created and ran your first Eclipse RCP application!

After you close the program, feel free to look around the Overview of your project and also the "src" folder that is part of your project. The "src" folder is where the code that defines your program resides. There should be a package named the same as your project containing a handful of .java files. If you double-click on any of the .java files, they will open up in an editor view in the center of the Eclipse IDE. You may find it satisfying to open up ApplicationWorkbenchWindowAdvisor.java and change the title of your application in the preWindowOpen() method, by changing the "Hello RCP" String to something different and re-running the application.

While the Hello World program is quite sparse in functionality, it is nonetheless the first step in creating a real application that actually does something useful.

Get the code: com.blogspot.eclipsercptutorials.helloWorld.zip
Next --->Adding a View to an Eclipse RCP Application
<--- Previous - Using Eclipse for RCP Application Development
Also see: Eclipse RCP Tutorial Table of Contents

Using Eclipse for RCP Application Development

2009-03-09T14:38:00.001-07:00

Eclipse is free and open-source software that people mainly use to write Java code and develop Java-based programs called Rich Client Platform (RCP) applications. Eclipse is an excellent, if not the best, Integrated Development Environment (IDE) for Java development. The goal of this article it to help anyone who is interested in creating computer applications, even if they never wrote a single line of code in their life before, to decide if Eclipse is right for them.

One popular RCP application created with Eclipse is Vuze, formerly known as Azureus, a BitTorrent client shown at right. A Rich Client Application can be a full-blown program with a menu bar, icons, toolbars, status bars, etc. It can have tabs, tables, buttons, charts, text boxes, wizards, preferences, dialog boxes, and more. It can be multi-threaded and there are virtually no limitations to your creativity. You could create your own version of Photoshop or just simple a program that plays your favorite song when you open it up. Anything is possible.

If you ever used Microsoft's Visual Studio for developing Windows applications with C#, Eclipse is like Java's version of an application used to develop other applications. I started using Microsoft Visual Studio back in 2005, but have since switched to Eclipse. Eclipse matches my programming philosophy and meets my needs much better than VS for the following reasons.

With Eclipse, you can develop your application once, and create exports for Windows, Mac, and Linux no matter what operating system (OS) you use as your development computer.
I found that creating an exported product with icons and everything to be much easier and intuitive with Eclipse.
Eclipse is free and open-source. Microsoft makes you pay for the IDE if you want the full-blown professional version. I like open-source.

I also think VS has its strengths over Eclipse:

The learning curve in creating your first application is much steeper with Eclipse. Getting used to the Eclipse IDE can be frustrating because it has many quirks, that until you figure out, you may spend a lot of time banging your head against the wall. I also found the classes used to simplify the layout of your GUI widgets (i.e. buttons, text boxes, graphics) were better designed in VS.
Online documentation and available quality books is much better for VS and programming Windows applications in C#.

All in all, I'm very glad I took the plunge and learned how to use Eclipse to develop RCP applications, and I don't miss VS at all. Some people argue that Java is slow, but I personally believe that is wrong. I've run my own similar C# and Java applications on a Windows system and I can't tell a difference. Java on a Mac and Linux is also very fast.

Another observation that I made is that an Eclipse RCP run on a Windows box will be slower than the same exact application run on a Mac or Linux machine with similar specs. After converting a Windows computer to a Linux computer, the application ran twice as fast and caught up to my other Mac and Linux machines. That's not saying Java is slow on Windows, just that Mac and Linux may be superior operating systems for Java applications. But in most cases, the difference will be negligible. The beauty of Eclipse is that you can choose whatever OS you like!

I want to write about my experience with Eclipse and help others avoid some of the frustrations I had getting started. It's my way of giving back to the people involved in making Eclipse possible because I've used it and enjoyed it a lot. So go ahead and download Eclipse and get started on your applications.

You'll want to download "Eclipse for RCP/Plug-in Developers", unzip it, and place it in an easy to access location in your file system. You can double click the Eclipse IDE launcher icon to open up Eclipse. Also make sure your computer has the Java JRE (Java 5 JRE or above) installed. If you have a Mac or a PC running Ubuntu (not sure about other Linux distros), it will already be installed. I like to make a shortcut on my desktop or drag the launcher icon to the dock (Mac).

You should be greeted with a splash screen as Eclipse loads...

and then the Welcome Page.

Next --->Hello World with Eclipse RCP - Your First Application
Also see: Eclipse RCP Tutorial Table of Contents

2009-03-08T12:06:00.000-07:00

After hours sweating over an Eclipse RCP solution, you deserve your moment of glory!

Just write us at eclipsercptutorials[at]gmail[dot]com

In your email, you should include the following info:

1. your name (if you want to be credited) and the link to your website (if any)
2. the title of your tutorial
3. a short description of your tutorial
4. brief step by step instructions, the briefer the better!
5. attach photos (screencasts are welcome too) or the link that help illustrate the steps and/or results
6. source code of the RCP project (zipped) see Import and Export an Eclipse RCP Application Project for help exporting the project

The Eclipse community thanks you!

We believe the most easy and effective way to demonstrate a concept or solution in RCP is to create a new Eclipse RCP Hello World Application first and add the minimal code to it necessary to demonstrate the technique. Therefore every tutorial should start with the step of creating a new Hello World application as shown in Hello World with Eclipse RCP - Your First Application, and be followed by a short list of steps describing what needs to be added and showing the added source code.

About

2009-03-08T12:04:00.000-07:00

You
This website is about you because without you there would be no community around Eclipse RCP technology. You may be here to learn from the tutorials others have shared or you may be here to contribute your own tips and examples. Hopefully you're here to do both! Check out the available tutorials! The open source philosophy encourages receiving and giving back in return. You may not have the time or skills to contribute new source code to the project, but there are plenty of other ways to return the favor. Don't hesitate, get sharing right away. It's easy!

Alison Redding
Alison has been programming in Java since 1997 and a fan of Eclipse RCP for the last 2 years. She currently works at a west coast University writing image processing software in a biotechnology lab. Alison handles our public relations and site promotion.

Tim Molter
Tim has been creating Eclipse RCP applications for over 3 years, first just for fun, and now professionally. His background and passion for physics and mathematics have lead him to seek out programming projects involving scientific automation and analysis. Tim is our main internal contributor of tutorials.

Frederik McGee
Frederik is a retired sailor/network administrator and programming enthusiast. Fred is our wesite designer and technical troubleshooter.

Please feel free to contact any of us at eclipsercptutorials[at]gmail[dot]com.

Frequently Asked Questions

2009-03-08T11:00:00.000-07:00

Is this website sponsored by or affiliated with Eclipse.org?
No. This website was created by a small group of RCP developers who wanted to give back to the Eclipse community in their own unique way. The open source philosophy of the Eclipse community is encouraged here meaning that the more people who share the better it is for the entire group. Please share!

Why should I share?
You should share because you invested a lot of time in figuring out how to get something to work and you deserve your moment of glory! Sometimes the programmatical solution for the feature you are trying to add to your program can be elusive. We've all spent hours searching the web for some particular method or trick to accomplish a task and were appreciative that someone else took the time to write about it online. This website was created as a medium to connect sharees and sharers. Don't hesitate, get sharing right away. It's easy!

What can be shared?
Any code snippet, how-to, tip or trick written in Java that demonstrates how to accomplish a certain task in developing an Eclipse RCP application.

Who owns the content that I share on this website?
In the spirit of open source technology, nothing on this site is owned by anybody. However, just as in open source, the contributors of the work are given credit. Every post will list the contributor and a link to their website. Of course the contributors can remain anonymous if they like.

Why can't I directly post something to the website?
Information is best when it is assured to be quality information. Submitted content is tested by one of the site administrators and converted into a consistent format ensuring that the code actually works while also presenting it in a familiar format.

Why are there ads on this site?
Just like the Eclipse Foundation is funded by annual dues from its members and governed by a Board of Directors to pay a core set of developers, this website is developed and actively updated by a core set of site administrators. The hope is to eventually get a real domain name and get the site properly hosted. If there is enough interest, the site will be redesigned to include a forum. By the way, please don't click on the ads unless you have a genuine interest in the product being advertised. Excessive ad clicking is bad.

Eclipse RCP Tutorial Table of Contents

2009-03-08T06:21:00.000-07:00