Click here for release notes for previous versions of BEA Workshop Studio.
Web Tools Platform (WTP)
The major feature upgrade from version 3.0 is that the Workshop Studio group of products now integrate Web Tools Platform (WTP) 1.0.2. This affects several functional areas, primarily:
Creating projects is now done using the WTP wizard. Projects created in version 3.0 must be upgraded.
Server management is done through the Servers view.
The following procedures have been changed and/or enhanced:
You must upgrade existing applications to explicitly enable AppXRay on your existing Workshop Studio 3.0 web projects in order for Studio's AppXRay and editors to be used. This operation has no associated risks; it merely creates a top level .settings folder that contains the project files.
The .m7project file is no longer used and can be deleted, since it is replaced by the .settings/com.bea.workshopstudio file.
Use File > New > Dynamic Web Project to create a new blank project. As before, this will create a blank application containing the libraries and configuration files related to the project facets you choose (Struts, JSF, Hibernate etc).
Use File > New > Dynamic Web Project From Existing Source to create a new web project from existing source files.
Use File > New > Example to create a project for any of the examples and tutorials bundled with Workshop Studio.
Use New > Other to create web project artifacts. The Studio 3.0 New Web Artifact wizard no longer exists, but you will find all its commands (and much more) in the New > Other wizard under the Web, Struts, JaveServer Faces, Hibernate and EJB3 Persistence nodes.
Use the Servers view to create server configurations, and to run/debug web applications. The "Window > Preferences > Workshop > Server Configurations" dialog no longer exists. The Servers view can be shown from Window > Show View > Other > Server.
Use Window > Preference > Web and XML to control the JSP/HTML/XML source editor preferences. This gives much more settings than the old Workshop Studio source editor preferences.
You can now add Struts, JSF, EJB3 Persistence, Hibernate and JSTL capabilities to existing projects. See Project > Properties > Project Facets.
Workshop Studio 3.1 provides additional enhancements to the following areas in WTP:
Project Creation: Workshop Studio adds the ability to create a WTP dynamic web project from existing source files. You use File > New > Dynamic Web Project From Existing Source. The creation process will automatically detect and configure the facets used in the application during the AppXRay analysis.
JSP Debugging: Workshop Studio has its own JSP debugger which replaces the WTP debugger. Studio also adds the JSP Variables view to the Debug perspective.
Server Deployment: In addition to WTP's WAR and EAR deployment, Workshop Studio adds exploded deployment to all servers (deployment directly from workspace). This enhances the development cycle by significantly speeding up server start time, and providing hot deployment for JSP and Java files (avoids lengthy manual republishing).
For Tomcat, the Workshop Studio deployer also provides built-in support for Sysdeo used to include external libraries in a web application.
JSP and XML editors: The Workshop Studio JSP and XML editors enhance the WTP editors by providing the AppXRay completion, validation and navigation.
Workshop Studio also enhances the WTP editing experience with fast and intuitive content validation and improved document navigation facilities.
WTP adds numerous features to Workshop Studio. Following are some of these features, for the complete list and details please refer to http://www.eclipse.org/webtools/:
EJB and EAR project types.
Web services creation.
Graphical WSDL editing.
Code completion for CSS and JavaScript in JSP/HTML files or in .css and .js files.
Source code auto formatting and cleanup (see the Format menu in the source editor context menu).
User defined code snippets for drag and drop from a special Snippets view (see Window > Show View > Other > Basic > Snippets).
User defined JSP/XML templates (see Window > Preferences > Web and XML > JSP Files > JSP Templates and Window > Preferences > Web and XML > XML Files > XML Templates). The templates you create here can be used as new file templates or code completion proposals.
XDoclet support.
Extensive preferences settings.
Other Changes and Upgrades
Drag and drop within the same page in the JSP design editor.
The documentation has been upgraded, including a new Hibernate tutorial. See File > New > Example > Hibernate > Workshop Hibernate Tutorial.
The free download BEA Workshop JSP Editor has been renamed to BEA Workshop for JSP. This change reflects the fact that beginning with the 3.0 release, Workshop for JSP added full iterative test and debug features to the previous editor features, for a complete professional development environment.
Changes to Supported Platforms
EJB3 Persistence - This release supports the final specification of EJB3 Persistence (aka JPA).
Full support is provided for BEA Kodo 4.0 as well as Hibernate Entity Manager 3.1 beta 8.
Struts - This release supports Struts 1.2.9.
Hibernate - This release supports the latest Hibernate 3.1.3 and 3.2 rc2. Upgrading existing applications can be done using Project > Properties > Project Facets.
Spring IDE - Workshop Studio 3.1 bundles the Spring IDE 1.3. Please refer to http://springide.org/project for the Spring IDE features.
Given the WTP version dependency, Workshop Studio can no longer be installed on top of IBM's WSAD and RAD, which use previous proprietary versions of Eclipse and WTP.
BEA Workshop Studio 3.0.1, build 493 (3/29/06)
WebSphere 6.0: Debugging and Automatic Deployment for the
WebSphere 6.0 application server. As usual you create the server configuration
from "Window > Preferences > Workshop> Server Configurations".
Empower the Free JSP Editor: The free JSP editor now has
full JSP debugging and validation (JSP/HTML/XML error reporting) capabilities.
Previously, this was only possible with the WorkShop Studio product flavors.
ORM Generation Wizard Enhancements:
The ORM Generation wizard is used to generate EJB3 Persistence and Hibernate
ORM mapping from a database schema. This wizard is now enhanced to:
Generate Java 1.5 generics when the project settings allow it.
Give control over whether a database column's bean property is generated.
Not re-generate the base class methods in the generated subclass.
EJB3 Persistence This build includes the following support for the pre-final EJB3 Persistence
"Proposed Final Draft" specifications. All features work with BEA
Kodo (early access release EA4) and Hibernate 3.1 (Hibernate Entity
Manager beta6 and Hibernate Annotations beta8):
Reverse Engineering of Schemas: By reverse engineering a database schema,
Workshop automatically generates the associated Java object model annotated
using the EJB3 persistence annotations. The generation wizard has the following
features:
Selectively choose which database tables to reverse engineer.
Automatic detection of entities associations based on the foreign key
definitions, with support for many-to-one, one-to-many, many-to-many and
one-to-one generation.
You also have control over the association directionality (bi-directional/uni-directional).
New associations can be created graphically in cases where the database
does not contain foreign key definitions.
The generation process is highly customizable in every aspect. For
example you can change the generated Java bean property names and visibility
for a given database column etc.
All settings are remembered when you need to redo/modify the generation
later.
Annotate existing Java classes: Workshop supports adding EJB3 persistence
annotations to existing Java classes, the top down development scenario.
The generation wizard provides a graphical interface for editing all of the
generation aspects: Database columns, join tables, column properties for DDL
generation, etc.
Entities Editor: Provides a productive way of managing EJB3 entities and
their relationships. It has the following features:
Shows a diagram of all the entities defined in the EJB3 persistence.xml
configuration along with their relationships. The diagram can be customized
using drag and drop positioning and special filters.
Modify any of the mapped classes and properties using Java-model-aware
and database-aware smart editors. The corresponding Java classes' annotations
are automatically updated. The editor also shows the Java beans non-mapped
(transient) properties and allows mapping generation thru rich wizards.
Navigation to the underlying Java classes and database tables and columns
(thru the DbXaminer).
EJBQL
Editor: Provides a simple way to edit and run arbitrary EJBQL (EJB3 Query
Language) statements, display and sort the result beans, view the generated
SQL statements, as well as inspect any of the result beans properties (including
other beans references and collections). The EJBQL editor also provides syntax
coloring and code completion.
This editor is accessible thru the icon bar of the DbXplorer view.
Validation and Consistency Checking: As usual, Workshop dynamically maintains
the consistency between the annotated Java classes, and report the validation
errors (invalid entity relationship, invalid mappedBy property, etc).
Configuration Editor: Modeless, form based, creation and modification of
the EJB3 persistence.xml configuration file properties, database connection
and mapped classes.
Adding EJB3 Persistence support: Using the Project Properties, EJB3 Persistence
support can be added to existing projects.
Hibernate 3.1 Support This build enhances our earlier Hibernate
support by providing the following features:
Hibernate EJB3 Entity Manager: When you add EJB3 Persistence capabilities
to a project, you can specify Hibernate as the EJB3 provider. In addition
to the EJB3 support described above, this will also let Workshop be more intelligent
about editing the persistence.xml EJB3 configuration file with the Hibernate
specific properties, for example the database connection properties.
Note that the persistence annotations in Java classes are recognized only
in a project with EJB3 support.
HQL Editor:
Provides a simple way to edit and run arbitrary HQL (Hibernate Query Language)
statements, display and sort the result beans, view the generated SQL statements,
as well as inspect any of the result beans properties (including other beans
references and collections). The HQL editor also provides syntax coloring
and code completion.
This editor is accessible thru the icon bar of the DbXplorer view.
Adding Hibernate support: Using the Project Properties, Hibernate support
can be added to existing projects. This includes configuring the project to
work with any of Hibernate 3.1, 3.0 and 2.1.
Database Enhancements This build enhances our earlier Database development
support by providing the following features:
Spring IDE This build bundles the Spring IDE (an installer option).
HTML Conversion
You can convert HTML pages to use Struts or JSF tags. The conversion wizard
gives you control over which tags to convert, and for each HTML form lets you
specify the corresponding Struts action or JSF managed bean and use it for binding
the form fields.
These commands are accessible thru the New Web Artifact wizard.
Misc.
The ORM Generation wizard (Database reverse engineering) now detects the
many-to-many associations.
The Entities Editor diagram has been enhanced to better show bi-directional
associations.
Update the new application templates and sample applications to use the
latest Struts (1.2.8) and MyFaces (1.1.1).
3.0 M2, build 471
(11/7/05)
Starting from this build NitroX has been renamed to BEA Workshop. The product
mission, vision, and commitment to developers are not changing!
BEA WebLogic Server 9.0
This build provides JSP debugging and automatic deployment for BEA WebLogic
Server 9.0. As usual you create the server configuration from "Window > Preferences
> Workshop > Server Configurations".
3.0 M1, build 465
(9/16/05)
Database
Development This build introduces the NitroX support for database exploration and
editing. We will continuously add to these features thru multiple milestones.
DbXplorer: The equivalent of AppXplorer for databases. It shows the database
schemas, tables and columns, and allows table data exploration.
DbXaminer: Diagram view for database schemas showing the tables and columns
relation ships (based on foreign key definitions).
A SQL Editor providing a simple way to define and run arbitrary SQL statements,
display and sort query results. The SQL editor also provides syntax coloring
and code completion (smart about the completion of schema, table and column
names).
Hibernate This build introduces the NitroX support for Hibernate 3.x and 2.x.
We will continuously add to these features thru multiple milestones.
Reverse Engineering of Schemas: By reverse engineering a database schema,
NitroX automatically generates the associated Java object model and Hibernate
mapping files. The generation wizard has the following features:
Selectively choose which database tables to reverse engineer.
Automatic detection of entities associations based on the foreign key
definitions, with support for many-to-one, one-to-many, many-to-many and
one-to-one generation.
You also have control over the association directionality (bi-directional/mono-directional).
New associations can be created graphically in cases where the database
does not contain foreign key definitions.
The generation process is highly customizable in every aspect. For
example you can change the generated Java bean property names and visibility
for a given database column etc.
Optionally generate XDoclet information in the generated Java classes.
All settings are remembered when you need to redo/modify the generation
later.
Generating Mappings from the Object Model: NitroX supports the generation
of Hibernate mapping files from a Java object model, the top down development
scenario.
The generation wizard provides a graphical interface for editing all of the
generation aspects. For example, for a bean property of type Collection, you
can specify the collection element type, how the database tables are joined
etc.
DDL Generation: Generation of SQL statements DDL file from Hibernate mapping
files. The generation supports all the databases supported by Hibernate.
Entities Editor: Provides a productive way of managing ORM entities and
their relationships. It has the following features:
Shows a diagram of all the entities defined in the Hibernate configuration
along with their relationships. The diagram can be customized using drag
and drop and special filters.
Modify any of the mapped classes and properties using Java-model-aware
and database-aware smart editors. The corresponding Hibernate mapping files
are automatically updated. The editor also shows the Java beans non-mapped
properties and allows 1-click default mapping generation.
Creation of custom property mappings thru rich wizards.
Navigation to the underlying Java code, mapping files, database tables
and columns (thru the DbXaminer).
Import from database and/or Java classes, and export to DDL SQL files.
Mapping File Editor: In addition to the Entities Editor, this version offers
a modeless, form based, editing of Hibernate mapping files. It has the same
editing and navigation capabilities of the Entities Editor, but only for the
entities defined in the mapping file.
The source editor supports live validation, and completion for bean properties,
database schemas, tables and columns, etc.
Validation and Consistency Checking: As usual, NitroX dynamically maintains
the consistency between the Java classes and mapping files, and report the
validation errors (invalid mapping property, invalid entity relationship,
etc).
Configuration Editor: Modeless, form based, creation and modification of
the Hibernate configuration file properties and mapping files.
A custom editor for JDBC and JNDI connection and pooling properties is also
available.
MyFaces Extensions
The MyFaces extensions tag library is now supported as follows:
Insertion Wizards and Smart Editors that understand the tags semantics,
and automatically generate/edit the required nested tags. For example, the
x:dataTable editor allows you to specify the table columns to be used for
sorting and inserts/modify the header tags accordingly.
Knowledge of the variables exposed by the tags and their type and scope.
Validation of the tags usage according to their specifications.
Custom rendering in the JSP Design Editor showing the tags in an almost-the-same-as-runtime
fashion.
CSS and JavaScript Editors
This build contains a .css and .js editors with syntax coloring and code completion.
Tag Libraries Customization It is now possible to customize many aspects of JSP tag libraries using
powerful (and simple) metadata files.
Most notably is the ability to write Velocity HTML rendering templates to customize
the rendering of JSP tags and JSF components in the JSP design editor.
Eclipse 3.1: NitroX now supports the final Eclipse 3.1
version.
Eclipse Update Manager: Support for the Eclipse Update
Manager allows automatic update of the currently installed NitroX plugin from
within Eclipse using the "Help > Software Updates > Find and Install..."
menu item.
JSF Tutorial: A JSF Tutorial can now be created from the
New Web Application Project wizard. The documentation is as usual accessible
thru the "Help > Help Contents" menu item.
Preferences Enhancement: The source editor preferences
now include settings for indentation, displayed tab width, maximum line length,
auto close strings etc.
AppXRay Performance enhancement for Eclipse 3.1 (On some
very large projects under Eclipse 3.1 AppXRay building was slow).
2.1 M3 (6/1/05)
Eclipse 3.1 RC1: NitroX now supports the latest Eclipse
3.1 RC1, as well as 3.1 M7.
CSS Enhancement:
A graphical CSS style editor is now available in all the tag attributes
representing a CSS style (For example the style attribute
in JSF, Struts and HTML tags).
Graphical UI for adding CSS style classes to a .css file when editing
a CSS style class attribute (For example the styleClass attribute
in JSF and Struts tags).
Resources Enhancement: Graphical UI for adding resource
keys to a .properties file when binding attribute values to resource-based
strings.
2.1 M2 (5/13/05)
JSF Support: Java Server Faces support is available in the
NitroX JSF IDE, NitroX Struts & JSF IDE, as well as in the first 15 days
of the free JSP Editor.
Graphical JSF Editing:
Graphical (WYSIWYG) representation and editing for all of the JSF standard
html and core tags (MyFaces and Sun's RI implementations).
Provides interoperability between JSF, HTML and JSP tags: JSF 1.1 has
a serious issue integrating JSF with HTML and JSP tags. Mixing these tags
gives unexpected results in many cases.
The NitroX editor hides this issue by (context-sensitive) usage of the
tags h:outputText, f:verbatim, h:panelGroup etc, so that what you insert
in the page behaves at runtime as expected.
This feature is more appreciated after reading this article.
Advanced JSF tables editing: Bridges the gap between the JSF tables
(h:dataTable and h:panelGrid) and HTML tables. The editor provides commands
for insert/delete the tables rows, column, headers and footers, and let
you freely edit the table (typing, drag and drop, etc) without worrying
about the JSF tags requirements (h:column can contain only JSF components,
f:facet can contain only 1 JSF component, etc).
JSF managed beans defined in the faces config files are available in
the Variables View for drag/drop into the JSP pages.
Smart Tag Editors: Insertion Wizards and Smart Editors that understand
the JSF html and core tags semantics, and automatically generate/edit
the required nested tags. For example the command button editor allows
the selection, or creation of an action method from a JSF managed bean,
or an accessible navigation case from the config files. Another example
is the form text field editor which allows the selection of the standard
input validators, as well as the validators defined in the config files.
The Smart Editors also allow binding attribute values to any of the variables
accessible to the page, and automatically generate the unerlying JSF expressions
and method bindings.
Graphical JSF Config: The JSF configuration editor provides
3 ways for editing the file:
Form based: Modeless, form based, creation and modification of all the
JSF config artifacts (Managed beans, Navigation rules, Navigation cases,
Converters, Validators, etc).
Source code editing is optionally available for simultaneous graphical/source
editing.
Navigation: Graphical diagram editing of the navigation flow (navigation
rules and navigation cases).
Source code editing is optionally available for simultaneous graphical/source
editing.
Source: Source code only editing.
Consistency Checking: Live checking and error reporting
for inconsistencies between JSP pages, JSF config files, Java classes, and
resource files. For example, a command button or link using an invalid navigation
outcome, a Java method used as an action method from a JSP page is returning
invalid navigation outcomes, an invalid method binding is used in a JSP page,
etc.
Navigation: Source code control-click, and smart editor
hyper-link navigation to binding methods implementations (action, validation,
etc), navigation rules, managed beans, bean properties, resource files, etc.
AppXaminer: The AppXaminer view provides graphical diagram
representaion of the JSF artifacts dependencies. For example you can see which
JSP page is using which navigation rule or managed bean. You can also navigate
to the locations where they are used.
Support for MyFaces and Sun RI: NitroX supports both MyFaces
and Sun's RI JSF implementations. It provides auto-deploy, debug, run, or
create new JSF apps using any of these implementations.
2.1 M1 (4/25/05)
AppXRay Enhancement
The AppXRay application analysis is now significantly faster (double
the speed on average). The improvement is gained in both the initial build
time as well as the incremental update when files are modified.
AppXRay analysis is now part of the Eclipse build system. This resulted
in the following benefits:
Building/Updating the AppXRay database now happens in the background.
The AppXRay builder can now be turned on/off thru the standard Eclipse
project properties (Project Properties > Builders
Debugger Enhancement
Added an Output Stream View for Tomcat 5.x.
This view shows the actual generated HTML while stepping in a JSP page.
You display this view from: Window > Show View > Debug > Output
Stream.
Note that you should first enable this feature in the Configuration tab
of your Tomcat 5.x Server Configuration (Window > Preferences >
NitroX > Server Configurations).
You can now choose a custom Tomcat configuration server.xml file to
be used when NitroX auto deploys the application (for run or debug).
This option is available for Tomcat 5.x in the Configuration tab of the
Server Configuration (Window > Preferences > NitroX > Server
Configurations).
The Sysdeo Devloader is now automatically configured by NitroX for applications
dependent on external libraries.
This feature is available for Tomcat 4.1.x & 5.x
You can now debug JBoss applications that use external libraries.
This feature is available for JBoss 3.2.4+ & 4.0.1
Misc.
Support for Eclipse 3.1 M6
Extended the UI for the NitroX project properties related to validation.
Added UI for the NitroX source code preferences (syntax highlighting
etc).
This is accessible thru Window > Preferences > NitroX > Source
Editor.
Support the web.xml <include-prelude> and <include-coda>
tags (used to implicitly include pages at the beginning and end of JSP
pages).
Pages using the extends attribute of the page directive
are now properly compiled.
Declarations of scriptlet variables inside the javascript tag are now
recognized.
NitroX 2.0.1, build 404 (3/24/05)
Eclipse 3.1: Support for Eclipse 3.1 (tested with the M4
and M5 releases).
Note that the Eclipse 3.1 M5 release is not supported for Linux Fedora Core
2.
This is the NitroX 2.0 final release. We enjoyed the ride, we hope that you
enjoyed it too!
Here are some of the final changes:
Update the documentation to include the new 2.0 features. This is accessible
from Help > Help Contents.
Support Struts Lazy Form Bean (currently available only in Struts 1.2.x
nightly builds).
Added a command in the Struts html:form smart editor to add/edit form validation.
Support for the JSP tags: jsp:directive.page, jsp:directive.include, jsp:directive.attribute,
jsp:directive.variable.
Fixed some issues with the source control systems VSS and CVS that made
them mistakingly think that the user is attempting to change a file when it
is first opened.
Fixed incorrect Java compilation errors when JSP tags are not properly closed.
Fixed invalid error when using [] in EL expressions like <c:out value="${children.rows[0].name}"
/>.
Added the validation.compile.jspQuotation project property
(in the .m7project file). This property controls whether to strictly follow
the JSP specification regarding the escaping rules used for string quoting
in JSP pages. The default is false (to be Tomcat friendly). If you are using,
for example, Resin and you get errors in tags like:
<jsp:includepage="<%= bean.getPath() + \"index.jsp\" %>" />. then
try to set the value to true.
Build 366 (2/4/05)
Complete JSTL: Full support for JSTL tags (core, fmt, xml
and sql) is now completed.
Complete tag contextual help: All the tag libraries supported
by NitroX now have contextual help (JSTL, JSP/JSP 2.0, web.xml, tld, Struts
config, Struts tiles, Struts validation etc).
The contextual help is accessible from the Tag Libraries view, the tag Smart
Editors, and by pressing F1 in the source or design editors. The entire tag
documentation is also accessible from "Help | Help Contents | NitroX User
Guide | Reference | Resources".
New External Variable: This command is accessible from
the menu in the Variables View title bar. It inserts a design time tag that
makes a variable available for tag attributes binding, and makes it visible
in the Variables View for insertion in the JSP pages.
This is usually used for external variables that were not detected by the
NitroX automatic detection mechanism, for example if the variable is set in
Java code inaccessible to NitroX.
Fix some usability issues with the installer and the license management.
Build 362 (1/28/05)
New Struts Navigation Editor: The Struts Navigation Editor
is accessible from the Navigation tab in the Struts config editor, and has
the following features:
Graphical editing of the Struts "navigational" artifacts: actions, forwards
and exceptions.
Graphical representation of the navigation flow with the ability to
drill down to any depth from a navigation node.
Integrates with AppXaminer to show the dependency of any node on any
of the other artifacts in the application.
Better usage of the display real estate.
web.xml Editor: The web.xml file now has a modeless, form
based, graphical editor which allows creation and modification of the various
deployment settings.
The source code editor is optionally available for simultaneous editing.
New Web Artifact: This command is present in the Eclipse
File>New menu. It allows you to create the following artifacts using in-depth
wizards customized for each case:
New Web Application Project: This command has been enhanced
to allow the creation of new web projects that use a combination of JSP (2.0/1.x),
JSTL (1.1/1.0) and Struts (1.2/1.1).
Debugger:
Sysdeo DevLoader support: The NitroX debugger and launcher now work
seemlessly with Sysdeo DevLoader.
If Sysdeo DevLoader is installed in Tomcat, its configuration file is
updated so that classes/jars from other projects or outside WEB-INF/lib
and WEB-INF/classes are visible to the web application at runtime.
Tomcat 5.5 support. Use the "Jakarta Tomcat 5" server configuration.
JBoss 4.0.1 support.
Misc:
Speedup the NitroX database updates when a Struts config file is modified.
Enhanced the xml completion and validation by taking the dtd/xsd containment
rules into account.
AppXaminer and Struts Navigation can now be printed.
Many pre-release bug fixes.
Build 352 (12/22/04)
JSP 2.0:
EL: This build provides full support for the JSP 2.0 Expression
Language as follows:
Code Completion: Context sensitive completion inside or outside
tag attribute values. Depending on the location in the EL fragment,
the completion proposals include variable names, bean properties,
EL functions, EL keywords.
Given the NitroX auto-detection of the variables available to a JSP
page, the EL completion is particularly neat.
Validation: Live validation and consistency checking of EL syntax
and semantic errors (variables usage, EL functions usage, etc).
Navigation: Ctrl-Click works as expected anywhere in an EL fragment
(navigate to variable/properties declarations, functions implementations
etc).
Syntax Highlight: Context sensitive styling of keywords, functions,
etc.
Debugging: When debugging a page with EL expressions, you can step-in
EL functions and step-return to the JSP page. Combined with the NitroX
debugger's JSP Variables view, this feature allows close inspection
of EL fragments.
NitroX provides this same support for JSP 1.2 applications when
used in JSTL 1.0, or Struts EL tag libraries.
Tag Files: This build provides full support for the JSP 2.0
tag files as follows:
Support for the tag files directives and tags (@tag, @variable,
@attribute, invoke). The support includes: Validation and consistency
checking, Smart Editors, Code Completion and Navigation.
Tag files (under WEB-INF/tags) are automatically available in the
Tag Libraries views, there is no need to declare these tags in any
of the TLD files. The Tag Libraries view is updated when modifying,
adding or removing tag files under WEB-INF/tags.
Modifying a tag file also validates all its usage.
Using NitroX, tags defined in tag files behave the same as classical
JSP tags, and have the same support: validation, completion, tag variables
available in the Variables View, etc.
Debugging: You can now step-in tag files just as you step-in the
Java code of a classical tag.
The debugger also understands the semantics of fragment attributes
and jsp:invoke. For example, step-in a jsp:invoke tag would step in
the JSP page containing the fragment at the location where the fragment
is defined. You can then continue to step in the fragment code or
step-return to the tag file.
EL Functions Editing: The TLD editor now contains a Functions tab that
allows graphical editing of the EL functions.
Enhanced Struts Config Editor: In addition to the Struts
Navigation editor, the Struts Config editor now has a Struts Config
tab that allows modeless, form based, creation and modification of all of
the Struts Config files tags. Smart Editors are now available for all of the
tags and attributes.
Source code editing is optionally available for simultaneous editing.
Struts 1.2 Wildcard Mappings Support:
Resolution of Struts actions in JSP pages takes into account wildcards
action mappings.
For example, if an action is defined as <action path="/Save*" name="{1}Form">, and a JSP page
is referring to it from
<html:form action="/SaveRegistration"> then NitroX will resolve
"/SaveRegistration" to the action "/Save*", allowing correct validation
and navigation.
Auto resolution of the wildcard parameter in the action's form bean.
In the example above, the form bean RegistrationForm would
be available in the JSP page using the wildcard action.
AppXaminer shows the dependencies on actions using wildcard mappings.
In the example above AppXaminer would show the dependency from the JSP
page to the wildcard action.
All references to a wildcard action are validated for correct usage.
In the example above, changing "/Save*" to "/Store*"
would report an error in the JSP.
Enhanced Tags Attribute Values: It is pretty common to
use nested tags as attribute values with HTML tags. For example: <img src="<c:url value='/hohoho.gif'/>" width="95" height="37"/>.
This build enhances the tags attribute values support as follows:
The nested tags now have code completion, are validated for consistency,
and are syntax colored.
The JSP design editor resolves the JSTL c:url and the
Struts html:rewrite when used as attribute values for JSP resources
(images, css etc), and renders the page properly by taking the actual
url values into account.
Misc.:
Added the "validation.missingFile" project
property, which is a boolean property controlling whether the missing
files errors are reported. The default value is true (i.e these errors
are reported).
Build 345 (11/29/04)
Enhanced Java in JSP pages:
Java completion and live compilation/validation are now done for JSP
expressions in tag attribute values.
Java Navigation: Control-Click navigation is now fully
functional in the Java portions in JSP pages (JSP scriptlets/expressions).
Enhanced Debugger:
Jetty 5.x Support: Debugging and Automatic Deployment
for the Mort Bay's Jetty 5.x server. As usual you create the server configuration
from "Window > Preferences > NitroX > Server Configurations".
The debugger now takes control when an unhandled exception occurs, and
displays the location in the Java class or JSP page where the exception
was caused. The Debugger's Thread view would show the full stack trace
including the JSP pages in the call chain.
Better WSAD Support:The Struts Tiles
and Validation config files editors are now available on WSAD/Eclipse 2.1
(no longer requires Eclipse 3.x).
AppXaminer Filters: The AppXaminer view now contains a
filter popup in its title bar which allows filtering out artifatcs and files
with specific extensions when viewing the dependencies diagram.
Build 339 (11/16/04)
AppXplorer: The AppXplorer is the NitroX equivalent of
the Eclipse Package Explorer used for Java development. In addition to showing
all the files in a web application, it also shows the web application artifacts.
For example, in a Struts application, AppXplorer displays the following artifacts
grouped by Struts module: Action Mappings, Form Beans, Tiles, Global Forwards,
Validation Forms, Validator Rules, Java Types, Resource Bundles, etc.
Using the context menu commands for an artifact, AppXplorer allows you to:
View, edit and navigate the web application artifacts independently
of their configuration/definition files. This helps focusing on application
constructs at a higher level, as opposed to getting constantly distracted
by the set of configuration files.
Navigate to an artifact definition. For example, double click a tile
in AppXplorer, and the corresponding tiles configuration file is opened
at the location where it is defined.
Create any of the artifacts using a graphical wizard. NitroX takes care
of which configuration file should contain the new artifact (no worries,
it will ask you if there is an ambiguity).
View a graphical diagram of the artifact's dependencies in AppXaminer.
Find all references to an artifact (JSP pages, Config files, Java code
etc).
By default, the AppXplorer is visible and docked in the Package Explorer panel.
If for any reason this is not the case, you can display it
from the Window menu by following the path: "Window/Show View /Other.../Web/AppXplorer".
AppXaminer: AppXaminer
is one of the most useful features in NitroX. We believe it is essential for
web application development.
Using a graphical diagram, the AppXaminer view displays all the references
to and from an artifcat. For example, right click a Struts Action
in AppXplorer, and choose Show AppXRay Dependencies, and AppXaminer
would then display all the JSP pages and Struts Actions referring to this
Action, in addition to all the JSP pages, Form Bean and Java classes used
by it.
AppXaminer also has the following capabilities:
Synchronization with AppXplorer: Clicking any node in AppXplorer (a
JSP page or any other artifact) synchronizes the AppXaminer view to show
the dependencies of the selected node. Enjoy clicking around.
Nodes in the diagram are expandable, so you can "drill down" to any
level of the artifacts inter-relationships.
Navigate to the underlying source code making a dependency. For
example if a JSP page is referring to a Struts Action in multiple locations,
the diagram allows you to see and navigate to any of these locations.
Navigate to an artifact definition. For example, double click a Validation
Rule in the diagram, and the corresponding validation configuration file
is opened at the location where it is defined.
AppXnavigator: This build adds full navigation capabilities
to all of the NitroX editors, for JSP, Struts and JSTL. This pretty much works
as you would expect, as follows:
Source Editor: Control-Click on a tag attribute value, a tag name, a
tag prefix, or a tag attribute name opens the file containing the clicked
item's definition.
This capability is available for the full range of artifacts that NitroX
understands, including: Java classes, resource bundles, Struts actions/tiles/form
beans/forwards/validation-rules, JSP/HTML pages, image files, css files
etc.
For example, control-click an action attribute value in an
html:form tag would open the Struts config file at the location
defining the action, and control-click the type attribute
value in a jsp:useBean tag would open the type's .java file.
Graphical Editors: Navigation is also available in the different graphical
editors, as well as the tags smart editors. If an item is navigable, its
label in the graphical editor is rendered as a hot link that opens the
definition location. Like the source editor case, this is available for
all the navigable artifacts.
In the coming NitroX build we will also add the control-click capability
to the Java code inside scriptlets.
Struts Validation Framework 1.1/1.0 (NitroX for Struts
only): Full support of the Struts Validation Framework as follows:
Validation configuration graphical editors: When a Struts validation
configuration file is opened, an editor with the following 3 tabs is displayed:
Forms: Allows a modeless, form based, creation and modification
of form beans validation. Source code editing is optionally available
for simultaneous graphical/source editing.
This editor offers visual editing of field validators, error messages
and their arguments, and validator variable values.
Validators: Allows a modeless, form based, creation and modification
of validator rules. Source code editing is optionally available for
simultaneous graphical/source editing.
This editor offers visual editing of the validation method, default
error message, Java Script, etc.
Source: For source code only editing.
Support of the Struts 1.2 POJO beans: With Struts 1.2 and NitroX, you
can specify any Java bean to be a form bean and specify validation information
for its properties. It works.
Validation awareness in the Struts configuration files: At any time
you can add or edit form beans validation information thru the Form Bean
Smart Editor.
Validation awareness in the JSP files: When inserting an html:form
associated with a form bean that has validation information, the insertion
wizard offers to insert the error messages, and the java script validation.
Consistency checking: NitroX automatically validates all of the Validation
Framework tags for consistency and validity. This is important to ensure
that a part of a web app can be changed/refactored without causing troubles
at runtime.
Some of the warnings/errors reported by NitroX are:
An invalid form bean is used (not present, or not extending the
proper Java class).
An invalid validator is used.
A validator required variable value is not specified (for example
the min variable of the intRange validator).
An invalid form bean property is used.
An error message argument is not specified.
An invalid resource key is used in any of the error messages or
their arguments.
Code completion: All of the Validation tag attributes have code completion
in the source editor: resource keys, bean properties, form names, etc.
Modules and multiple validation config files support: In Struts, validation
forms and validator rules could be specified per Struts module, and they
could be split into multiple configuration files for each module. NitroX
supports this file organization and understands which config files are
visible to which module (including the case where some files are shared
between multiple modules). This is taken into account, for example, in
the consistency checking, and the wizards' forms and validators pickers.
Plain Old Java Objects (POJO): Struts 1.2 added the powerful feature
of allowing form beans to be any java bean, removing the need to subclass
org.apache.struts.action.ActionForm/org.apache.struts.validator.ValidatorForm
etc.
All the existing NitroX features for Struts-derived form beans are now
available also for POJO beans. For example, the auto creation of forms
in jsp pages, drag and drop bean properties from the Variables View, adding
bean properties validation using the Struts Validator editors, etc.
Module attribute: Struts 1.2 added a module attribute to some of the
tags (for example html:link,html:img, forward
etc), to make it possible to link to different modules.
This build understands these attributes in the tags editing wizards, and
when validating the tags for consistency.
For example, if you are using Struts 1.2, the Struts Config forward
tag Smart Editor would show a module combo box showing the available modules,
and the forward path editor would take the module value into account when
showing the possible choices.
Struts 1.2 templates: The New Web Application Wizard now has application
templates for Struts 1.2.
More Contextual Help: Added help content for the tags in
the following tag libraries: JSTL, Struts JSP Tiles, Struts Tiles config,
Struts Validation config.
You show the help content for a tag by clicking the help icon in the Smart
Editor or in the Tag Libraries View, or by pressing F1 when inside a tag in
the source editor.
Misc.:
Fixed a bug that was causing java compilation errors when scriptlets
are used inside tags.
For example: <BODY <%if(isOK){%>onload="initDoc()"<%}%>>
Build 329 (10/21/04)
Struts Tiles (NitroX for Struts only): This build includes
full support of Struts Tiles as follows:
Tiles configuration graphical editors: When a Struts tiles configuration
file is opened, an editor with the following 3 tabs is displayed:
Definitions: Allows a modeless, form based, creation and modification
of tiles. Source code editing is optionally available for simultaneous
editing.
Diagram: A graphical diagram editor of the tiles specified in the
config file. This also displays the tiles inter-relationships (tile
B extends from tile A etc). Source code editing is optionally available
for simultaneous editing.
Source: For source code only editing.
The graphical editors offer the capability of creating and modifying tiles
using wizards that understand the tiles inheritance mechanism, as well
as the tile attributes used in the tile template pages.
For example, if you insert a tile that uses a template page layout.jsp
then the wizard will remember for you that the page has 3 attributes header,
body and footer, and will help you specifying
them using JSP pages or other tiles.
Or, right click on a node in the Diagram editor and choose the "Extend"
command. The wizard will allow you to overload the tile attribute values
specified in the parent tile and will insert the entire child definition.
Tiles awareness in the Struts configuration files: When editing the
Struts configuration files, NitroX will know which tag attribute can have
a tile name value and offers a "tile picker". For example, the path
attribute of the forward tag has a custom editor that allows
you to choose whether to forward to a JSP page, an action or a tile.
Tiles viewer: One of the most powerful features of Struts Tiles is the
possibility of specifying tiles definitions in the xml tiles configuration
file. This effectively specifies "virtual" JSP pages that are assembled
dynamically at runtime when a tile is requested.
At the same time, this makes it impossible for a developer to visualize
the tiles, and know what they mean until the application runs.
NitroX overcomes this issue by offering a tiles viewer that assembles
a tile from its definition and renders it using the NitroX JSP Design
Editor.
You can view a tile by double clicking its icon in the tiles config file
Diagram Editor, or in a Struts config file Design Editor (when an action
forwards to a tile for example).
Tiles JSP tag library: The tiles tags tiles:get, tiles:getAsString,
tiles:importAttribute, tiles:insert, tiles:useAttribute
are supported as follows :
Insertion Wizards and Smart Editors that understand the tags semantics.
For example, tiles:insert has an associated wizard that
can edit the nested put tags using JSP pages or other
tiles.
Knowledge of the variables exposed by tiles:importAttribute
and tiles:useAttribute. The variables beans (and their properties)
are then displayed in the Variables View, and can be inserted in the
JSP page, or used to bind tag attribute values to bean properties.
Custom rendering in the JSP Design Editor. For example the tiles:insert
tag shows the assembled target tile content.
Consistency checking: NitroX automatically validates all of the tiles
tags (both the JSP tag library and the tiles config tags) for consistency
and valid attribute values. For example, if you create a tile definition
using a JSP page as a template, NitroX ensures that all the required template
attributes are specified in the definition and that they have valid values.
It also ensures that all paths used in a tile definition are valid JSP
pages, tile definitions, or actions.
Modules and multiple tiles config files support: In Struts, tile definitions
could be specified per Struts module, and they could be split into multiple
configuration files for each module. NitroX supports this file organization
and understands which config files are visible to which module (including
the case where some files are shared between multiple modules). This is
taken into account, for example, in the consistency checking, and the
wizards' tile pickers.
Hot Deployment of Configuration Files (NitroX for Struts
only): If a Struts config file or tiles config file is modified while the
web application is running (debug mode or not), then NitroX automatically
re-deploys the application.
This means that you no longer need to restart the server when you add or modify
an action or a tile.
Note that this works only under Tomcat 4.1, Tomcat 5 and Resin 3.
TLD Graphical Editor: The tag library definition (.tld)
files now have a modeless, form based, graphical editor which allows creation
and modification of the library's tags, their attributes and variables.
The source code editor is optionally available for simultaneous editing. See more on the TLD editor.
Display, Execute and Inspect: The NitroX JSP debugger now
supports these commands (available in the Eclipse Java debugger). They work
on the current selection in a JSP page, when the app is stopping at a breakpoint.
Usually your selection would contain a Java expression in a scriptlet or in
a tag attribute value.
.jspf and .tag Files: The .jspf and .tag are now recognized
by the NitroX editor as JSP files.
Changing the Default Browser: When you run or debug a web
application, NitroX launches IE on Windows and Netscape on Linux. You can
change the command that NitroX uses to launch the browser by changing the
property platform.browser.command in the preference file located
at {workspace directory}\.metadata\.plugins\org.eclipse.core.runtime\.settings\com.m7.nitrox.prefs.
For example, on Linux, you can change it to: platform.browser.command=firefox
${url}
which would execute the command after replacing ${url} by the proper page
url.
Build 318 (10/4/04)
Allow NitroX installation on Linux systems other than Red Hat 9 or Fedora
Core 2. Note that only these 2 configurations have been tested by M7.
Build 316 (9/20/04)
Linux: The Linux versions of NitroX for Struts and NitroX
for JSP are now available.
This version requires Red Hat 9 or Fedora Core 2 (or later versions). It also
requires JDK 1.5, but this requirement is transparent as a built-in JDK 1.5
is automatically used by the NitroX launcher.
Resin 3.0: Debugging and Automatic Deployment for the Caucho
Resin 3.0 application server. As usual you create the server configuration
from "Window > Preferences > NitroX > Server Configurations".
Initial EL: This build introduces the Expression Language
(EL) support in NitroX. EL support is available only when EL is enabled in
a JSP page. as specified in the JSP 2.0 specification (section JSP.3.3.2):
"Each JSP page has a default setting as to whether to ignore EL expressions.
The default mode for JSP pages in a Web Application delivered using a web.xml
using the Servlet 2.3 or earlier format is to ignore EL expressions. The default
mode for JSP pages in a Web Application delivered using a web.xml using the
Servlet 2.4 format is to evaluate EL expressions . Page authors can override
the default mode through the isELIgnored attribute of the page
directive".
Note that EL is always enabled in JSTL and Struts EL tags as they have a built-in
EL evaluation that does not rely on the JSP container.
The following summarizes the EL support in this build:
EL expressions are generated by NitroX when a tag attribute value is
bound to a variable. You bind an attribute value to a variable by using
the "thunder" button available in the Property Sheet (when an attribute
value field is activated), and in the Smart Editor.
EL expressions are validated when used in a tag attribute value. For
example ${user.address.zipcode} would report an error if the Java class
behind "address" does not have a "zipcode" property.
Initial JSTL 1.0/1.1: The JSTL tags c:forEach, c:forTokens,
c:import, c:out, c:set, fmt:formatDate, fmt:formatNumber, fmt:message, fmt:setBundle
are now supported as follows :
Insertion Wizards and Smart Editors that understand the tags semantics,
and generate the proper EL expressions based on GUI selections of beans
and bean properties.
Knowledge of the variables exposed by the tags and their scope. The
variables beans (and their properties) are then displayed in the Variables
View, and can be inserted in the JSP page, or used to bind tag attribute
values to bean properties.
Validation of the tags usage according to their JSTL specifications.
Dynamic code completion (for example completion of the key
attribute of the fmt:message tag would propose the resource keys
of the active resource bundle used in the page).
Custom rendering in the Design Editor.
In addition, following are things to notice:
c:import: The content of the included page is displayed in
the Design Editor when the including page is rendered.
When debugging, stepping in a c:import tag steps in the included JSP page.
c:forEach: When the items attribute represents a java.util.Collection,
you can specify the type of the collection element in the Insertion Wizard
or the Smart Editor. You can then drag and drop bean properties from the
Variables View.
fmt:message: The resource content corresponding to the resource
key is rendered in the JSP Design Editor.
Struts EL (NitroX for Struts only): The Struts HTML, Logic
and Bean EL libraries are now supported.
Debug Server-Generated Java: You can now view and debug
the Java code generated by the servlet container for a JSP page. This is done
by toggling the menu item "Show Java Source" while debugging a JSP page. This
menu item is in the drop down menu located in the title bar of the Debug panel.
Run To Line: The "Run > Run To Line" menu command now
behaves similar to the Java debugger when executed while debugging a JSP page.
Project
Properties: The .m7project file (found in the root level of a web
application directory) now contains project properties that control some of
the JSP validation and consistency checking aspects.
Note that in order for NitroX to start taking the changes made in the project
file into account, you'll need to either exit/relaunch Eclipse, or close/reopen
the project.
The following properties now exist in the project file and can be changed
if needed:
validation: A boolean property indicating whether validation
is performed for NitroX managed documents (JSP, XML etc). The default
value is true.
If you set this value to false, then the other validation.xx
properties are ignored.
validation.compile: A boolean property controlling whether
Java compilation is performed as part of the JSP page validation. The
default value is true.
validation.unresolvedVar: A boolean property controlling whether
the "The variable {0} cannot be resolved" errors are reported. The default
value is false (i.e these errors are not reported by default).
Preferences: The preference file located at {workspace
directory}\.metadata\.plugins\org.eclipse.core.runtime\.settings\com.m7.nitrox.prefs
can now contain the following properties. Note that you need to have a property
in this file only if its value is different than its default value.
editor.source.reconcileDelay=500: The idle time in milli seconds
after which the source and design editors are synchronized after source
code modifications.
editor.source.maxLineLen=80: The maximum number of characters
in a source code line, after which the line is wrapped.
This is only used for the source code generated by NitroX.
editor.source.indentChar=space: The character used for indentation
in the source code. Allowed values are space and tab.
This is only used for the source code generated by NitroX.
editor.source.indentCount=2: The number of characters used
for source code indentation. The character used for indentation is specified
by the "editor.source.indentChar" property mentioned above.
This is only used for the source code generated by NitroX.
editor.design.showToolTips=true: A boolean property controlling
whether to show tooltips for the objects rendered in the Design Editor
(JSP, Struts config etc).
varView.showToolTips=true: A boolean property controlling whether
to show the tooltips in the Variables View.
outlineView.showToolTips=true: A boolean property controlling
whether to show the tooltips in the Outline View.
Design Time Tags: NitroX defines a set of optional design-time
tags that can be inserted in a JSP page to change some of the NitroX behavior.
All tags should be placed in a JSP comment, and should have a nitrox
prefix.
nitrox:var: Defines an external variable that was not detected
by the NitroX automatic detection mechanism (for example if the variable
is set in Java code inaccessible to NitroX). Adding this tag would make
the variable visible in the Variables view so that it can be used for
binding and page display. This tag has 2 attributes, name and type that
indicate the variable's name and Java type.
ex: <%-- <nitrox:var name="date" type="java.util.Date"/>
--%>
nitrox:set-property: Changes the value of one of the NitroX
page properties:
