The Isomorphic Blog


30% off Release Sale Extended to Friday, January 20th, 2012

Release Sale Extended

Due to popular demand, we’ve extended the Smart GWT 3.0 / SmartClient 8.2 release sale until Friday, January 20th, 2012. This is the last chance to get all the new features of Smart GWT 3.0 and SmartClient 8.2 at the discounted price. Buy now at 30% off to lock in your savings today!

If you are upgrading from a previous version, we’ll stack the 30% discount on top of the discount you receive for owning a qualifying older license. Contact sales for an upgrade quote.

More Reasons to Buy

  • Get Upgrades or New Licenses for both your existing team and future hires. Licenses are perpetual, so why wait?  Buy now.
  • Get Optional Modules for Analytics or Real-time Messaging at the 30% off sale price until January 20th. Analytics provides specialized components for viewing, navigating and editing very large, multi-dimensional data sets. Messaging provides real-time data delivery via HTTP streaming (aka “Comet”) for monitoring, command & control, trading desk and real-time collaboration applications involving time-sensitive, continuously updated data. Request a quote.
  • Get Support for next year.  You’ll get unlimited access to our expertise to help solve problems, and there’s no commitment to renew the following year for any of our Support Plans.
  • Setup Training for recent team members or for new teams that may use Isomorphic products in 2012. Rather than give you a cookie cutter program, we work with you to build a Training curriculum that’s customized to your needs.
  • Sponsor a Feature you’ve always wished for with Feature Sponsorship. Isomorphic can deliver enhancements that meet your specific requirements and deadlines.
  • Fast track a new project by having an Isomorphic consultant build the first few screens of your application with our Jump Start program.
  • Get Consulting Help.  Take advantage of our turnkey application delivery services for projects that have to be done right and done right now.  Or, add an Isomorphic engineer to your team, full time or part time, via our Embedded Developer Program.

Here’s what’s new and improved in Smart GWT 3.0 and SmartClient 8.2.

New Features

  • Drawing:  Create cross-browser, mobile-enabled graphics in your applications with our general-purpose vector graphics library. Works everywhere with no plug-ins required.
  • Automatic Joins:  Include fields with a single property from another SQL, JPA or Hibernate DataSource using an efficient SQL join, just by setting a single property.
  • Field-Level Declarative Security: Restrict access privileges by role to ensure granular security at a per-field level. A single declaration drives both server enforcement and client-side UI behavior.
  • Client-side Tree Filtering:  Tree components have been upgraded to minimize expensive server round trips for more responsive searches.

Here’s what’s coming in future 3.x and 8.x releases. Buy now and these features are yours as soon as they’re released!

Coming Soon

  • CSS3 skins:  Upgraded CSS3 skins are easier to modify, use radically less media, and render faster in modern browsers.
  • Server Script Blocks: Embed code snippets directly in .ds.xml files for server-side business logic.
  • *Workflow System: Loadable XML workflow definitions that can handle multiple steps of user interaction and server contact to make multi-step wizards entirely declarative (*SmartClient only).

You can learn more about what’s new in Smart GWT 3.0 and SmartClient 8.2 in the Feature Roadmap. Download the new releases today!

Happy New Year!

The Isomorphic Team

Smart GWT 3.0 / SmartClient 8.2 Released

Smart GWT 3.0 and SmartClient 8.2 have been released!  Starting today, you can purchase new licenses or upgrade existing licenses at 30% off until the end of the year Friday, January 20th, 2012. You can learn more about what’s new in Smart GWT 3.0 and SmartClient 8.2 in the Feature Roadmap.

Feature List

Coming Soon

  • CSS3 skins
  • Server Script Blocks
  • Workflow System (*SmartClient only)

Download the new releases today!

Enjoy,

The Isomorphic Team

Field-Level Declarative Security

What is it?

The Declarative Security system allows you to declare security rules directly in your DataSources using XML attributes. While previous releases allowed for control of individual DataSource operations, Field-Level Declarative Security (coming soon in Smart GWT 3.0 and SmartClient 8.2) will enable role-based access control to specific operations on fields. This allows restriction of access privileges by role to ensure granular security at a per-field level. View, search, initialize or update DataSource fields requiring specific roles with automatic consequences in the UI.

How does it work?

