The Isomorphic Blog

Just landed: User-defined data highlighting

Just landed in nightly builds for both SmartClient and Smart GWT: user-defined data highlighting.

A very common requirement in enterprise applications is highlighting important or unusual data values, that is, coloring them an eye-catching color, or coloring different ranges of values different colors.

However, in all but the most trivial applications, the rules for what should be highlighted are highly dynamic and context specific – you can’t just hardcode what is considered a high or low value when your application is portfolio management or threat analysis.

The ideal solution is to:

  • enable users to define their own highlighting rules on the fly
  • enable users to save and share highlighting rules

This is what the new data highlighting system does.   We’ve made it extremely simple – calling editHilites() provides a complete, pre-configured editing interface for hilites, starting with this screen:

This dataset involves countries of the world.  On the left, you have all the available fields that you can use to define highlighting rules – clicking on a field name adds a line to the right where you can pick an operator, a value, and a color to show.  With a few clicks, you could set up ranged highlighting to emphasize high GDP countries:

After hitting save to return to the grid, it looks like this:

Let’s say we wanted to do something more advanced – the “Add Advanced Rule” button leads to an interface where you can define truly arbitrary criteria on multiple fields.  In the screenshot below, we’re picking out countries with either a population over 1 Billion, or less than 5 Million square kilometers with a population over 100 million.

When we press “Save” in this dialog, we see all of our rules together.  A prose description is automatically generated for our complex filter criteria.

Finally, here’s what the grid looks like once we’ve saved these rules.  China and India qualify with their over 1 Billion populations; nations over 100 million with relatively smaller area include Indonesia, Japan and Mexico.

We got all of this behavior just by calling editHilites().  This works with any grid and any DataSource.  The criteria are applied client-side, so there’s no server-side code necessary to support this.  And this entire system also works with loading data on demand with no additional configuration – the highlights are simply applied to the data as it’s retrieved.

You can even highlight user-created formula fields – for example, you can create a GDP per capita field for the above dataset by dividing GDP by population, then highlight high and low values.

Highlights are also easy to persist and restore.  ListGrid.getHiliteState() gives you a String that contains the highlight rules in serialized form; just save this to a database column or similar, and you can re-apply it via ListGrid.setHiliteState() later.

To take a deeper look at the new highlighting system, see the samples under Grids -> Hiliting in the Showcase.

Smart GWT QuickStart Guide

Now available: the Smart GWT QuickStart Guide.

This is the first piece of documentation to read when learning about Smart GWT.  It is structured as a set of brief introductions to the major features of Smart GWT, with hands-on code samples you can run and experiment with, and links to deeper documentation to learn more.

This guide also introduces a huge amount of new material on the Smart GWT Server Framework and how it is intended to be used.  Even if you’ve already been working with Smart GWT Pro/EE for a while, you should read these sections – even some internal Isomorphic developers learned new things while reviewing the guide.

To give an idea of the scope of this document, here is a partial list of chapters and major sub-headings:

1.    Overview

2.    Installation

Starting a New Project

Adding Smart GWT to an Existing Project

4.   Visual Components

5.    Data Binding

Databound Components



Customized Data Binding

DataSource Operations

DataBound Component Operations

6.   Layout

Component Layout

Container Components

Form Layout

7.    Data Integration

DataSource Requests

Request and Response Transformation

Criteria, Paging, Sorting and Caching

Authentication and Authorization


8.   Smart GWT Server Framework

DataSource Generation

Server Request Flow

Direct Method Invocation

DMI Parameters

Adding DMI Business Logic

Returning Data

Queuing & Transactions

Queuing, RESTHandler, and SOAs

Operation Bindings

Declarative Security

Dynamic Expressions (Velocity)

SQL Templating

SQL Templating — Adding Fields

Custom DataSources

9.   Extending Smart GWT

New Components

New Form Controls

Switching Theme

Customizing Themes

10. Tips

Architecture Tips

11.  Evaluating Smart GWT

Evaluating Performance

Evaluating Interactive Performance

And here is a brief sample of some of the content:

Note: please use the QuickStart Guide with the latest nightly builds – some small enhancements were made that are utilized in some of the samples.

HTML5 Charts with mobile support

A new HTML5-based charting engine is now available as part of the Analytics module – download the Smart GWT or SmartClient Evaluation to try it out.

This charting engine is based on the Drawing module (which will also be available soon for direct use), which provides a cross-platform vector graphics engine that uses VML in IE6-8, and can use either SVG or <canvas> in other browsers.  It works in mobile WebKit as well (iPhone, iPad, Android).

Here’s a sample Radar chart:

The new charting engine is delivered as a single component FacetChart which supports multiple different chart types. Like the CubeGrid component, a FacetChart actually understands the data model it’s displaying, and can provide different visualizations of it on the fly.  In fact, there is a built-in context menu that allows end users to switch.

Picking ChartType -> Area leads to this:

Picking Unstack would have led to this:

Finally, picking Swap Facets would have led to:

This last option is obviously a poor visualization of the dataset – which is exactly the point.  If the user had started with this visualization, the context menu would have allowed them to navigate to any of the other visualizations shown above.

This is extremely key for dynamic, exploratory data analysis, a common use case among our customers. In several deployments, users can request a grid view of any dataset, customize it (show/hide/resize columns, set criteria), generate charts from the grid view, customize those as well, save all the settings and share it with other users.  It’s essentially ad-hoc reporting in a browser.

SmartClient makes it simple to build such an interface, customized to the type of reporting your users need to do, without all the baggage of a general-purpose reporting engine.  And because it’s based on SmartClient, adding entirely novel components is also simple (for example, molecular visualization).

But even if your application could not be called “exploratory data analysis”, why not let your users chart whatever they’d like to?  SmartClient makes it trivial to generate a chart from any subset of the data shown in a ListGrid (ListGrid.chartData()), so,  just add the feature to every grid via a context menu, and stop fielding enhancement requests for specific charts on specific screens.

Check out the online samples for Smart GWT and for SmartClient – note for the Advanced Cube samples, right click to chart the current cell by any two dimensions.  Also check out a further sample of standalone FacetChart usage in Smart GWT, posted to the forums here.

Finally, download the Smart GWT 2.4 or SmartClient 8.0 Evaluation to try it out and get started building beautiful charts!

Licensed nightly builds available

If you’ve purchased a license, you can now download licensed nightly builds.  Just log in to, then go here to download:

If you also have support, you can get support for nightly builds, but the process is slightly different – see the overview at the above URL.

Smart GWT EE 2.3 released

Go get it:

If you already have a 2.x license, you’ll get an email with download links by the end of the day.  The LGPL version will be available within a few days.

Note, we skipped version 2.2 since this release differs substantially from 2.2 LGPL.  If you were waiting to upgrade to 2.2, use 2.3.

In addition to new features described here, the following features have been added:

  • Google App Engine support & GAE/JPA DataSource

    A runnable sample project deployable to Google App Engine, demonstrating persistence to Google App Engine datastores via the JPA API, with no server code required.

  • New Validation samples

    Demonstrates using the new isUnique and hasRelatedRecords validators, as well as using validateOnExit to dynamically contact the server during data entry so that server-based validation logic can be run.

All of the following features are new relative to Smart GWT EE 2.1, but were already announced for SmartClient 8.0 beta a few days ago.  Included here for completeness.

  • Automatic transactions for SQL & Hibernate (Requires Power Edition or Enterprise Edition)

    Batches of updates, such as a multi-row drag or mass editing of grid rows, are now automatically grouped into a transaction when using either the SQL or Hibernate connectors. APIs have been added to be notified of transaction success or failure, manually initiate transactions and include or exclude specific requests.

  • True Excel (.xls) export

    Goes beyond CSV (comma-separated-values) export by including hilites, and delivering dates and numbers with type information so Excel can sort and filter properly. See com.smartgwt.client.types.ExportFormat for more details.

  • Client-driven export

    An alternative mode for exporting, this export preserves all client-side formatting. LGPL users note: upgrading to Pro gets you this export mode without having to rework any of your databinding code. See DataBoundComponent.exportClientData() for more details.

  • New ultralight ‘Simplicity’ skin

    The new “Simplicity” skin takes advantage of early CSS3 support in modern browsers like Firefox, Safari and Chrome to deliver look and feel similar to our classic skins (rounded elements, gradients, and other touches) while remaining almost image free. Appearance degrades gracefully in Internet Explorer to a more square / solid color appearance.

  • (Preliminary) Touch & Mobile support

    Support for iPhone, iPad and iPod touch devices and partial support for Android devices. No code changes required, and the full range of interactions is supported, including drag and drop and flick scrolling with momentum. SmartClient on mobile is a strong choice for long-session mobile & touch applications (like iWork for the iPad) and especially for offline mobile applications.

  • JPA DataSource

    Similar to the built-in SQL and Hibernate connectors, a connector has been added for JPA-based persistence. Runnable sample project included. Does not yet have a DataSource Wizard but support is planned. Supports simple Criteria for now. Support for Advanced Criteria will be available for Power edition in the future.

  • Annotation-based configuration in Hibernate

    Support for Hibernate configuration via annotations rather than explicit mapping files, and support for looking up Hibernate configuration via Spring. Supported both the DataSource Wizard and via declarations in .ds.xml files. See for more details.

  • RESTConnector

    A new built-in servlet exposes all of the operations defined in your .ds.xml files for access via REST – the same protocol as defined for the RestDataSource. This allows other client technologies and automated systems to re-use the same services you provide for your SmartClient front-end.

