<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta content="Apache Forrest" name="Generator">
<meta name="Forrest-version" content="0.9-dev">
<meta name="Forrest-skin-name" content="pelt">
<title>History of Changes </title>
<link type="text/css" href="skin/basic.css" rel="stylesheet">
<link media="screen" type="text/css" href="skin/screen.css" rel="stylesheet">
<link media="print" type="text/css" href="skin/print.css" rel="stylesheet">
<link type="text/css" href="skin/profile.css" rel="stylesheet">
<script src="skin/getBlank.js" language="javascript" type="text/javascript"></script><script src="skin/getMenu.js" language="javascript" type="text/javascript"></script><script src="skin/fontsize.js" language="javascript" type="text/javascript"></script>
<link rel="shortcut icon" href="favicon.ico">
</head>
<body onload="init()">
<script type="text/javascript">ndeSetTextSize();</script>
<div id="top">
<!--+
    |breadtrail
    +-->
<div class="breadtrail">
<a href="http://www.apache.org/">apache</a> &gt; <a href="http://lenya.apache.org/">lenya</a><script src="skin/breadcrumbs.js" language="JavaScript" type="text/javascript"></script>
</div>
<!--+
    |header
    +-->
<div class="header">
<!--+
    |start group logo
    +-->
<div class="grouplogo">
<a href=""><img class="logoImage" alt="Lenya" src="images/apache-lenya-light.png" title=""></a>
</div>
<!--+
    |end group logo
    +-->
<!--+
    |start Project Logo
    +-->
<div class="projectlogo">
<a href=""></a>
</div>
<!--+
    |end Project Logo
    +-->
<!--+
    |start Search
    +-->
<div class="searchbox">
<form action="http://www.google.com/search" method="get" class="roundtopsmall">
<input value="lenya.apache.org" name="sitesearch" type="hidden"><input onFocus="getBlank (this, 'Search the site with ');" size="25" name="q" id="query" type="text" value="Search the site with ">&nbsp; 
                    <input name="Search" value="Search" type="submit">
</form>
</div>
<!--+
    |end search
    +-->
<!--+
    |start Tabs
    +-->
<ul id="tabs">
<li class="current">
<a class="selected" href="index.html">Project</a>
</li>
<li>
<a class="unselected" href="docs/index.html">Developer</a>
</li>
<li>
<a class="unselected" href="community/index.html">Community</a>
</li>
<li>
<a class="unselected" href="docs/2_0_x/index.html">Version 2.0</a>
</li>
<li>
<a class="unselected" href="docs/1_2_x/index.html">Version 1.2</a>
</li>
</ul>
<!--+
    |end Tabs
    +-->
</div>
</div>
<div id="main">
<div id="publishedStrip">
<!--+
    |start Subtabs
    +-->
<div id="level2tabs"></div>
<!--+
    |end Endtabs
    +-->
<script type="text/javascript"><!--
document.write("Last Published: " + document.lastModified);
//  --></script>
</div>
<!--+
    |breadtrail
    +-->
<div class="breadtrail">

             &nbsp;
           </div>
<!--+
    |start Menu, mainarea
    +-->
<!--+
    |start Menu
    +-->