To attach role requirements to a DataSource, DataSourceField, or individual OperationBinding, just add a requiresRole attribute as a comma-separated list. If the current user is assigned one of the authorized roles, they are permitted to invoke the operation. These rules are evaluated as the DataSource is loaded, so that at the field-level:

  • If a user is not allowed to see a field, that field is omitted entirely from the DataSource definition, and automatically omitted from data delivered to that client
  • If a user is not allowed to edit a field, that field is shown as read-only by all DataBoundComponents that support editing, and any attempt to modify the field will be rejected automatically by the server

This will allow you to quickly and declaratively address use cases such as fields that can only be set when a record is created and can only be changed by an administrator going forward.

The current user’s roles are determined by calling the standard Java servlets method httpServletRequest.isUserInRole(). As a result, this API works automatically with both J2EE and JAAS security systems with no setup – just start adding requiresRole attributes. This API can also be easily adapted to work with any security framework by calling RPCManager.setUserRoles() before requests are processed which is typically done as a subclass of the built-in IDACall servlet.

For more information, please see our Quick Start Guides (Smart GWT, SmartClient) or the reference docs.

Featured Use Cases

  • Switch fields to read-only, or disable search based upon a user’s role.
  • Create a “super user” role with access to all operations regardless of the requiresRole settings. This can be set with authentication.superuserRole in the server.properties file (see reference docs).
  • Create an “admin” role that can see deleted records by combining Declarative Security with variations on core operations via Operation Bindings (see Quick Start Guides for example code).
  • Restrict public access using the requiresAuthentication attribute to determine if a user must be authenticated in order to access a DataSource or Operation Binding.
  • Configure a capability security system by using capability names (i.e. “canEditAccounts”) instead role names (i.e. “manager”) in the requiresRole attribute, and use RPCManager.setUserRoles() to provide the current user’s list of capabilities.

To get started even faster, we’ve also created a pre-built administration console and login process available as a preview in the Enterprise edition. Take advantage of our Jump Start program for training and starter code to begin using this functionality today!

Pre-requisites

  • Field-level Declarative Security will be available in the Pro and above editions of Smart GWT 3.0 and SmartClient 8.2 (coming soon).

  • Note to existing Smart GWT 2.x Users: 3.x will be a paid upgrade for 2.x license holders. If you just bought a 2.x Smart GWT license, don’t worry, upgrade costs are based on how recently you bought. If you bought very recently, you’ll get access to the entire 3.x series for a fraction of the license price. In addition, our upcoming release sale will stack a 30% discount is on top of the discount you receive for owning a 2.x license. For a quote please contact sales.

Smart GWT 3.0 and SmartClient 8.2 Release Sale / Charts move to Pro

Release Sale (coming soon)

We’re pleased to announce that Smart GWT 3.0 and SmartClient 8.2 will be available for download in just a few weeks. In celebration of the 3.0/8.2 release, you will be able to purchase new licenses or upgrade existing licenses at 30% off until the end of the year Friday, January 20th, 2012. Learn more about what’s new in the Feature Roadmap.

Charts move to Pro

We’re changing the licensing requirements in 3.0/8.2 to make HTML5 Charts available to more of our users. The FacetChart component used to require the Power Edition + Analytics module, but will now only require the Pro Edition starting with Smart GWT 3.0 and SmartClient 8.2. Get high-quality charts pre-integrated with Smart GWT components that don’t require plug-ins while supporting both older and mobile browsers. You’ll be paying an amount comparable to purchasing third-party charting packages plus you get all the other advantages of Pro. You can learn more about the FacetChart in our article HTML Charts with mobile support.

If you’re a long-time user of the LGPL Edition, please note that as soon as you install Pro you immediately gain the ability to export any grid as an Excel spreadsheet and export any printable screen as a PDF document without revisiting your data binding layer.

  • Export any grid to an Excel spreadsheet with exportClientData()
  • Export to a PDF document with RPCManager.exportContent()

So if you’ve been debating the purchase of Pro or a higher license, this is the time to jump in and help support the awesome open source framework you’ve been using. Please visit our Product Overview page for more information about our editions.

A Note for Smart GWT customers with 2.x Licenses

3.x will be a paid upgrade for 2.x license holders. If you just bought a 2.x Smart GWT license, don’t worry, upgrade costs are based on how recently you bought. If you bought very recently, you’ll get access to the entire 3.x series for a fraction of the license price. In addition, this 30% discount is on top of the discount you receive for owning a 2.x license. For a quote please contact sales.

30% Sale Pricing

*Starting on release day, ending on 12/31/2011.