Advanced charting and cubes in a phone

Of course, you’d probably want to use the mobile-specific version.  But it’s nice to know the full version is there too.

The stacked area chart is dynamically generated inside mobile Safari using HTML5, based on a cube dataset being loaded on demand from the server.

The same charting component works for desktop browsers.  In IE, it uses VML for rendering and looks identical.

SmartClient 8.0 beta

SmartClient 8.0 is officially entering public beta.  To download it, simply download the latest nightly build.

SmartClient Enterprise Eval Nightlies:

SmartClient LGPL Nightlies:

8.0 is another monster release, with spectacularly powerful new features and a gorgeous look & feel refresh.

  • Expandable rows: several built-in modes including showing a nested grid for related records (see below), as well as the ability to create your own component on expansion.  Multi-nesting (grid within grid within grid) supported.


  • Masked text input: specify the mask in a regular-expression like format, and the rest is handled for you.  Works in grids too.


  • New Enterprise skins: The Enterprise skin has been refined and new Enterprise Blue and Graphite skins have been added.


  • New ultralight ‘Simplicity’ skin: the new “Simplicity” skin takes advantage of early CSS3 support in modern browsers like Firefox, Safari and Chrome to deliver look and feel similar to our classic skins (rounded elements, gradients, and other touches) while remaining almost image free.  Appearance degrades gracefully in Internet Explorer to a more square / solid color appearance.
  • (Preliminary) Touch & Mobile support: support for iPhone, iPad and iPod touch devices and partial support for Android devices.  No code changes required, and the full range of interactions is supported, including drag and drop and flick scrolling with momentum.  SmartClient on mobile is a strong choice for long-session mobile & touch applications (like iWork for the iPad) and especially for offline mobile applications.  The shot below is of a CubeGrid with a preliminary HTML5 Chart (not yet available), running in an iPad.  We also have a separate “ultralight” offering that is already quite far along – stay tuned.


  • Declarative Security:  protect operations by role by simply declaring requiresRole=”manager” on an operationBinding.  Codeless integration with J2EE security and JAAS – if your security solution is causing httpServletRequest.isUserInRole() to return appropriate values, it just works.  If instead you need to provide roles dynamically, you can do so with a single API call (RPCManager.setUserRoles()).
  • Declarative output restriction: declare which fields should be returned by the server on a per-operation or per-request basis  (dsRequest.outputs / operationBinding.outputs).  Use this to cut down on network traffic for combo boxes and other scenarios where only a few fields are needed from a record with dozens of fields.  Or, combine it with Declarative Security to enforce data visibility rules.
  • New server-side validators: “isUnique” makes it trivial to enforce common cases like having a unique user name.  “hasRelatedRecords” can enforce that inter-record references are valid.
  • Validate On Exit: declare that validation for a particular field should be run when focus leaves the field.  This includes automatic trips to the server to run any server-only validators you’ve defined.  Combined with the new isUnique validator, this makes on-the-fly unique username checks entirely declarative.
  • Server-side declarative custom validators: write a Velocity expression right in your .ds.xml file, or declare a Java class to call (like DMI)
$value.getTime() < $record.deadline.getTime()
  • Grid totals / summaries: whole grid and group level summaries.  Several built-in functions (sums, averages, etc) and the ability to add your own.


