NitroX-What's New

NitroX 2.1

2.1 M3 (6/1/05)
2.1 M2 (5/13/05)
2.1 M1 (4/25/05)

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.

NitroX 2.0

Build 371 (3/2/05) - 2.0 Final Release
Build 366 (2/4/05)
Build 362 (1/28/05)
Build 352 (12/22/04)
Build 345 (11/29/04)
Build 339 (11/16/04)
Build 329 (10/21/04)
Build 318 (10/4/04)
Build 316 (9/20/04)

Build 371 (3/2/05) - 2.0 Final Release

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:include page="<%= 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:
  • Web pages (JSP, Struts, HTML).
  • JSP 2.0 tag files.
  • TLD files.
  • Struts modules.
  • Struts configuration files (struts-config, tiles, validation).
     
• 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).
   
• See more on AppXplorer.
   
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.
     
  • See more on AppXaminer.
     
• 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.
     
  • See more on AppXnavigator.
    
     
• 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.
     
  • See more on Validation support.

• Struts 1.2:
  • 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.
     
  • See more on Tiles support.
     
• 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:
    • validation: Overrides the validation project property.
      ex: <%-- <nitrox:set-property property="validation" value="false"/> --%>
    • validation.compile: Overrides the validation.compile project property.
      ex: <%-- <nitrox:set-property property="validation.compile" value="false"/> --%>
    • validation.unresolvedVar: Overrides the validation.unresolvedVar project property.
      ex: <%-- <nitrox:set-property property="validation.unresolvedVar" value="true"/> --%>