Raja Kannappan's Blog

Eclipse RCP - Converting Dependencies to OSGi Bundles

2010-02-28T21:30:00.000-05:00

Introduction:

Your Eclipse Bundle (plugin) may have many dependencies to third party libraries or to your own API/utility libraries. There are two ways to use them. One is to add them to your bundle classpath or convert them to bundles, add it to target platform and use them as bundle dependency (called as Plug-in Dependencies in Eclipse).

(Plugin and Bundle are one and the same. Plugin is Eclipse terminology and Bundle is OSGi terminology.)

Why you need to convert dependencies to bundles?

You already have your third party dependency (log4j, apache commons collections etc.,) as jars and all you need to do is add it to your bundle classpath. This is simple and it works as long as you are developing only one bundle or your bundles do not share common dependencies.

But, in reality, you might be creating a bunch of bundles and they all would use common dependencies. The problem here is in the way OSGi classloading works. Each bundle has it's own classloader and so if you have two bundles both using log4j as jar dependency in their classpath, and when you try to reference log4j in each of the bundles, each would try create their own instances of the log4j classes in their respective classloaders. This might cause classloader constraint violation issues or ClassCastExceptions. If you convert these dependencies to OSGi bundles, then these problems would no longer happen. This is because now each of your dependency (say log4j) has it's own classloader and so whenever your Bundle A or Bundle B want to load log4j class, it will load it from log4j bundle classloader.

What is OSGi bundle anyway?

OSGi bundle is also a regular jar but has OSGi information in it's manifest. For example, this is how commons-lang bundle's manifest looks like. This has OSGi information like bundle name, what packages it exports, what packages it imports etc.,

Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Created-By: 1.4.2_16 (Apple Computer, Inc.)
Built-By: hen
Build-Jdk: 1.4.2_16
Implementation-Title: Commons Lang
Implementation-Vendor: The Apache Software Foundation
Implementation-Vendor-Id: org.apache
Implementation-Version: 2.4
Specification-Title: Commons Lang
Specification-Vendor: The Apache Software Foundation
Specification-Version: 2.4
X-Compile-Source-JDK: 1.3
X-Compile-Target-JDK: 1.2
Bundle-License: http://www.apache.org/licenses/LICENSE-2.0.txt
Import-Package: org.apache.commons.lang;version="2.4",org.apache.commo
ns.lang.builder;version="2.4",org.apache.commons.lang.enum;version="2
.4",org.apache.commons.lang.enums;version="2.4",org.apache.commons.la
ng.exception;version="2.4",org.apache.commons.lang.math;version="2.4"
,org.apache.commons.lang.mutable;version="2.4",org.apache.commons.lan
g.text;version="2.4",org.apache.commons.lang.time;version="2.4"
Bnd-LastModified: 1205638979942
Export-Package: org.apache.commons.lang.math;version="2.4",org.apache.
commons.lang.enums;version="2.4",org.apache.commons.lang.builder;vers
ion="2.4",org.apache.commons.lang.exception;version="2.4",org.apache.
commons.lang.enum;version="2.4",org.apache.commons.lang.mutable;versi
on="2.4",org.apache.commons.lang.text;version="2.4",org.apache.common
s.lang.time;version="2.4",org.apache.commons.lang;version="2.4"
Bundle-Version: 2.4
Bundle-Description: Commons Lang, a package of Java utility classes fo
r the classes that are in java.lang's hierarchy, or are consid
ered to be so standard as to justify existence in java.lang.
Bundle-Name: Commons Lang
Bundle-DocURL: http://commons.apache.org/lang/
Bundle-ManifestVersion: 2
Bundle-Vendor: The Apache Software Foundation
Bundle-SymbolicName: org.apache.commons.lang
Tool: Bnd-0.0.238

How to convert dependencies to bundles?

As OSGi is getting popular, many libraries are already published as bundles. But still, there are many which are not converted already. There are several ways to convert dependencies to bundles.

You can always manually do it by hand i.e take the jar add a manifest with OSGi information in it and re-jar it. But, this is error-prone and also cumbersome if you have many dependencies.
You can use Eclipse File->New->Plugin Development->Plugin from existing jar archives. In the plugin project properties screen, make sure to check "Analyze library contents and add dependencies". This will add appropriate require-bundle entries to the manifest. Also, use "Unzip the jar archives into the project" option. This way is less error-prone, but still cumbersome if you have many dependencies.
There are public repositories which provide OSGi bundles for popular third party libraries. For example, look at Eclipse Orbit or SpringSource Bundle Repository. But still it is hard to find all libraries or the latest versions of the popular libraries.
The best way is to use BND bundle tool. You could use BND directly or use BND maven plugin, which is very powerful and easy to use.

Converting your third party dependency libraries using BND maven plugin:

If you want to convert all of the third dependencies to OSGi bundles, then you could use "bundleall" goal from the maven plugin. I suggest creating a separate bundle generator project and list all the direct dependencies (of all of your Eclipse GUI Bundles) in it's POM. Then, add the build section listed below. See that it uses "bundleall" goal, which is bind to "process-classes" build lifecycle phase.

<dependencies>
<!-- List all top level dependencies. -->
<!-- This will bring other dependencies transitively. -->
</dependencies>

<build>
<plugins>
 <plugin>
  <groupId>org.apache.felix</groupId>
  <artifactId>maven-bundle-plugin</artifactId>
  <version>2.0.1</version>
    <executions>
       <execution>
           <id>bundle-manifest</id>
           <phase>process-classes<phase>
              <goals>
                  <goal>bundleall</goal>
              </goals>
       </execution>
    </executions>
 </plugin>  
</plugins>
</build>

Now, when you go to command-line and type "mvn process-classes" (or any build lifecycle phase greater than process-classes. For more info on maven lifecycles and it's phases, refer here), all the OSGi bundles for all dependencies (including transitive) will be generated in the output folder (default is target\classes). You can just copy them from the output folder to your Eclipse target platform or maven repository.

Converting your API libraries using BND maven plugin:

If your API libraries do not change often, then you could use what is suggested above for third party libraries. But, if they are in active development (which might be the case often) and you want your GUI to work against their SNAPSHOTs, then that may not work. Good way to convert your API/utility libraries is to modify the POM's of these libraries or better their parent POM. Look at "Adding OSGi metadata to existing projects without changing the packaging type" section in the BND maven plugin page here. This will make sure that your library is still packaged as jar, but it's manifest would have OSGi information now. So, now your API project will always be automatically published as OSGi bundle to your maven repository.

Automate Copying Bundles to Eclipse target platform:

For third party libraries, I said above that you could either copy them to target platform or maven repo, since they are static and do not change everyday. But, for your own API libraries which change everyday and if you want to work against their SNAPSHOTs, you need to get their OSGi bundles to Eclipse target platform in an automated fashion. For that, I suggest adding POM to your target platform. (By the way, we maintain target platform in subversion) and use "copy-dependencies" goal from maven dependency plugin. Adding the following block to your target platform POM.

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.1</version>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>process-resources</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>${pluginsDir}</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>

Whenever you do "mvn process-resources", this would pull in latest OSGi bundle dependencies from maven repo and copy to plugins folder in target platform. So, the workflow would be, your CI system would publish your API libraries as OSGi bundles to maven repo and then GUI developers would use this maven command in their target platform, so that their target platform has the latest API bundle dependencies. Also, target platform has to be reloaded/refreshed in your Eclipse IDE using Window->Preferences->Plugin Development->Target Platform. I don't know of a way to automate this part yet.

Conclusion:

We saw the issues with using bundles dependencies as regular jars in bundle classpath and why they need to be converted to OSGi bundles. We looked at what an OSGi bundle is and saw different ways to create an OSGi bundle. Finally, we looked at how to use maven BND plugin to convert third party or your own API/utility libraries to OSGi bundles and how to update your Eclipse target platform automatically.

Automating Eclipse Help Generation

2010-02-27T17:55:00.007-05:00

This article assumes that you are familiar with Eclipse Help. If you are not, you can refer to my earlier blog entry to learn more about it.

Some of the common formats used to author Eclipse Help are DocBook and DITA. Both of these formats use XML as source. The main benefits of using XML (instead of binary files) as source are, you can use your version control to maintain history (and see diffs) and can publish the source to multiple formats (PDF, HTML, EclipseHelp etc.,), using the same consistent formatting.

We used to use DocBook, but transitioned to use DITA since Adobe FrameMaker had good support for DITA and our technical writer was comfortable with using FrameMaker as well. Here is an article on how to author DITA topics using FrameMaker.

The next step is to transform DITA to EclipseHelp. You could use DITA open toolkit directly to produce help files. Better way is to use DITA maven plugin, which can be found here. If your Eclipse Help plugin does not have a POM, create one first. Then, all you need to do is to make sure that your POM follows this usage explained here. Look at the executions where Eclipse Help generation is bind to generate-sources phase.

output.dir specifies the directory where Eclipse Help will be generated.
args.input specifies the location of the ditamap. ditamap is where DITA topics are mapped. See here if you want to know what a ditamap is. ditamap supports both top-down and bottom-up composition. Make sure to use bottom-up composition and if you are not sure about the difference, you can see it from my earlier blog entry.
transtype specifies the output format and can be "pdf", "htmlhelp", "xhtml" or "eclipsehelp".

If you use style sheets to format your help, you could use args.css, args.csspath and args.copycss parameters to specify information about your css. Finally, make sure you have all the dependencies listed are in your maven repository.

That's it. Now, all you have to do is type "mvn generate-sources" (or any build lifecycle phase greater than generate-sources. For more info on maven lifecycles and it's phases, refer here) in command-line to generate Eclipse Help. You still need to maintain plugin.xml of your Help Plugin and make sure that toc and index files are referenced properly. But, this is easy and the hard work of creating html files and toc files are done by the maven plugin.

OutOfMemoryError (on HeapSpace, PermGen) and JVM Performance Tuning

2010-01-18T17:03:00.013-05:00

HeapSpace OutOfMemoryError:

"Exception in thread "main" java.lang.OutOfMemoryError: Java heap space"

Most of you would have encountered this error before. This means JVM's usage of heap space exceeded what you specified in -Xmx vm argument or the default max heap size (if you did not specify one).

When you get this error, before you increase your -Xmx value, make sure to profile your application and see whether the usage is justified or if there is any memory leak. See below section on profiling tools.

PermGen OutOfMemoryError:

"java.lang.OutOfMemoryError: PermGen space"

Sometimes, you would also get a different kind of out of memory error. In JVM heap, there are different generations - Young, Tenured and PermGen. Young and tenured generations are where the regular objects from your application are stored. Size of young + tenured generation is controlled by -Xmx variable you saw above. PermGen is where JVM stores string pool, metadata about your application's classes etc.,

This error would normally happen only if your application loads a large number of classes, but is not unloading for some reason, which could be either legitimate or a memory leak. Also, make sure to check if your application heavily uses String.intern(), which could also contribute to this error.

JVisualVM provides a good insight on how your permgen grows and how many classes are loaded/unloaded at any point in time. You could also use JConsole to find this, although it is more clear and easy to find in JVisualVM. These tools only show how many classes are loaded/unloaded, but if you want to find out which classes are loaded/unloaded, you can use JVM debugging options like -XX:+TraceClassLoading and -XX:+TraceClassUnloading. They print the actual full class name which is loaded/unloaded. You can also use -XX:+PrintGCDetails and see how the permgen size grows/shrinks.

If your profiling shows that it is legimiate, increasing the max permgen size would avoid this issue. For example, this vm argument -XX:MaxPermSize=128m would set the max perm size to 128MB.

Related articles/resources on PermGen:

http://www.brokenbuild.com/blog/2006/08/04/java-jvm-gc-permgen-and-memory-options/
http://www.freshblurbs.com/explaining-java-lang-outofmemoryerror-permgen-space
http://www.alessandroribeiro.com/?q=en/node/41
http://www.codeinstructions.com/2009/01/busting-javalangstringintern-myths.html
http://kohlerm.blogspot.com/2009/01/is-javalangstringintern-really-evil.html

Performance Tuning:

If you are setting max heap size or max permgen size, it is a good idea to also set min heap size (-Xms) and min permgen size (-XX:PermSize). This could avoid unnecessary resizing of the heap and might improve performance. Make sure these are set to at least what your application needs to start. This would avoid heap resizing during start up and would improve your application start up time. You could also set min and max to be the same to avoid resizing at all, but you should be very cautious and make a good choice of heap size in this case.

You could use some of the advanced performance options like -XX:NewRatio, -XX:SurvivorRatio etc., More details on other available performance options can be found here:
http://java.sun.com/javase/technologies/hotspot/vmoptions.jsp#PerformanceTuning

Before using these advanced options, it is good to profile and see what are the typical allocations in young and tenured generation for your application. This depends on the infant mortality of your application's objects i.e how long the objects live in your application. It could turn out that they are dependent on user's actions and features they use in the application. In that case, it is better not to tune them in the deployed application by default and instead profile and tune them on a per case basis, if a particular client have issues etc.,

Related articles/resources on Performance Tuning:

http://java.sun.com/javase/technologies/hotspot/gc/gc_tuning_6.html
http://java.sun.com/docs/hotspot/gc5.0/ergo5.html
http://java.sun.com/docs/hotspot/gc1.4.2/faq.html

Profiling Tools:

You could use the free tools which come with JDK - JConsole, JVisualVM, JMap, JHat, JVMStat etc., These could be found in your JDK bin directory. You could also use TPTP, Eclipse Memory Analyzer etc., which are also free. To download Eclipse Memory Analyzer plugin, you can point to the galileo update site - http://download.eclipse.org/releases/galileo and download General Purpose Tools->Memory Analyzer plugin.

Or, if you can afford, you could use these commercial profiling tools - JProfiler, JProbe, YourKit etc.,

You could also use the debugging options in vm args to get more information. Some common debugging options are -XX:-HeapDumpOnOutOfMemoryError, -XX:-PrintGCDetails, -XX:-TraceClassLoading, -XX:-TraceClassUnloading etc., For more information on other available debugging options, see here - http://java.sun.com/javase/technologies/hotspot/vmoptions.jsp#DebuggingOptions

Updating UI in Eclipse RCP

2010-01-10T00:39:00.001-05:00

Introduction:

In Eclipse RCP, generally the code is executed in UI thread most of the time. Running long operations here would freeze UI. I've blogged about this in my previous post. So, the solution is to either spawn off a separate thread or if you want to show progress to the user, use Jobs API as illustrated in point 5 in previous post and execute long running operation there. But, if you want to update UI while the code is running in non-UI thread, you need to make sure that it is done via UI thread. Otherwise, you will get bizzare behavior during runtime.

Swing:

If you are a Swing programmer, you are already familiar with this concept. In Swing, generally the code is run in event dispatch thread and all UI update operations need to be done from this thread. If you want to update UI while running long operations in another thread, you need to use SwingUtilities.invokeLater or SwingUtilities.invokeAndWait for this purpose. You can read more about it from this post.

Eclipse RCP:

In Eclipse, the idea is similar. All UI update operations need to be done from UI thread. So, if you want to update UI from other threads, you need to use Display.asyncExec or Display.syncExec method.

Display.getDefault().asyncExec(new Runnable() {
public void run() {
// Update UI here
}
});
System.out.println("This could be printed before run method finishes...");

Display.asyncExec would execute the run() method asynchronously (similar to invokeLater) i.e the thread which calls executes asyncExec line would get executed in parallel with the run() method.

Display.getDefault().syncExec(new Runnable() {
public void run() {
// Update UI here
}
});
System.out.println("This would be printed after run method finishes...");

Display.syncExec follows similar syntax and would execute the run() method synchronously (similar to invokeAndWait) i.e the thread which calls executes syncExec line would get executed wait until run() method finishes.

In general, it is good to use asyncExec, unless you specifically want the calling thread to block.

Eclipse RCP - Prevent UI freezing while running long operation

2010-01-09T00:13:00.007-05:00

According to this blog post, the number one mistake which Eclipse developers do is running long operations in UI thread. I certainly agree this is a terrible mistake. Doing this will freeze the UI and lead to bad user experience. As stated in this blog, users need to make sure that long running operations run in a separate non-UI thread. But, in Eclipse, it is not very clear when we are in UI thread and when we are not. I attempt to clarify that in this post and explain few related things in more detail.

1) Any regular code, say in createPartControl of a view or an editor are executed in UI thread. Don't do any long operations in this. Spawn off a separate thread and do them there.

2) Code inside any SWT listener methods are also executed by UI thread. This is also stated in the eclipse-tips blog.

3) Code inside run() method in your Action class is also executed by UI thread.

4) Code inside run() method in your Handler class is also executed by UI thread.

5) If you use Jobs API to run long running operations, your code would typically look like this:
Job job = new Job("Long Job") {
protected IStatus run(IProgressMonitor monitor) {
monitor.beginTask("Job started...", 10);
// Run long running task here
monitor.done();
return Status.OK_STATUS;
}
};
job.setUser(true);
job.schedule();

Here the code inside run() method is in not in UI thread and you are in worker thread. Running long tasks is fine here. But, what if you want to update UI while your long running task is running. You should use either asyncExec or syncExec for this purpose. I will explain about them in more detail in my next post. If not, you will have problems while running your application.

6) If you just want to show busy indicator while running long operation, your code would typically look like this:

BusyIndicator.showWhile(PlatformUI.getWorkbench().getDisplay(), new Runnable() {
public void run() {
// Long operation goes here
}
});

