<![CDATA[Eclipse RCP Blog]]>https://rage5474.github.ioRSS for NodeSun, 11 Nov 2018 07:20:20 GMT60<![CDATA[Eclipse Scripting Basics (EASE)]]>

Motivation

Last time I thought that I would be nice to evaluate automated the output of an application started by Eclipse. E.g. to get an error dialog message when an exception is thrown or at least see an log entry in the Error Log View. Then I thought I would be nice to enable the Eclipse User to write directly a script in Eclipse that evaluates the console output directy. We implemented a similar approach in our Eclipse RCP based application at Elektrobit. After a few minutes searching the internet I found the Eclipse project EASE, that is enabling scripting for Eclipse. But I found not that much tutorials for that and that’s why I want to blog about it.

Installation

I tested the installation with a clean Neon (Version 2) Eclipse. The download links for EASE can be found hier http://www.eclipse.org/ease/download/ .

Installation is as usual:

  • Start Eclipse

  • Help → Install New Software…​

  • Enter following address in the Work with field:

  • Check all features and click Next and

  • again Next and

  • accept licenses and click Finish and

  • accept warning dialog and

  • restart Eclipse after installation has finished.

Basic usage

There is a special perspective for scripting, to activate it simple click CTRL-3 for Quick Access and type scripting and select select Scripting from the Perspective section.

After the perspective switch your Eclipse should look like this:

01 ease scripting view.png

You can see three important views in this perspective, the Script Explorer, Script Shell, and the Module Explorer.

Script Shell

The easiest way to play around with EASE is to use the Script Shell. This is an interpreter for different scripting languages. Default script engine is Rhino (JavaScript). Following picture explains main features of the script shell.

02 ease script shell.png

 (1) Enter your script commands here (Script Input Field, e.g. print("Hello World.")).
 (2) Entered commands and results can be found here (Script Console).
 (3) Start here script recording, toggle button again to save your commands to a script file.
 (4) Load modules by mouse.
 (5) Clear Script Console (is not resetting script engine)
 (6) Hide Variable area.
 (7) Switch script engine(e.g from JavaScript to Python)
 (8) Reset script engine.
 (9) Open an additional script engine.
(10) Open help.

Script shell is nice to play, but in the most cases people want to write script to re-use them.

Create a script

Let us start with a HelloWorld script. Writting a script is easy. Just create a General Project in your Project Explorer.

  • File → New → Project…​

  • Select Project (Section General) and click Next

  • Enter a name and click Finish

  • Select the new project in your Project Explorer and open context menu

  • New → File

  • Enter file name with extension, e.g. js

  • Open script and enter print("Hello World") to the script file and save file.

Run a script with Run as

  • Select created script and open context-menu

  • Run as…​ → EASE Script

  • Hello World should be printed at the console.

Run a script with Script Explorer

There is a second possibilty to run scripts. Therefore exists a separate view call Script Explorer. To get a script visible in the script explorer it has to be registered via scripting preferences.

To activate our HelloWorld script for the Script Explorer do following:

  • Window → Preferences

  • Scripting → Script Locations

  • Click Add Workspace…​ and select your project.

After that your script should be visible in the Script Explorer. The overall picture show look like this now: 03 ease script explorer.png

Script Explorer has four different actions:

  • Run a script

  • Edit a script

  • Reload repository and (only via button)

  • Rename a script (only via context-menu)

Run, edit, and rename a script is pretty clear. Reload repository is useful, if a script was added to a registered repository (means here a registered script location) outside of Eclipse. To become all script visible trigger it by this button.

Conlusion

So now all should be able to play around with EASE. Next time I will show how to write more cool scripts.

]]>https://rage5474.github.io/2017/01/08/Eclipse-Scripting-Basics-EASE.htmlhttps://rage5474.github.io/2017/01/08/Eclipse-Scripting-Basics-EASE.htmlSun, 08 Jan 2017 00:00:00 GMT<![CDATA[Eclipse RCP 3.x with Compatibility Layer]]>

Today I want to show a step-by-step tutorial how to build a simple Eclipse RCP 3.x application based on Eclipse Mars.

Motivation

  • There exists many Eclipse RCP 3.x applications, which cannot be moved to the latest Eclipse RCP version.

  • There are a few descriptions in the internet what must be done to use the Compatibility Layer, but no step-by-step tutorial

Background

Prerequisite

Tutorial

To create a simple feature-based Eclipse RCP 3.x application we need for plug-ins:

  • One plug-in with UI logic (here only an example table): io.rage5474.rcp.example.ui.plugin

  • One feature plug-in with represents the feature for the UI plug-in(s): io.rage5474.rcp.example.ui.feature

  • One target platform plug-in, which contains only the taegt platform file: io.rage5474.rcp.example.tp

  • One product plug-in, which contains the product configuration: io.rage5474.rcp.example.product

So let us start.

Create sample plug-in

