<!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.3</h3>

Updated Component Reference and Javadoc documentation.

<h3>Release 2.3-rc-1</h3>

<ul>
<li>Installed Apache Foundation license and copyrights into all source files.</li>
<li>Added Spanish translation of validation strings, contributed by Juan Alvarez.</li>
<li>Fixed some deployment issues when deploying into Tomcat.</li>
</ul>

<pre>
[ 650592 ] Add MaskEdit component
[ 651331 ] Added DatePicker disable parameter
[ 655089 ] Add ExternalPageCalback
[ 660372 ] Add Global object
</pre>

<h3>Release 2.3-beta-1</h3>

<ul>
<li>Tapestry is now available under the terms of the Apache Software License.  Previous
releases were released under the LGPL, but are now retroactively
licensed under the ASL as well.</li>

<li>Added a <a href="dev.html">Developers Page</a>.</li>

<li>
Removed code dependency on Log4J, using
Jakarta's
<a href="http://jakarta.apache.org/commons/logging.html">commons-logging</a> wrapper layer instead.
Use the <code>Enum</code> implementation from Jakarta's
<a href="http://jakarta.apache.org/commons/lang.html">commons-lang</a> library.
</li>

<li>
Reworked dynamic code loading so that a subclass of
<a href="doc/api/net/sf/tapestry/ApplicationServlet.html">ApplicationServlet</a>
is no longer necessary.
</li>

<li>Added methods to
<a href="doc/api/net/sf/tapestry/INamespace.html">INamespace</a> and
<a href="doc/api/net/sf/tapestry/IPage.html">IPage</a>
to make dealing with namespaces and qualified page names easier.
</li>

<li>
Joe Panico has contributed the PopupLink component.
</li>

<li>
<code>&lt;jwc id="..."&gt;</code> is no longer allowed in HTML templates.
</li>

<li>
Upgraded to OGNL 2.3.0.
</li>

<li>
Added German translation of validation strings, contributed by Sven Homburg,
and a Traditional Chinese translation, contributed by Zhenbang Wei.
</li>
</ul>

<pre>
[ 619481 ] use jakarta commons lang Enum
[ 627478 ] Don't require servlet subclass
[ 614324 ] Add a param "raw" in addition to "key"
[ 627332 ] NPE in BaseValidator (form without body)
[ 557332 ] Use a search path for properties
[ 625721 ] Forms never stateful
[ 637048 ] Add PopLink
[ 643239 ] Add EmailValidator
[ 633608 ] ServiceLink docs missing service param
[ 644235 ] Body component ignores element
[ 643728 ] user supplied RequestContext
[ 643729 ] user supplied MultipartDecoder 
[ 628153 ] add getAttribute to RequestContext
[ 633073 ] Rollover doesn't work in form
[ 631764 ] AbstractComponent API
[ 648435 ] Using java.util.Date in DatePicker
</pre>

<h3>Release 2.2</h3>

Use the version of Jetty that's compatible with JDK 1.2.

<pre>
[ 619444 ] Contrib:DateField min/max params broken
[ 620496 ] JS net/sf/tapestry/form/Calendar.js
</pre>

<h3>Release 2.2-rc-1</h3>

<pre>
[ 616489 ] IPublicBean not accessible.
[ 616377 ] DatePicker value error
[ 582614 ] ValidField doesn't call getValidator()
[ 617327 ] Contrib:DateField specification invalid
[ 616851 ] Can't redirect to a library page
[ 617867 ] ImageSubmit null image
[ 618317 ] Contrib:NumericField missing type param
[ 618342 ] NPE in AbstractComponent toString
</pre>

<h3>Release 2.2-beta-3</h3>

Upgrade to Jetty 4.1.0 and OGNL 2.1.4.

<p>
Mind Bridge has contributed a Table component (really, a complete framework
for creating sortable tables that present data in page-sized blocks).

<p>
We now boldly present our <a href="http://tapestry.sf.net/doc/clover/">code coverage reports</a>
online.

<pre>
[ 608368 ] DataSqueezer / ClassLoader
[ 608764 ] Work around errant valueUnbound()
[ 608162 ] ExternalService allows only 1 parameter
[ 611551 ] DTD validation error with XML Spy
[ 613441 ] SelectPropertySelectionRenderer HTML
[ 604194 ] Specify charset by Shell component
[ 610376 ] Expose Foreach's index as a property
</pre>


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

The <a href="doc/ComponentReference/ValidField.html">ValidField</a> now performs
client-side validation of input.  If a field is in error when the form
is submitted, then an alert is displayed and the field is selected.

<p>Begin making more use of OGNL expressions in place of Java code.

<p>Malcom Edgar has contributed a <a href="doc/ComponentReference/DatePicker.html">DatePicker</a>
component.

<p>Some more refactorings: IComponent methods  addWrapped()/renderWrapped() -> addBody()/renderBody().

<p>Tapestry documentation is now available in PDF format.

