Showing posts with label RIA. Show all posts
Showing posts with label RIA. Show all posts

Sunday, 26 July 2009

Using XML/SWF Gauge

I have been looking for flash widgets to show data in a dashboard. The XML/SWF Gauge has become my best choice so far. It only requires one gauge.swf file which takes in a XML configuration file to instruct it what and how to draw the gauge. I used it to implement a Radar View as part of my dashboard.

I like the simplicity of the XML/SWF Gauge when using it. Yet it generates versatile and visually pleasing results. It also supports dynamic data display and scheduled update/refresh.

Since I used it in a ZK web application, naturally I used ZK to generate the input XML file dynamically. By default XML files are not passed to the ZK Loader to handle. To force it to be passed to ZK Loader I had to add a servlet mapping in web.xml file:


   zkLoader
   *.xml

I can use the same gauge.swf to generate all sorts of views - radar, meter, dial ... all I needed is to generate the appropriate XML file to feed the gauge.swf as shown in the following ZUL file segment.
...


        // ...


 if (view.getName().equals(event.getData())) {
  // recalculate view attributes...
  // refresh:
  gaugeFlash.invalidate();
 }


I do have the following complaints on XML/SWF Gauge:
  1. It does not support concurrent/nested animation.
  2. It does not support event-driven updates (vs. scheduled updates).
If you have come across any good flash gauge packages, please leave a comment.

Thursday, 11 June 2009

One Year On

I started this blog one year ago in June 2008. I have been using Google Analytics to track the site. Here are some visitor (mostly from IT and development communities) trends collected in the last year or so.

Browsers used:

OS used:

Browser + OS used:

Java support:

As of June 2009 the top 5 visited posts on this blog site are:

  1. Consuming WCF Web Service Using Java Client, July 2008
  2. Consuming Web Services from Android, August 2008
  3. IE8 + Outlook Web Access = Problems, May 2009
  4. WPF Splash with ProgressBar, July 2008
  5. How To Add Unicode Fonts to N95, September 2008

There are a couple of trends worth noticing:

  1. Firefox has a bigger market share than IE among the technical users and rightly so. It will be interesting to see how Chrome will measure up against the top two. Chrome has certainly great momentum considering it has only been launched 9 months ago and already in 3rd place.
  2. Java support is not as ubiquitous as I first thought. I wouldn't develop my next RIA business application on JavaFX any time soon. So right now I will stick to ZK (and maybe SmartSWT) and wait for HTML5 to take over.
  3. It only took less than a month for the IE8 + Outlook Web Access = Problems post to claim the no. 3 spot. It just shows how bad IE8 is.
  4. The post on number 5 spot has far more comments than the rest. It proves once again that non-technical people are far more social

Tuesday, 16 December 2008

The Sorry State of JavaFX 1.0

The release of JavaFX 1.0 officially marks Sun's defeat in the RIA battle. Why? Because JavaFX 1.0 is inferior to its competitors in all major battlefronts of the RIA war. It looks like a rushed job to make a marketing deadline.

The JavaFX 1.0 APIs

The JavaFX 1.0 is shipped with 2D graphical capabilities and that's pretty much it. Even basic things such as 3D graphics, faster video codecs are labeled with 'coming soon...' on their demo site. Forget about building any business RIAs because there are only a handful of simple Swing widgets at your disposal. On the other hand, people have been using Flash to build business applications for years; Silverlight has got 3D capabilities since v1.0.

Design/Development

The JavaFX plugin for NetBeans is a joke - it's buggy, sluggish and poor in features. One mistyped word or bracket can result in red squiggly lines all over the screen; then it produces unhelpful error hints such as 'sorry I was expecting so and so but I saw such as such...' so that the user has to read through the whole sentence several times and still hard to figure out what the complaint is. What happens to KISS principle?

Sure, Sun had said that they intended the plugin to be used by designers also - hence the 'user friendly' error messages. But let's get serious, how can anyone assume graphical designers will be using computer programming language to define simple things such as Timelines? Sun doesn't have to look far to find a better way - Microsoft has Expression Web to be used by graphical designers, and VS.NET 2008 to be used by programmers when it comes to Silverlight design and development workflow. (The JavaFX plugin for Illustrator is only good for editing shapes).

Deployment

