<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- $Id$ -->
<html>
<head>
	<title>Tapestry: What's New</title>
<link rel="STYLESHEET" type="text/css" href="scripts/style_virtlib_pcIE55.css">
</head>

<body bgcolor="#839cd1" leftmargin="0" topmargin="0" marginwidth="0" marginheight="0">
<table width="100%" border="0" cellspacing="0" cellpadding="2">
	<tr>
		<td valign="top" align="left"><img height="44" src="images/ico_t.gif" alt="[Tapestry Logo]" width="44" align="absMiddle" border="0">&nbsp;<img height="22" alt="Tapestry" src="images/hd_tapestry.gif" width="100" align="absMiddle" vspace="17" border="0">

<h3>Release 2.1-beta-2</h3>

Note the change in Tapestry release naming,
described in detail in the
<a href="doc/ContributorsGuide/releases.html">Tapestry Contributor's Guide</a>.

<pre>
[ 574792 ] localized strings don't work
[ 573860 ] Shell component hardcodes DTD
[ 573858 ] No way to remove PageDetachListener
[ 573753 ] client TCP reset causes SocketException
[ 573653 ] broken assets
[ 574181 ] ValidationDelegate should eval form name
[ 575228 ] Validation messages not localized
</pre>

<h3>Release 2.0.5</h3>

Updated Tapestry to automatically configure the demo for
<a href="http://www.jboss.org">JBoss</a> 3.0.0 (this includes
a switch to the JDK 1.3 compiler, for compatibility with
the JBoss libraries).

<p>
Cleaned up the look of the default exception page.
Reorganized the home page, to link to the new 
<a target="_top" href="wiki_frame.html">Tapestry Wiki</a>,
and to move more static content onto SourceForge.

<pre>
[ 563552 ] IllegalStateException not beeing caught
[ 559647 ] Switch to JBoss 3.0.0
[ 566158 ] ValidField NPE if no delegate
[ 566943 ] Submit problem with tag type
[ 566000 ] Add field to Spec classed to record DTD
</pre>

<h3>Release 2.0.4</h3>

Significant improvements to localization support, including support
for localized properties files for each component, the
&lt;string-binding&gt; element for accessing localized strings,
and a new form of markup in the template
to access localized strings.

<pre>
[ 556766 ] Improve localization support
[ 560256 ] Make some property bindings invariant
[ 560255 ] ListEdit: doesn't render element
[ 559575 ] Component Frame cannot render
[ 558165 ] TextField value attribute not required
[ 560506 ] Cannot disable Checkbox component
[ 560217 ] Upload problems depending on browser
[ 550279 ] Define serialVersionUID for classes
</pre>

<h3>Release 2.0.3</h3>

Renamed Java packages from <code>com.primix.tapestry.*</code>
to <code>net.sf.tapestry.*</code>, along with some significant other
reorganizations, especially to the way component parameters are handled.

<p>
Added an initial <a href="doc/ContributorsGuide/ContributorsGuide.html">Contributor's Guide</a> for Developers
wishing to contribute code to the Tapestry project.

<pre>
[ 549479 ] Rename packages to net.sf.tapestry
[ 550280 ] Remove IDirectListener
[ 555165 ] Simplify setupLogging()
[ 553310 ] Set properties from parameter bindings
[ 552851 ] Add frame component
[ 549312 ] Delete support for old specifications
[ 556359 ] Inspector doesn't raise at javanuke
[ 555167 ] Maintain JDK 1.2.2 compatibility
</pre>

<h3>Release 2.0.2a</h3>

<pre>
[ 549482 ] NPE in RequestCycle.observeChange()
</pre>

<h3>Release 2.0.2</h3>

Changed the inspector icon into an animated GIF for compatiblility with more browsers.

<p>
Created the new <a href="doc/api/net/sf/tapestry/link/GenericLink.html">GenericLink</a> component, which allows links to arbitrary URLs (including JavaScript event handlers), but
is still an <a href="doc/api/net/sf/tapestry/components/IServiceLink.html">IServiceLink</a> which means it can wrap 
<a href="doc/api/net/sf/tapestry/html/Rollover.html">Rollover</a> components.