Unlike point 5, here the code inside run() method is not executed in worker thread. The code is run by UI thread only. So, make sure not to execute too long running operations here.

Books I've read in 2009

2009-12-31T19:51:00.005-05:00

I normally read online articles/blogs to keep me up to date. Even if I read books, I normally read only the relevant topics or use them as reference when needed. Below are some of the books which I've read completely (or almost) this year:

Programming Groovy - I just started reading this book 2 weeks back and I'm about 80% done reading this book. Hope to finish it in the next week or so. When I started, I was more of a beginner in Groovy. Within 2 weeks, I can say I'm confident of Programming in Groovy and understand the concepts very well. The author explains the concepts very clearly and all the code examples are clear to the point. I tried all the code examples so far in this book. I highly recommend this book for any beginner/intermediate Groovy programmers.
Eclipse Building Commercial Quality Plugins (2nd Edition) - Even though this is an older edition, most of the concepts are still valid. (Need to get the recent edition soon though.) This is a pretty huge book (around 750 pages) and I read around 75% of this book some sequentially and some topics on demand, when I needed to develop those features. This is an excellent book with great examples and I highly recommend to any Eclipse RCP programmer.
Career 2.0 (Take Control of Your Life) - Excellent book with lots of career advices. I've also heard Jared Richardson's talk on this topic in NJFS last year (2008). This book gives clear advices on how to improve and take control of your career. Highly recommend this book to anyone in the software industry.
The name is Rajinikanth - This is not a technical book and I actually read the Tamil version of this book. RajiniKanth is Super Star of Tamil Movies and this book is about his life history. He is very famous in South India and also in Japan. I am a big fan of his and I admire him for many of his qualities beyond acting. Reading this gave me insight on his life and I also learned many practical day to day things and importance of hard work by reading this book. I recommend this book to any of his fans. By the way, if you are looking for the English version of this book, you can get it from here.

Looking forward for a very exciting year 2010. Wish everyone a very Happy New Year!

Groovy Strings - Different ways of creating them

2009-12-26T00:24:00.019-05:00

There are different ways to create strings in Groovy - Using single quotes, double quotes, three single quotes, three double quotes and forward slashes. All of them have a purpose. I'll explain the different flavors and when you need to use which one.

1) Single quotes:

Simple:

lst = 'This is my blog post'
println lst
println lst.getClass().name

This is the simplest way to create a string. Here classname returns java.lang.String. The output of this is:

This is my blog post
java.lang.String

Variable Interpolation:

Variable interpolation does not work with single quotes.

postName = "Groovy Strings"
lst = 'This is my blog post $postName'
println lst
println lst.getClass().name

The output of above is:

This is my blog post $postName
java.lang.String

2) Double quotes

Simple:

lst = "This is my blog post"
println lst
println lst.getClass().name

You can also create string using double quotes. Here also class name is java.lang.String. And this behaves same like single quotes. Output is:

This is my blog post
java.lang.String

Variable Interpolation:

But, double quotes also gives us variable interpolation, when needed.

postName = "Groovy Strings"
lst = "This is my blog post $postName"
println lst
println lst.getClass().name

The output of above is shown below. You can see that variable interpolation worked. Also, in this case, since variable interpolation is used, groovy is smart enough to create GStringImpl instead of regular String.

This is my blog post Groovy Strings
org.codehaus.groovy.runtime.GStringImpl

3) Three Single Quotes

Simple:

lst = '''This is my blog post.
I love it.'''
println lst
println lst.getClass().name

This is mainly used to support multi-line Strings. We don't have to use the + operator or the append() method from StringBuffer or StringBuilder anymore. You can see that Strings created using three single quotes is also regular java.lang.String like the one created with single quotes. Output is shown below:

This is my blog post.
I love it.
java.lang.String

Variable interpolation:

Just like single quotes, three single quotes does not support variable interpolation.

postName = "Groovy Strings"
lst = '''This is my blog post.
$postName'''
println lst
println lst.getClass().name

The output of above is:

This is my blog post.
$postName
java.lang.String

4) Three double quotes:

This is similar to three single quotes and is used for supporting multi-line strings. The only difference is, this supports variable interpolation just like single double quotes does.

Simple:

lst = """This is my blog post.
I love it."""
println lst
println lst.getClass().name

Output is shown below. You can see that the class name is regular String.

This is my blog post.
I love it.
java.lang.String

Variable interpolation:

postName = "Groovy Strings"
lst = """This is my blog post.
$postName"""
println lst
println lst.getClass().name

Output is shown below. You can see that class name is GStringImpl.

This is my blog post.
Groovy Strings
org.codehaus.groovy.runtime.GStringImpl

Both three single quotes and three double quotes behave similar to their single quote counterparts except that they support multi-line strings.

Forward Slashes:

Forward slash behaves very similar to single double quotes. It supports variable interpolation. It does not support multi-line strings. One good thing with forward slash string is it does not need any escape characters. It is used to create regular expressions also.

Simple:

lst = /This is my blog post./
println lst
println lst.getClass().name

Output is:

This is my blog post.
java.lang.String

Variable interpolation:

postName = "Groovy Strings"
lst = /This is my blog post - $postName/
println lst
println lst.getClass().name

Output is:

This is my blog post - Groovy Strings
org.codehaus.groovy.runtime.GStringImpl

Escape characters:

pathName = /c:\develop\grooy\myprojectdir/
println pathName

If you use double quotes or single quotes, then you need to escape the slashes i.e pathName = "C:\Develop" will give compile error. It needs to be defined as pathName = "C:\\Develop". Forward slash strings prevent the hassle of providing escape characters.

The output of above is:

c:\develop\grooy\myprojectdir

Regular Expression:

Using forward slashes, also creates a RegEx. For example, /(B/b)log/ creates a RegEx.

lst = "This is my blog post."
pattern = /(B|b)log/
if (lst =~ pattern) {
println 'matching'
} else {
println 'not matching'
}

The output of above is:

matching

