<?xml version="1.0"?>
<!--
   Copyright 2004 The Apache Software Foundation
  
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
  
       http://www.apache.org/licenses/LICENSE-2.0
  
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-->
<!DOCTYPE document PUBLIC "-//APACHE//DTD Documentation V1.2//EN" "./dtd/document-v12.dtd">
<document>

 <header>
  <title>Jakarta Tapestry - What's New</title>
 </header>

<body>

... or perhap's, "What's Old". These are release notes from earlier versions of Tapestry. More recent changes
are in a different format, on the <link href="site:changes">Change Log page</link>.

<section><title>Release 3.0-beta-1</title>
<ul>
<li>Major refurbishment of the Virtual Library example to use all the latest and greatest Tapestry facilities.</li>
<li>Removed the "rows" and "columns" parameters from TextArea; use informal parameters "rows" and "cols" instead.</li>
<li>Removed unused/unneeded exceptions <code>RollbackException</code> and <code>PageRecorderSerializationException</code>.</li>
<li>The default for the <link href="http://jakarta.apache.org/tapestry/doc/ComponentReference/Hidden.html">Hidden</link> component is now to encode its parameter.</li>
<li>Ugraded to OGNL 2.4.2.</li>
<li><link href="http://jakarta.apache.org/tapestry/doc/ComponentReference/Shell.html">Shell</link> comp;onent now allows multiple stylesheets.</li>
<li>Added a <link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/util/io/DataSqueezer.html">DataSqueezer</link> adaptor for
<code>Enum</code> types.</li>
<li>Switched over to using JBoss 3.0.6 for demos.</li>
<li>Renamed method <code>generateAttributes()</code> to <code>renderInformalParameters()</code> in
<link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/AbstractComponent.html">AbstractComponent</link>.</li>
<li>Added support for the informal parameters of a component to be passed down to a contained component
using the inherit-informal-parameters attribute. </li>
<li>Added <link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/IRequestCycle.html">IRequestCycle</link>.activate() as a replacement for setPage(). 
Besides setting the page to be rendered, it also invokes page.validate() and handles the page redirections.</li>
<li>Added addValidateListener() and removeValidateListener()
to <link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/IPage.html">IPage</link>.</li>
<li><link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/util/io/DataSqueezer.html">DataSqueezer</link>: Squeezed strings are now always prefixed with 'S'</li>
<li>Added mechanism for checking that super-class implementations of key methods are invoked.</li>
<li>Added checks that <link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/IPage.html">IPage</link> methods
<code>validate()</code> and <code>detach</code> are properly overriden by subclasses.</li>
<li>Changed Form, Hidden and ListEdit so that all hidden fields are written out with the &lt;form&gt; tag.</li>
<li>Added new features to the script specification, bumping its DTD to 1.3. It is now possible
to generate page-unique ids from within the script (using the new <code>unique</code> attribute
on <code>&lt;let&gt;</code>, as well as to
render a block only once per page render (using <code>&lt;unique&gt;</code>)
</li>
<li>Integrated Per Norrman's vastly improved <link href="http://jakarta.apache.org/tapestry/doc/ComponentReference/DatePicker.html">DatePicker</link> component</li>
</ul>

<pre>
[ 18340 ] ApplicationRuntimeException doesn't compile on jdk 1.3.
[ 18336 ] Tapestry 2.4a5 - LOGGING images missing for Inspector component
[ 18490 ] compile warning for Workbench 
[ 18013 ] typo in EvenOdd javadoc
[ 18607 ] Check for unimplemented abstract methods    
[ 17904 ] Ongoing LGPL Issues 
[ 19153 ] Easier way to override validation messages  
[ 19263 ] Change error message for null parameter 
[ 18880 ] DatePicker broken under Mozilla  
</pre>

</section>
<section><title>Release 2.4-alpha-5</title>

<ul>
<li>Added some simple optimizations to keep the engine instance from being stored
into the session unecessarily often.</li>
<li>Fix NPE when image parameter of Image component is bound but value is null.</li>
<li>Create a basic JSP tag library to allow JSPs to access Tapestry pages using the page and external services.</li>
<li>Added support for primitive arrays, java.lang.Object[] and java.lang.String[] 
for connected parameters.</li>
<li>Added connected parameter support for missing primitive types byte and char</li>
<li>Added support for primitive arrays, java.lang.Object[], and java.lang.String[] for declared properties.</li>
<li>Replaced JFreeChart with JCharts, due to licensing considerations.</li>
<li>Refactored to use Jakarta Digester to parse specifications.</li>
<li>Changed specification and template parsers to track locations of specification objects and attach them 
to runtime objects and exceptions for error reporting purposes.</li>
<li>Severely refactored exceptions, removing many exception classes and flattening all others
 under ApplicationRuntimeException.</li>
<li>Simplified the URL format, merging the "service" and "context" parameters together.</li>
<li>Removed the "displayWidth" and "maxLength" parameters from TextField and ValidField
(HTML attributes "size" and "maxlength", as informal parameters, are sufficient).</li>\
<li>Added two new application extensions to allow page and component specifications and templates
to be provided in non-standard ways (when not found using the default rules).</li>
<li>Changed file upload to work using Jakarta Commons FileUpload (patch provided by Joe Panico).</li>
<li>Added new parameter direction: <code>auto</code>, which creates a synthetic property backed by
 the binding.</li>
</ul>

<pre>
[ 18249 ] file upload using Commons FileUpload 
[ 17905 ] Link to mailing list and archives is wrong.  
</pre>

</section>
<section><title>Release 2.4-alpha-4</title>

<ul>
<li><b>All packages have been renamed from <code>net.sf.tapestry</code> to <code>org.apache.tapestry</code></b>.</li>
<li>Several non-ASL libraries (including Jetty) have been removed from both CVS and the distribution.  To
build Tapestry and run the demos is now more involved; it requires obtaining several external dependencies.
The Tapestry distribution is much smaller, however.  This was done for licensing reasons.
Sorry.</li>
<li>Expression bindings in HTML templates are now in the format
<code><i>attribute</i>="ognl:<i>expression</i>"</code>.</li>
<li>String bindings (to localized strings) in HTML templates are now in the format
<code><i>attribute</i>="string:<i>key</i>"</code>.</li>
<li>Allow &lt;set-property&gt; element of specification to specify the expression as an attribute or
as wrapped character data.</li>
<li>The interfaces for <link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/valid/IValidationDelegate.html">IValidationDelegate</link>,
 <link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/valid/IValidator.html">IValidator</link> and
  <link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/valid/ValidatorException.html">ValidatorException</link>
changed incompatibly.  This will only be an issue if you have created custom validation delegates or custom
validators.</li>
<li>Added methods to <link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/valid/IComponentStrings.html">IComponentStrings</link> for formatting localized strings
with arguments.</li>
<li>Remove ejb.jar and any direct dependencies on javax.ejb classes (application servers are responsible for properly replicating
EJBObject and EJBHome instances).</li>
<li>Added a <code>createRequestCycle()</code> method to 
<link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/engine/AbstractEngine.html">AbstractEngine</link>.</li>
<li>Moved the invocation of the 
<link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/IMonitor.html">IMonitor</link> method  <code>serviceEnd()</code>
to always occur after the invocation of <code>serviceException()</code>.</li>
<li>The <link href="http://jakarta.apache.org/tapestry/doc/ComponentReference/Upload.html">Upload</link> component now works with the enclosing Form
to automatically set the encoding type to <code>multipart/form-data</code>.  It is no longer necessary to set
the <code>enctype</code> attribute of the Form.</li>
<li>Removed the code related to making copies of persistent properties.</li>
<li>Removed non-ASL libraries from CVS.  These files will need to be downloaded separately.</li>
<li>Removed some of the old tutorials, leaving just the Workbench and Virtual Library as examples.</li>
<li>Removed the "Demo" pages from the web site, until we find a stable home.</li>
</ul>		
	
</section>
<section><title>Release 2.4-alpha-3</title>

<ul>
<li>
Reorganized the packaging into a binary distribution (which includes documentation) and a second,
smaller, source-only distribution.</li>
<li>Renamed the JARs, stripping off the "net.sf." prefix.</li>
<li>Updated all examples to use the 1.4 Specification DTD.</li>
<li>Refactored (severely) the relationship between services and link components, splitting
 the rendering portion of links into a separate interface.</li>
<li>Upgrade to McKoi database 0.94h.</li>
<li>Tapestry will now create properties for connected parameters, if the properties
 do not already exist (or are abstract).</li>
<li>Renamed the <code>java-type</code> attribute of the <code>&lt;parameter&gt;</code> element (in component
 specifications) to <code>type</code> (for the 1.4 DTD).</li>
<li>Allowed more elements to specify values as character data inside the element as an alternative
to using a particular attribute (useful for complex OGNL expressions).</li>
<li>Continued extending the JUnit test suite.</li>
<li>Deprecated the <code>PageCleanupListener</code> interface and removed support for it.</li>
</ul>
		
<pre>
[ 665622 ] net.sf.tapestry.html.Frame uses old DOCTYPE
[ 675882 ] option component generates invalid HTML
[ 622691 ] Full release
[ 679655 ] Upload component very slow on file uploads
</pre>		
		
</section>
<section><title>Release 2.4-alpha-2</title>

<ul>
<li>Made improvements to how Tapestry handles arrays of objects and scalars</li>
<li>Upgrade demos to deploy into JBoss 3.0.4</li>   
<li>Merge in changes from Tapestry 2.3</li>
<li><code>&lt;binding&gt;</code> elements may now specify the expression as the parsed data
instead of the expression attribute</li> 
<li>The template extension may now be overriden using the configuration property <code>net.sf.tapestry.template-extension</code></li>
<li>Added support for declarative transient and persistent properties via <code>&lt;property-specification&gt;</code> element in page and component specifications.  Tapestry will create (on the fly) a subclass with the necessary accessor methods and fields, as well as any necessary notification and cleanup methods. </li>
</ul>

<pre>
[ 594878 ] Deploy Tapestry into JBoss 3.0.4
[ 672743 ] Pages Implementing Listeners cause NPE
</pre>

</section>
<section><title>Release 2.4-alpha-1</title>

<ul>
<li>
Added support for specifying expressions in the component template.  Expressions
are specified as attributes with the format "<code>[[ <i>expression</i> ]]</code>".
The brackets and leading and trailing whitespace are removed.
Expressions specified this way are the equivalent of the
<code>&lt;binding&gt;</code> 
        element in a specification. 
</li>
<li>
Tapestry now supports <i>implicit components</i>.  Implicit components are
declared exclusively in the containing component's template (instead of in
the containing component's specification) using a special
<code>jwcid</code> syntax:
<code>@<i>type</i></code> (for anonymous components) or
<code><i>id</i>@<i>type</i></code> (for named components). Implicit 
        components are especially useful for components that take no parameters, 
        but may also make use of template expressions. 
</li>
<li>
Added support for the <code>&lt;listener-binding&gt;</code> element in page 
and component specifications.  This allows a listener method to be provided,
directly within the specification, as a script written in a 
<link href="http://jakarta.apache.org/bsf">BSF</link>-supported language. 
</li>
<li>
A number of non-backwards compatible changes were made to several
framework interfaces to support more flexibility on where specifications
and templates may be located, but these should not affect the overwhelming
majority of Tapestry users.  In addition, private assets and context assets
may also be relative. <br/>
Private assets are relative to the component 
specification which declares them, context assets are relative to the 
application servlet (within the servlet context). 
</li>
<li>
Moved the Inspector out of the framework and 
into the contrib library. 
</li>
<li>
Created smarter checks for stale sessions for 
ActionLink, DirectLink and Form. The action and direct services used by
the components now encode whether the application was stateful into the
URL. The stateful check only occurs if the application was stateful when
the URL was rendered. 
</li>
<li>
Changed Form to record the exact ids generated during the render (it used to just store the count).
This allows a more useful exception message to be generated 
for the
<link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/StaleLinkException.html">StaleLinkException</link>. 
</li>
<li>
Changed the default StaleLink page to have a 
        message property, and to display the message from the 
        StaleLinkException. 
</li>
<li>
Components (and even pages) can now implement page listener interfaces
(<link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/event/PageDetachListener.html">PageDetachListener</link>,
<link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/event/PageRenderListener.html">PageRenderListener</link> or
<link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/event/PageCleanupListener.html">PageCleanupListener</link>)
and <code>finishLoad()</code> will <i>automatically</i> add them as a listener to the 
        corresponding page events. 
</li>
<li>
The entire mechanism used to store persistant 
        page properties has been revised. 
</li>
<li>
Implemented a number of improvements to
<link href="http://jakarta.apache.org/tapestry/doc/api/org/apache/tapestry/util/pool/Pool.html">Pool</link>
to support greater flexibility in managing objects stored into and discarded
from the pool.
</li>

</ul>

<pre>
[ 653358 ] IPage.getName() == qualified name
[ 608768 ] Changes saved AFTER IPage.detach()
</pre>

</section>
<section><title>More ...</title>
<p>
<link href="more_new.html">Earlier entries</link>
</p>
<!-- END Content -->
</section>
</body>
</document>