Selenium Support

  • Selenium support: including Selenium IDE and Selenium Remote Control.  We created a Selenium extension to allow recording abstract “locators” generated by SmartClient which are valid across browsers, across skins, across versions of SmartClient, and have fallback strategies that allow them to work across application changes like adding or reshuffling components.  Support for Selenium RC means you can now write test cases in Java and other languages.  A sample locator:
  • Automatic Transactions (SQL/Hibernate): batches of updates, such as a multi-row drag or  mass editing of grid rows, are now automatically grouped into a transaction when using either  the SQL or Hibernate connectors with Power edition or better.  APIs have been added to be  notified of transaction success or failure, manually initiate transactions and include or exclude specific requests.
  • Deeper SQL customization: customize the SQL used for select, insert and update for an individual field while retaining full support for automatic query generation, efficient data paging, multi-level sort and all other features of the SQLDataSource.  See DataSourceField.customSelect/Insert/UpdateExpression, as well as sqlStorageStrategy.
  • JPA DataSource: similar to the built-in SQL and Hibernate connectors, a connector has been added for JPA-based persistence.  This connector does not yet have a DataSource Wizard, but support is planned.  Supports simple Criteria for now – support for Advanced Criteria will be available for Power edition in the future.
  • Annotation-based configuration in Hibernate: support for Hibernate configuration via annotations rather than explicit mapping files, and support for looking up Hibernate configuration via Spring.   Supported in both the DataSource Wizard and via declarations in .ds.xml files.
  • REST Connector: a new built-in servlet exposes all of the operations defined in your .ds.xml files for access via REST – the same protocol as defined for the RestDataSource.  This allows other client technologies and automated systems to re-use the same services you provide for your SmartClient front-end.
  • Widgets in grid cells: attach any component to any Grid cell.  Includes automatic lifecycle management of components for load-on-demand grids, including a component pooling mode.  Works for trees too.


  • Per-Column AutoFit: you can now enable per-column auto-fitting to data or to the field title, or both, in the ListGrid or TreeGrid with field.autoFitWidth.  This integrates with load on demand and incremental rendering by only auto-fitting to initially visible loaded data, so it scales to very large datasets with only a small performance penalty.
  • Relative date filtering: enables date filters like “last 5 days” or “next week”.  When the user specifies relative dates, saving and restoring criteria preserves the relative date.  This is now also the default filtering interface in grids and the FilterBuilder.


  • Enhanced printing: more control over printed output (eg, number of rows to print in grids); more styling options
  • True Excel (.xls) export: goes beyond CSV (comma-separated-values) export by including hilites, and delivering dates and numbers with type information so Excel can sort and filter properly
  • Client-driven export: an alternative mode for exporting, this export preserves all client-side formatting.  LGPL users note: upgrading to Pro gets you this export mode without having to rework any of your databinding code.
  • Wrapper components for Plugins: the components for managing browser plugins (Java Applets, Flash players, etc) are now part of the free product (formerly ClientBridges Optional Module)
  • Direct editing in Visual Builder: directly drag and drop components into the application and drag to rearrange.  Double click titles to edit them.   In grids, show and hide columns, sort them, resize them, or freeze them and the changes are saved to the generated code.


  • WSDL enhancements: automatic loading of imported XML Schema and WSDL files, and support for services with portType vs binding elements in different files
  • New WSDL Wizard: Visual Builder features a new WSDL wizard suitable for much less technical people.  Import a service and the set of operations and elements within the service is shown in a panel.  Just drag and drop elements into the application pane and they create appropriate user interface elements.  Drag the operation node out to create a button that invokes the service, automatically using data values from UI controls bound to the input message of the service, and automatically using the result to populate UI controls derived from the output message of the service.
  • Tree selection: cascades up/down, with visual indicator for partial selection


  • Multi-level sort: ctrl-click, or use a dialog to configure sort levels.  Client and server support.


  • Portal layout components: the drag and drop, multiple column portal-style layout manager previously shown as a sample is now an officially supported component.
  • 18 language packs: SmartClient and SmartGWT are now single-sourcing language packs.  All common locales are covered.
  • Shared caching: DataSources now have an option to load and cache all data up front (DataSource.cacheAllData), which can cut down on repeated queries for smaller datasets.  This is similar to the existing “clientOnly” mode, except that update/add/remove operations will “write through” to the server.
  • Toolstrip: a comprehensive skinning overhaul, including toolstrip/toolbar-specific button and menu styling