LGPL PRO POWER ENTERPRISE
Free $522 $745 per developer
(30% off)
$1365 $1950 per developer
(30% off)
Choose: Per Developer
or Per CPU
or Flat Rate
Download Now
Free
Download Now
Free, Full-Featured 60-day trial
Download Now
Free, Full-Featured 60-day trial
Download Now
Free, Full-Featured 60-day trial
Buy Now
1 Pro License
$522
$745
(30% off)
Buy Now
1 Power License
$1365
$1950
(30% off)
Get Quote
Ready to buy?
Buy Now
4 Pro Licenses
$2086
$2980
(30% off)
Buy Now
4 Power Licenses
$5460
$7800
(30% off)
Buy Now
10 Pro Licenses
$5215
$7450
(30% off)
Buy Now
10 Power Licenses
$13650
$19500
(30% off)

For more information on licensing options, please see the Product & Licensing FAQ.

Smart GWT 3.x / SmartClient 8.x Feature Roadmap

Today, to help our customers plan for the future, we’re announcing features that are planned for the 3.x series of Smart GWT releases and the 8.x series of SmartClient releases.

Several of these features are available in nightly builds now, with documentation and samples – see below for details on how to download and where to look.  These features will be incorporated into Smart GWT 3.0 and SmartClient 8.2, which are currently scheduled for Q4 this year.

Note that these features are just the committed features for 3.x and 8.x – we will be announcing yet more features, and bear in mind it is always possible to influence the roadmap through Feature Sponsorship.

So here’s what’s coming:

New Features

  • Drawing:  Create cross-browser, mobile-enabled graphics in your applications with our general-purpose vector graphics library. Works everywhere with no plug-ins required. For more information, see our previous feature announcement on Drawing Cross Browser Vector Graphics.
  • Automatic Joins:  Include fields from another DataSource with a single property on a DataSource field causing an efficient SQL join to be used. Supported for SQL, JPA and Hibernate DataSources.
  • CSS3 skins:  Existing skins have been upgraded with a ‘CSS3 mode’. CSS3 skins have the same look and feel as current skins on modern browsers, but use radically less media, have a simpler Document Object Model (DOM) for faster rendering, and are easier to modify.
  • Client-side Tree Filtering:  Tree components have been upgraded to perform client-side, tree-oriented filtering. Similar to Adaptive Filtering for grids, client-side filtering minimizes expensive server round trips for more responsive searches.
  • Field-Level Declarative Security:  Declare that viewing, searching, initializing or updating DataSource fields require specific roles with automatic consequences in the UI. In previous releases you could control access to individual DataSource operations, and now you can control access to specific operations on fields. This enables you to limit access privileges by role to ensure granular security at the field-level.
  • Server Script Blocks: Embed code snippets directly in .ds.xml files for server-side business logic. Use Java or any other language that can run in a Java Virtual Machine (JVM): including Groovy, server-side JavaScript, Python, Ruby, Scala and Clojure.
  • *Workflow System: Loadable XML workflow definitions that can handle multiple steps of user interaction and server contact, making multi-step wizards entirely declarative (*This feature is committed for inclusion in SmartClient only for now).
  • HTML5 Charts with mobile support (Licensing):  In the coming weeks, we will be changing the licensing requirements to make this popular feature available to more of our users. To learn more about Charts, see our previous post on HTML5 Charts with mobile support.

Many of these features are nearly complete and can be evaluated now in our Smart GWT 3.x and SmartClient 8.x nightly builds. For example:

  • Drawing has samples:
    • shapeGallery
    • rotation
    • zoomAndPan
    • linesAndArrowheads
    • gradients
  • Automatic Joins have samples:
    • includeFrom
    • includeFromDynamic.
  • Client-side Tree Filtering behavior is covered in the reference docs:
    • TreeGrid.fetchData()
    • Tree.getFilteredTree()
  • Field-Level Declarative Security has several interlinked documents in the reference docs.
    • viewRequiresRole links to all the other properties.
    • DataSource.viewRequiresRole is a good starting point.

Although many of the other features are functional, for now if you’d like to begin working with them we recommend signing up for a Jump Start program. As always, please send us any bug reports or feedback in the Forums. Please be clear about which product and version you are using when reporting problems. Download Smart GWT 3.x or SmartClient 8.x to get started using these new features today!

A Note for Smart GWT customers with 2.x Licenses

