The Isomorphic Blog


Smart GWT 2.4 & SmartClient 8.0 final release

To kick off the New Year, Smart GWT 2.4 and SmartClient 8.0 final have been released!  Download the new releases here.

This list of new features is relative to Smart GWT 2.3 and the SmartClient 8.0 beta – note that for SmartClient in particular, this is a massive release with around 4x the new features covered here, so be sure to check out the 8.0 beta announcement to discover all the other new features.

  • Offline support

The new Offline subsystem provides a simple put/get capability for persistently storing data on an end user’s system.  Under the covers, it uses HTML5 standard “localStorage” where available, falling back to older APIs where necessary.  Roughly 0.5 MB of local storage is reliably available across all browsers, including IE6.  As the new “Offline Preferences” sample demonstrates, it’s trivial to use this API to take the extensive preference information exposed by a ListGrid (column order & size, frozen columns, custom formula columns, user-defined hilites, etc) and store it persistently.

The DataSource subsystem now has built-in offline capability as well.  With a single property – DataSource.useOfflineStorage - you can enable automatic offline caching of recently fetched data, so that if a user goes offline, they still have access to the last ~0.5MB of data that they viewed.  This works with any data provider (Java server framework, WSDL, REST, whatever).

  • HTML5 Charting (requires Power+Analytics)

Separately covered in more depth here, the new HTML5-based FacetChart is now the default charting engine.  This charting engine supports all browsers (including IE6 and Mobile Safari in iOS and Android) without the need for plugins.  New features since the last announcement include logarithmic scaling support and the ability to show interactive data points with click and hover events.

  • CubeGrid for Smart GWT (requires Power+Analytics)

At long last, the uber-powerful CubeGrid component is now available for Smart GWT.  In a nutshell, the CubeGrid is a high-end data analysis engine wrapped up as a single component that requires only a standard DataSource to function.  Check out the sample here.

  • new QuickStart Guide

Separately covered in more depth here, the QuickStart Guide provides a tutorial-style overview of the major subsystems of the product, including sample code, best practices, and approaches for extending and customizing components.  This is a must-read, particularly the extensive chapter on the Server Framework, which provides an eye-opening glimpse of the simplicity and power that are possible when both client and server-side concerns are addressed in a single architecture.

  • Enhanced support for widgets-in-grids

Support for components in grids has been enhanced in several ways – there’s more control over sizing and placement of components, performance is much better, and the feature now works in tandem with several other features that it was previously incompatible with (frozen columns, certain auto-sizing modes, etc).

  • Simplified server-side dynamic DataSources (Pro+)

Applications that offer advanced features like user-defined fields or user-defined validation rules need the ability to construct DataSources dynamically.  This has always been supported, but a new API DataSource.addDynamicDSGenerator() greatly simplifies the process: just register a generator and your dynamic DataSources behave just like statically defined DataSources, including automatic pooling.

  • User-defined Data Highlighting

Allows end users to define their own data highlighting rules, which are easily persisted or shared between users.  Covered in more depth here.

  • Hover Components

A new subsystem that makes it easy to create sophisticated hovers that use any UI components you want – grids, charts, etc.  Covered in more depth here.

  • 24 hour Calendar support

The Calendar component now supports 24 hour time formatting.

For further coverage of new features, including the Simplicity skin, see Sanjiv’s blog post on Smart GWT 2.4.

Download the new releases here.

Enjoy!

New hover features: show related records or load detail fields

Now available in nightly builds for both SmartClient and Smart GWT: Advanced Hover components

Rather than just showing a string of HTML in a hover, new APIs make it easy to use any UI component as a hover, such as a grid, chart or even a layout combining several components.

To enable the feature, set showHoverComponents:true on a ListGrid. ListGrid.hoverMode can be set to one of the built-in modes, which include showing related records in a grid, or showing the full details of a record in a DetailViewer. To provide your own components, just override ListGrid.getCellHoverComponent() and return whatever you’d like.

The power of the new hover feature is shown below. In this example,  the extended detail of an item record is displayed when the  hover event is triggered. In SmartClient terms a DetailViewer has been opened in the hover component, showing the complete detail of the record.  This is particularly useful as a way of displaying additional data records in a DataSource without having to add new pages to your application, or introduce horizontal scrolling on your main Listgrid , which can be awkward when trying to get a full picture of  the data.

What is particularly flexible here is a hover component can auto-size to show the full values for fields that are clipped in the grid.

Further, as an example of retrieving multiple records below, you can see that the hover component has been amended to show customer order internal messaging. This is particularly useful for getting the immediate status of a customer,  without having to manage multiple pages or grids of information.

You can use detailDS to provide a DataSource to the automatically generated hover component, a ListGrid in this case.. The standard hover sizing properties can then be used to manage the size of the hover component.

The flexibility of this hover feature can be utilised in whatever manner best suits your needs, for example:

  • Displaying notes or discussion related to a record in a list (as in the above example)
  • Show CPU and Memory Usage as you hover over individual servers in a list
  • Show full employee or user details when hovering over a first/last name list
  • Show recent medical history in an appointment booking system as you hover over patient appointments

To learn more please look at the Feature Explorer examples and code or refer to the Reference documents in the latest SmartClient and SmartGWT nightly builds.

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

Fields

DataSources

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

Relogin

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 SmartClient.com, then go here to download:

http://www.smartclient.com/builds

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 com.smartgwt.client.docs.HibernateIntegration 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.

iphonefullcube1
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:

http://www.smartclient.com/builds/eval/

SmartClient LGPL Nightlies:

http://www.smartclient.com/builds/lgpl/

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.

grid-nested-grid

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

phone-mask

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

enterprise-blue

  • 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.

cubepad1

  • 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.

grid-summaries

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:
//ListGrid[ID="itemList"]/body/row[itemID=1996||itemName=Sugar||2]/col[fieldName=SKU||1]
  • 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.

grid-cell-widgets

  • 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.

relative-date

  • 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.

vb-direct-edit

  • 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

checkbox-tree

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

multi-column-sort

  • 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

toolstrip

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!

Page 4 of 6« First...«23456»