Difference between revisions of "Scout"

Revision as of 07:26, 15 March 2010

The Eclipse Scout project is a proposed open source project under the Eclipse Technology Project.

Please note that these pages are work in progress and still far from complete.

What is it

The eclipse Scout Plug-Ins are used to build applications based on eclipse and equinox. These may be standalone apps, client/server apps, headless apps on server-side equinox etc.

Eclipse Scout consists of a runtime and an SDK part. The runtime part consists of approx. five Plug-Ins, the SDK consists of approx. three Plug-Ins.

The runtime is purely based on equinox, and eclipse. The SDK part is an extension to JDT and PDE with a complete perspective for easy click-and-build of a complete application.

Key Concepts

An applications built with eclipse Scout typically has a UI with perspectives, views, forms and pages. It may also have a back-end part that is running in an application server with server-side equinox. Perspectives, views, forms and pages are not limited to SWT, Scout supports complete GUI pluggability and also supports Swing of the box.

With eclipse Scout you have

1. Separation of UI (user interface layer) and GUI (graphical user interface). SWT and Swing GUI factory
2. Complete workspace overview, multiple Plug-Ins participating to the same application are visualized with their high-level dependencies
3. Much convenience and support in writing only the code you want to write when for example writing a new form with many sections and fields
4. Automatic nls support as-you-type
5. Soap-based remote service tunnel for hi-speed service remoting to a eclipse server-side application
6. Extension point for declaring OSGi services and remote service proxies
7. Extension point for UI component to gui widget mapping
8. Complete abstration layer for desktop (workbench), outlines (perspectives), forms (views, dialogs) and fields
9. Configurable code
10. Template concept for creating abstract class libraries
11. Strong typed code, minimized "string binding" and therefore best support by PDE and JDT
12. No meta data and no one-way code genration; everything is in the Java code you write. If you prefer to write code manually, or via click-and-build, doesn't matter

Screens

My first application

Easiest way to begin is creating a new eclipse Scout project group and choosing the mail sample application. A project group is a set of Plug-Ins that make up your application. Project name: com.example.mail Project parts: client, server, SWT UI This will create the Plug-Ins (listed by layer)

1. com.example.mail.ui.swt.core
2. com.example.mail.client.core
3. com.example.mail.shared.core
4. com.example.mail.server.core

A Scout form

To get an idea consider a form with only a title and two string fields. This form is displayed as a complete SWT form with SWT fields when using the SWT GUI Plug-In. It can also be displayed using the Swing GUI Plug-In, or (in development) using the apache wicket GUI Plug-In to serve the form from the server as a web page.

public class PersonForm extends AbstractForm{

  public PersonForm(){
 }

  /**
  * This method and all other getConfigured* and exec* methods can be written manually 
  * or via the property editor in the scout sdk view
  */
 @Override
 protected String getConfiguredTitle(){
   return Texts.get("MailReader");
 }
 

  public MainBox getMainBox(){
   return (MainBox)getRootGroupBox();
 }
 
 public FirstNameField getFirstNameField(){
   return getFieldByClass(FirstNameField.class);
 }

  public LastNameField getLastNameField(){
   return getFieldByClass(LastNameField.class);
 }
 
 public OkButton getOkButton(){
   return getFieldByClass(OkButton.class);
 }

  public CancelButton getCancelButton(){
   return getFieldByClass(CancelButton.class);
 }

  /**
  * Start the form with the create handler
  */
 public void startCreate() throws ProcessingException{
   startInternal(new CreateHandler());
 }

  /**
  * Start the form with the modify handler
  */
 public void startModify() throws ProcessingException{
   startInternal(new ModifyHandler());
 }

  @Order(10)
 public class MainBox extends AbstractGroupBox{

    @Order(10)
   public class FirstNameField extends AbstractStringField{
     @Override
     protected String getConfiguredLabel(){
       return Texts.get("FirstName");
     }
   }
   

    @Order(20)
   public class LastNameField extends AbstractStringField{
     @Override
     protected String getConfiguredLabel(){
       return Texts.get("LastName");
     }
   }
   

    @Order(30)
   public class OkButton extends AbstractOkButton{
   }
   
   @Order(40)
   public class CancelButton extends AbstractCancelButton{
   }
   
 }

  /**
  * This is the form handler when started with .startCreate();
  */
 public class CreateHandler extends AbstractFormHandler{
   protected void execLoad() throws ProcessingException{
     //...
   }

    protected void execStore() throws ProcessingException{
     //...
   }
 }

  /**
  * This is the form handler when started with .startModify();
  */
 public class ModifyHandler extends AbstractFormHandler{
   protected void execLoad() throws ProcessingException{
     //...
   }

    protected void execStore() throws ProcessingException{
     //...
   }
 }
 
}

How Tos

• Create a Scout Dialog
• Create a Scout Process Service

Where do I load data into a TablePage?

• override method execLoadTableData where you call an outline service operation that returns a Object[][] field
• Parameter SearchFilter of execLoadTableData contains all additional WHERE clauses (that start with „AND…“) defined in the getConfiguredSearchTerm methods