3.x will be a paid upgrade for 2.x license holders. If you just bought a 2.x Smart GWT license, don’t worry, upgrade costs are based on how recently you bought.  If you bought very recently, you can get access to the entire 3.x series for a fraction of the license price. For a quote please contact sales.

Drawing Cross Browser Vector Graphics

Our new Drawing Module was created to answer a simple question:

How do I draw in the browser?

If you’ve ever wanted to draw and modify non-rectilinear, browser-native shapes in your web applications, then our new Drawing Module was designed with you in mind. Create, manipulate, and edit arbitrary shapes and styles within your applications without the hassle of cross-browser incompatibility. The Drawing Module allows easy creation of interactive diagrams, flowcharts, custom charts or other data visualizations and interfaces.  This new cross-browser vector graphics package and more are coming soon in Smart GWT 3.0 and SmartClient 8.2.

Works everywhere. No plug-ins required.

We’ve used native browser drawing capabilities to provide a consistent interface requiring no plug-ins or third party software when using commonly used browsers. As with our HTML5 charting feature, the Drawing module utilizes Scalable Vector Graphics (SVG) or <canvas> in modern browsers, and Vector Markup Language (VML) in Internet Explorer 6-8 to ensure cross-platform compatibility.  In addition, the Drawing Module works in mobile WebKit for integrated mobile device support (iOS and Android). The result is a flexible vector graphics library that works everywhere you need it.

Drawing Preview (in the online Feature Explorer)

Features

  • Drawing of shapes such as Line, LinePath, Path, Rectangle, Oval, Triangle, Curve, and Sector.
  • Rotation of shapes and panes to alter the perspective and orientation of shapes.
  • Zoom and Pan to re-size and move shapes to scale.
  • Customize Line cap styles, format, and colors using Line Width, Line Style, and Line Cap Style.
  • Customize Fill opacity, format, and colors using Simple, directional Linear, or Radial color gradients.
  • Drag and Drop support allows users to easily move and manipulate shapes as desired.
  • Interoperability with other Smart GWT and SmartClient components. It just ‘works’.

In today’s discussion we’ll show examples of shapes, rotation, zoom and pan, and line and fill customizations.

  • Drawing of shapes: [shapeGallery.js]. Below is a gallery of shapes that are instantly available.

Shape Gallery

  • Rotation of shapes and panes: [rotation.js]. Rotate individual shapes or if needed the entire field of view.

Rotation examples

  • Zoom and Pan: [zoomAndPan.js]. Shrink and expand the scale of selected shapes.

Zoom and Pan examples

  • Customize Line: [linesAndArrowheads.js]. Modify cap styles (round, square, or butt), line styles (solid, dot, dash, short dot, short dash, or long dash), and line widths.

Custom line examples

  • Customize Fill: [simpleGradient.js, linearGradient.js, and radialGradient.js] Modify opacity, gradient, format, and color palette to match your exact design aesthetic.

Custom Fill examples

Interactive Examples

To get a sneak preview of these new features, a basic example can be found in the online Feature Explorer’s Drawing Preview.  Detailed examples and code are available for download in the Smart GWT 3.x nightly build and SmartClient 8.x nightly build.

  • Drawing Preview in the online Feature Explorer (basic example, no download required)
  • Download Smart GWT LGPL Edition (3.x Nightly)
  • Download SmartClient Full-Featured Evaluation (8.x Nightly)

Pre-requisites

  • Smart GWT 3.0 (coming soon) or SmartClient 8.2 (coming soon)
  • Note to existing Smart GWT 2.x Users: 3.x will be a paid upgrade for 2.x license holders. Upgrade costs may vary according to which version of Smart GWT 2.x is currently under license. For a quote please contact sales.
  • The Drawing Module is already deployed with select clients. To begin using this functionality now, take advantage of our Jump Start program for training and starter code.

Download Smart GWT or SmartClient to get started using our Drawing Module today!

Introducing the CubeGrid

What is a CubeGrid?

The CubeGrid is a high-end data analysis engine that wraps OLAP cube functionality into a single interactive grid component for fast access to multidimensional data and calculations. The CubeGrid enables you to view, analyze, and extract data using any standard data source from multiple perspectives.  They are typically used as front-ends for business intelligence, analytics and reporting applications to empower your teams to generate powerful reports, identify key patterns and trends, and plan ahead using real-time data.