<div id="menu">
<div onclick="SwitchMenu('menu_selected_1.1', 'skin/')" id="menu_selected_1.1Title" class="menutitle" style="background-image: url('skin/images/chapter_open.gif');">Project</div>
<div id="menu_selected_1.1" class="selectedmenuitemgroup" style="display: block;">
<div class="menuitem">
<a href="index.html">About</a>
</div>
<div onclick="SwitchMenu('menu_selected_1.1.2', 'skin/')" id="menu_selected_1.1.2Title" class="menutitle" style="background-image: url('skin/images/chapter_open.gif');">Changes</div>
<div id="menu_selected_1.1.2" class="selectedmenuitemgroup" style="display: block;">
<div class="menuitem">
<a href="tlp-HEAD.svn-revision.xml">current revision number</a>
</div>
<div class="menuitem">
<a href="tlp-HEAD.svn-sh.xml">create svn log shell</a>
</div>
<div class="menuitem">
<a href="tlp-HEAD.svn.html">log HEAD</a>
</div>
<div class="menuitem">
<a href="tlp-2007-12.svn.html">log 2007-12</a>
</div>
<div class="menuitem">
<a href="tlp-2007-11.svn.html">log 2007-11</a>
</div>
<div class="menuitem">
<a href="tlp-2007-10.svn.html">log 2007-10</a>
</div>
<div class="menuitem">
<a href="tlp-2007-09.svn.html">log 2007-09</a>
</div>
<div class="menuitem">
<a href="tlp-2007-08.svn.html">log 2007-08</a>
</div>
<div class="menuitem">
<a href="tlp-2007-07.svn.html">log 2007-07</a>
</div>
<div class="menuitem">
<a href="tlp-2007-06.svn.html">log 2007-06</a>
</div>
<div class="menuitem">
<a href="tlp-2007-05.svn.html">log 2007-05</a>
</div>
<div class="menuitem">
<a href="tlp-2007-04.svn.html">log 2007-04</a>
</div>
<div class="menuitem">
<a href="tlp-2007-03.svn.html">log 2007-03</a>
</div>
<div class="menuitem">
<a href="tlp-2007-02.svn.html">log 2007-02</a>
</div>
<div class="menuitem">
<a href="tlp-2007-01.svn.html">log 2007-01</a>
</div>
<div class="menuitem">
<a href="tlp-2006-12.svn.html">log 2006-12</a>
</div>
<div class="menuitem">
<a href="tlp-2006-11.svn.html">log 2006-11</a>
</div>
<div class="menuitem">
<a href="tlp-2006-10.svn.html">log 2006-10</a>
</div>
<div class="menuitem">
<a href="tlp-2006-09.svn.html">log 2006-09</a>
</div>
<div class="menuitem">
<a href="tlp-2006-08.svn.html">log 2006-08</a>
</div>
<div class="menuitem">
<a href="tlp-2006-07.svn.html">log 2006-07</a>
</div>
<div class="menuitem">
<a href="tlp-2006-06.svn.html">log 2006-06</a>
</div>
<div class="menuitem">
<a href="tlp-2006-05.svn.html">log 2006-05</a>
</div>
<div class="menuitem">
<a href="tlp-2006-04.svn.html">log 2006-04</a>
</div>
<div class="menuitem">
<a href="tlp-2006-03.svn.html">log 2006-03</a>
</div>
<div class="menuitem">
<a href="tlp-2006-02.svn.html">log 2006-02</a>
</div>
<div class="menuitem">
<a href="tlp-2006-01.svn.html">log 2006-01</a>
</div>
<div class="menuitem">
<a href="tlp-2005-12.svn.html">log 2005-12</a>
</div>
<div class="menupage">
<div class="menupagetitle">log 2005-11</div>
</div>
<div class="menuitem">
<a href="tlp-2005-10.svn.html">log 2005-10</a>
</div>
<div class="menuitem">
<a href="tlp-2005-09.svn.html">log 2005-09</a>
</div>
<div class="menuitem">
<a href="tlp-2005-08.svn.html">log 2005-08</a>
</div>
<div class="menuitem">
<a href="tlp-2005-07.svn.html">log 2005-07</a>
</div>
<div class="menuitem">
<a href="tlp-2005-06.svn.html">log 2005-06</a>
</div>
<div class="menuitem">
<a href="tlp-2005-05.svn.html">log 2005-05</a>
</div>
<div class="menuitem">
<a href="tlp-2005-04.svn.html">log 2005-04</a>
</div>
<div class="menuitem">
<a href="tlp-2005-03.svn.html">log 2005-03</a>
</div>
<div class="menuitem">
<a href="tlp-2005-02.svn.html">log 2005-02</a>
</div>
<div class="menuitem">
<a href="tlp-2005-01.svn.html">log 2005-01</a>
</div>
<div class="menuitem">
<a href="tlp-2004-12.svn.html">log 2004-12</a>
</div>
<div class="menuitem">
<a href="tlp-2004-11.svn.html">log 2004-11</a>
</div>
<div class="menuitem">
<a href="incubator-2004-07-10.svn.html">inc-2004-07-10</a>
</div>
<div class="menuitem">
<a href="incubator-2004-04-06.svn.html">inc-2004-04-06</a>
</div>
<div class="menuitem">
<a href="incubator-2004-01-03.svn.html">inc-2004-01-03</a>
</div>
<div class="menuitem">
<a href="incubator-2003-11-12.svn.html">inc-2003-11-12</a>
</div>
<div class="menuitem">
<a href="incubator-2003-10.svn.html">inc-2003-10</a>
</div>
<div class="menuitem">
<a href="incubator-2003-09.svn.html">inc-2003-09</a>
</div>
<div class="menuitem">
<a href="incubator-2003-08.svn.html">inc-2003-08</a>
</div>
<div class="menuitem">
<a href="incubator-2003-07.svn.html">inc-2003-07</a>
</div>
<div class="menuitem">
<a href="incubator-2003-06.svn.html">inc-2003-06</a>
</div>
<div class="menuitem">
<a href="incubator-2003-05.svn.html">inc-2003-05</a>
</div>
<div class="menuitem">
<a href="incubator-2003-04.svn.html">inc-2003-04</a>
</div>
<div class="menuitem">
<a href="incubator-2003-03.svn.html">inc-2003-03</a>
</div>
<div class="menuitem">
<a href="incubator-2003-01-02.svn.html">inc-2003-01-02</a>
</div>
<div class="menuitem">
<a href="incubator-2002-10-12.svn.html">inc-2002-10-12</a>
</div>
<div class="menuitem">
<a href="incubator-2002-08-09.svn.html">inc-2002-08-09</a>
</div>
<div class="menuitem">
<a href="incubator-2002-05-07.svn.html">inc-2002-05-07</a>
</div>
<div class="menuitem">
<a href="incubator-2002-01-04.svn.html">inc-2002-01-04</a>
</div>
</div>
<div class="menuitem">
<a href="who.html" title="Explain who is involved">Who we are</a>
</div>
<div class="menuitem">
<a href="screenshots.html">Screenshots</a>
</div>
<div class="menuitem">
<a href="roadmap.html">Roadmap</a>
</div>
<div class="menuitem">
<a href="license.html">License</a>
</div>
<div class="menuitem">
<a href="related-projects.html">Related Projects</a>
</div>
<div class="menuitem">
<a href="history.html">History</a>
</div>
<div class="menuitem">
<a href="http://www.apache.org/foundation/sponsorship.html">Sponsoring Apache</a>
</div>
<div class="menuitem">
<a href="http://www.apache.org/foundation/thanks.html">Sponsors Thanks</a>
</div>
</div>
<div id="credit"></div>
<div id="roundbottom">
<img style="display: none" class="corner" height="15" width="15" alt="" src="skin/images/rc-b-l-15-1body-2menu-3menu.png"></div>
<!--+
  |alternative credits
  +-->