SmartClient 7.0RC2 & 7.1

There has been some confusion over when there would be a “final” 7.0 release.  As we’ve been communicating to customers, 7.0RC2 is a final, supported release, and you can see that several patches have been made available for it.

In retrospect, we realize we should not have simply promoted the release candidate to the final version, as a number of companies have had internal issues with using a build marked “RC” no matter how clear of an assurance they receive that it is a supported product.  We’ll avoid that in the future.

There will also be a 7.1 release that rolls up patches applied to 7.0RC2 and includes a few new samples and smaller features.

SmartGWT EE 1.2 is Now Available!

SmartGWT EE is now available for download.

New in this release:

  • Many new examples, covering custom DataSource implementations, Batch Upload, and various scenarios of adding business logic
  • Eclipse project files for each sample project, for one-step Eclipse setup

Download it today!

SmartClient 7.0 Release Candidate available

[UPDATE: RC2, available on the download page, has been declared an official supported release]

At last, a release candidate of SmartClient 7.0 is available.  Download it here:

What do we mean by release candidate?  We are at zero critical bugs according to internal testing, we are in code freeze and will only be fixing newly reported bugs as well as adding and updating documentation and samples.  We expect the RC period to last roughly two to three weeks.

If you plan to move your application to 7.0 any time in the next 6 months, you should definitely grab this release and starting testing now, and submit any bugs you find.

What’s in 7.0

There’s really no way around it once you see the list of new features: this obviously should have been two or more major releases.  The breadth of new functionality is dizzying.  This list below includes only major new feature areas – see the changelog in the SDK to discover the hundreds of minor features that were also added.  Features shown in italics below are new just since 7.0 Beta.

  • Enterprise, SilverWave and BlackOps skins, three more professionally designed, free (LGPL) skins
  • Calendar component: complete drag and drop, databound event editing similar to Google Calendar
  • TileLayout & TileGrid components: display records as a series of tiles, with databinding,
    load on demand, filter and sort, and drag and drop capability
  • Advanced Filtering: client- and server-side support for field-operator-value filtering of
    data, including arbitrarily nested queries
  • Filter Builder: specialized form for end user construction of advanced filters of arbitrary
  • SQL Templating: customize the SQL generated by SmartClient’s SQL connector right in the
    DataSource file. Clause by clause overrides make it easy to add simple and complex joins,
    grouping and aggregation while retaining full search features and database independence
  • Transaction Chaining: a transaction where some operations depend on the
    results of other operations can be declared with simple XML in your DataSource
  • DataSource Wizards: generate fully functional DataSources from existing Hibernate entities
    or SQL tables with a simple point and click wizard in Visual Builder
  • Batch DataSource Generator: connect SmartClient to your entire object model in one step by
    generating DataSources from SQL tables, Java Beans or other metadata with a customizable process.
  • CSV / Excel Export: just call grid.exportData() to export the current contents of the grid
    to Excel via CSV, including current sort, filter criteria, column order and column visibility
  • Automatic databound dragging behaviors: grids and trees will now inspect data
    relations declared in DataSources and automatically “do the right thing” for a databound drag
  • Batch Uploader: provides an interface to upload a CSV, validate it and allow the user to
    make corrections before committing, all without coding.
  • Advanced Java Reflection: Java <-> JavaScript translation transparently handles JVM 1.5
    features like Generics and Enums, including nested collections of objects.
  • ColumnTree component: ITunes™-like tree navigation (one column per level)
  • Hiliting: declare hiliting rules based on AdvancedCriteria. Completely client-side
    behavior that works automatically with data paging and filtering
  • Printing: comprehensive and customizable support for rendering printable views of
    SmartClient applications
  • Formula and Summary fields: built-in wizards for end users to define formula fields that
    can compute values using other fields, or summary fields that can combine other fields with
    intervening / surrounding text. Available in all DataBoundComponents, easy to persist as
  • ColorPicker component: a full-spectrum color selection component similar to those found in
    graphics packages and other desktop software
  • HeaderSpans: second level headers in grids, for grouping related columns
  • Grid row rollover effects and controls: general purpose ability to attach SmartClient
    components to rows, allowing rounded selection, controls that appear on rollover, and more
  • Grid header rollover: drop-down menus appear on rollover, offering column show/hide,
    freezing and grouping options that previously required right click to discover
  • Data autofitting: horizontal and vertical autofitting to data for ListGrids
  • Grouping modes: built-in and custom grouping modes, such as the ability to group a date
    column by week, day, month or year
  • Visual Builder “toolskin”: edit applications in any skin while Visual Builder itself
    retains consistent look and feel
  • Visual Builder “auto-add”: double-click palette items to intelligently add to last, for
    ludicrously fast screen building
  • AutoFitTextAreaItem: autofits to contained text as the user types
  • Full Tree connectors: TreeGrid connectors support now optionally includes full connector
  • CubeGrid facet auto-derivation: greatly simplified creation of simple cubes