=~ returns a matcher and groovy evaluates that to true if matcher has at least one match. Since the matcher had a match in 'blog', the if statement evaluated to true and printed 'matching'.

Conclusion:

We saw several different ways to create Strings in Groovy. This might be confusing for beginners. In the beginning, you might be better off using just double quotes and three double quotes since it supports what single quotes can support and also does variable interpolation. Also, Groovy is smart enough to create the regular java.lang.String if double quotes string does not use variable interpolation.

Groovy - Different ways to invoke closure or method with closure as parameter

2009-12-25T01:43:00.006-05:00

Closure is one of the most powerful features of Groovy. In Groovy, if a method takes closure as a parameter, there are several different ways to invoke the method. Also, there are different ways to invoke a closure. I'll also show some cases which you might expect to work, but don't. These can sometimes be confusing for a beginner. I'll show them with examples here.

Invoking method with closure as parameter:

The below method takes closure as it's second parameter.

def getOddNumbers(n, closure) {
for (int i=1; i<=n; i+=2) {
println "in method ${closure(i)}"
}
}

There are many ways (i.e syntaxes) to invoke this method:

1) getOddNumbers(10, {
println it
it
})

The closure is the second parameter passed to method. All it does is print the number and return that number. Now, we'll see the other ways.

2) getOddNumbers 10, {
println it
it
}

This syntax is same as 1, except that the open and close braces are optional. This really has nothing to do with closure, but I wanted to show this other syntax also.

3) getOddNumbers(10) {
println it
it
}

If closure is the last parameter to the method, then it can be passed as a separate code block like above. This is very elegant and widely used way to pass closure to a method.

4) printingClosure = {
println it
it
}
getOddNumbers(10, printingClosure)

We can assign closure to variable and use that in our method call later. Also,
getOddNumbers 10, printingClosure will work too i.e we can omit braces here. But getOddNumbers(10) printingClosure does not work though.

Invoking Closure:

Also, there are different ways to invoke the closure. In our above method, we used closure(i) to invoke the closure. We could also do closure i to invoke the method. This works as long as we don't use the return value. But, if we do
x = closure i or println closure i, this fails. closure(i) works fine in these cases and is the common way to invoke closure.

Java to Groovy Incompatibilities

2009-12-25T00:53:00.007-05:00

I'm fairly new to Groovy. One of the things which I've heard many times (from various sources) is that I can take a Java file, rename it as .groovy and can run it. While this is true for the most part, there are some incompatibilities, which caught me by surprise. The following list may not be exhaustive, but I'm listing the incompatibilities which I've read from books/online sources or came across while coding:

If your Java code uses == (reference equal), then groovy does not treat it the same. In groovy == is (almost) equivalent to using .equals() method. Even this also first uses the compare() method (if present) and if that is not present, then it uses equals() method in the class to find out if the two objects are equal. If you want to compare the references of two objects, then you need to use is() in Groovy. For example, obj1.is(obj2) will return true if the obj1 and obj2 point to the same reference.
def and in are keywords in Groovy. So, if your Java code has these variable names, then you may encounter issues. Also, it has a special meaning (closure parameter) in Groovy. If you have a variable named it, you might have issues.
Code blocks like this are not supported by Groovy. It gets confused since it looks like a closure. { System.out.println("Code Block") }
Declaring an array like int[] arr = new int[] { 10, 20, 30 } does not work in Groovy. In Groovy, it needs to be declared like int[] arr = [10, 20, 30]
In Java, both public static void main(String args[]) and public static void main(String[] args) will work i.e the placement of [] does not matter. However, in Groovy, the former one does not work. Only String[] args will work in Groovy.
As of Groovy 1.6, inner classes are not supported. They are now supported in 1.7. See this in Groovy 1.7 release notes.
Even in 1.7, the behavior of inner class is not exactly the same. For example, if the nested class (B) need to refer an instance variable (say counter_) from outer class (A), in Java you can do this using A.this.counter_. This syntax does not work in Groovy.

What did I learn today - Adding new style tabs in Eclipse RCP application

2009-12-03T20:55:00.007-05:00

If you are building an Eclipse RCP application, by default all of the views and editors would have the traditional old style rectangular tabs. If you want curvy ended tabs, like the one in Eclipse IDE, you can implement that by setting this preference value in PlatformUI preference store. Just add the following line to preWindowOpen() method in your ApplicationWorkbenchWindowAdvisor.

PlatformUI.getPreferenceStore().setValue(
IWorkbenchPreferenceConstants.SHOW_TRADITIONAL_STYLE_TABS, false);

By default, traditional style tabs are set to true. You need to turn it OFF to get new style tabs.

Eclipse BIRT plugin - Chart scaling issue

2009-11-25T23:59:00.006-05:00

Background:

We are using Eclipse BIRT plugin 2.5.0 in our application. We encountered a strange issue with BIRT. As you would normally do, we set the scaling in our BIRT chart (in report design) to AUTO, so that BIRT can dynamically figure out the min/max and step size for the axis. It worked fine until we hit a corner case. I wanted to share my problem and the workaround I used to solve this problem so that it helps anyone having the same issue.

Problematic case:

In one of our cases, all the values for the axis were either 0 or less than 0. In this case, it was between 0 and -.02 and so when displayed in percent it was from 0 to -2%. In this case, BIRT chose the axis scale to be from 0 to -100% and so the chart got squeezed (since the entire range is only between 0 and -2%), making the chart unusable. This seems like a bug in BIRT. I've just filed a bug for this: https://bugs.eclipse.org/bugs/show_bug.cgi?id=296207

Workaround:

Aftering unsuccessfully googling for some time and searching for other alternatives, I tried setting the step number and that solved the problem. This made BIRT choose the proper min/max and enlarged my chart.

If you are in report designer, edit chart and go to Format chart tab (or right click on chart and select Format chart). Under Chart Area->Axis, select the axis and hit scale button. This will open "Axis Scale" window. Here instead of "Auto" select the "Step Number" radio button. Specify a number here (10, 15 etc.,) to indicate the number of steps in the axis. This should add the following to the xml source of chart in rptdesign.