<div id="credit2">
<a href="http://wiki.apache.org/lenya/MeetingFreiburg2008"><img border="0" title="Meeting Freiburg 2008" alt="Meeting Freiburg 2008 - logo" src="images/apache-lenya-meeting-freiburg-2008.png" style="width: 160px;height: 40px;"></a>
</div>
</div>
<!--+
    |end Menu
    +-->
<!--+
    |start content
    +-->
<div id="content">
<div title="Portable Document Format" class="pdflink">
<a class="dida" href="tlp-2005-11.svn.pdf"><img alt="PDF -icon" src="skin/images/pdfdoc.gif" class="skin"><br>
        PDF</a>
</div>
<h1>History of Changes </h1>
<div id="front-matter">
<div id="minitoc-area">
<ul class="minitoc">
<li>
<a href="#introduction">Introduction and explanation of symbols</a>
</li>
<li>
<a href="#version_2005-11">Version 2005-11 ()</a>
<ul class="minitoc">
<li>
<a href="#1.2">1.2</a>
</li>
<li>
<a href="#2.0">2.0</a>
</li>
<li>
<a href="#Documentation">Documentation</a>
</li>
<li>
<a href="#Site">Site</a>
</li>
<li>
<a href="#">Contributors to this release</a>
</li>
</ul>
</li>
</ul>
</div>
</div>
<p>
<a href="changes.rss"><img alt="RSS" src="images/rss.png"></a>
</p>
<a name="N10011"></a><a name="introduction"></a>
<h2 class="h3">Introduction and explanation of symbols</h2>
<div class="section">
<p>Changes are sorted <translate>by "{0}" and then<param>type</param>
</translate> chronologically with the most recent at the top. These symbols denote the various action types:<img class="icon" alt="add" src="images/add.jpg">=add, <img class="icon" alt="remove" src="images/remove.jpg">=remove, <img class="icon" alt="update" src="images/update.jpg">=update</p>
</div>
<a name="N10047"></a><a name="version_2005-11"></a>
<h2 class="h3">Version 2005-11 ()</h2>
<div class="section">
<a name="N1004F"></a><a name="1.2"></a>
<h3 class="h4">1.2</h3>
<ul>
<li>
<img class="icon" alt="add" src="images/add.jpg">[1.2] deprecated source type action added <a href="http://svn.apache.org/viewcvs.cgi?rev=332041&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[1.2] updated Forrest with fixed SourceTypeAction thanks to Josias <a href="http://svn.apache.org/viewcvs.cgi?rev=332042&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[1.2] input module to make content dir configurable started <a href="http://svn.apache.org/viewcvs.cgi?rev=332057&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[1.2] ProxyGenerator with https resp. getScheme enhanced <a href="http://svn.apache.org/viewcvs.cgi?rev=332837&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="remove" src="images/remove.jpg">[1.2] obsolete libraries <a href="http://svn.apache.org/viewcvs.cgi?rev=332043&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] Open live page in a new window <a href="http://svn.apache.org/viewcvs.cgi?rev=330213&view=rev">Diff</a> 
       Committed by jann.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] bug re hardcoded filename generation fixed. DocumentIdToPathMapper is now being used <a href="http://svn.apache.org/viewcvs.cgi?rev=330231&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] getChildFileName fixed such that one is forced to upgrade the creators because of the DocumentIdToPathMapper bug <a href="http://svn.apache.org/viewcvs.cgi?rev=330247&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] getChildFileName fixed such that one is forced to upgrade the creators because of the DocumentIdToPathMapper bug <a href="http://svn.apache.org/viewcvs.cgi?rev=330248&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] there seems to be a bug re concat filesystem path. TODO added <a href="http://svn.apache.org/viewcvs.cgi?rev=331231&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] preparations for making root content dir configurable <a href="http://svn.apache.org/viewcvs.cgi?rev=331233&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] content authoring element fixed <a href="http://svn.apache.org/viewcvs.cgi?rev=331768&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] SourceTypeAction package name changed <a href="http://svn.apache.org/viewcvs.cgi?rev=332044&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] content-dir input module added as TODO <a href="http://svn.apache.org/viewcvs.cgi?rev=332058&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] Get the content path with help of the new PublicationContentDirModule in all default's sitemaps <a href="http://svn.apache.org/viewcvs.cgi?rev=332085&view=rev">Diff</a> 
       Committed by edith.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] Get the content path with help of the new PublicationContentDirModule in all default's sitemaps <a href="http://svn.apache.org/viewcvs.cgi?rev=332086&view=rev">Diff</a> 
       Committed by edith.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] paths neutralized <a href="http://svn.apache.org/viewcvs.cgi?rev=332247&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] paths neutralized <a href="http://svn.apache.org/viewcvs.cgi?rev=332248&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] needs also to work without configuration in order to stay backwards compatible <a href="http://svn.apache.org/viewcvs.cgi?rev=344356&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] needs to work also without configuration in order to stay backwards compatible <a href="http://svn.apache.org/viewcvs.cgi?rev=344357&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] note about xopushandler action added <a href="http://svn.apache.org/viewcvs.cgi?rev=344359&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] Revision controller prepared such that it works with configurable content directories <a href="http://svn.apache.org/viewcvs.cgi?rev=344363&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] getDocument added to make content dir configurable <a href="http://svn.apache.org/viewcvs.cgi?rev=345212&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] advanced methods such that document root dirs will be configurable commented <a href="http://svn.apache.org/viewcvs.cgi?rev=345783&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] security patch <a href="http://svn.apache.org/viewcvs.cgi?rev=348771&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] thanks to Josias Thoeny the sitetree bug re access controlling has been fixed <a href="http://svn.apache.org/viewcvs.cgi?rev=349402&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] patch update from Josias <a href="http://svn.apache.org/viewcvs.cgi?rev=349410&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[1.2] call fallback for the root transformation and the sitetree2nav.xsl, so that they can be overwridden in the pubs (ex: no language suffix _ in url) <a href="http://svn.apache.org/viewcvs.cgi?rev=349988&view=rev">Diff</a> 
       Committed by edith.</li>