To me there is not much point of deploying RIA as a thick client using Java Web Start. I am only interested in running RIA in a browser. With the new way of deploying applets in Java, JNLP is used, so that the HTML file points to a JNLP file and the JNLP file points to the JAR files and more JNLP files... It's a bit like my multi-hop flight from Sydney to Kathmandu (via Bristane then Bangkok) that took me over 20 hours and 6 of which was waiting at BKK for transit (that that is how I have the time to write this post) all because my company was too cheap to book the Qantas flight.

This is unnecessarily complicated because Sun doesn't want to have JavaFX plugin to the browser. On the other hand, Flash/Silverlight plugins are installed onto the browser so that all you need to specify is the object or embed tag in the HTML file without the hassle of running the myriad javascripts to detect/download the additional framework JAR files every time.

The User Experience

If you are using a browser that does not have the latest Java plugin (that supports JavaFX) installed (such as on my Nokia N95, or using the PC in the Thai Airways lounge at Kathmandu international airport), then you will be greeted with a message box forcing you to redirect to Sun's download website. There is no option to cancel!

Moreover, those javascripts do not report any errors if something goes wrong - it just hangs there with the Java logo spinning around and around forever...

Wednesday, 10 December 2008

Merry Christmas JavaFX 1.0

JavaFX 1.0 was finally released last Friday. After over 2 years of brooding, I wonder what Sun has come up with - oh boy what a disappointment the JavaFX IDE (NB plug-in) is! But that is for another post.

The JavaFX 1.0 is no good for developing any RIA business applications for its lack of widgets. Instead it is OK for little toys such as those demos published on javafx.com. Immersed in the holiday season atmosphere, I implemented my Christmas card in JavaFX. A screenshot is shown below.

The Christmas card has the following features:

  • Transformation - the red and yellow text fly into the screen using a combination of Translation, Rotation and Scale.
  • Media playback - background music (mp3 file) from Michael Buble - Let it snow.
  • Animation - snow fall simulation
  • Drag out - when run as applet in a browser, the card can be dragged out of the browser.

The Project Structure

The project was created using NetBeans 6.5 with JavaFX plug-ins (installed from within NetBeans). I created a JavaFX project called MerryChristmas. The project structure is shown below:

The only files that I added are:

  1. LetItSnow.mp3 - the background music song
  2. tree.png - the background image: photo of Christmas tree shot at Darling Harbour on December 8, 2008.
  3. Main.fx - the main JavaFX file containing the scene and its contents
  4. SnowFall.fx - the CustomNode simulating snow fall and snow flakes (using circle)

The Main Contents

The contents of the main scene are two Texts, one background image, one background music and the snow fall (implemented as CustomNode).

The texts and their animation (actually transformation) are created as shown below. Notice the transforms which use binding data changed by the Timeline definition.

...
var x:Number;
var y: Number;
var scaleX : Number;
var scaleY:Number;
var angle:Number;

Timeline {
    repeatCount: 1
    keyFrames: [
        at (0s) {x=>180; y => 250; scaleX => 0.0; scaleY => 0.0; angle => -180},
        at (10s) {x=> 0; y => 0;
        scaleX => 1.0; scaleY => 1.0;
        angle => 0
        tween Interpolator.EASEOUT},
    ]
}.play();
...
var lighting = Lighting{
    light: DistantLight{
        azimuth: 60,
        elevation: 70
    }
    surfaceScale: 5
};

