Eclipse.exe and windows processes

One of our clients mentioned that his users sometimes wish to kill the process associated with its Scout client application in the Windows Task Manager. Scout applications use the Eclipse Launcher exe like any Eclipse RCP application or the Eclipse IDE itself. I will use “eclipse.exe” as application name in this blog post.

The problem was that in order to completely terminate the client application, they need to be aware of the fact that their application was actually running in two processes, the eclipse.exe and the javaw.exe process. By just using “End Process” (button or context menu) on the eclipse.exe process in the Task Manager, only the smaller process is killed and the much larger javaw.exe process continues to run. Only by selecting “End Process Tree” in the task manager the complete application is terminated. Only few users were aware of this setup that is not really user-friendly.

End process in Windows Task Manager

After some investigation we could propose a solution to address the client’s issue. The Scout client application now appears as a single process in the Task Manager and it no longer matters if users click on context menu “End Process” or “End Process Tree”.

In the reminder of this article we summarize our findings that should directly apply to any Eclipse RCP application or the Eclipse IDE itself.
Read the rest of this entry »

Eclipse Scout Roadmap 2016

For the 2016 release of the Scout framework we will introduce two significant changes. These changes address major pain points we have suffered from in the past. As the scope of the two changes is substantially larger than in previous releases, we would like to start talking about them well ahead of time. So remember in the text below that this is a blog about the future of Eclipse Scout scheduled for 2016, not about the upcoming Mars release.

The first change is driven by our vision of the future of UI technologies for business applications. The second change addresses the need of our customers and BSI that Scout applications should be easy to integrate in a Java EE or Spring based environment. In the text below we will discuss these two changes individually. Read the rest of this entry »

Scout Adopters we didn’t know about.

At BSI (the company behind the Scout Framework) we have recently discussed our knowledge about the community of Eclipse Scout users and found that it is too limited. This was one of the lessons we learned from our first Scout User Group Meeting. For this meeting we have invited our Scout customers and colleagues. By customer we mean individuals from companies that have paid for services in relation to Scout (consulting, trainings, change requests, project bootstrap, …). And by colleague we mean people we already met (at conferences or democamps) that where doing something with Scout. This get together was important, informative and supported the networking between customers/contacts. However, we found that the real challenge is to contact and learn from Scout adopters that we do not know (yet). Read the rest of this entry »

A new Scout Widget Application

Since quite some time we had our old Scout widget application to demonstrate most of the Scout widgets that are available out of the box in the Eclipse Scout package available on the Eclipse download site.

This old widget application has historically grown over time and includes many special that have been added to demonstrate and fix bugs or features. While starting to document the individual Scout widgets we found that a renewal would help to better showcase the typical usage patters for the different widgets and also highlight the most frequently used configuration options. As a result, the old widget application has been rewritten accordingly.

The client only application is organized into separate outlines for thematic groups of widgets. Each of the application’s outline then presents a list of widgets in a navigation tree. This is shown below for the Simple Widgets outline that contains examples for simple UI widgets such as label fields or string fields.

For each UI widget a corresponding example form presents a number of typical use cases and configuration options. The example forms are designed to be independent from each other. It should therefore be possible to read and understand the source code of each example form with minimal effort. Via the Open in Dialog … context menu the content of the view is displayed in a modal scout form. As shown below, the complete source code for the selected form can be accessed via the View Source on GitHub context menu.


Read the rest of this entry »

HTML & Diff & normalization with JSoup

We are working on an Eclipse help document for the Eclipse Scout project. Our vision is to re-use content from the existing Scout book where possible. For this, we want to be able to share text modules between the two documents. In order to do so, I am currently working on the setup of each document and I am extracting some existing text into independent modules.

The difficulty of this task is that you should not break anything in the existing documents. Manual review of hundreds of pages was out of question, so I came up with the idea of doing a diff on the HTML between 2 versions (before and after the refactoring).
Read the rest of this entry »

Generating Eclipse Help from existing HTML Documentation

Creating a Eclipse Help bundle for the Eclipse IDE is simple. You only need three things:

  • Some HTML content (one or several pages)
  • A specific XML file describing the “Table of content” (a toc file)
  • An entry to contribute to the org.eclipse.help.toc extension point.

If you do not know how to start, you can use the “Plug-in with sample help content” template when you create you new plug-in Project.

New Plugin Project Wizard - Template: Plug-in with sample help content

The painful aspect of the work is manually keeping the XML toc file in sync with your existing HTML documents (i.e. the output of your documentation tool). Luckily, there are tools that help to reduce substantially this pain.