</ul>
<a name="N101DC"></a><a name="2.0"></a>
<h3 class="h4">2.0</h3>
<ul>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] First steps re. JCR-only approach: removed dependencies on JCR block, added own JCR libs, started JCR facade objects and content migration build target. <a href="http://svn.apache.org/viewcvs.cgi?rev=330793&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] Added 1st version of new Lenya repo interfaces + JCR-based implementation <a href="http://svn.apache.org/viewcvs.cgi?rev=330846&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] Robert Goene's lucene usecase added <a href="http://svn.apache.org/viewcvs.cgi?rev=345026&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] lucene XSLTs added <a href="http://svn.apache.org/viewcvs.cgi?rev=345027&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] lucene specific classes re Robert Goenes code <a href="http://svn.apache.org/viewcvs.cgi?rev=345031&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] lucene module of Robert Goene added <a href="http://svn.apache.org/viewcvs.cgi?rev=345033&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] more lucene stuff of Robert Goene added <a href="http://svn.apache.org/viewcvs.cgi?rev=345035&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] lucene config added <a href="http://svn.apache.org/viewcvs.cgi?rev=345041&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] simple opendocument XSLT added <a href="http://svn.apache.org/viewcvs.cgi?rev=345271&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] replaces the SourceWritingTransformer with a flow approach that uses
the processPipelineTo() method of the cocoon flow object. When exiting the flow
a plain status code is sent back to the browser.