First we create the plug-in io.rage5474.rcp.example.ui.plugin with our simple application logic. Therefore we use the integrated plug-in generator. Go to File → New → Other and select Plug-in Project from the folder Plug-in Development.

comp layer tut 1.png

After clicking Next you have to add your plug-in name, here io.rage5474.rcp.example.ui.plugin.

comp layer tut 2.png

After clicking Next we have to select the option Would you like to create a rich client application? to Yes.

comp layer tut 3.png

Again a click on Next leads us to the plug-in generator. Select here RCP 3.x application with a view

comp layer tut 4.png

and Finish the dialog. In the end you should have a new plug-in in your workspace, that looks similar to this one:

comp layer tut 5.png

Cool, first step was successful. Let us go on.

Create sample feature

As I think it is better to work with feature (groups of plug-ins) instead of working only with plug-ins, we have to create a feature plug-in, that contains in the end only one plug-in. We name the feature plug-in io.rage5474.rcp.example.ui.feature.

So start again with File → New → Other and select Feature Project from the folder Plug-in Development. Enter the feature name io.rage5474.rcp.example.ui.feature and click Finish.

comp layer tut 6.png

Now you should have a second plug-in in your workspace. Open the file feature.xml (simply be double-click), which is located in io.rage5474.rcp.example.ui.feature. Go to the tab Included Plug-ins on the bottom of the editor and click Add. A new window should come up. Select the plug-in with the name io.rage5474.rcp.example.ui.plugin and click OK.

comp layer tut 7.png

Save the feature.xml file (CTRL-S).

So step 2 was also successful!

Create target platform plug-in

Now we must create our target-platform (contains all Eclipse RCP plug-ins we need to get our application running!). I decided to use here Eclipse Mars as target platform. So we put the target platform file in a separate plug-in. We start again with File → New → Other and select Project from the folder General. Enter the corresponding plug-in name, here io.rage5474.rcp.example.tp and click Finish.

comp layer tut 8.png

Now we add a Target Definition file to this project. Go to File → New → Other and select Target Definition from the folder Plug-in Development and click Next.

comp layer tut 9.png

Now select the our target platform plug-in io.rage5474.rcp.example.tp, add mars.target as File name and select the option Nothing from the section Initialize the target definition with: and click Finish.

comp layer tut 10.png

Now we have our third plug-in. At the moment our Target Definition file is empty. So open it with a double-click on the file mars.target and click the Add button to add a Software Site to this Target Definition.

comp layer tut 11.png

Select Software Site and click Next.

comp layer tut 12.png

Enter following URL in the field Work with and hit enter: http://download.eclipse.org/releases/mars . Search and select following three features:

  • Eclipse RCP

  • Equinox p2, minimal support for RCP applications

  • Eclipse Platform Launcher Executables

comp layer tut 13.png

Use the search field to find the right feature fast. Tip: Disable Group by Category.

comp layer tut 14.png

Click on Finish and click Set as Target Platform. After a while the target platform should be available.

Create sample product

So we almost finished. We only need the possibility to start our application, therefore we need a product file. We separate this again in a new plug-in. We start again with File → New → Other and select Project from the folder General and enter the plug-ins name io.rage5474.rcp.example.product and click Finish.

comp layer tut 15.png

Now we have to add a Product Configuration file to that plug-in. We create this with File → New → Other and select Product Configuration from the folder Plug-in Development and click Next.

comp layer tut 16.png

Select the right plug-in (io.rage5474.rcp.example.product) and enter a product configuration file name, here example.product and click Finish.

comp layer tut 17.png

Now we have to configure our product. Open the product file (example.product) by double clicking. Click on new and select the plug-in io.rage5474.rcp.example.ui.plugin in the field Defining Plug-in and enter a Product ID, e.g. rcp_product. Before clicking Finish switch the toogle button from plug-ins to features.

comp layer tut 18.png

Now switch to the tab Contents and add following feature by clicking on the Add button:

  • org.eclipse.rcp

  • org.eclipse.emf.common

  • org.eclipse.emf.ecore

  • io.rage5474.rcp.example.ui.feature

comp layer tut 19.png

Now we have to modify the run configuration. Switch to the tab Configuration and select Add Recommended.

comp layer tut 20.png

Save your product definition file (CTRL-S) and switch back to the tab Overview and click the link Synchronize from the section Test.

Launch example application

Now we can give it a try. Click the link Launch an Eclipse Application again from the section Testing. The result should look similar to this:

comp layer tut 21.png

Source Code

The full example source code can also be found here: https://github.com/rage5474/rcp.3.x.comp.layer.example .

References