<pre>
[ 463649 ] NN6 &amp; ShowInspector
[ 544394 ] Release notes / deleted methods
[ 548183 ] Component specification of Option error
[ 548188 ] Component Option implementation error
[ 549144 ] tutorial load-on-startup and WL issue
[ 549142 ] WL issue with default tapestry jar name
[ 549314 ] Spec parse error
[ 521456 ] Allow IRequestCycle.discardPage() from listeners
</pre>
		
		
<h3>Release 2.0.1</h3>

Removed a lot of deprecated code.

<pre>
[ 536289 ] remove Jetty dependencies
[ 537398 ] Fix synch/double check bugs
[ 537426 ] Remove object pooling
[ 539600 ] java-class should be java-type in docs
[ 494221 ] Add PDF (or printable) documentation
</pre>

<h3>Release 2.0.0</h3>	

Added the <a target="_top" href="quotes_frame.html">Quotes</a> page to this website.  Added two new tabs to the
Workbench, demonstrating redirects and exception reporting.  
Marked a number of methods (related to object pooling) as deprecated.

<p>Minor formatting changes to the web site and Virtual Library.

<h3>Release 1.0.10</h3>

Changed the build to include debugging symbols with the frameworks.  Fixed a deployment problem with
the Tutorial.  Added descriptions to most components and parameters.  Modified the Inspector to
display component and parameter descriptions.

<p>Added a new page to the Workbench Tutorial: Chart.  The Chart page allows a user to dynamically
create a pie chart.

<p>Made it easier to create subclasses of 
<a href="doc/api/net/sf/tapestry/AbstractResponseWriter.html">AbstractResponseWriter</a>.

<pre>
[ 532562 ] Submit.jwc contains error
[ 532587 ] Submit throws NPE
[ 532815 ] ValidationDelegate errors
[ 532758 ] add descriptions to builtin components
[ 499655 ] HTMLResponseWriter enhancements
</pre>

<h3>Release 1.0.9</h3>

<p>The framework and contrib jar files are now named with the release number (i.e.,
<code>com.primix.tapestry-1.0.9.jar</code>).  In addition, 
the source code for these frameworks, and the examples, is now distributed as 
Jar files instead of directories of files in the <code>src</code> directory. 
This makes for easier source lookup when using 
<a target="_top" href="http://www.eclipse.org">Eclipse</a>, and shrinks the size of the distribution
as well.

<p>The way engine services are defined and used has been completely overhauled.  
Services are now defined
in the application specification and a single
instance of the service object is instantiated
and shared by all engine instances (for the application).

<p>Made it easier to override the creation of the specification source, template source, etc. in subclasses
of 
<a href="doc/api/net/sf/tapestry/engine/AbstractApplication.html">AbstractApplication</a>.


<p>The <a href="doc/api/net/sf/tapestry/form/Submit.html">Submit</a> and 
<a href="doc/api/net/sf/tapestry/form/ImageSubmit.html">ImageSubmit</a> components may now have 
their own listener, which is notified before the containing form's listener.

<p>More reworking of validation; the validation delegate can now
track errors in any kind of form component and can track errors that
aren't associated with any particular component.