Thanks to a patch by Felix R&ouml;thenbacher <a href="http://svn.apache.org/viewcvs.cgi?rev=345494&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] replaces the SourceWritingTransformer with a flow approach that uses
the processPipelineTo() method of the cocoon flow object. When exiting the flow
a plain status code is sent back to the browser.

Thanks to a patch by Felix R&ouml;thenbacher <a href="http://svn.apache.org/viewcvs.cgi?rev=345495&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] Update Jetty to version 5.1.4
Thanks to a patch by Felix R&ouml;thenbacher <a href="http://svn.apache.org/viewcvs.cgi?rev=345639&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] Update Jetty to version 5.1.4
Thanks to a patch by Felix R&ouml;thenbacher <a href="http://svn.apache.org/viewcvs.cgi?rev=345640&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] clean up, moved lucene specific files into the lucene module directory <a href="http://svn.apache.org/viewcvs.cgi?rev=348067&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] moved lucene specific files into lucene module directory <a href="http://svn.apache.org/viewcvs.cgi?rev=348074&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] applied Patch for removing log4j:WARN removing upon Jetty start-up,
Bug 37240,  Thanks to a patch by Felix R&ouml;thenbacher <a href="http://svn.apache.org/viewcvs.cgi?rev=348422&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] moved lucene stylesheets into resource specific modules xslt directory
Thanks to Felix 
Fixes Bug 37626 <a href="http://svn.apache.org/viewcvs.cgi?rev=348759&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="add" src="images/add.jpg">[2.0] Extended repo API, updated JCR repo implementation to a more generic approach (using a repository facade and path structures) <a href="http://svn.apache.org/viewcvs.cgi?rev=350074&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="remove" src="images/remove.jpg">[2.0] LGPL code removed <a href="http://svn.apache.org/viewcvs.cgi?rev=345270&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Don't call opendocument2xhtml.xsl: the transformation is replaced by the xslt of art rhyno <a href="http://svn.apache.org/viewcvs.cgi?rev=330006&view=rev">Diff</a> 
       Committed by edith.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] the attribute for the style's properties change from style:properties into style:local-name()-properties <a href="http://svn.apache.org/viewcvs.cgi?rev=330083&view=rev">Diff</a> 
       Committed by edith.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] allow to patch lenya.roles by publications and modules <a href="http://svn.apache.org/viewcvs.cgi?rev=330229&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0]  <a href="http://svn.apache.org/viewcvs.cgi?rev=330292&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0]  <a href="http://svn.apache.org/viewcvs.cgi?rev=330293&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Accidental commit (messing around with cform type), sorry about that <a href="http://svn.apache.org/viewcvs.cgi?rev=330294&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] fixed img references for up/down arrows <a href="http://svn.apache.org/viewcvs.cgi?rev=330541&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Changed cform code that it is possible to use a cancel button. <a href="http://svn.apache.org/viewcvs.cgi?rev=330572&view=rev">Diff</a> 
       Committed by thorsten.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Fixed typo in usecase.js. Spotted by Felix. Thx Felix. <a href="http://svn.apache.org/viewcvs.cgi?rev=330789&view=rev">Diff</a> 
       Committed by thorsten.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] prompt for clean build of cocoon with new local.blocks.properties <a href="http://svn.apache.org/viewcvs.cgi?rev=330833&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Added a fallback for module specific menu generation. Now you can override the menus provided by the modules. e.g. If you want to override the menu provided by the xhtml module, just create a file in pub-id/conf/menus/xhtml.xsp and provide your own menu implementation for the module. <a href="http://svn.apache.org/viewcvs.cgi?rev=331273&view=rev">Diff</a> 
       Committed by thorsten.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Usecase exit parameters can now be supplied without a value in the xconf, 