The CubeGrid allow users to perform sophisticated analysis of very large data sets to rapidly answer multidimensional analytical (MDA) queries. Cubes allow the user to re-organize or re-orient the way information is viewed on the fly. Effortlessly slice, dice, drill in and out, roll-up, and pivot data according to your needs.

Components such as the CubeGrid are often called crosstabs for their cross-tabular display of data dimensions in nested rows and columns. They are also called pivot tables for their ability to ‘pivot’ dimensions between rows and columns to view a data cube from different perspectives. Please see below for an explanation of the terminology associated with our CubeGrid component, or read the documentation for more details.

Terminology

The CubeGrid refers to the dimensions of a data cube as facets, the possible values in each facet as facet values, and the values within the data cube as data values or cell values. Equivalent terms that are commonly used in data warehousing or business intelligence systems include:

  • facet: dimension, attribute, feature
  • facet values: dimension member, attribute value, feature value
  • cell value: data value, metric value, measure

What is a facet / dimension?

By facet we mean an aspect of data that is independent of other aspects of data so that combining values from any two facets makes sense. For example:

  • Two facets that are independent are ‘quarter’ and ‘region’. It makes sense to combine any quarter and region. i.e. First quarter sales for the West region.
  • Two facets that are NOT independent are ‘city’ and ‘state’. It’s doesn’t make sense to combine any city and state. i.e. San Francisco and Florida. In this case, a tree facet [getIsTree] that combines ‘city’ and ‘state’ values would be appropriate.

Features

  • Add and Remove facets on the fly.
  • Expand or Collapse within facets and across facets.
  • Drag-and-Drop re-arrangement and pivoting of facets.
  • Interactive Operations such as select, resize, reorder, minimize, maximize, or auto-fit of columns.
  • HTML5 Charts with mobile support for instant graphical analysis.
  • Frozen Headers constrain scrolling to one axis (row headers only scroll vertically, while column headers only scroll horizontally) so that values for the visible cells are always displayed.
  • Load-on-Demand system only loads visible data.
  • Works with Standard ISC data sources.

In today’s discussion we’ll cover adding facets, removing facets, moving facets, and HTML Charts. If you’d like to follow along, please see our Interactive Analytics example.

  • Add Facet: [underlying API is ‘addFacet’]. Facets can be added to the view, exposing more detail, by dragging the menu buttons directly onto the grid, or into the ‘Row Facets’ and ‘Column Facets’ listings.

How to Add a Facet: Before

How to Add a Facet: After

  • Remove Facet: [underlying API is ‘removeFacet’]. Facets can be removed from the view by using the menus to set a facet to a fixed value. For example, use the ‘Regions’ menu to show just data from the West: ‘Regions -> Fix Regions Value -> All Regions -> West’.

How to Remove a Facet: Before

How to Remove a Facet: After

  • Move Facet: [underlying API is ‘moveFacet’]. Facets can be moved or rearranged by:
    1. Drag-and-drop of a facet label directly on the grid,
    2. Toggling the contextual menus from [in columns] to [in rows] (or vice versa).
    3. Drag-and-drop of a ‘Row facet’ or ‘Column facet’ in the corresponding menus.  Please note that you can stack facets in any preferred alignment on either axis (i.e. in the example below I can move the ‘Region’ facet from rows to columns either above or below the ‘Time’ facet).

How to Move a Facet: Before

How to Move a Facet: After

  • HTML5 Charts can be instantly created with a right-click of any cell value, row header, or column header. This allows you to plot how each cell value may vary across any two facets (i.e. Sales of ‘Storage/Accessories’ by ‘Time’ and ‘Region’ in the example below).

How to Create an HTML5 Chart: Before

In addition, a right-click on the resulting chart enables further customization including pivoting, selection of chart type, fill, and stack.  For further details, please read our post on HTML5 Charts with mobile support.

How to Create an HTML5 Chart: After

Interactive Examples

Pre-requisites

Other topics such as data binding and load-on-demand will be covered in future posts. Stay tuned. Download the Smart GWT or SmartClient Evaluation to get started using our advanced analytics today.

Enjoy!

The Isomorphic Team

Welcome to the Isomorphic Public Wiki

We are happy to announce the launch of our first public wiki located at:

http://wiki.smartclient.com/

Our new wiki is part of an ongoing effort to bring our developer community the best, most relevant content possible for creating applications on the SmartClient and Smart GWT platforms.