<pre>
[ 602881 ] Add hooks for ValidField client-side
[ 603023 ] StaleSession.page has error
[ 603208 ] Support parameter direction "form"
[ 603269 ] ListEdit improvements
[ 603362 ] Inconsistency in Tapestry_1_3.dtd
[ 603132 ] Add a service similar to ExternalService
[ 582436 ] Script / Required Symbols
[ 604834 ] InspectorButton disabled param
[ 604646 ] ImageSubmit ignores disabledImage
[ 603260 ] make Form "listener" not required
[ 603826 ] IUploadFile provide Mime Type
[ 604944 ] Add DateEdit component
[ 603130 ] Add an initPage() method to AbstractPage
[ 607074 ] Make IMarkupWriter a bit smarter
[ 604201 ] Markup Writer should output XHTML
[ 607451 ] log error when unmatched components
</pre>

<h3>Release 2.2-beta-1</h3>

<p>Tapestry has now replaced its simple
property path support with the far 
more powerful <a href="http://www.ognl.org">Object Graph
Navigation Library</a> expressions.  This promises to greatly extend
the expressiveness of the specifications and further reduce
the need for Java code.  The <code>property-path</code>
attribute of the <code>&lt;binding&gt;</code> element has been renamed
to <code>expression</code> (this only affects the latest, 1.3, version
of the DTD).

<p>There are some small costs to using OGNL; the largest being
a restriction in bean names, component ids and asset names.  All
of these must now be valid Java identifiers, and so cannot contain the 
dash ('-') character, which was previously permitted.  This affects all
specifications, including older versions.

<p>Malcolm Edgar has lead the push to provide an excellent
<a href="doc/ComponentReference">Tapestry Component Reference</a>.

<p>
You can now control the exact location of a component template by 
declaring an asset named <code>$template</code> (which is not normally
a legal asset name, due to the dollar sign).  If such an asset exists,
then it is used as the template.

<p>A number of poorly named components have been renamed:
<ul>
<li>Action -> ActionLink
<li>Direct -> DirectLink
<li>InsertBlock -> RenderBlock
<li>InsertWrapped -> RenderBody
<li>Page -> PageLink
<li>Service -> ServiceLink
<li>ShowInspector -> InspectorButton
<li>Text -> TextArea
</ul>

<p>Previous names will be maintained until at least release 2.3.

<p>
In addition, the documentation has been brought (largely) up to date
with the significant changes so far in release 2.2.

<pre>
[ 582421 ] Way to specify template location
[ 596929 ] NumericField params require java-type
[ 597314 ] Problems with URLs
[ 595985 ] Tapestry behind firewall
[ 598609 ] NumericField displayWidth inconsistent
[ 598371 ] Radio and RadioGroup broken
[ 599608 ] App startup exception
[ 599663 ] Disallow spec path a comp. type
[ 601018 ] Use OGNL instead of home brew
</pre>


<h3>Release 2.2-alpha-4</h3>

Update to latest versions of JCommon, JFreeChart and Log4J.  Added the
&lt;extension&gt; element to the application and library specifications.

<pre>
[ 584040 ] Add hooks for custom configuration
[ 579081 ] getApplicationSpecification
[ 587683 ] Frameset tag for JavaScript
[ 589818 ] Forward, not redirect, to local resource
[ 591352 ] &lt;bean&gt; should allow &lt;property&gt;
[ 592289 ] helper bean: render lifecycle
[ 591801 ] Exception changing log priority
</pre>

<h3>Release 2.2-alpha-3</h3>

Tapestry now supports libraries, which can provide components, pages and engine services to
an application.  Libraries can also include libraries.  The application specification
has been ammended to include a new &lt;library&gt; element, and a new type of specification,
the library specification, has been added.

<p>
Renamed all page specifications from ".jwc" to ".page".

<pre>
[ 584466 ] Cant set bean prop from localized string
[ 494453 ] invalid-date-format message string wrong
[ 584731 ] Text's value parameter required
[ 579843 ] PageLoader INFO msg wrong
[ 586171 ] Add namespace/library support
</pre>

<h3>Release 2.2-alpha-2</h3>

Revamp how services construct and parse URLs.  Rework service parameters to
be typed objects, instead of simple strings (this is a change which
may break some existing code).

<p>
A new version of the DTD may now be used which distinguishes between
page specifications and component specifications (page specifications
do not specify several attributes and elements related to 
component parameters).

<pre>
[ 581199 ] Slashes in service parameters
[ 581160 ] Wrong case in WAR file name
[ 579583 ] Simplify PropertySelection
[ 581691 ] Object not String for service parameters
[ 582614 ] ValidField doesn't call getValidator()
[ 583665 ] ValidatingTextField specification wrong
[ 583693 ] Extend Block/InsertBlock
[ 534055 ] Make page-spec and comp-spec distinct
</pre>


<h3>Release 2.2-alpha-1</h3>

Update to Jetty 4.0.4.

<pre>
[ 576523 ] Better syntax for Script documents
[ 562964 ] Non-unique app name problems
[ 578869 ] InsertComponent/DateField, null values
[ 578921 ] Error in listener map error message
[ 579131 ] Load order problem with string-binding
[ 579642 ] Rename Direct context param
[ 579689 ] Hidden should convert values
[ 579141 ] IOExceptions related to exception page
</pre>

	

<h3><a href="more_new.html">More ...</a></h3>

			<!-- 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">&copy; 2003 Apache Software Foundation.
					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>