Each of these major new features deserves a blog post of its own, and we hope to in fact post about some of them, although the many new examples and new docs speak for themselves.

Note that this list doesn’t include two “Previews” that are also included in 7.0:

  • Drawing: a cross-platform vector graphics package that provides drawing of arbitrary shapes, zoom and pan, drag and drop and other interactivity.  No plugins required.
  • Portal: a more advanced portal layout engine and related facilities for persisting not just layout, but an extensible set of information exposed by Portlets, a special class of components with lifecycle management and persistence features.

Pro vs Enterprise Licensing details

If you download and compare the different packages above you’ll get a much more detailed picture of the distinction between our Pro and Enterprise packages.  In a nutshell, from a features perspective, Pro comes with everything except:

  • SQL/HQL Templating
  • Transaction Chaining
  • Server-side Advanced Filtering (client-side filtering  is LGPL)
  • Batch DataSource Generator (but DataSource Wizard is included in Pro)
  • Batch Uploader
  • Network Performance Module
  • Real-Time Messaging Module
  • Analytics Module

The revised licensing page being prepared for the official 7.0 launch will break out the LGPL / Pro / Enterprise split in a graphical fashion (the usual table with rows of checkmarks for features), including links to live examples and docs demonstrating the capabilities of the Pro & Enterprise versions.

We’re very excited about this because, to be perfectly forthright, when we switched SmartClient to open source, our marketing efforts continued to emphasize the overall SmartClient solution, and we made a mistake in not explaining the server functionality very well.  Because SmartClient LGPL seems so complete and so broad when compared to other solutions, there’s been a misconception that the SmartClient Server is a minor add-on to SmartClient, whereas the reality is, it’s the other half.  The cornerstone of SmartClient – the powerful databinding architecture that has so many pervasive benefits in creating your UI – extends onto the server side, where it is arguably even more effective at reducing the amount of code you have to write – frequently, to zero.

If you skipped over the SmartClient Server because the benefits weren’t obvious, now is the time to revisit that choice.  Download the release candidate and start with the new “Server Examples” folder in the Feature Explorer.

Roadmap to 8.0 and beyond

As soon as we get 7.0 final out the door we’ll be posting some more roadmap information about 8.0 and beyond.  We will first put forward a list of areas that we’ll definitely be persuing, then soliciting feedback from customers and open source users about what they want most.  This is all part of an effort to provide more transparency and help teams plan around future SmartClient releases.  Stay tuned.



SmartGWT Enterprise Edition available


The first release of SmartGWT Enterprise Edition is now available.

Download it here.  Check out the Showcase here.

SmartGWT EE Showcase

What is it?

SmartGWT Enterprise Edition (SmartGWT EE for short) is to SmartGWT what SmartClient Enterprise Edition is to SmartClient – an enterprise version of the product that includes Java Server side functionality, additional tools, and a classic commercial license in lieu of the LGPL.

For teams with existing Java functionality, SmartGWT EE provides greatly accelerated integration with SmartGWT’s visual components.  In many cases it is possible to take existing Java methods in an application and bind a SmartGWT grid or form to those methods without writing any new code, simply by specifying what method to call in a DataSource XML file.

