<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!--
	
	*******************************************************************
	
	This file is no longer used! Information within the file is being
	transferred to ${root.dir}/status.xml!
	
	*******************************************************************
-->	
<!-- $Id$ -->
<html>
<head>
	<title>Tapestry: What's New</title>
<link rel="STYLESHEET" type="text/css" href="scripts/style_virtlib_pcIE55.css">
</head>

<body leftmargin="0" topmargin="0" marginwidth="0" marginheight="0">
<table width="100%" border="0" cellspacing="0" cellpadding="2">
	<tr>
		<td valign="top" align="left"><IMG alt="[Tapestry Banner]" src="images/Tapestry-Banner.png" border="0">
		
<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-alpha-1</h3>

<p>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.

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

<p>
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.

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

<p>Add 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.

<p>
Joe Panico has contributed the PopupLink component.

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

<p>
Upgrade to OGNL 2.3.0.

<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
</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).

<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() -&gt; 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 -&gt; ActionLink
<li>Direct -&gt; DirectLink
<li>InsertBlock -&gt; RenderBlock
<li>InsertWrapped -&gt; RenderBody
<li>Page -&gt; PageLink
<li>Service -&gt; ServiceLink
<li>ShowInspector -&gt; InspectorButton
<li>Text -&gt; TextArea< /li> 
</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>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**** -->

<p>
<a href="http://jakarta.apache.org"><img src="images/jakarta-banner.png" border="0" alt="Jakarta Banner"></a>
<br>&copy; @COPY_YEARS@ Apache Software Foundation.	All rights reserved.

</body>
</html>