the value will be picked up from the parameters passed to the usecase.
This fixes Bug 37362 <a href="http://svn.apache.org/viewcvs.cgi?rev=331627&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Fixes non working cancel buttons <a href="http://svn.apache.org/viewcvs.cgi?rev=331826&view=rev">Diff</a> 
       Committed by thorsten.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Configuration of log4j.xconf <a href="http://svn.apache.org/viewcvs.cgi?rev=332068&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] languages choice is hidden if just one language available in publication
Thanks to a patch by Simon Litwan, fixes Bug 37434 <a href="http://svn.apache.org/viewcvs.cgi?rev=332227&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] added userId, groupId, and ipRangeId to exit usecases where needed <a href="http://svn.apache.org/viewcvs.cgi?rev=332235&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] fixes ability to save in kupu using webdav interface instead of kupu usecase.  
Will clean up usecase if this seems to work out.  Post processing (before validation) of
document can be done with modules/xhtml/xslt/clean-xhtml.xsl if needed.   <a href="http://svn.apache.org/viewcvs.cgi?rev=332356&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Example of a optional xhtml sample in the default pub.  Perhaps someone can provide a patch for a better example of a 2 column page <a href="http://svn.apache.org/viewcvs.cgi?rev=332385&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] comment this sample out untill there is a way to make additional samples publication specific <a href="http://svn.apache.org/viewcvs.cgi?rev=332439&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] JCR integration: implemented writing and reading document content <a href="http://svn.apache.org/viewcvs.cgi?rev=332599&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] removed reference to non-existing entry module from blog publication <a href="http://svn.apache.org/viewcvs.cgi?rev=344086&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Added ContextUtility to allow the DocumentPolicyManagerWrapper to access the context on demand. This fixes bug #36494. Credits to Felix Roethenbacher. <a href="http://svn.apache.org/viewcvs.cgi?rev=344087&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Throw comprehensible exception when a resource type does not support a particular format. <a href="http://svn.apache.org/viewcvs.cgi?rev=344088&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Added XHTML format to search resource type <a href="http://svn.apache.org/viewcvs.cgi?rev=344089&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Apply module menu fallback to menus.xmap, not to single XSPs <a href="http://svn.apache.org/viewcvs.cgi?rev=344095&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] return proper status code on success PUT request <a href="http://svn.apache.org/viewcvs.cgi?rev=344237&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Fixed missing i18n namespace in cforms module and example. <a href="http://svn.apache.org/viewcvs.cgi?rev=344352&view=rev">Diff</a> 
       Committed by thorsten.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Calling DocumentManager.isValidDocumentName() from CreateDocument usecase to validate document names. DocumentManagerImpl allows only characters and numbers in document IDs. <a href="http://svn.apache.org/viewcvs.cgi?rev=345016&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] config for Jeceira Repository Factory added <a href="http://svn.apache.org/viewcvs.cgi?rev=345019&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Lucene block added <a href="http://svn.apache.org/viewcvs.cgi?rev=345022&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] lcr changed because of additional lucene block <a href="http://svn.apache.org/viewcvs.cgi?rev=345029&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] lucene code of Robert Goene added <a href="http://svn.apache.org/viewcvs.cgi?rev=345032&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] search field added <a href="http://svn.apache.org/viewcvs.cgi?rev=345034&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] added kupusave.xsl as import to clean up kupu generated source before validation <a href="http://svn.apache.org/viewcvs.cgi?rev=345036&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] indexing added <a href="http://svn.apache.org/viewcvs.cgi?rev=345038&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] indexing added <a href="http://svn.apache.org/viewcvs.cgi?rev=345039&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] opendocumenttext fixed <a href="http://svn.apache.org/viewcvs.cgi?rev=345280&view=rev">Diff</a> 
       Committed by michi.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Added infrastructure for module test builds <a href="http://svn.apache.org/viewcvs.cgi?rev=345521&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Updated custom_nodetypes.xml to new Jackrabbit syntax <a href="http://svn.apache.org/viewcvs.cgi?rev=345522&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Improved repo interfaces and JCR-based implementation, added JCRRepositoryTest, updated migration class accordingly <a href="http://svn.apache.org/viewcvs.cgi?rev=345523&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Initialize all mandatory JCR properties. The migrate-14 target works now. <a href="http://svn.apache.org/viewcvs.cgi?rev=345525&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] added JOB_DATA column to qrtz_triggers table