For those using Hibernate, it’s even simpler.  A Wizard within Visual Builder allows you to simply pick any registered Hibernate entity from a list, and SmartGWT EE will create a SmartGWT DataSource that provides full read-write binding to that Hibernate entity.  Just provide the generated DataSource to a SmartGWT grid or form with no other configuration, and you have a full CRUD UI: create, retrieve, update, and delete Hibernate-managed entities.  It can even execute the complex search criteria that the FilterBuilder allows a user to specify.  There’s no need to create redundant Data Transfer Objects (DTO’s), or worry about Hibernate-managed lazy associations between entities in your domain model. Only those properties mapped in the data source are passed to the client, and during updates only those properties that have been modified (and not the entire bean data) are sent from the client to the server with the changes transparently reflected in your server.

Hibernate Wizard

A corresponding Wizard exists for binding to database tables stored in any popular database, again with full read-write binding.  And in both cases, you can easily add business logic that runs before or after the Hibernate or SQL binding, which can modify the request before it executes, modify the output, or take any other action.

There’s even a “batch” version of the binding tool.  Do you have a large application with 1000+ Java Beans, or 1000+ SQL tables?  Make them all accessible to SmartGWT UI widgets in one step.  The batch version of the tool includes source code, so you can customize how generation is done.  Do you have Java annotations that could be used to drive UI behaviors like required:true or canEdit:false?  There’s sample code for that.  Do you need to show a special input control or add special validators wherever a field with a certain Java type is used?  Easy change.

This is ideal for large scale enterprise development:

  1. you get all the benefits of model-driven development, including rapid prototyping and the ability to make pervasive changes driven by changes in the model
  2. you retain full extensibility: you’re working with a UI platform that allows you to build completely customized interfaces where necessary
  3. your customizations are minimal and easy to maintain; you don’t have to maintain the “code soup” typically output by code generator tools

SmartGWT EE future features

This first release of SmartGWT EE omits certain advanced components and services, including the CubeGrid and the Messaging module.  These are coming soon; we’ll be rolling out enhancements to SmartGWT EE at a rapid clip similar to what we’ve been doing with SmartGWT.

Also in this release, while Visual Builder is fully functional, it currently saves screens as XML files which cannot (yet) be readily converted into Java code for use outside of the tool.  These XML files are in SmartClient’s Component XML format and can be edited and re-loaded by Visual Builder (as with SmartClient).  Future versions of Visual Builder for SmartGWT EE will include tools to generate Java from this format, so any screens you build now are forward compatible.


As part of the final release of SmartGWT Enterprise Edition, we’re introducing a new pricing level that works better for small teams, called SmartGWT / SmartClient Pro.  This product will have all of the client-side functionality of SmartGWT / SmartClient LGPL as well as server-side functionality similar to the 6.5.1 release of SmartClient Enterprise – server connectors, validation, basic Hibernate and SQL connectors, as well as Visual Builder – and will be offered at a price that approaches $600-800 per developer for a team license.  There will no longer be a distinction between an Intranet vs a Small Vendor Edition license.   In a nutshell this very closely matches the existing Enterprise offering, but is now less expensive.

SmartClient and SmartGWT Enterprise Edition will now come with a different license suited to larger deployments which will carry stronger legal guarantees (eg indemnity), and for that reason will also be a “Contact us” licensing level.  A handful of new features in 7.0 will be held back to the Enterprise level license, including two shown in the new SmartGWT EE showcase: a feature we call Transaction Chaining which is demonstrated in the Queued Master/Detail Add example, and the batch mode of the DataSource generator mentioned above.  Hence the need to announce the upcoming pricing changes today – further details on the feature breakdown will be posted soon.

Anyone who has already bought licenses to SmartClient Enterprise will be able to continue to renew at the currently posted pricing, which we will also continue to honor for the next 45 days (including any quotations).  So, now is a great time to purchase Enterprise Edition, as you have an opportunity to purchase the Enterprise feature set at slightly above the price of Pro, if one of our website licenses works for you.

About SmartClient 7.0

Everything discussed for SmartGWT EE above is also included in SmartClient 7.0.  Our apologies to users of the free version for the delay in getting a final release out (most enterprise customers opted to get certified on an interim build).  However, it’s worth the wait.  If we were to take a cue from the Mozilla foundation, who recently renamed Firefox 3.1 to 3.5 to reflect how much is new, we might have to skip a few numbers (kidding – we’ll stick with 7).  Stay tuned.

Page 5 of 7« First...«34567»