<Scale>
<StepNumber>10</StepNumber>
</Scale>

This solved my problem. Note that this workaround maintains the dynamic nature and does not hard code the chart values. The min/max (and so the step size) values in the chart are still dynamic based on the values in the chart.

What did I learn today - Using ArrayContentProvider (Eclipse RCP - JFace)

2009-11-22T23:38:00.007-05:00

If your table view displays a collection of objects for example, collection of Person objects, Collection of Employee info etc., instead of writing your own content provider, consider using ArrayContentProvider. This takes the viewer input (collection) and converts it to an Array.

For example, say your code does something like this:

this.viewer.setContentProvider(new EmployeeInfoContentProvider());
this.viewer.setLabelProvider(new EmployeeInfoLabelProvider());
// Assume employeeInfoSet is a Set of EmployeeInfo objects
this.viewer.setInput(this.employeeInfoSet);

EmployeeInfoContentProvider code:

public class EmployeeInfoContentProvider implements IStructuredContentProvider {

@Override
public Object[] getElements(final Object inputElement) {
if (inputElement instanceof Set) {
return ((Set) inputElement).toArray();
}

return new Object[0];
}

@Override
public void dispose() {
//Nothing to do
}

@Override
public void inputChanged(final Viewer viewer, final Object oldInput, final Object newInput) {
//Nothing to do
}

}

In the above code, EmployeeContentProvider does nothing but translating the collection to array. In this case, you can remove EmployeeContentProvider and use ArrayContentProvider, which does the conversion for you. So, your view code would look like this:

// Replacing EmployeeInfoContentProvider with ArrayContentProvider
this.viewer.setContentProvider(new ArrayContentProvider());
this.viewer.setLabelProvider(new EmployeeInfoLabelProvider());
// Assume employeeInfoSet is a Set of EmployeeInfo objects
this.viewer.setInput(this.employeeInfoSet);

Less code is better right!

What did I learn today - Adding key listeners to trees and tables (SWT/JFace)

2009-11-08T23:08:00.007-05:00

I wanted my trees and tables to listen to DEL key so that when user presses it, the selected nodes in the tree or the selected cells in the table would get deleted. I was looking for the method to add key listener to the table/tree viewer, but found that I need to add it to the viewer control.

Below is the code to add listener to the delete key on your tree viewer.

this.treeViewer.getControl().addKeyListener(new KeyAdapter() {
@Override
public void keyReleased(final KeyEvent e) {
if (e.keyCode == SWT.DEL) {
IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();
if (selection.isEmpty()) {
return;
}

// Business logic to handle deletion - remove from model, view etc.,
handleDelete(selections);
}
}
});

You can do it similarly for other viewers (table viewer etc.,) or to listen to other keys also.

If you are working directly with SWT, you will add listener directly to the tree/table (i.e the control itself) like tree.addKeyListener(), table.addKeyListener() etc., You can add this to any control in SWT.

What did I learn today - Invoking help from Welcome Screen in Eclipse RCP

2009-10-28T21:22:00.004-04:00

I wanted to know how to launch help window from the welcome screen. From the welcome screen, either we could link to other html pages or we could link to help content. Since the help content topics are already in help, it makes more sense not to duplicate it, but to link to it. Basically, when I click on "How to do feature X?" link in welcome screen, I want my Help window to open up and go to that topic directly. Very similar to context sensitive help, but from welcome screen.

After some fight, I got it working. If you want to link from the intro content xml file, you can add this within the page.

<page id="root" style="content/root.css" style-id="page">
<group id="Introduction">
<link label="Getting started" url="http://org.eclipse.ui.intro/showHelpTopic?id=/my.test.plugin.help/html/intro1.html" id="intro1">
</link>
</group>
</page>

Or, if you need to launch help topic from within the html or xhtml welcome screen pages, you could use this:

<body>
<div id="header">
<h1>My Application</h1>
</div>
<div id="content">
<li>
<a href="http://org.eclipse.ui.intro/showHelpTopic?id=/my.test.plugin.help/html/intro1.html" id="intro1">
Getting started with my application.
</a>
</li>
</div>
</body>

Here my.test.plugin.help is the id of my help plugin.

What did I learn today - Cross plug-in help in Eclipse plugins

2009-10-19T19:58:00.004-04:00

Each plugin in Eclipse typically has it's own corresponding help plugin. Sometimes, it is necessary to link help topic in one plugin from a help topic in another plugin. I was not sure how to do that. Found that we can do it by having the link in the following form:

<a href="PLUGINS_ROOT/com.mycompany.mypluginid/html/mytopic.html">My Topic</a>

Here, com.mycompany.mypluginid is the id of the target plugin where mytopic.html lives.

Note: Before Eclipse 3.2, the cross plugin help link used to be referenced like "../com.mycompany.mypluginid/html/mytopic.html". It is recommended not to use it anymore.

What did I learn today - Eclipse IDE Java Editor Save Actions (Automatic code formatting/clean-up)

2009-10-18T20:22:00.007-04:00

Formatter/Code Clean-up:

In our organization, we have our builds set up so that they fail even if the source has one PMD/Checkstyle error. Until recently, I'm used to running formatter, clean-up and removing unused import options (available via right click context menu) before committing my source code, so that I don't break the build. You could also have clean-up do formatting and remove unused imports as part of clean-up. If you don't know what I'm talking about, look at formatter and clean-up options under Java->Code Style preferences.

How to automate?

While this is good, I recently found that I can automate this. Go to Window->Preferences->Java->Editor->Save Actions preferences page. Here there are options so that formatter, clean up and removing unused imports all run automatically whenever the source code is saved.

Available Options:

In save actions preferences page, Check "Perform the selected actions on save" to enable the other options below. Check "Format source code" and make sure to select "Format edited lines" option so that only the lines you edit are formatted. This would avoid formatter changing every line in the file. Check on "Organize imports" and also check on "Additional Actions". The actions here are (almost) same as the clean-up options available under Java->Code Style->Clean Up preferences. Click on configure button in "Additional Actions" and make sure that they both have the same configuration. Only thing missing here (which would have been really nice!) is that the additional actions does not automatically point to the clean up preferences defined already and so you have to define it again here. Also, you cannot use a clean-up profile here either. But, still the automatic save actions really save me time and makes sure that my code is always clean. Finally, the main thing is, I break our builds much fewer now!

What did I learn today - Eclipse PluginSpy

2009-10-17T20:47:00.006-04:00

Eclipse PluginSpy has been there for sometime now. Select any view or editor and do ALT+SHIFT+F1. This will open the plugin-spy popup window and shows information about the view/editor selected. It shows information about Active Shell, Active Part, Active Selection and Active Help. Try it if you did not know about this feature.

What's new in Eclipse 3.5 is, PluginSpy now works for toolbar and menu items also. Do ALT+SHIFT+F2 and move the mouse over toolbar or menu item. You will see the cursor change to a book like image. Now, click the toolbar or menu item and you will see that plugin-spy popup window come up for that also. This shows Active Selection and Contributing Plugin Information for the selected toolbar or menu item.

I find it very useful. I'm sure every Eclipse Plugin Developer will appreciate this great feature.

Wish everyone a very Happy Diwali!

Eclipse RCP - Saving Editor State and Layout

2009-10-10T01:01:00.010-04:00

Introduction:

In the previous article, we saw how to save view layout and state. In this article, we will see how to save editor layout and state.

Saving Editor State and Layout:

Saving editor state is slightly more complicated than saving the view state. Below are the steps which needs to be done to save the editor state.

1) First of all, make sure that initialize method in ApplicationWorkbenchAdvisor has save and restore enabled. Add the following line to the initialize method for this: configurer.setSaveAndRestore(true);

2) The editor input needs to implement getPersistable() method and should return an IPersistableElement. Mostly, my editor input itself implements IPersistableElement and so getPersistable() would return this. IPersistableElement is responsible for saving the current state of the element and also tells the id of the factory which is responsible for reconstructing the editor from current state of the application. The methods (listed in points 4 and 5 below) need to be implemented in IPersistableElement.

3) The editor input needs to implement exists() method and make sure that it returns true.

public boolean exists() {
return true;
}

4) Implement saveState method in IPersistableElement - public void saveState(final IMemento memento) {}

This method is responsible to save the current editor state into the memento. See the previous article on how saveState method works for views and it behaves exactly the same for editors too. Make sure to save all the information in memento, which are needed to reconstruct the editor later.

5) Implement getFactoryId method in IPersistableElement - public String getFactoryId() {}

This method should return the id of your IElementFactory which is responsible for re-creating the editor from the saved memento. We will see more about IElementFactory below in 6 and 7.

6) Open plugin.xml and go to extensions tab. Add a new extension point org.eclipse.ui.elementFactories and add a new factory for your editor. Give it an Id (this is the ID which needs to be returned in getFactoryId method in IPersistable element - see point 5 above) and class (the class name which implements IElementFactory).

7) Implement your IElementFactory class. It needs to implement public IAdaptable createElement(final IMemento memento) {} method. This method is passed the IMemento which is saved when application was closed last time. createElement method need to re-create the editor and need to return IAdaptable. IEditorInput is an instanceof IAdaptable. So, for editors, you would typically get info from IMemento, create your IEditorInput (using info from IMemento) and return that.

This is all you need to do to save your editor state and layout. Eclipse takes care of remembering the layout of the editors. Main thing here is, we need to make sure that we persist all state information (in saveState method - point 4) and be able to recreate the editor in exactly the same state (in createElement method - point 7).

How this works?

Behind the scene, whenever the application is closed, getPersistable method for all the open editors is called. If it is not null, then the IPersistableElement's saveState method is called and all the state information is saved into the memento. Also, getFactoryId is called so that eclipse can know which class is responsible for recreating this editor later. This information is saved in <youreclipseworkspacedir>\.metadata\.plugins\org.eclipse.ui.workbench\workbench.xml file. Take a look at this file and you will see that the information saved in memento and also factory information is persisted there.

Note that if getPersistable() returns null, then the state of the editor will not be saved. You can use this in cases where you don't want to save the editor state. For example, if user switches to a different workspace or to a completely different environment, you don't want to save the editor state because they are no longer applicable in the new workspace/environment. In these cases, you could just return null in getPeristable() method.

When application is re-openened, platform reads the workbench.xml file, creates IElementFactory instance and passes it the proper memento. Then, the IElementFactory knows how to recreate the editor from the saved information.

Conclusion:

In this article, we saw how to save editor state and layout so that the application can re-open in exactly the same state as it was closed last time.

Eclipse RCP - How to save view layouts and state?

2009-10-04T23:55:00.002-04:00

Introduction:

Saving the state of the application and reopening the application in the same state as previously opened vastly improves user experience. This article explains how to save the layout and state of the views in your application.

Saving Views and Layout:

First of all, you need to enable saving and restoring application state at workbench level. Make sure you override initialize method in your ApplicationWorkbenchAdvisor and add configurer.setSaveAndRestore(true);

@Override
public void initialize(final IWorkbenchConfigurer configurer) {
super.initialize(configurer);
configurer.setSaveAndRestore(true);
}

Adding this automatically saves opens views along with their layouts and makes sure they are reopened appropriately in the same layout. Isn't that amazing? Almost half of our work is done just by adding the above code block to ApplicationWorkbenchAdvisor. The remaining thing is saving the internal view state (i.e saving details of inside the view) .

Saving View State:

Let's say you have a navigator view in your perspective which displays a tree. By adding the above code block, the navigator view would be reopened in the same spot when application reopens again. But, the internals of navigator view would be lost. For example, if the tree had few selections and few nodes opened, they would be lost. Below, I'll explain how to preserve tree selections in your view.

1) Override saveState method (from ViewPart) in your view.