Here you’ll find developers from around the world writing about what they’re working on. You’ve got developers and product experts highlighting the latest and greatest. They’re here to collaborate and share best practices so you can get the most out of our products. We’ve also added several articles pointing to popular forums threads along with entirely new content.

This service has been created as a resource for you, the developers, so please let us know if you have suggestions or feedback in the Forums.  We’re just getting started with our community resources, but we’re excited about what we have and what’s in store.

Enjoy!

The Isomorphic Team

How to Join

Commenting does not require sign-up, but if if you would like to contribute or edit content please create an account:

http://wiki.smartclient.com/signup.action

You can also click the Sign Up link on the wiki. To learn more about the wiki and how it works, please click the “Welcome Screen” link located at the top right hand corner of the page.

Benefits

The new wiki will allow you to:

  • Create new pages that will be useful resources for all. Addition of new examples, documentation, setup procedures, and other vital information will get you noticed while helping out the entire community. Every user has a voice and everyone’s contribution is seen, heard, and can be commented upon.
  • Spread the word by adding links on the wiki to resources you find helpful. Post links when you find a thoughtful forum thread, blog post, or other items of interest so you and others can refer to it later.

When adding new content, please:

  • Show your respect for other contributors by carefully placing pages and links to your content according to who might be interested.
  • Visit the Forums when reporting bugs, making feature requests, or asking questions.

Grails Plugin for SmartGWT – Part 2

In the first post on this topic we looked at a standard Grails application and how to add the SmartGWT plugin to it.  In this post we’re going to explore some more features of the plugin.

Customising the scaffolded UI

If you run the sample app at the end of the last post and filter on Film you’ll notice that the ‘Language’ and ‘Original Language’ fields are empty:

In the domain class for Film these fields are an association to Language and by default these are fetched lazily so the data is not sent to the browser.  We can alter this behaviour and instruct the SmartClient DataSource to fetch an association by default.  To do this change the ‘static smartclient’  to the following:

  1. static smartclient = {
  2.     DataSource() {
  3.         fields {
  4.             language(fetchMode: ‘JOIN’)
  5.         }
  6.     }
  7. }

This will override the default Data Source definition and change the Hibernate fetchMode to ‘JOIN’, causing the field to be returned and displayed:

By default the scaffolded code will display the name property of an association (if one exists) but you can alter this by specifying your own formatCellValue function – in the Groovy smartclient definition or programmatically in your GWT module.

In our sample database all originalLanguage fields are NULL and we may want to remove them from being shown in the ListGrid field.  To do this we can update our SmartClient definition as follows:

  1. static smartclient = {
  2.     DataSource() {
  3.         fields {
  4.             language(fetchMode: ‘JOIN’)
  5.         }
  6.     }
  7.     ListGrid() {
  8.         fields {
  9.             originalLanguage(hidden: true)
  10.         }
  11.     }
  12. }

We may want to use formatCellValue to provide some formatting for the ListGrid.  The following example demonstrates this using the JS tag for rentalRate and using a String Method for replacementCost – both are functionally equivalent:

  1. static smartclient = {
  2.     DataSource() {
  3.         fields {
  4.             language(fetchMode: ‘JOIN’)
  5.         }
  6.     }
  7.     ListGrid() {
  8.         fields {
  9.             originalLanguage(hidden: true)
  10.             rentalRate {
  11.                 formatCellValue {
  12.                     JS(‘function(value) {return “$ ” + value}’)
  13.                 }
  14.             }
  15.             replacementCost {
  16.                 formatCellValue(‘”$ ” + value’)
  17.             }
  18.         }
  19.     }
  20. }

In this way the generation of SmartClient DataSource, ListGrid, DynamicForm and DetailViewer widgets can be customised.  You can add any attributes to these widgets that are understood by SmartClient according to the documentation.

Creating your own DataSources and UI widgets

It is also possible to generate additional DataSources and UI widgets by specifying an ID attribute (which will become the ID of the generated DataSource or UI widget):

  1. static smartclient = {
  2.     DataSource(ID: ‘MyCustomDataSource’) {
  3.         …
  4.     }
  5.     ListGrid(ID: ‘MyCustomListGrid’) {
  6.         …
  7.     }
  8. }

If you’d like to create types of widgets other than ListGrids, DynamicForms and DetailViewers or don’t want widgets to have the default scaffold properties then create them in the /smartclient/ui folder.  You can place regular Component Schema XML files (as long as the file extension is .xml) in this directory or Groovy files (files ending in .groovy).  Groovy files will be converted to XML and XML files will be copied to web-app/shared/ui during Grails packaging.  The simplest way to get started with the Groovy syntax is to use the generated widgets as a starting point.

