4.2

New Features

Data Framework

The Data Framework is a declarative – no programming needed just XML – and programmatic framework for getting data into the display.  This new framework allows users to define a data source, bind it to user interface elements such as tables and labels and format the output.  Developers can also specify that the interface should update whenever the data source changes.

Now by placing some simple XML statements in their user interface developers can automatically load, display and update complex data – all without writing code (aside from the application itself).  Using the ObjectDataSource developers can traverse a complex Java object tree to automatically display data in the user interface, and even directly invoke Java methods and display the output – again, all without code. 

Desktop Client (Seperately Licensed Component - Contact Nexaweb Sales for more details)

Desktop client functionality allows programmers to create web applications that can be packaged with an installer and installed to the desktop.  The application can communicate with the server as little or as much as desired and it can be switched from online to offline while running.  The programming model remains consistent across modes (online/offline) and the APIs used to access remote resources are redirected to access them locally when offline – providing a very clear path to creating occasionally connected applications.

Applications built using desktop client are able to auto-upgrade without additional effort.  Whenever new versions of either the Nexaweb components or end user built components are available on the server, the desktop client application will alert the user that an update is available, automatically download the update and restart the application. 

Support for minimum client environment requirements

Previous versions required developers to write their own application loader to prevent users from loading the application on non supported versions of the JVM (Nexaweb itself supports everything).  This enhancement provides a simple configuration option that allows the developer to specify include/exclude logic based on a variety of parameters including: JVM version, JVM vendor, user-agent and screen resolution.  The developer can then redirect the application to an error URL.

In addition, new options are available in client.xml for startup screen customization.

Client Load Time Performance Tuning

This feature provides an XML report that contains the loading time and sequence for a specific session.  This allows developers to see with granularity which objects and in what order are being loaded.  This enables them to make packaging decisions that can speed this up.

The report will be available via the services console (a Server instrumentation feature) while active.  They are written to a file once the session is completed.

Full support AWT automation tools such as Mercury QuickTestPro

All user interface elements within Nexaweb have been updated to support using tools such as Mercury QuickTestPro to automate test cases.  They will now work with virtually any tool that supports Java AWT automation testing.

Previous versions of Nexaweb supported only “low level” recording and playback; this level of automation records exact mouse and keyboard events and plays them back.  This was not sufficient to enable true automation testing of the user interface.  With this version components can be scripted and queried back.

Nexaweb supported server load testing starting with version 4.1.

Parameterized Macros

The current Nexaweb UI definition supports macros: small fragments of XML that use XUpdate to change the existing user interface document.  Until now these macros could not be easily reused, instead only existing to execute one particular task.  This feature allows macros to have parameters, implemented using JavaMessageFormat, that allow them to be reused.  This brings Nexaweb one step closer to full scripting in the UI.  Parameters can be strings or Xpath statements referring elsewhere in the same or other local documents.

Support for PDF print output

Extending the existing printing support, which consists of sending a copy of the screen image to the printer, the Platform will now support XSL-FO an XML pagination markup language for creating documents.  The open source library used allows transformation from NXML into Adobe’s PDF.  Transformation takes place via XLST; end users can modify the transformation to meet specific needs.

NXML does not readily lend itself to document formats.  There is built in support is provided only for table and text elements (label, textArea, textView).  This provides end users with the ability to generate reports based on common large data displays such as tables, etc.  The transformation can be enhanced by developers to support additional required interface elements.

The XSL-FO version included is the Alpha version.  The latest available version is Beta, but this is less stable.  This library does not work on BEA WebLogic when using JRockit (BEA’s JVM).

4.2 does not directly support Unicode (internationalized strings). 

Enhancements to the plug-in architecture

This is the second revision of the plug-in architecture focused on moving the initial design forward and enabling further ease of development and use.  End user developers can develop custom XML tags that provide behavior and/or user interface.  These tags can combine built in user interface elements into complex elements to provide custom widgets.  Once written these plug-ins can be reused easily across applications and accessed simply by specifying the customer XML tag within the user interface markup file (NXML file).

Support for pack200 compression

Using a more efficient compression algorithm available in Java 1.5+ the client, and associated customer code, can be 3-4x smaller than with previous JAR (Java archive) compression.  End users accessing with previous versions of the JVM will automatically receive the smaller file size,

New Clustering Message option added

Nexaweb has added a new default UDP messaging option for clustering.  This will be installed as the default instead of JGroups; JGroups can still be used if needed.  See the clustering documentation for more details.

Drag and Drop outlines

New drag and drop styles have been added to enhance the visual flexibility of Drag and Drop.

New attributes and events

onAfterSort event added to provide the ability to manage sorted data

System Container

In releases prior to 4.1, a hidden system container existed which allowed calling certain Nexaweb defined objects using the "mco://" syntax, the use of this syntax has been deprecated, to access a system-level object, no prefix is necessary. For instance:

<button text="Browse Nexaweb Home" onCommand="mco://NetService.openBrowser('http://www.nexaweb.com')"/>

becomes

 <button text="Browse Nexaweb Home" onCommand=="NetService.openBrowser('http://www.nexaweb.com')"/>

since NetService is a Nexaweb defined system object.  New system-level objects can be created by adding the to the system container, available through the ClientSession interface.

MCO calling conventions

See the MCO documentation for more detail, all previous conventions still function the same.  New calling conventions added:

Strings surrounded by ' such as 'myString'
Objects from containers, such as mco://myMco or document://nxml
Method calls, such as mco://myMco.do.

For example, the following will now work:

onCommand="mco://myMco.do( mco://myOtherMco, mco://myOtherMco.do('hello') )"

Removing Stylesheets

DisplayService has a new method called unloadStyleSheet() . To unload the default style sheet pass it: classpath://defaultstylesheet.txt

Cell transition into edit mode (for tables)

Setting the attribute editing="true" causes a cell to go into edit mode (if it is editable).

Document Container

A document container has been added to the client to allow declarative access to registered documents on the client side. To supply a document to an mco as a method argument, for instance, use
"mco://mco_name:method_name(document://document_name)" .

Support for multiple containers

In addition to the mco container, now the client supports multiple named containers. In the client for example, there are containers defined for defined macros (macro://), registered documents(document://), and of course, the mco container (mco://). In addition, containers may be added by using ClientSession's addContainer(String name, Container container) method.

Changes

Disabled components no longer receive mouse or keyboard events.  Tooltips will still display. (defect 4846)

Known Issues

XSL-FO, used for PDF printing, requires a large amount of memory

Be sure to properly configure the server JVM when using this functionality.

Support for JBoss 4.03 SP1+

To deploy multiple J2EE applications via JBoss it is necessary to set "Enable deployment isolation/call by value" at install time.  For more information refer to the JBoss documentation.