Stage {
    ...
    scene: Scene {
        content: [
            ...
            Text {
                content: "Merry Christmas & \nHappy New Year!"
                font: Font.font("Arial Bold", FontWeight.BOLD, 40)
                textOrigin: TextOrigin.TOP
                textAlignment: TextAlignment.CENTER
                x: 10
                y: 20
                transforms: bind[
                    Translate{
                        x:x
                        y:y}
                    Scale{
                        x:scaleX
                        y:scaleY}
                    Rotate{
                        angle: -angle
                        pivotX: 180
                        pivotY: 20 }
                ]
                fill: Color.RED
                effect: lighting
            },
            Text {
                content: "From Romen"
                font: Font.font("Times", FontWeight.BOLD, 40)
                textOrigin: TextOrigin.TOP
                x: 90
                y: 470
                transforms: bind[
                    Translate{
                        x:x
                        y:y}
                    Scale{
                        x:scaleX
                        y:scaleY}
                    Rotate{
                        angle: angle
                        pivotX: 180
                        pivotY: 450}
                ]
                fill: Color.YELLOW
                effect: lighting
            },
...

Any suggestions on how to make unicode text work are welcome.

The background image and music are easy enough:
...
            ImageView {
                image: Image {
                    url: "{__DIR__}tree.png"
                }
                x:0,
                y:0
            },
...
            MediaView {
                mediaPlayer: MediaPlayer {
                    autoPlay: true
                    media: Media {
                        source: "{__DIR__}LetItSnow.mp3"
                    }
                }
            },
...

Drag Out

To enable drag out when run as an applet in browser, I added the following extension to the Stage:
    extensions: [
        AppletStageExtension {
            shouldDragStart: function(e): Boolean {
                return e.primaryButtonDown;
            }
            useDefaultClose: false
        }
    ]
Also I had to specify in the Project's properties dialog and check the Draggable checkbox so that it will generate the .html file with the draggable set to true. The generated .html file snippet:
...

...

Snow Fall

All snow related classes are in the SnowFall.fx file. I used white circle as the snow flake:
public class SnowFlake extends Circle {
    init {
        fill = Color.WHITE;
        radius = 3 + Math.random() * 3;
        opacity= Math.random() * 0.5 + 0.5;
    }
}
The SnowFall class takes 3 attributes:
  • height, width - these specify the size of the canvas so that all the snow flakes can spread out in the canvas making it more realistic
  • numberOfFlakes - the number of snow flakes to be drawn and animated. The more flakes, the more threads JavaFX will have to create and manage under the hood.
The animation of the snow flakes are a bit tricky. Initially all the snow flakes are generated and randomly placed around the canvas; then, they start to fall. The movement of the snowflakes are as such: every second the snow flake will move left (negative) or right (positive) by a random amount, and move down by a random amount - i.e. the horizontal movement (x) can be either positive or negative, the vertical movement (y) is positive only. This is shown below:
                            KeyFrame {
                                ...
                                values: [
                                    x =>
                                    x + (Math.random() - 0.5)
                                    y =>
                                    y + Math.random() tween Interpolator.LINEAR
                                ]
...
When the snow flake hits either side of the boundary, it sort of bounces back a little; when it moves off the bottom of the canvas, it is wrapped around and re-appears at the top of the canvas and falls down again. This is achieved by using action of Keyframe which are executed at the beginning of each key frame.
...
                               action: function() {
                                    if(flake.centerY+y >height) {
                                        y=0; flake.centerY=0;
                                    }
                                    if(flake.centerX+x>width) {
                                        x=0; flake.centerX=width;
                                    }
                                    if(flake.centerX+x<0) {
                                        x=0; flake.centerX=0;
                                    }
                                }
...
The SnowFall class generates all the snow flakes in a for loop. Each snow flake is accompanied by a Timeline controlling its animation. The number of frames in each Timeline is also randomised (between 60 and 120 seconds per cycle), to avoid the situation where all snow flakes suddenly reset at the same time.
for ( i in [1..numberOfFlakes]) {
...
                    def timer = 60+60*Math.random();
                    Timeline {
                        repeatCount: Timeline.INDEFINITE
                        keyFrames: [ for (j in [0..timer]) {
                            KeyFrame {
...
Want to see the Christmas card in action? Well, you will have to wait till Christmas! [Update NYe2008]Now that it is NYE 2008, click here to run the e-card.

Meanwhile, here are the complete source code.

SnowFall.fx

/*
 * SnowFall.fx
 *
 * Created on 10/12/2008, 09:55:19
 */

package merrychristmas;

import java.lang.Math;
import javafx.animation.Interpolator;
import javafx.animation.Timeline;
import javafx.scene.CustomNode;
import javafx.scene.Group;
import javafx.scene.Node;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.animation.KeyFrame;
import java.lang.System;

/**
 * @author ROMENL
 */

public class SnowFall extends CustomNode {
    public var height:Number;
    public var width:Number;
    public var numberOfFlakes:Number;

    override function create():Node {
        return Group {
            content: [
                for ( i in [1..numberOfFlakes]) {
                    var x:Number;
                    var y:Number;
                    x=1;
                    y=1;
                    var flake = SnowFlake{
                        centerX: Math.random() * width
                        centerY: Math.random() * height
                        translateX: bind x;
                        translateY: bind y;
                    }

                    def timer = 60+60*Math.random();
                    Timeline {
                        repeatCount: Timeline.INDEFINITE
                        keyFrames: [ for (j in [0..timer]) {
                            KeyFrame {
                                time: bind Duration.valueOf(j * 1000)
                                values: [
                                    x =>
                                    x + (Math.random() - 0.5)
                                    y =>
                                    y + Math.random() tween Interpolator.LINEAR
                                ]
                                action: function() {
                                    if(flake.centerY+y >height) {
                                        y=0; flake.centerY=0;
                                    }
                                    if(flake.centerX+x>width) {
                                        x=0; flake.centerX=width;
                                    }
                                    if(flake.centerX+x<0) {
                                        x=0; flake.centerX=0;
                                    }
                                }
                            }
                        }
                        ]
                    }.play();
                    flake
                }]
            
        };
    }
}
public class SnowFlake extends Circle {
    init {
        fill = Color.WHITE;
        radius = 3 + Math.random() * 3;
        opacity= Math.random() * 0.5 + 0.5;
    }
}

Main.fx

/*
 * Main.fx
 *
 * Created on 9/12/2008, 15:29:24
 */

package merrychristmas;

import javafx.animation.*;
import javafx.scene.effect.*;
import javafx.scene.effect.light.*;
import javafx.scene.image.*;
import javafx.scene.input.MouseEvent;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.scene.media.MediaView;
import javafx.scene.paint.Color;
import javafx.scene.Scene;
import javafx.scene.text.*;
import javafx.scene.transform.Rotate;
import javafx.scene.transform.Scale;
import javafx.scene.transform.Translate;
import javafx.stage.AppletStageExtension;
import javafx.stage.Stage;

/**
 * @author ROMENL
 */
var width=390;
var height=540;
var x:Number;
var y: Number;
var scaleX : Number;
var scaleY:Number;
var angle:Number;

Timeline {
    repeatCount: 1//Timeline.INDEFINITE
    keyFrames: [
        at (0s) {x=>180; y => 250; scaleX => 0.0; scaleY => 0.0; angle => -180},
        at (10s) {x=> 0; y => 0;
        scaleX => 1.0; scaleY => 1.0;
        angle => 0
        tween Interpolator.EASEOUT},
    ]
}.play();

var lighting = Lighting{
    light: DistantLight{
        azimuth: 60,
        elevation: 70
    }
    surfaceScale: 5
};

Stage {
    title: "Merry Xmas JavaFX"
    width: width
    height: height
    scene: Scene {
        content: [
            ImageView {
                image: Image {
                    url: "{__DIR__}tree.png"
                }
                x:0,
                y:0
            },
            Text {
                content: "Merry Christmas & \nHappy New Year!"
                font: Font.font("Arial Bold", FontWeight.BOLD, 40)
                textOrigin: TextOrigin.TOP
                textAlignment: TextAlignment.CENTER
                x: 10
                y: 20
                transforms: bind[
                    Translate{
                        x:x
                        y:y}
                    Scale{
                        x:scaleX
                        y:scaleY}
                    Rotate{
                        angle: -angle
                        pivotX: 180
                        pivotY: 20 }
                ]
                fill: Color.RED
                effect: lighting
            },
            Text {
                content: "From Romen"
                font: Font.font("Times", FontWeight.BOLD, 40)
                textOrigin: TextOrigin.TOP
                x: 90
                y: 470
                transforms: bind[
                    Translate{
                        x:x
                        y:y}
                    Scale{
                        x:scaleX
                        y:scaleY}
                    Rotate{
                        angle: angle
                        pivotX: 180
                        pivotY: 450}
                ]
                fill: Color.YELLOW
                effect: lighting
            },
            MediaView {
                mediaPlayer: MediaPlayer {
                    autoPlay: true
                    media: Media {
                        source: "{__DIR__}LetItSnow.mp3"
                    }
                }
            },
            SnowFall {
                height: height
                width: width
                numberOfFlakes: 30
            }
        ]
    }
    extensions: [
        AppletStageExtension {
            shouldDragStart: function(e): Boolean {
                return e.primaryButtonDown;
            }
            useDefaultClose: false
        }
    ]
}
Related Posts:
  1. Happy New Year
  2. Happy New Year of the Ox
  3. The Sorry State of JavaFX 1.0

Friday, 19 September 2008

The Shortest Self-Printing Code

#!/bin/ksh
cat `whence $0`

Could this be the shortest self-printing code?

Saturday, 13 September 2008

Of Tatami, jMaki and Others...

Tatami 1.2 Beta was released a few days ago.

Both GWT and Dojo are Javascript frameworks for creating Rich Internet Applications (RIA). The GWT team focuses on the foundation of the framework and does not bother with making state-of-the-art cool widgets. While Dojo has a mature and good-looking widgets library. Wouldn't it be good if the two can be seamlessly integrated at the API and runtime levels so that one can leverage on the advantages of both frameworks? That's exactly what Tatami offers.

Tatami is a widget/component library for GWT. What makes it interesting is that it is a GWT wrapper of Dojo components. With Tatami, the Dojo widgets become GWT widgets; the Dojo utilities become GWT helper classes. If you don't have the stomach for editing CSS+XHTML+Javascript directly, but still want to use the Dojo components, then Tatami is good news. The development experience is back to Java and that's it.

Another web framework which provides Dojo wrapper is the jMaki framework. While jMaki has a nifty NetBeans plug-in, the development experience is improved somewhat. However, as a developer, you'd still have to deal with a mixture of JSP, Javascript and Java: the page templates are written in JSP, the glue code is written in Javascript for event handlers (using a pub-sub mechanism), the server side code is written as Java servlets - maybe this hodge-podge is really what they mean by mash-up.

Another wrapper is the GWT-EXT, which is a GWT wrapper for EXT/JS. I have blogged about the EXT/JS, EXT-GWT and GWT-EXT and the licensing issues revolving EXT/JS previously. Well, the licensing of Dojo is very liberal, without the GPL issues introduced by EXT/JS. Thankfully, Tatami is LGPL.

Friday, 5 September 2008

Why Google Chrome?

The release of Google Chrome beta is indead exciting news. Chrome is going to be bigger than iPhone! What makes it exciting is not the GUI - in fact, it looks and behaves pretty much just like any other browser. It is what's under the hood that make people (OK, developers) pumped about the new browser.

Google made it very clear on why they built a browser: "What we really needed was not just a browser, but also a modern platform for web pages and applications, and that's what we set out to build." So it is clear that Google intends to make Chrome to host and run next generation rich internet applications (RIA). Google's RIA platform is the Google Web Toolkit (GWT), which just had version 1.5 released a few days ago (Developer's Guide here). JavaFX folks are also excited about Chrome as shown in this article.

Google is a big proponent of Javascript. GWT 'compiles' Java code into Javascript and uses Javascript in runtime. A sophisticated GWT application can result in a large Javascript file, which poses a performance problem for the initial download of the application (a similar problem faced by Java Applets, which Java 6 Update 10 solves by allowing downloading relevant JARs only, without having to download the whole JRE libraries). Google Gears is another component that Google pushes to increase performance of Javascript applications. Yet, users have to download and install it separately if they want to take advantage of it. Therefore, it is natural for Google to come up with a browser as a unified platform for great support of Javascript. From Chrome web site, Google stated: "We also built V8, a more powerful JavaScript engine, to power the next generation of web applications that aren't even possible in today's browsers." Here we can see a glimpse of what to expect from Google on the Chrome, Gears and GWT fronts. GWT applications will run faster on Chrome than any other browser, thanks to Javascript optimisation on Chrome.

No wonder people are speculating that Microsoft is contemplating on suing Google for antitrust!

Related posts: Why Not Chrome?

Monday, 25 August 2008

The Sorry State of JavaFX

[Update: since JavaFX 1.0 has come out, this article is out-dated. See The Sorry State of JavaFX 1.0 instead.]

It's been over a year since F3 has been rebadged JavaFX in May 2007. I had enjoyed programming in JavaFX script and it really is easy to learn and enables rapid application development.

JavaFX is fine for its original goal of delivering a 'media' stack for the Java platform. However, as JavaFX is more and more being pitched to compete with Silverlight and Flash to be Sun's answer to Rich Internet Application (RIA) platform, it is falling short.

A major requirement of a RIA platform is to be able to run the application seamlessly in a web browser - i.e. using the browser as a canvas, not just using the browser to download the fat client. JavaFX does not do that. Both Silverlight and Flash's home pages promote their own technologies by using them. But what does javafx.com use? Javascript! So far almost none of the JavaFX demos show an application running in browser. For the few that do show, such as the Applet Example, when I tried it using javafx-sdk1.0pre1, all I got was a blank applet canvas. (I did manage to run a JavaFX application as an Applet from HTML via trial and error though).

Also, no support for being inlineable with HTML will decrease its flexibility as a RIA. Tey Chui gave a comprehensive argument on this issue.

Sun has been promising a browser javafx plugin for a while now. I do hope they can deliver it together with the proper 1.0 release. Talking about the releases, I was really surprised by the drastic changes made in the current 1.0pre1 release. It has pervasively changed the JavaFX script syntax so that your previous JavaFX code in the last 2 years simply will not compile anymore. Furthermore, the bundled JARs have also been totally changed - the javafx.ui.* simply disappeared! This suggests a deeper underlying architectural change.

Well, making big changes may not be a bad thing, especially considering JavaFX' beta status. However, the documentation available in supporting the developer community to cope with the change is totally inadequate. Sun does have JavaFX Reference documents. However, the current state of these documents are nothing near to be complete or even adequate. For example, the Migration Guide does not tell you what had happed to 'trigger on new' or nullable datatypes (e.g. int?) or recommendations for replacing javafx.ui.* with the scene graph libraries...

For now, I will put my JavaFX exercises on halt and wait for the final v1.0 release.

Sunday, 15 June 2008

GWT - RIA of Choice ?

I have been evaluating RIA frameworks (incl. Echo 2, GWT, JavaFX and Silverlight) for building business applications since a year ago. So far GWT has come as a clear winner.

GWT is especially appealing to Java developers - you develop your application in Java: server side, client side GUI, the lot. The GUI development is much like Swing, except that you are dealing with GWT APIs, but the programming experience is pretty much the same. AJAX is also supported by simply writing Java callback code without touching any XML or Javascript. These Java code is then translated into high quality and high performance Javascript by GWT and at deployment time, the JS code is downloaded to the browser and gets executed there - freeing the server side from handling presentation responsibilities. (Echo 3 also promised to take a similar approach). When I first learnt and programmed in GWT, it was such a refreshing experience - it was a joy to use.

The GWT team focuses on the foundation of the framework and does not bother with making state-of-the-art cool widgets. That responsibility has been given to third-parties. Sanjiv Jivan has created the wonderful GWT-Ext project which takes on this responsibility. Some people claimed that between GWT and Flex, they chose Flex because of its better look and feel. I guess they did not include GWT-Ext in their picture.

GWT-Ext provides a set of cool and useful widgets with complete documentation, demo and sample applications. It is a tremendous amount of work for an individual to take on. The result is simply superb.

One major issue of GWT-Ext is that it is a GWT wrapper of Ext-JS library, which used to be LGPL and now GPL (since version 2.1) and a commercial license is also available. Apparently this change of licensing policy has created much stir in the community. The effect of this change is also evident in the GWT-Ext distribution - in earlier versions (e.g. v0.9.2) the Ext-JS is bundled with the GWT-Ext download; but in newer ones (e.g. v2.0.3) you have to download and install Ext-JS yourself.

Furthermore, the maker of Ext-JS, Ext also created a similar product called Ext-GWT (not to be confused with GWT-Ext), which directly competes with GWT-Ext. The technical difference between GWT-Ext and Ext-GWT can be found here.

As a commercial application developer, if you want to stick with GWT-Ext, then there are the following choices:

  1. use older version of Ext-JS with new version of GWT-Ext for free
  2. pay for latest version of Ext-JS but use GWT-Ext for free
  3. hope/wait for someone to fork Ext-JS and maintain a LGPL branch

I can't wait to work with GWT-Ext 2.0.3 which has full Drag-and-Drop (DnD) support in its widgets. Note that by DnD I don't mean just repositioning a widget on screen (which many RIA frameworks can do), but the kind of DnD capability that you would expect in Swing or WinForms, e.g. to drag a row in a grid and drop it into a text area so that the text area can be populated with the data from the corresponding business object being DnD'ed.

I hope Sanjiv stays true to the open source ideology, continues with the good work of GWT-Ext and doesn't change the licensing policy.