Creating GWT modules and pages

The GWT plugin includes scripts to allow you to create modules and pages.  This plugin extends this functionality to allow you to create modules and pages that meet the SmartGWT requirements:

  • grails create-smartgwt-module <PACKAGE_NAME>.<MODULE_NAME>
  • grails create-smartgwt-page <GSP_FILE_NAME> <PACKAGE_NAME>.<MODULE_NAME>

Note on DataSource and UI generation

If you modify your Domain Classes while your application is running then the plugin will automatically detect and re-generate any DataSource and UI widgets defined in them.  If your application is not running when you make changes then you can re-generate them using the following scripts:

  • grails generate-data-source <Optional, whitespace separated list of Domain Class names>
  • grails generate-ui <Optional, whitespace separated list of Domain Class names>

The domain class names are case sensitive, if no parameters are provided then all will be generated.

If you expose a new Domain Class with a ‘static smartclient’ property after generating scaffolding you will need to run grails generate-scaffolding again.

Summary

The plugin allows you to create UI widgets declaratively in Groovy DSL and then re-use those widgets in your application.  The idea is to give developers the ability to rapidly create, customise and manage basic widgets.

This plugin is intended to be used with the GWT module but it is also possible to use SmartClient from regular (non-GWT) pages – this will be explored in the next post.

SmartGWT 2.5 / SmartClient 8.1 Released

Smart GWT 2.5 and SmartClient 8.1 have been released!  Download the new releases here.

  • New Chart Modes: Pie, Doughnut, Bar (with Power + Analytics)

The FacetChart has picked up several new modes that now make it a superset of our existing FusionChart support.  Like the existing charting modes, users can swap between the different chart types on the fly, and the Pie and Doughnut modes supports two different ways of displaing multi-series data.  Below is an “Unstacked” multi-series Doughnut chart:

And this is a “Stacked” multi-series Doughnut chart:

Check out the samples and be sure to right-click to see all the different ways that a single chart component can visualize a single dataset – present just one FacetChart to an end user and you’ve given them a dozen different ways to visualize their data with no additional effort.

  • Real-Time Messaging for SmartGWT (with Power + Messaging)

Our Messaging module enables real-time delivery of data for use cases such as trading desks,  monitoring systems, and defense applications.

The Messaging Module has been available for SmartClient for several years, and has also been used in several SmartGWT applications built for specific customers, but is now available as a GA feature for SmartGWT, with samples showing a grid and a chart receiving real-time streaming updates from the server.   Click through to the sample to see the chart below slide left as new updates come in – as with any chart you can right-click for a different real-time visualization (radar and pie modes are mesmerizing).

Messaging Chart sample

  • Chart Gradients & Shadows (Power + Analytics)

Note the details on the charts above – gradients, shadows, 3d edge effects – the FacetChart will now use linear and radial gradients for various chart types, automatically generating attractive gradients from the base colors you specify.  They even work on IE6-IE8.

  • JPA 2.0 support,  Auto-derivation of DataSources

In addition to the existing JPA 1.0 connector, we now have a JPA2DataSource supporting the JPA 2.0 API.    Both JPA connectors also support automatic derivation of DataSource fields from your JPA annotations or persistence declarations, for a completely declarative connection from any data-aware component to any JPA entity.  Check out this sample to see how easy it is to connect to JPA.

  • JPA & Hibernate: Automatic Relation Update Handling

JPA and Hibernate DataSources will now automatically persist changes to related entities, including cases where the field(s) that store IDs of related entities are not explicitly declared.  Handling such updates normally requires several different JPA calls which are different for each entity – the JPA & Hibernate connectors now handle this transparently and automatically for any JPA or Hibernate entity.

Check out this extraordinarily simple sample of a master-detail editing screen – all declarative code, just the JPA beans and DataSources which are auto-derived from them.

  • JPA AdvancedCriteria & Automatic Transactions (Power Edition and above only)

Both JPA connectors have also been upgraded with support for automatic, codeless execution of AdvancedCriteria submitted by UI components, as well as automatic transaction support (Power and above only).  This sample shows a FilterBuilder connected to a JPA entity, allowing complex search criteria to be defined for any field.

  • Expression Filtering