https://www.eclipse.org/community/eclipse_newsletter/2013/february/article3.php http://eclipsesource.com/blogs/2016/01/08/migrating-from-eclipse-3-x-to-eclipse-4-e4/ http://www.vogella.com/tutorials/Eclipse4MigrationGuide/article.html

]]>https://rage5474.github.io/2016/09/19/Eclipse-RCP-3x-with-Compatibility-Layer.htmlhttps://rage5474.github.io/2016/09/19/Eclipse-RCP-3x-with-Compatibility-Layer.htmlMon, 19 Sep 2016 00:00:00 GMT<![CDATA[Declarative Annotations in Eclipse Neon]]>

Motivation

Many Eclipse RCP applications are using OSGi Services make their application leightweight and flexible. The most convient method is to use OSGi Services in combination with Declarative Services. This allows to specifiy OSGi Services by XML files. Why this can be quite convient can be found here DS@Vogella. Before Eclipse Neon there were two possibilties to create or modify these XML files.

  1. By Hand - Disadvantage: Error prone.

  2. Integration editor - Disadvantages: Error prone on re-factoring, no consistent naming scheme.

No Eclipse Neon integrated a third solution: Generation of XML files by code annotations. In this blog I want to show more detailled how this can work.

Code Example

Expecting a simple HelloWorld OSGi application, with

  • a HelloWorldService and

  • a HelloWorldClient.

The HelloWorldService is exporting following simple interface.

package my.osgi.ds.example.helloservice.api;

public interface HelloWorldService {
    // Prints 'Hello + name' to the console
    public void sayHello(String name);
}

Whenever sayHello is called 'Hello + name' is printed on the console.

Here is the corresponding implementation of this OSGi Service. So the implementation is quite straight forward. Now let us come to the interesting part of this class - the @Component DS Annotations.

package my.osgi.ds.example.helloservice.impl;

import org.osgi.service.component.annotations.Component;
import my.osgi.ds.example.helloservice.api.HelloWorldService;

@Component
public class HelloWorldServiceImpl implements HelloWorldService {

	@Override
	public void sayHello(String name) {
		System.out.println(("Hello " + name + "!"));
	}

}

To register a class as OSGi-Service (Component is used here as synonym) just use @Component as class annotation. That’s the minimum to register a class as OSGi service. Whenever you save this class, automatically a new XML file my.osgi.ds.example.helloservice.impl.HelloWorldServiceImpl.xml will be generated OSGI-INF.

<?xml version="1.0" encoding="UTF-8"?>
<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="my.osgi.ds.example.helloservice.impl.HelloWorldServiceImpl">
   <service>
      <provide interface="my.osgi.ds.example.helloservice.api.HelloWorldService"/>
   </service>
   <implementation class="my.osgi.ds.example.helloservice.impl.HelloWorldServiceImpl"/>
</scr:component>

So in the most cases this should be enough. Look’s quite easy.

Let us have a look on the HelloWorldClientImpl. It’s the service that is using our HelloWorldService. At first it has to become also a OSGi service. So @Component`annotation is needed. Then we need the reference to the `HelloWorldService. This is done by a method, which is annotated by @Reference. But here its also a special parameter unbind needed, which also points to the unbind method. So the @Reference method is used inject the HelloWorldService to the HelloWorldClientImpl. In case you have multiple @Reference methods, you should use the @Activate method to start your component. Otherwise it’s not guaranteed, that all service references were already injected.

package my.osgi.ds.example.helloclient.impl;

import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;

import my.osgi.ds.example.helloservice.api.HelloWorldService;

@Component
public class HelloWorldClientImpl {
	private HelloWorldService helloWorldService;

	@Reference(unbind = "unbind")
	public void bind(HelloWorldService helloWorldService) {
		this.helloWorldService = helloWorldService;
	}

	@Activate
	public void start() {
		helloWorldService.sayHello("Mr. X");
	}

	public void unbind(HelloWorldService helloWorldService) {
		this.helloWorldService = null;
	}

	@Deactivate
	public void stop() {
		this.helloWorldService = null;
	}
}

Again a XML file my.osgi.ds.example.helloclient.impl.HelloWorldClientImpl.xml is generated in the folder OSGI-INF.

Content looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0"
	activate="start"
	deactivate="stop"
	name="my.osgi.ds.example.helloclient.impl.HelloWorldClientImpl">
    <reference
   	bind="bind"
        cardinality="1..1"
        interface="my.osgi.ds.example.helloservice.api.HelloWorldService"
        policy="static"
        unbind="unbind"/>
   <implementation class="my.osgi.ds.example.helloclient.impl.HelloWorldClientImpl"/>
</scr:component>

Advantages

  • Naming scheme of XML files are always the same.

  • Usability is trivial.

  • Annoations can be easily used for byte code generated traces (I will write another post for this topic!).

Try it out

A full example can be found here: ds.annotation.example@github.

]]>https://rage5474.github.io/2016/08/29/Declarative-Annotations-in-Eclipse-Neon.htmlhttps://rage5474.github.io/2016/08/29/Declarative-Annotations-in-Eclipse-Neon.htmlMon, 29 Aug 2016 00:00:00 GMT