Thursday, December 17th, 2009
Category: Ext, GWT
Sanjiv Jivan has released Smart GWT 2.0, a big release for the project.
The core updates are:
GWT 2.0 support
Smart GWT supports GWT 2.0 and continues to remain compatible with GWT 1.5, 1.6 and 1.7. This release is a drop-in upgrade for users of earlier versions of Smart GWT. The API’s of Smart GWT have been very stable and as a result there will be no upgrade cost or migration effort for users upgrading to Smart GWT 2.0
New Enterprise Blue theme and significantly improved Enterprise Gray theme
These themes now closely follow the Vista UI specification and guidelines. Incorporating the new theme is as simple as inheriting the new EnterpriseBlue theme module and does not require any other changes.
And other features include:
- Drop-in upgrade with no upgrade or migration effort
- Multi-Column sort support
- Grid Row Expansion support for
- memo rows
- detail views
- nested editable form
- nested editable grid (useful for representing 1-many relationships)
- any custom embedded component
- Collection of standard Window icons, picker icons and transfer buttons as part of every theme
- Improved Showcase demo with ability to search for samples by keyword. Added several new samples
- Various other enhancements like Date field masks, improved IE 8 and Safari strict mode support.
To see the breadth of the project, make sure to check out the showcase which is very deep indeed. Nice work guys!
Tuesday, December 8th, 2009
Category: GWT, Google
Here is Speed Tracer, the new tool to aid us Web developers in our quest for great applications:
Ben and I are at Google Campfire One with a Who's Who from the Web developer space. When I first met the GWT team they were talking about revolutionary new Web tools that they wanted to create, and I have a feeling that they will be talking about what they have come up with.
David Glazer (Engineering Director) and Andrew Bowers (GWT PM) are kicking off the build up with the obligatory ra-ra for HTML5 and the great new browsers we have to build "modern Web applications".
Next, Andrew gets into the world of development and deployment of Web apps and the productivity and performance improvements.
First up, productivity. Andrew is discussing AdWords which uses GWT in places. AdWords uses a UiBinder a declarative approach to building GUIs:
HTML:
-
-
<ui :UiBinder ... ugly xml ns ...>
-
<ui :style/>
-
<g :HTMLPanel>
-
... insert HTML or widgets ...
-
-
<g :Button ui:field="closeWidget">Close</g>
-
</div>
-
</g>
-
</ui>
-
AboutDialog.java:
JAVA:
-
-
@UiHandler("closeWidget")
-
void onClick(ClickEvent e) {
-
hide();
-
}
-
After the demo he talks about the Developer Plugin and support for multiple browsers.
Matt Mastracci, founder of Dotspots, is now "by the fire" ready to talk to us about how they use GWT. First up he shows a GWT application that compiles down and uses it as a Firefox add-on. They have also used the same code that they incorporate in a Chrome Extension and other areas. GWT 2.0 contains a new "developer mode" and Matt shows it in action as he hits Eclipse from the browser to quickly iterate. No need to recompile.... (since GWT is a compiler). Of course, using JS itself allows you to make a change and reload :)
Bruce Johnson, co-creator of GWT, is now "fired up" to talk about the deployment stage. How does the GWT compiler do its job? It can Prune dead code, Devirtualize, Inline, Eval, and Obfuscate.
Developer guided code splitting is next up which cuts down the initial download and only grabs what it needs.
Someone from MediaBeacon shows a rich app (which looks exactly like how I envision a GWT app ;) as a demo of code splitting.... going from 1.5MB to 100k in 16 lines of code.
Now Kelly Norton (awesome guy) is up on stage with a "Web Workers" ice hockey jersey. He has the new tool, Speed Tracer! It monitors apps in real time, shows hidden browser events, and gives advice through hints.
Kelly has fired up Google Calendar to show a demo. I love the "Sluggishness" activity bar showing work in real time. The graph view is nice, and seeing the events is fantastic. E.g. script eval, script parse, paints, parse HTML, DOM layout, CSS style calculation. You can see it!
Speed Tracer itself is a Web application deployed as a Chrome Extension. One nice feature is that you can export a trace and send it over to someone via email and they can manipulate and play with the view on that data. It is a GWT app itself, and it looks not-like you think of a GWT app. Very nice indeed.
That's a wrap, thanks for the new tool Kelly, Bruce, Andrew and team!
Tuesday, August 25th, 2009
Category: Articles, GWT
Sorry about the cheesy title, I couldn't resist. In one of those moods I guess. Chris Lowe has posted a detailed example of a new-age GWT application that uses lots of cool tech based on Ray Ryans talk on MVP pattern;
Use a command pattern;
Use an Event Bus (a.k.a Event Collaboration);
Use Dependency Injection.
Chris takes these ideas and applies them to the starter project created by the Google plugin for Eclipse. To get this done, he uses a slew of libraries:
NOTE: currently GIN needs to be built from source using SVN/Ant.
You'll also need the following libraries at the server:
Then, the tutorial walks you through setting up your views, presenters, and events. It is Java, so you will notice a fair amount of source code (but at least the GuiceServlet gets rid of most of the XML). Just joshing with ya!
It was cool to see my buddy Rob's Customware being the place that created some of the key libraries. Good on ya mate!
Thursday, July 2nd, 2009
Category: Component, GWT, Library
John Gunther has released GChart 2.5, a client-side library that adds a new canvas-rendering option for sharper, better looking, alpha-transparent, pie, line, and area charts.
John told us:
Canvas-rendering corrects GChart's most serious visual quality limitations (including the most often mentioned problem by its users: the banded-filled pie slice).
Coupled with its existing feature set and ease of GWT integration, the canvas-rendering option makes GChart an excellent choice for those who want to add basic charts to a GWT application without a lot of fuss.
To access these features, you'll need to plug an external canvas library into GChart (GWTCanvas in the gwt-incubator is reccommended) as described in detail in the setCanvasFactory method.
With the external canvas in place, the next step is to tell GChart you want a curve to be "continuously filled" by invoking setFillSpacing(0).
With each such continuously filled curve, GChart automatically exploits your external canvas library to improved the quality and speed of that curve's rendering. Specifically, banded-filled pie slices become solid filled, dotted connecting lines become continuously connected, and (the biggest stretch) bar charts become area charts. See the setFillSpacing method's javadocs for a detailed description of how each existing symbol type implements this new "continuously-filled", canvas-powered, rendering option.
Note that GChart's previous HTML-only rendering is still available, and is the default rendering mode if you don't bother to plug in an external canvas.
Check out the demo
Tuesday, March 10th, 2009
Category: Framework, GWT, Java
With the release of IT Mill Toolkit 5.3.0, the server-side RIA framework is now ready for production. I announced the initial release of 5.0 back in December of 2007. Since that time, IT Mill 5 has gone through several revisions and the release of GWT 1.5 (which means you can use Java 5 now on both the client and the server). As a reminder, server-side RIA frameworks let you write your app completely in the server and uses a client-side Ajax engine to render the interface. The nice wrinkle with IT Mill is that both the server side and the client side are written in Java, so if you want to add a component, you don't have to break out the JavaScript (see the extensive and high quality reference manual for details on how to develop your own custom components in GWT). If you're a Java shop, that's got to be a good thing.
Tuesday, February 10th, 2009
Category: GWT, Showcase
What would a fun Ajax interface to piano composition look like? Jason Freeman, a prof in the music department of the Georgia Institute of Technology has created an interface using GWT called Piano Etudes.
His project lets users create and share their own versions of short piano pieces (and print them out as musical scores for use in live concert performances). It was built using GWT and, among other things, it shows that it's relatively easy to put together a simple GarageBand-style music editing interface using Ajax.
Wednesday, January 28th, 2009
Category: GWT, Showcase
Ray Cromwell has the ability to do amazing things in the browser. We have often linked to his work on Chronoscope and more, and this time he has a screencast showing of Timescope "our charting engine, written in GWT, runnable as Servlet or Android native application, renders huge numbers of points at interactive rates, scriptable, annotatable like Google Maps, and stylable via CSS-like stylesheet mechanism."
For those who know of Chronoscope, this is the commercial version, big changes include more accurate multiresolution filtering algorithm, Android native version, Chart Server, iPhone integration, synthetic datasets, a number of other things. We eventually hope to include a subset of complete implementation of R in GWT, to allow statistical work to be done totally in browser.
At the 7:20 mark, you can see GSS, which is an implementation of a CSS parsing and cascade engine in GWT, to support our totally custom set of properties, elements, and pseudo-classes.
Very cool indeed Ray.
Tuesday, January 6th, 2009
Category: GWT, Showcase
SendMeHome lets you to assign a unique code, called a SendMeHome ID, to any physical item. We are launching our newest feature, Stories, which connects a group of people through an item as it travels the globe. Social networks such as Facebook mainly involve users communicating with their ‘friends’, SendMeHome is unique because it uses a real-world object to tell a story that enables interaction between new and like-minded people who may otherwise have never known of each other’s existence.
Our beta users have already created stories to write a collaborative novel, share cooking tips, discuss political events, and even transport a statue to Easter Island.
The site uses GWT components and integrates with services such as good ole Google Maps. You can check out a story. Having a code associated to items is a lot of fun (read: Webkinz) and seems to be something that can be useful.
Wednesday, December 3rd, 2008
Category: GWT, JavaScript, Toolkit
You may remember Sanjiv Jivan as the GWT-Ext developer that changed over the debacle. He then went on to start work on a GWT version of SmartClient libraries and has now released SmartGWT 1.0.
It is a tour de force of not only a huge widget library, but he explains how it is much more:
So what's so smart about SmartGWT? Let me try to explain. SmartGWT is not just another Widget library. While most Ajax frameworks focus primarily on presentation and displaying mostly read-only data, either local or via XML / JSON, SmartClient was built with server side integration in mind. Most enterprise applications are not just about about data presentation, but about being able to propagate data changes made by the user to the backend. So while its tempting to use library X that has a cool tree widget, it's not until you actually try to use it your application that you encounter the real world hard problems. For example, how do you take data from your business objects on the server to not only display in a tree widget, but also be able to update your data model when, say, the user reorders the tree nodes or make edits / deletes in the UI. How do you display hierarchical data where nodes may have hundreds of children? And so on..
Most Ajax frameworks stop short and leave it up to the user to manage state on the client side and propagating the changes to the server. This is not a trivial problem! Over the past few years UI widget libraries have improved significantly and there are now various options available to users. Simply put, having good looking widgets is not the hard problem today. In addition to having good looking widgets, having end-to-end integration of the UI components with the backend is the hard problem. It's this 20% of the functionality that takes 80% of the time in building most enterprise applications.
The showcase will give you a good feel for what is out there, and it contains some interesting items including:
- Miller Columns: The ColumnTree provides an alternate navigation paradigm for Tree data, sometimes called "Miller Columns" and seen in iTunes
- Nested Grid: A convenient way to display 1-n relationships
- Printable Views: SmartGWT supports printable views of its components.
- Advanced Filter Builder: a databound filter builder.
- Tile View: Representation of data as "tiles". Again, TileGrid supports data binding so sort / filter and edits can be easily performed.
- Calendars : A Google Calendar like widget that supports databinding so edits and drag drop changes can easily be propgated to the server for persisting.
- TreeGrid : Supports multiple columns, editing, column locking, lazy loading and more.
- Live Grid / Tree: Grid / Tree virtual scrolling or live grid
Really amazing work. Sanjiv recently had a Q&A session with InfoQ where he talks about the approach taken in developing SmartGWT and the his thoughts on the differences between SmartClient and Ext.
Monday, December 1st, 2008
Category: Canvas, GWT, Java
Rodrigo Reyes has announced a new project called AbstractCanvas, a GWT project that sits on top of HTML Canvas and Java2D.
The same code can thus run in the browser, or on the server.
You can then write code such as:
JAVA:
-
-
VerticalPanel vPanel = new VerticalPanel();
-
-
CanvasPanelExt canvas1 = new CanvasPanelExt(300,150);
-
-
canvas1.
setFillStyle(Color.
WHITE);
-
canvas1.setGlobalAlpha(1.0);
-
canvas1.fillRect(0, 0, canvas1.getCoordWidth(), canvas1.getCoordHeight());
-
-
canvas1.addCanvasPainter(new ColorTest()); // <- Note the use of CanvasPainter here
-
canvas1.addCanvasPainter(new PathTest()); <- and here
-
-
vPanel.add(canvas1);
-
Monday, November 3rd, 2008
Category: GWT, Mapping
Alexander (aka Sasha) Maryanovsky has been hacking away with GWT, and has some come up with a couple of interesting project.
The first, is a fun chess diagram builder that lets you build out a chess diagram and export it out:
Also, he has created Sasha Maps, an API that abstracts mapping implementations allowing you to plugin your own system (but Google Maps and WMS are implemented).
The appropriate Hello World could look something like this:
JAVA:
-
-
package com.maryanovsky.mapdemo.client;
-
-
import java.util.Arrays;
-
import java.util.List;
-
import com.google.gwt.core.client.EntryPoint;
-
import com.google.gwt.user.client.ui.RootPanel;
-
import com.maryanovsky.gwtutils.client.UiUtils;
-
import com.maryanovsky.gwtutils.client.UserEventManager;
-
import com.maryanovsky.map.client.*;
-
import com.maryanovsky.map.client.impl.Google;
-
-
/**
-
* The entry point of the Map demo.
-
*/
-
public class TutorialDemo implements EntryPoint {
-
/**
-
* Starts the map demo.
-
*/
-
public void onModuleLoad() {
-
List tileLayers =
Arrays.
asList(new TileLayer
[]{Google.
NORMAL_TILE_LAYER});
-
-
Map map =
new Map(Google.
MERCATOR_PROJECTION, tileLayers,
0,
17);
-
LatLng initialLocation = new LatLng(60.050317, 30.350161);
-
int initialZoom = 13;
-
-
MapWidget mapWidget = new MapWidget(
-
new MapLocationModel(0, 17, initialLocation, initialZoom));
-
mapWidget.setMap(map);
-
-
UserEventManager eventManager = mapWidget.getUserEventManager();
-
eventManager.setDragAction(MapWidget.DRAG_MAP_ACTION);
-
eventManager.setDoubleClickAction(MapWidget.ANIMATED_ZOOM_IN_ACTION);
-
eventManager.setWheelAction(MapWidget.ANIMATED_ZOOM_ACTION);
-
eventManager.setRightClickAction(MapWidget.ANIMATED_PAN_MAP_ACTION);
-
-
UiUtils.disableContextMenu(mapWidget.getElement());
-
UiUtils.addFullSize(RootPanel.get(), mapWidget);
-
}
-
}
-
The API gives you interfaces to setup custom maps, actions, overlays, map widgets, and more.
Tuesday, October 7th, 2008
Category: GWT, Python
Last week, we posted a story about deploying GWT to PHP back-ends. We've got another GWT-ish post this week: Pyjamas, a sort of GWT for Python.
The SourceForge project page has a brief overview and pointers to a tutorial, a widget showcase, and more.
Friday, October 3rd, 2008
Category: GWT, PHP, Showcase
Here's an interesting link for a Friday. Viktor Zeman on Quality Unit sent us a link to "PostAffiliateXpress", some boring IT application with an interesting interface and an even more intriguing back-end.
The UI combines a Vista-like "Start" menu along with an OS X-like dock (using everyone's favorite fish-eye widget). It also has a built-in widget system that leverages Google Widgets. Overall, it's a pretty nice implementation of a desktop and windowing in Ajax.
The framework itself is "GwtPHP" which attempts to take all the advantages of GWT and deploy them to PHP backends in an attempt to solve the problem of limited Java-friendly hosting services. Unfortunately, the framework isn't available for use until sometime in early November.
Dual-License
The developers intend to use the familiar "free for hobbyists, pay up for commercial use" licensing model (what their licensing page calls a "what for what" model).
Give some feedback
Viktor says that they are quite keen to get feedback from folks on the project, so interested folks should get in touch, let them know what you think about the licensing model, and perhaps get early access, etc.
Thursday, September 18th, 2008
Category: Ext, GWT
Darrell Meyer has announced the release of Ext GWT 1.1 which is said to "shortens the feature set gap between Ext JS."
New Features
The Grid component wraps the Ext JS grid, and it includes support for grid plugins which fit into component lifecycles. You can also use a subclass, EditableGrid which.... allows you to edit content on the fly.
Auto complete has been added to the combo boxes a la Google Suggest.
Portal is a custom layout container that uses a multi-column layout on contains Portlets. Each Porlet can be drag and dropped to change order or move to another column. Each Portlet can contain any content and supports icons to expand / collapse, close, etc.
The desktop mimics the behavior of the operating system look at feel. It is now possible to create multi-window applications with support for a task bar and start menu. Windows support normal, maximize, and minimize states. The start menu is a custom menu that allows new menu items. In addition, there is support for a “task” area for adding additional items.
Java Bean Support with BeanModel
The Ext GWT Store and Binder API work with ModelData instances. The primary goal of ModelData is to provide a type of “introspection” as GWT does not allow runtime inspection of Java objects. You can query ModelData for a list of properties it contains, and these properties can be retrieved and set using the parameter name with the get and set methods.
Although this approach works, it forces you to either implement the ModelData interface in your Java Beans or extend the Ext GWT base classes that implement the ModelData interface. What is missing is a way to use your Java Beans as is, without having to extend the Ext GWT base classes or implement an “invasive” interface.
There are also new examples:
- Forum search is an example of a combo box, using a custom XTemplate, and remote data. The data can be paged with built-in support for a paging toolbar.
- Image Chooser shows loading a ListView in a Window. Each item has a linked details view, and the ListView supports custom sorting and filtering.
- This example shows a Dialog using an AnchorLayout to “anchor” the form fields to the dialog dimensions. When resized, the fields will adjust their size to match the dimensions of the dialog.
Friday, August 29th, 2008
Category: GWT, Google, Java, Library
I have seen the GWT team working very hard indeed on GWT 1.5, and they must be very happy to see the final release shipped and complete:
GWT 1.5 delivers what we think are an impressive number of improvements, about four hundred issues if you're counting. We're also happy that one of those is issue 168, our most-requested feature, Support for Java 5.
The high level new feature sets are:
- Java 5 language support and enhanced JRE emulation
- Performance optimizations and easier JavaScript interop
- Prettier widgets, better DOM, accessibility, and bi-di
You can see a lot of this at work in the showcase area. There you will see all of the widgets and examples that come out of the box, and the community has developed even more for you. In particular, Ray Cromwell has some great real world examples that he shares in his book and talk.
Download GWT and take a look.
Thursday, August 28th, 2008
Category: GWT, Gears, Google
GWT has long had a project that aimed to give rich support for Google APIs called GALGWT, or "Google API Libraries for Google Web Toolkit".
This project has stepped up to higher gear recently, and we have seen the GALGWT 1.0 release candidate appear.
What is in GALGWT?
The project is a collection of libraries that provide Java language bindings
and API specific 'plumbing' for some Google JavaScript APIs. The goal is to
make it easy for developers to use these JavaScript APIs with GWT. Libraries
available at this time include a new version of Gears, as well as new
libraries for Gadgets and the Google AJAX Search API.
Gears 1.1 Library
A new version of the Gears library is available. In addition to the earlier
version's support for the Gears LocalServer, Database, and WorkerPool, 1.1
adds integrated support for offline applications and updated sample
applications. The bindings have also been refactored to use GWT 1.5
JavaScript overlay types and a new package hierarchy.
Gadgets 1.0 Library
The Gadgets library simplifies gadget development with GWT by automatically
generating a Gadget specification from Java source and inserting a selection
script in the specification much like a regular GWT project. After compiling
your gadget with GWT, all files are in place to publish your gadget. This
version currently supports the legacy Gadgets API based on the _IG_...
namespace.
Google AJAX Search 1.0 Library
The Google AJAX Search API lets you put Google Search in your web pages,
including Web, Local, and Multimedia searches. This library allows you to
access the API from Java code compiled with the GWT compiler without having
to write additional JavaScript code.
Next Page »