fixes error "Column count does not match in statement" when trying to schedule a job
 <a href="http://svn.apache.org/viewcvs.cgi?rev=345632&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] Takes care of class cast exception when scheduled job tries to publish <a href="http://svn.apache.org/viewcvs.cgi?rev=345636&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] allows publish usecase to reindex doc in live index when run from scheduled job <a href="http://svn.apache.org/viewcvs.cgi?rev=345637&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] made lucene indexes area (live and authoring) specific,
lucene usecase which can be called as an exit usecase of other usecases <a href="http://svn.apache.org/viewcvs.cgi?rev=348547&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] xhtml2index xsl path changes <a href="http://svn.apache.org/viewcvs.cgi?rev=348760&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] JCR module: added Assertion utility class, fixed some NPE issues <a href="http://svn.apache.org/viewcvs.cgi?rev=349406&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] added ability to request shared resources [js or css] inherited [or ancestor] from templated pubs

ex: page.css

@import url(page.inherited.css);
/* pub specific css */ <a href="http://svn.apache.org/viewcvs.cgi?rev=349588&view=rev">Diff</a> 
       Committed by chestnut.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[2.0] don't allow to reload cocoon for security reasons. see bug #37631 <a href="http://svn.apache.org/viewcvs.cgi?rev=350020&view=rev">Diff</a> 
       Committed by josias.</li>
</ul>
<a name="N10599"></a><a name="Documentation"></a>
<h3 class="h4">Documentation</h3>
<ul>
<li>
<img class="icon" alt="add" src="images/add.jpg">[Documentation] started documentation about repository layout <a href="http://svn.apache.org/viewcvs.cgi?rev=330093&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[Documentation] added documentation about usecase parameters <a href="http://svn.apache.org/viewcvs.cgi?rev=332040&view=rev">Diff</a> 
       Committed by andreas.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[Documentation] Add the University of Zuerich to the live site <a href="http://svn.apache.org/viewcvs.cgi?rev=345470&view=rev">Diff</a> 
       Committed by jann.</li>
</ul>
<a name="N105C8"></a><a name="Site"></a>
<h3 class="h4">Site</h3>
<ul>
<li>
<img class="icon" alt="update" src="images/update.jpg">[Site] Adding Uni Zuerich to the live websites <a href="http://svn.apache.org/viewcvs.cgi?rev=348525&view=rev">Diff</a> 
       Committed by jann.</li>
<li>
<img class="icon" alt="update" src="images/update.jpg">[Site] Adding Uni Zuerich to the live websites <a href="http://svn.apache.org/viewcvs.cgi?rev=348526&view=rev">Diff</a> 
       Committed by jann.</li>
</ul>
<a name="N105E9"></a>
<h3 class="h4">Contributors to this release</h3>
<p>We thank the following people for their contributions to this release.</p>
<p>This is a list of all people who participated as committers:<br> (andreas),  (chestnut),  (edith),  (jann),  (josias),  (michi),  (thorsten).</p>
</div>
</div>
<!--+
    |end content
    +-->
<div class="clearboth">&nbsp;</div>
</div>
<div id="footer">
<!--+
    |start bottomstrip
    +-->
<div class="lastmodified">
<script type="text/javascript"><!--
document.write("Last Published: " + document.lastModified);
//  --></script>
</div>
<div class="copyright">
        Copyright &copy;
         2002-2007 <a href="http://www.apache.org/licenses/LICENSE-2.0">The Apache Software Foundation.</a>
</div>
<div id="feedback">
    Send feedback about the website to:
  <a id="feedbackto" href="mailto:dev@lenya.apache.org?subject=Feedback%C2%A0for%C2%A0tlp-2005-11.svn.html">dev@lenya.apache.org</a>
</div>
<!--+
    |end bottomstrip
    +-->
</div>
</body>
</html>