You can now type simple filter expressions directly into the query-by-example interface of the ListGrid’s built-in FilterEditor.

This provides a convenient middle ground between the simple query-by-example interface and the uber-powerful FilterBuilder interface: novice users can just type what they want to see, but power users are free to specify advanced filter criteria in the same interface, without ever leaving the grid view.

All of the common AdvancedCriteria operators have shortcut strings, and simple expressions (this or that, this and that) are also supported.  The criteria shown above mean: Country name does not contain and “i”, Capital starting with a letter between A and F, and Population under a million or over 100 million.

Since this new interface is just causing “fetch” requests with ordinary AdvancedCriteria, it’s supported by our built-in SQL, JPA & Hibernate DataSources (in Power Edition or above) and by any existing custom implementation that supports AdvancedCriteria.

  • Multi-field ComboBox & SelectItem filtering

The new ComboBoxItem.filterFields property allows you to simply declare that text typed into a ComboBox should be used as search criteria for multiple fields of a DataSource – everything else is automatic.

A similar enhancement for SelectItem allows the ListGrid query-by-example interface to be used within the drop-down list.

Combine the interface on the right with the Expression Filter support and users can do advanced searches right inside a SelectItem.

Both enhancements avoid the awkwardness of a modal pop-up dialog for choosing related entities, enabling users to search without leaving the context of the form, with all of the other values in the form still visible during the search.

  • AdvancedCriteria helper classes (Pro+)

Server-side helper classes have been added for working with AdvancedCriteria, so you no longer have to deal directly with the Java Collections-based representation of criteria when  writing server-side code to create or manipulate AdvancedCriteria.  For details, see the server-side APIs dsRequest.getAdvancedCriteria() and dsRequest.getCriteriaValue().

  • New Summary Modes

New modes have been added to the extremely popular summary display mode of grids.  If you have more than one summary function you want to show, such as both average and total, or both first and last, just provide a list of summary functions for the field.  The second (or third, etc) summary value will be shown as additional summary lines, as shown below.

Or, perhaps you want to get more compact instead.  Summary information can now be shown in the expand/collapse row for the group.  This makes the summary information visible even when the group is collapsed.


  • Formatted SelectItems

New samples and documentation have been added to make it more obvious how to achieve effects like those shown below: on the left, a select item shows a formatted value based on multiple fields from the related record.  On the right, the drop-down list itself shows a formatted value derived from multiple fields of the related record.

Both effects can be combined if desired, both work with load on demand, and as usual, our SelectItem separately tracks the actual stored value so that the ID of the related record is what’s really saved.

  • Internet Explorer performance improvements

We’ve made some big strides in the ongoing quest to help IE6 through IE8 keep up with modern browsers.  You’ll notice speedier rendering in grids, especially those with lots of columns.  Across all browsers, you’ll notice less media is required as well.

  • Simplified CanvasItem value management & samples

The extremely powerful CanvasItem allows you to take any interface you can build in Smart GWT and use it to display and edit values in a form.  A new, simplified interface for interacting with the form now makes it much simpler to build a re-usable CanvasItem-based editor, and samples have been added to illustrate how to use a CanvasItem to create an interface for editing related records.

In one of the two in-depth samples, an editable ListGrid is wrapped as a custom subclass of CanvasItem, and allows sub-records to be edited right in the same DynamicForm.  The CanvasItem is reusable in any DynamicForm, for editing any kind of nested data that has a DataSource.

  • Accessibility / ARIA enhancements

SmartClient and Smart GWT have long had support for the ARIA standard, which allows screen reader software to correctly read advanced AJAX interfaces.  In this release, we’ve taken advantage of new features in the ARIA specification to make our components read even better.  We’ve also added support for the NVDA screen reader, which is very popular among developers because it is both free and has an option to turn off the voice synthesizer and display the text that would be read instead.

This release is the last 2.x release for Smart GWT (other than a 2.5.1 bugfix release).  The next major release, Smart GWT 3.0 / SmartClient 8.2, is already well underway, and a beta with several major new features will be announced shortly (including an HTML5 vector drawing library and more CSS3 skins).

If you just bought a Smart GWT 2.x license and are now worried about what you might be missing out on in 3.0, never fear, our upgrade pricing policy is based on how recently you bought – you’ll be able to upgrade and pick up the entire 3.x series of releases for a very reasonable price.

Page 3 of 6«12345»...Last »