@Override
public void saveState(final IMemento memento) {
IStructuredSelection sel = (IStructuredSelection)this.treeViewer.getSelection();
if (sel.isEmpty()) {
return;
}
memento = memento.createChild("tree-selections");
Iterator iter = sel.iterator();
while (iter.hasNext()) {
String nodeName = iter.next();
memento.createChild("selected-nodes", nodeName);
}
}

IMemento provides way for user to store the application state in XML. User does not have to deal with XML directly and IMemento API takes care of it. When application is closed, if a view is open, it's saveState method is called before it is closed. This way, internal state of the view can be persisted before it is closed.

Restoring View State:

If you want to restore your view state (from the saved memento), you need to override the init method with memento i.e override this method

public void init(IViewSite site, IMemento memento) throws PartInitException {}

instead of

public void init(IViewSite site) throws PartInitException {}

Then, you can read the contents of the memento and restore view's internal state.

// Stores the memento so that it can be used after view is created
@Override
public void init(final IViewSite site, final IMemento memento) throws PartInitException {
init(site);
this.memento = memento;
}

@Override
public void createPartControl(Composite parent) {
// Create view here - For example, create tree viewer here

restoreState();
}

// Method which reads memento and sets selections on the tree
private void restoreState() {
IMemento selectionsMomento = this.memento.getChild("tree-selections");
if (selectionsMomento != null) {
IMemento selectedNodes[] = selectionsMomento.getChildren("selected-nodes");
if (selectedNodes.length > 0) {
ArrayList selections = new ArrayList(selectedNodes.length);
for (int i = 0; i<selectedNodes.length; i++) {
String id = selectedNodes[i].getID();
if (id != null) {
selections.add(id);
}
}

this.treeViewer.setSelection(new StructuredSelection(selections));
}
}
}

The contents of the view is created in createPartControl. Once the contents are created, it's state is set by using the restoreState method, which uses memento to get the internal state of the view last time. Above, we get selected node names from the memento and set tree selection appropriately.

Conclusion:

In this article, we saw how to preserve view layout and it's internal state so that views are reopened in exactly the same way as it was closed last time. In the next one, we'll see how to preserve editor layout and it's state.

What did I learn today - Eclipse Search

2009-10-03T00:35:00.000-04:00

We all learn something new everyday (hopefully!). Starting today, I plan to start writing short tips or articles about what did I learn today. It helps me in remembering them and hope it helps everyone else too...

I came across this eclipse search site - http://www.cypal.in/Eclipse_Search.html (Powered by Google, ofcourse).

This site is very focused and does not clutter my search results with non-eclipse related hits as in regular google search.

Creating tree table in RCP (Eclipse 3.4 - Ganymede)

2009-08-29T00:58:00.000-04:00

Introduction:

In this article, I will explain about how to create tree table functionality. Here, I assume that you are familiar with creating trees and tables.

Creating tree table:

First of all, do not use TableTreeViewer and TableTree to create tree table. They are deprecated as of 3.1. Creating tree table is easy if you know how to work with trees and tables. Tree table is nothing but a tree which has columns. This is basically how you will create tree table.

Let's assume that you have a tree which displays your organization hierarchy (tree of employee names) . But now, you want to convert that into a tree table so that you can also display employee age and salary (in separate columns) in the hierarchy.

this.treeViewer = new TreeViewer(parent);

Tree tree = this.treeViewer.getTree();

final GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
this.treeViewer.getControl().setLayoutData(gridData);

this.treeViewer.setUseHashlookup(true);

/*** Tree table specific code starts ***/

tree.setHeaderVisible(true);
tree.setLinesVisible(true);

TreeColumn treeColumn = new TreeColumn(tree, SWT.LEFT);
treeColumn.setText("Name");

treeColumn = new TreeColumn(tree, SWT.LEFT);
treeColumn.setText("Age");

treeColumn = new TreeColumn(tree, SWT.LEFT);
treeColumn.setText("Salary");

TableLayout layout = new TableLayout();
int nColumns = 3;
int weight = 100 / nColumns;
for (int i = 0; i < nColumns; i++) {
layout.addColumnData(new ColumnWeightData(weight));
}

tree.setLayout(layout);

/*** Tree table specific code ends ***/

this.treeViewer.setContentProvider(new OrgHierachyContentProvider());
this.treeViewer.setLabelProvider(new OrgHierarchyLabelProvider());
this.treeViewer.setInput(this.employeeOrgHierarchyModel);

If you are familiar with creating tree, you would be familiar with the first few lines (creating tree) and the last few lines (setting content provider and label provider). The middle section (as marked above) deals with the tree table specific code. If you are familiar with creating tables, then you would understand this. Basically, you are saying that header and column lines should be visible in the tree and you are also creating tree columns and setting the layout for the columns.

Tweaking label provider:

Your content provider would be exactly same as you would do for any tree. This is because underlying data is still the same. In this particular case, the content provider provides employee object for every tree node. Only the representation of model data is going to be in tree table form instead of tree. So, once the above code is set up, you need to tweak the label provider so that it provides labels for individual columns in the tree node.

For tree, you would normally implement ILabelProvider and implement getImage and getText (which just had employee name in our case). For tree table, you should implement ITableLabelProvider (just like you would do for tables) and implement getColumnImage and getColumnText. This way for each column we know what employee attribute to return. Below is a snippet of how your label provider would look:

public String getColumnText(final Object element, final int columnIndex) {
if (element instanceof Employee) {
if (columnIndex == 0) {
return (Employee(element)).getName();
} else if (columnIndex == 1) {
return (Employee(element)).getAge();
} else if (columnIndex == 2) {
return (Employee(element)).getSalary();
}
}

return "";
}

Conclusion:

Basically you set up tree table as specified above and your data (content provider) provides tree data i.e bean for every node. Then your label provider takes the bean and provides values for different columns in the tree node. That's all you need to create a tree table. So, if you are familiar with trees and tables, creating tree table is very easy.