<pre>
[ #510175 ] add service registration to .application
[ #511256 ] Enhance Validation Framework
</pre>

<h3>Release 1.0.8</h3>

<p>A complete overhaul of the validating text field support.  The previous implementation
used subclasses of AbstractValidatingTextField (which no longer exists) to add new types
of validation; the new implementation has a single component, 
<a href="doc/api/net/sf/tapestry/valid/ValidField.html">ValidField</a>, and many implementations
of <a href="doc/api/net/sf/tapestry/valid/IValidator.html">IValidator</a>.

<p>At long last, the <a href="doc/api/net/sf/tapestry/form/Upload.html">Upload</a> component.

<p>Reimplemented the Virtual Library application using
<a target="_top" href="http://mckoi.com/database/">McKoi Database</a>, to be compatible with JBoss 2.4.3 (which no
longer includes InstantDB).

<pre>
[ #506661 ] private asset configuration
[ #494456 ] StringValidator minLength message wrong
[ #488476 ] Generated URLs should contain entities.
[ #488432 ] Make duplicate page names illegal
[ #487394 ] NumericField doesn't work with long
[ #501750 ] StringValidator
[ #499057 ] BaseValidator summary typo
[ #487619 ] javadoc link errors
</pre>


<h3>Release 1.0.7</h3>
				
<p>Removed Primix copyrights, as I no longer work there or do any work on their time.

<p>Consolidated and cleaned up many of the tutorials into the new Workbench.

<p>Improvements to Inspector's Properties Explorer.  It is now more tolerant of exceptions thrown while
accessing properties.

<p>Streamlined the distribution by removing the source for documentation.


<PRE>
[ #480433 ] StatementAssembly - access to JBDC 2.0
[ #469747 ] more flexible application parser
[ #484184 ] JavaDoc error
</pre>
				
				<h3>Release 1.0.6</h3>
				
				<p>Tapestry now uses <a target="_top" href="http://jakarta.apache.org/ant">Ant</a>
				as its build tool.  The GNU Makefile Java Build Environment has
				been removed.
				
				<p>The Tapestry Inspector now has a powerful Properties Explorer which allows
				for dynamic navigation and display of an object's properties (similar
				to what a debugger provides).
				
				<p>Localization of context assets was broken in Tomcat; it now works
				in both Tomcat and Jetty.
				
				<h3>Release 1.0.5</h3>
				
				<p>Added a mechanism to clear out pooled objects when they haven't been used
				for some time.  The interface <a href="doc/api/net/sf/tapestry/util/ICleanable.html">ICleanable</a>
				has the details.
				
				<p>Made a number of other efficiency improvements.  Particularily, the page loader now weeds
				out informal parameters that can't be used (because they conflict with formal parameter names,
				or because the component owns the attributes), preventing them from being added as component
				bindings.  The old method was to weed out the unwanted parameters on every
				render, which was more expensive.
				
				<p>Improved the <a href="doc/api/net/sf/tapestry/valid/NumericField.html">NumericField</a>
				component to deal with null values in an intelligent manner.
				
				<p>It is now possible to set properties of
				<a href="doc/DevelopersGuide/components.helper-beans.html">helper beans</a>.
				
				<p>The full distribution now bundles 
				<a target="_top" href="http://jetty.mortbay.com">Jetty 3.1RC9</a>
				and the Virtual Library is now compatible with
				<a target="_top" href="http://www.jboss.org">JBoss 2.4.0</a>.
				
                <h3>Release 1.0.4</h3>
                
                <p>Release 1.0.4 debuted the finished Tapestry Home and Virtual Library.
                
                <br>
			<!-- END Content -->
		</td>
	</tr>
</table>
<!-- ****END BODY WRAPPER**** -->

<!-- ****FOOTER**** -->
<table width="100%" border="0" cellspacing="0" cellpadding="0">
	<tr bgcolor="#8e9cd1">
		<td>&nbsp;</td>
	</tr>
	<tr bgcolor="#4b5887">
		<td height="47">
			<img src="images/spacer.gif">
		</td>
	</tr>
	<tr bgcolor="#333333">
		<td height="65">
			<table width="724" border="0" cellspacing="0" cellpadding="3" bgcolor="#000000">
				<tr height="65">
					<td width="654" align="right" valign="bottom" class="clsFooter">&#169;2000-2002 Howard Lewis Ship.
					All rights reserved.</td>
					<td width="70">&nbsp;</td>
				</tr>
			</table>
		</td>
	</tr>
	<tr bgcolor="#333333">
		<td>
			<table width="724" border="0" cellspacing="0" cellpadding="3" bgcolor="#000000">
				<tr height="65">
					<td height="200" width="654">&nbsp;</td>
					<td width="70">&nbsp;</td>
				</tr>
			</table>
		</td>
	</tr>
</table>
<!-- ****END FOOTER**** -->
</body>
</html>
