Over at Pushing Pixels i have ran the series on adding animations to enable rich interactivity expected from modern SWT applications. The code is part of the Granite project which aims to provide blueprints for animated SWT applications powered by the Trident animation library, and the series has covered the following:

• Part 1 – adding simple animation behavior to such scenarios as component appearance (fade in) and window disposal (fade-out) using built in and custom class attributes and setters.
• Part 2 – adding animated load progress indication while the application is loading data.
• Part 3 – loading the album art matching the specific search string and asynchronously displaying the associated images.
• Part 4 – scrolling the album covers showed in the container and adding animations to the scrolling.
• Part 5 – complex transition scenarios.

How can you run this code locally?

• Get the latest SVN snapshots of Trident and Granite
• Add the following Eclipse libraries to the project: org.eclipse.core.jobs, org.eclipse.equinox.common, org.eclipse.osgi
• The Onyx distribution contains the lib/amazon.jar. It has been created with the following steps:
  • wsimport -d ./build -s ./src -p com.ECS.client.jax http://ecs.amazonaws.com/AWSECommerceService/AWSECommerceService.wsdl .
  • jar cvf ../amazon.jar .
• Get an Amazon E-commerce key
• Run the org.pushingpixels.granite.DemoApp class, passing your Amazon key as the only parameter to this class, adding the Amazon, Trident and Granite classes, as well as Eclipse jars to the classpath

If all went right, you should see the main application running and displaying Sarah McLachlan albums as in this video:

I hope you enjoyed this series. If you’re interested in adding rich animations to your SWT applications, you’re more than welcome to explore Trident and Granite and report any bugs and missing features in the project forums and mailing lists.

I am thrilled today to announce the availability of the final release for version 1.0 of Trident animation library for Java applications (code-named Acumen).  Trident aims to simplify the development of rich animation effects in Java based UI applications, addressing both simple and complex scenarios – and you can read the available documentation in the project Wiki.

The current published API set follows the “simplicity before generality” approach. Trident is a continuation of the internal animation engine that has been part of the Substance look-and-feel for the last two years. Extracting it to a standalone library was accompanied by a significant overhaul of the API facets to:

• Provide a shallow learning curve
• Address real world use cases

It is very easy to start with Trident. To add animations to your application, simply create a timeline, configure it to change a value of some property and play it. From here, you can go progressively deeper towards the more powerful – and the more complex – Trident APIs:

• Adding more properties to interpolate
• Specifying intermediate values during the interpolation
• Controlling the rate of the property interpolation
• Listening to lifecycle events of timelines
• Creating parallel and sequential timeline scenarios
• Creating staged timeline scenarios
• Creating timeline scenarios with arbitrary dependencies

At each level you get more control over the animations – as you get more comfortable with what Trident can do to address the animation requirements of your application.

During the development of this version i have created a number of simple and more advanced examples using Trident. These examples have driven the current shape of Trident APIs. The simple examples include animating the foreground color of a button, showing an indeterminate progress indication, emulating fireworks and Matrix rain. In addition, Amber and Onyx are more complicated applications that integrate animation scenarios into UIs that fetch and display information from the web-based backend services – such as Digg, Twitter and Amazon. These examples strive to be the blueprints for using Trident in Java applications.

If i had to choose three features that bring the most functionality to interested applications, those would be:

• Timeline scenarios that allow creating progressively complex dependency graphs of timelines, runnables, swing workers and custom application actors
• Support for threading rules of UI toolkits that frees the application code from creating convoluted nested inner classes and prevents it from deadlocking and freezing the UI
• The extensibility layer that allows application to extend the existing core functionality to additional property classes and UI toolkits

Going forward, i intend to evolve Trident, and i already have a couple of post-1.0 features in the pipeline. The next major release of Substance will be rewritten to use Trident – further testing the published APIs for usage in real-world scenarios. In addition, the next major release of Flamingo ribbon will add Trident-based animations – where applicable.

Finally, no project is complete without the users trying the different features, pushing the existing APIs, reporting bugs and asking to support additional requirements. Subscribe to the mailing lists and let me know what is missing, and how the existing APIs can be improved. If you find a bug, report it in the issue tracker. If you want to take a look at the code, check out the SVN repository and subscribe to the "commits" mailing list.

Trident is an animation library for Java applications, and this week i’ve written about the concepts behind it and APIs available to interested applications:

• Part 1 – Hello world
• Part 2 – interpolating fields
• Part 3 – timeline life cycle
• Part 4 – duration fraction and timeline position
• Part 5 – supporting UI toolkits
• Part 6 – simple Swing / SWT examples
• Part 7 – parallel timelines in Swing and SWT
• Part 8 – timeline scenarios
• Part 9 – key frames
• Part 10 – extending the core with plugins

What’s next? Version 1.0 (code-named Acumen) is right around the corner. Release candidate is scheduled for June 29, and the final release is scheduled for July 13.

Trident is a new library, and its APIs need to be tested in real-world scenarios. While i have a few small test applications that illustrate the specific API methods, as well as medium sized demos (Onyx and Amber), there is always room for improvement.

Going forward, i intend to evolve Trident, and i already have a couple of post-1.0 features in the pipeline. Trident has evolved from the internal animation layer of Substance look-and-feel, and the next major release of Substance will be rewritten to use Trident – further testing the published APIs for usage in real-world scenarios. In addition, the next major release of Flamingo ribbon will add Trident-based animations – where applicable.

Your input and feedback are always highly appreciated. Download the latest daily bits, and read the documentation. Subscribe to the mailing lists and let me know what is missing, and how the existing APIs can be improved. If you find a bug, report it in the issue tracker. If you want to take a look at the code, check out the SVN repository and subscribe to the “commits” mailing list.

Swing / SWT applications do not have to be boring. Trident aims to simplify the development of rich animation effects in Java based UI applications, addressing both simple and complex scenarios. But it can only be as good as the applications that are using it. So, read the documentation, download the sources / binaries, integrate it in your applications and let me know what you think.

I am pleased today to announce the availability of the final release for version 4.1 of Flamingo component suite (code-named Guenivere). It is a stabilization release that adds a few minor features and fixes all known bugs.

Here is the list of minor features added in release 4.1:

• Multi-row controls in ribbon bands
• Rich tooltips for ribbon band expand buttons
• Horizontal alignment for wrapped ribbon components
• Internal tracking of disabled state of popup / action areas on command buttons for selecting the correct displayed icon
• Tree breadcrumb adapter class is now abstract to enforce applications to provide the segment caption

To see the Flamingo ribbon component in action under core look-and-feels, run the following WebStart demo:

To see the Flamingo ribbon component in action under Substance look-and-feel, run the following WebStart demo:

If you want to test the ribbon in your applications, you would need the following (the last two only for applications running under Substance look-and-feel):

• The 4.1final drop of Flamingo (code-named Guenivere)
• The 5.2final drop of Substance (code-named Quebec)
• The 5.2final drop of Substance Flamingo plugin

You are more than welcome to take Flamingo 4.1 for a ride and report any problems in the project mailing lists, forums or issue tracker.

Release 4.1 will be the base for the JavaOne technical session 4143 that will be held next Thursday, June 4th at 13:30 in Hall E 135. If you’re interested to hear about the ribbon and the Swing implementation, as well as in a few ribbon tricks that you might not be aware about, please drop by.