Read the rest of this entry »

Multi Column SmartField

During the Scout User Group Meeting each participant has presented how he was using Eclipse Scout. It was nice to see that many of them were already using a new feature introduced with Luna: Multi-Column SmartField.

Scout Multi-Column SmartField

SmartField to select a position in the Swiss train network.

Read the rest of this entry »

Why should I contribute?

One of the opening slides of our “Eclipse Scout Contributor” training looks like this:


There is nothing new in this slide. It just re-states an aspect of the open-source mechanic.

In our opinion the benefits of contributing to open source is often not fully understood. That is why we would like to share some of our thoughts.
Read the rest of this entry »

Eclipse Icons for your Presentations

I am giving a lot of trainings lately. Some of them are for our co-workers at BSI (topics around Java and Eclipse). And some of them for external clients, mostly related to the Eclipse Scout framework.

For these trainings, I often have to prepare slides on short notice. As an example, the slide below explains the location of the tests in an Eclipse Scout RT project:

Where are the tests?

Frequently, a lot of icons representing the Eclipse IDE elements are needed in such slides. Unfortunately the icons of the IDE itself are too small (16×16 pixels) to be used on the slides, but luckily I found this page (UI Graphics > Design > Common Elements > Wizard elements) on the Eclipse wiki. This page also contains an Adobe Illustrator file including the wizard Icons. And those icons are exactly what I needed for my slides. From this Illustrator file, I could extract all icons with or without background and save them into individual files for both PNG and SVG formats.

Wizard icons

I checked with the Eclipse Foundation and got an answer from Mike Milinkovich: the icons I have created are licensed under EPL because they are a derivated work of the original file.

Hoping that this exercise may be useful to others, I have made my code and approach available on GitHub: common_wizard_elements (or just download the common_wizard_elements.zip to get the SVG and PNG files).

Disclaimer: I am not a graphic designer and I have limited knowledge of the SVG file format. Feel free to give me feedback (as comment on this blog or on the GitHub project).

And just in case: should you be interested in Eclipse Scout trainings, please let us know.

Scout Links

Project Home, Forum, Wiki, Twitter

Snipmatch: a solution for configuring scout properties from the java editor?

Scout comes with powerful tools in the Scout perspective. You have a logical representation of your application in the “Scout Explorer” view and a “Scout Object Properties” view where you can set or change a property for the selected object. A modification in the property view updates the java code and a code modification is reflected in the property view. This allows the developers to work as they want.

Scout Property View

The problem is that power users are not using this property view very often. The explanation is simple: using the view breaks the flow when you are typing code in the java code editor. You need to switch to the mouse, find your current object in the scout explorer and set the properties in the other view.

When you know the name of the getConfigured method you want to set, then you are quicker if you stay in the java editor. The problem is that what the JDT is offering by default is not really what you need in this case. Lets see how Snipmach can help.

With the JDT

If you are in a column’s inner-class you might want to define it as editable. You need to override the getConfiguredEditable() method and return true instead of the default false.

The JDT can help: enter “getCondiguredEdit” and press control space:

Jdt CTRL Space

This works well, but the result is not as efficient as it could be:

Jdt result

My problems are:
* I really do not need the “(non-Javadoc) comment” block.
* The cursor is not at the correct position; It would be preferable to have the cursor in the line of the return statement.
* In this specific case I do not need to call the super implementation at all.
* And the TODO statement makes sense in a lot of cases, but not here.

With Snipmach

Snipmatch can help too. I have defined snippets to handle those cases. They are shared in this git repository. In my column, press CTRL + Alt + Space + the search filter set to “edit”, I can find the snippet I am looking for:

Snipmatch CTRL+Alt+Space

Now when I press enter, there is a big difference with what the JDT override assist function provides:

Snipmatch result

The cursor is where it should be. In the Snippet’s definition, I have defined as first choice the value that will be most likely used at this point (in this case true because the default in AbstractColumn is false). The result is really straight forward.

Just to be clear, I am not complaining about the JDT doing a bad job. We are comparing a generic feature coming out of the box in the JDT and another approach where someone needs to configure the possible snippets. It is normal to have a better user experience with a specific tool because it is a specific use case.

What is missing in snipmatch?

The snippets do not have any metadata to define a context. The consequence is that the search engine is only based on the keyword entered by the user in the search box. It would be nice to be also able to influence the search result depending on the cursor position. I have commented Bug 435632. Let’s hope that the code recommenders team will propose something going in this direction to improve the user experience.

Scout Links

Project Home, Forum, Wiki, Twitter