• Home
  • Events
  • About
  • release – Canoo RIA Suite 2012

    September 17th, 2012

    To view the newsletter on our website, please click here.

    Canoo logo
    Dear Reader,

    The Canoo Engineering Team is delighted to be able to present you the latest Version of Canoo RIA Suite. Numerous new features are now available. Here is an overview of the new functions:

    • migration of RIA Suite to Java 6
    • numerous new Java 6 Swing APIs
    • the optimized RIA Suite package ULC Chart
    • the new RIA Suite package ULC Graph
    ULC Chart
    The chart creation features – previously integrated in ULC Core – now offer additional individuality in the shape of ULC Chart1) as a separate RIA Suite package. You can generate high quality charts in a flash in your ULC application. In addition to the classic pie charts, bar charts and graphs, the package offers a wide variety of additional presentation options.
    ULC Chart
    ULC Graph
    The new package ULC Graph2) enables you to quickly and simply visualize company data or processes, e. g. workflow visualizations, organigrams or graphs. And these views can easily be adapted because of the link to your database and intuitive editing features.
    ULC Graph
    See for yourself and put our ULC Chart Demo and ULC Graph Demo to the test.
    All the information regarding feature requests and individual bug fixes is available as usual in our release notes for the Canoo RIA Suite 2012.A Magnificent Outlook
    You can also look forward to many more innovations in the coming months in Canoo’s RIA Suite:

    • ULC Push supports a push mechanism via long polling (October 2012)
    • RIA Suite minor release (December 2012)
    • ULC Analysis provides map, table and chart based components for the analysis of large data volumes (April 2013)
      Take a look at the first two main components, ULC BigTableExplorer and ULC GeoMaps.

    We trust that you will enjoy developing using the new Canoo RIA Suite!
    Your Canoo Team

    1) ULC Chart is no longer a component part of ULC Core. A new license need not be acquired for its usage.

    2) ULC Graph is a new Canoo RIA Suite package. A ULC Graph license must be acquired in order to use it. You can find further information about this on our website, or simply call us on +41 61 228 94 44.

    NEW – Canoo offers ULC Platinum Support

    July 10th, 2012
    Canoo logo
    Dear Reader

    Magicians, conjurers or illusionists – there are many designations for this most ingenious of professions which have one common hallmark. Namely, a baffled and amazed audience is frantically left asking “How do they do that?” Likewise, during software development, engineers like to take a look behind the scenes of utilized libraries and gain an insight into the how, what and why. But surely the entire source code – rather than a binary file – at one’s disposal must be unaffordable? Or perhaps not!

    Good advice need not cost the earth
    Using Canoo RIA Suite you can develop attractive web-based business applications in next to no time. Furthermore, you can make use of our wide range of support services. We have now enhanced this support with the new ULC Core Platinum Support. Customers with our ULC Core Premium Support can benefit from the license upgrade with immediate effect. This offer provides many advantages, likewise to new customers.

    Exclusively for you

    The new Platinum Support includes all the services of the Premium Support. When you purchase a Platinum Support license we additionally provide you with the ULC Core Source Code as unobfuscated binary and source JAR Files*). For you this means first and foremost simpler and more rapid development. You obtain a deep insight into the workings of RIA Suite and can integrate this know-how into your own development. This represents an enormous benefit for you.Take advantage of your new opportunities
    You can find all the necessary information regarding Platinum Support on our website. We would be pleased to prepare a non-binding quotation for you. Call us or simply send us an email at ulc-sales@canoo.com.We wish you every success with your Platinum Support license!
    Your Canoo Team

    *) A license for ULC Core Platinum Support costs 1’750 EUR, while the upgrade from Premium Support to Platinum Support costs 1’000 EUR. Both licenses are acquired for a term of 12 months. Please note that the delivered JAR Files may only be integrated in the development projects of the respective licensee. It is not permitted to unpack, modify, reuse, rebuild or redistribute the JAR Files containing the source code together with derivative work. These JAR Files are intellectual property of Canoo. As a licensee you agree to protect the source code from any unauthorized third party access.

    Maintenance Release Canoo RIA Suite ULC Update 1

    October 1st, 2010

    We are pleased to announce that the maintenance release
    Canoo RIA Suite ULC Update 1 is now available for download !

    This is a maintenance release for the Canoo RIA Suite.
    Besides many bug fixes and improvements it includes

    – Builtin animations for ULCLabel, ULCScrollPane,
    ULCSplitPane and ULCInternalFrame
    – Radial Gradient Paints

    Please see the release notes for the complete list of
    implemented feature requests and fixed problem reports.

    And don’t miss the demos.

    Please note: the ULC Core license key and any ULC Package license key
    are valid for all releases labeled Canoo RIA Suite ULC. If you already have
    any Canoo RIA Suite license key, no new license key is required.

    Java Without the Boilerplate – Project Lombok

    July 26th, 2010

    Project Lombok is a very cool little Java library that aims (and succeeds) in removing boilerplate, meaningless, and uninteresting code from your Java objects. The basic idea is to replace things like getters and setters with simple annotations, and then let the Java compiler generate the necessary bytecode in the .class file so that tools such as Eclipse and the Java compiler have no idea what anything unusual happened. Lombok hooks into the compiler to make sure this happens correctly.

    First we’ll cover some Lombok basics and then show how it can be used with the Canoo RIA Suite (ULC) project and and view generators. This includes details on how to mix Lombok annotated objects with JPA annotations, which you might want to glance at before leaving!

    Update: You do not need ULC to work with Lombok. The two are separate projects.

    Lombok in Action
    So let’s see Lombok in action. Consider this Java class that includes a Lombok annotation:

    OK, so there is an @Data annotation in there. So what? Well, to javac and tools (like Eclipse) this class has getters and setters for all three fields, an equals and hashcode implementation, and a toString method. Eclipse tools still give you autocomplete the Navigator shows the correct methods. Not only did you not have to write (or generate) the code yourself, but you don’t have to see that code when coming back in maintenance mode. The interesting bits of your class are no longer buried in the noise. Consider what this looks like without lombok:

    That’s a lot of code for something so simple. It doesn’t even fit in my browser margins without funky line breaks! Sure, IDEs can generate it for you. But what if something interesting is buried in the equals() method? Or perhaps a setter has a side-effect? You can’t easily see this with the reams of boilerplate typical of Java. With lombok, only the essentials are displayed, so the unique parts of the object will stand out to the future reader. And yes, even using @Data you are free to provide your own implementations for any of these methods.

    Richard Gabriel made this observation when comparing old programs (like MacPaint) to “modern” programs writen in langauges like Java:

    I’m always delighted by the light touch and stillness of early programming languages. Not much text; a lot gets done. Old programs read like quite conversations between a well-spoken research worker and a well-studied mechanical colleague, not as a debate with a compiler. Who’d have guessed sophistication brought such noise.

    Now, with Lombok, sophistication is finally taking the noise away, rather than adding to it.

    Just a couple important details before moving on to a Lombok example that uses Canoo’s RIA Suite

  • Lombok is compile time only. It does not need to be deployed with your app
  • Lombok works with javac and Eclipse. IntelliJ IDEA will not ‘see’ the added methods
  • lombok.jar contains an installer that configures your eclipse.ini file correctly. Be sure to run “java -jar lombok.jar” after you download it (especially for those on 64 bit Linux like me)
  • Lombok with Canoo RIA Suite
    The point of this was to make sure I could use Lombok on my next RIA Suite(aka ULC) project. It’s looks like I can, and you can too. To prove it, let’s generate a RIA Suite project, add a domain class using Lombok, generate the views, and run the application.


  • Install Eclipse for Java EE Developers. Make sure that you have for Java EE developers.
  • Install Canoo RIA Suite. Get your download and evaluation key from our customer portal.
  • Install Lombok. Download it and run “java -jar lombok.jar”.
  • Steps
    Here are the steps we’ll perform to get this thing working:

  • Generate a Project using ULC’s Project Generator in Eclipse
  • Add the lombok Jar to your project
  • Create a domain object called Contact and annotate it with @Data
  • Generate the views using ULC’s generate-beans-view in Eclipse
  • Run the app and behold a default, thin client, CRUD application
  • Generate the Project
    The ULC Application Development Guide contains a 10 page getting started tutorial that walks you through the process from starting at zero and going to a deployed RIA Suite application. Really, it is quite simple. You just need to add the Project Generator as an external tool in Eclipse. Although it is a bunch of screenshots, this is a common task for Eclipse users and little can go wrong.

    In Eclipse, click Run -> External Tools > Open External Tools Dialog… and point a new external tool to your “/addon/generators/build-setup.xml” from the RIA Suite install. Your window should look like this:


    Now you’ll have the menu entry for Run -> External Tools -> ULC Project Generator, which you should click now. You’ll be prompted for a project name and whatnot, and a sample Contacts application will look like this:


    The script runs and you now have a project on disk that can be run. Just click to File -> Import to import it, navigating to where it is on disk. Your import screen should look like this:


    If it all goes well your project should be open and your Project Explorer should look like this:


    Add the Lombok Jar
    We need to add the lombok.jar to the Contacts project, add it to the build classpath, and click Refresh to make sure Eclipse is aware that something changed.

    Copy the lombok.jar to ./Contacts/lib/development directory in your project. Then edit the project properties (right click the Contacts project and select Properties), select the Java Build Path entry, and add lombok.jar as a Jar. Should look like this:


    Create Domain Object
    Let’s add a domain object with JPA persistence to our project. A Contacts application must show a Contact, right? This looks about right:

    Let me explain a few details… The class is marked @Entity so that JPA persistence works. The class will map to a Contact table in the database. The class is marked @Data so that lombok will weave in getters, setters, toString, equals, and hashcode methods. The @Id annotation on the “id” field marks that field as the primary key to JPA, and the @GeneratedValue means the field auto increments. I use the GenerationType.SEQUENCE strategy because I plan on deploying to Google App Engine, otherwise this parameter here is unneeded. Lastly, getters and setters are supressed on the id field by adding @Getter(AccessLevel.NONE) and @Setter(AccessLevel.NONE). If you don’t do this then the view-layer automation of Ria Suite is going to, by default, provide you with edit fields for the id, which you should not do.

    Generate the View Layer
    To generate the view layer, click Run -> External Tools -> “Contacts generate-beans-view”. This tool was installed for you by the Project Generator. Running it generates a simple Create-Read-Update-Delete (CRUD) interface with a table, buttons, and entry editor. You’ll see a couple new classes and property files in your application after you run the tool.

    Run application
    Last thing to do is run the app. Click Run -> Run History -> Contacts (again installed by the project generator), sit back, and behold an application.


    That’s it!

    Next step is to deploy to Google App Engine using that Contacts-copy-to-GoogleApp tool that the generator installed, but that is a blog post (and task) for another day.


    Juggling with DLLs, WebStart and Maven

    May 6th, 2010

    Juggling with DLLs, WebStart and Maven

    Recently we were asked to implement a Drag & Drop mechanism between Microsoft Outlook and a Java based internet application. This necessitated our Java server having to communicate with COM objects on the client side. How do you do that?

    The good thing is that our application was built using UltraLightClient, so we had java on both the server and on the client side. And after some thinking, the steps seemed pretty clear, even if a tiny bit of juggling would be required. However, the juggle almost turned into a struggle when we encountered some unexpected pitfalls.

    In this blog I will give a quick sketch of our solution and point out some of the traps to be aware of.

    Step 1: Talking COM using JACOB

    In order to communicate with Microsoft programs from Java you need a Java COM Bridge.
    We were using JACOB and it was surprisingly easy to extract Outlook mails into Java objects.

    The idea:
    The following method extracts the selected outlook mails to a directory and returns the list of created files:

    The trap:
    Using the email subject as a file name is practical, but it can contain many weird characters which may not be supported when the files are created. We found out that JACOB has problems creating files containing even characters like “:” and “,”. Furthermore, no exception is thrown, although the file fails to be created completely.

    The solution:
    Replace potentially dangerous characters with something neutral using regular expressions:

    To be on the safe side we were using a whitelist approach. We treat everything as invalid except for characters which are listed after the “^” character.

    Step 2: Shipping a DLL with Webstart

    JACOB can talk to Outlook because it comes with a DLL which has to be present in the classpath. This means we either have to ensure that all our users have this library installed (yikes!) or we ship it together with the application client using Java Webstart.

    The idea:
    We include the DLL in the jar file and sign it with a valid certificate. Then it can be referenced from the JNLP file that launches your web application:

    The trap:
    We were using the optional parameter download=”lazy” to ensure that the library is only downloaded when it is really needed. The result was that it never got loaded at all(!) because we did not specify to which “part” the library belongs. This is another optional parameter which turns mandatory in combination with download=”lazy”.
    Unfortunately this little detail is not too well documented. The only hint found was this one (in german). It took me quite some time to find this critical information.

    The solution:
    Since the jar containing our DLL is really small we chose to use download=”eager” (which is the default anyway) instead of defining “parts” in our JNLP.

    Step 3: Using native lib references with the webstart-maven-plugin

    We already were using Maven as a build system and our client distribution is generated with the webstart-maven-plugin as follows:
    – We use a separate module with packaging type “pom” for the generation of the webstart client. Of course, this module is part of the multi module build for our application.
    – We provide a template for the JNLP file containing a parameter “$dependencies” which will be replaced by a list of the dependencies of the current module
    – At build time the dependencies will be signed and put into a zip file together with the JNLP file.
    – The zip file can be extracted to a java webstart server or, in our case, into a war file that will be deployed on a server.

    The idea:
    Since JACOB is available via Maven Central integration seemed pretty easy. We only have to generate the correct reference to the native library.

    The trap:
    Unfortunately the current version of the webstart-maven-plugin (1.0-alpha-2) does not support native libs (open issue). So we will need a workaround that wraps the jacob.dll into a jar file and generates the nativelib reference in our JNLP.

    The solution:
    Perform the following steps:
    – Change the packaging type for the module from “pom” to “jar”.
    – Configure the pom.xml to copy jacob.dll from the maven repository into the build directory of the module using the maven-dependency-plugin
    – Add the nativelib reference to the velocity template using the build artifact of the current module as a reference.


    After successfully having avoided the traps (okay: by stepping into them and finding a way out again) we got an application with a pretty cool feature integrated seamlessly in our build process. Nice!