diff --git a/_projectCommon.php b/_projectCommon.php
deleted file mode 100644
index 9153217..0000000
--- a/_projectCommon.php
+++ /dev/null
@@ -1,23 +0,0 @@
-<?php
-
-	# Set the theme for your project's web pages.
-	# See the Committer Tools "How Do I" for list of themes
-	# https://dev.eclipse.org/committers/
-	# Optional: defaults to system theme 
-	$theme = "solstice";
-	
-	# Define your project-wide Nav bars here.
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# these are optional
-#	$Nav->addNavSeparator("Project Home", 	"index.php");
-#	$Nav->addCustomNav("Downloads", 		"downloads.php", 	"_self", 2);
-#	$Nav->addCustomNav("Installation", 		"install.php", 		"_self", 2);
-#	$Nav->addCustomNav("FAQ / Known Issues","/epp/faq.php",          "_self", 2);
-#	$Nav->addCustomNav("Members", "members.php", "_self", 2);
-#	$Nav->addCustomNav("Bugs", "https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&product=EPP&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED", "_self", 2);
-#    $Nav->addCustomNav("Usage Data Collector", "/epp/usagedata/index.php", "_self", 2);
-    $Nav->addCustomNav("Milestone Builds", "https://www.eclipse.org/downloads/index-developer.php", "_self", 2);
-    $Nav->addCustomNav("CI Builds", "https://ci.eclipse.org/packaging/job/simrel.epp-tycho-build/lastSuccessfulBuild//artifact/org.eclipse.epp.packages/archive/", "_self", 2);
-    $Nav->addCustomNav("Logging / AERI", "https://wiki.eclipse.org/EPP/Logging", "_self", 2);
-
-?>
diff --git a/content.php b/content.php
deleted file mode 100644
index dfe9e2d..0000000
--- a/content.php
+++ /dev/null
@@ -1,190 +0,0 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-
-	#*****************************************************************************
-	#
-	# index.php
-	#
-	# Author: 		Markus Knauer
-	# Date:			2007-02-20
-	#
-	# Description: Download page of the Eclipse Packaging Project
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "EPP Package Content";
-	$pageKeywords	= "eclipse, download, packages, packaging, features, content";
-	$pageAuthor		= "Markus Knauer";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 3);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);
-
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
-
-<div id="maincontent">
-
-
-<!-- MIDCOLUMN START -->
-<div id="midcolumn">
-
-<h1>$pageTitle</h1>
-
-<p>The initial content of the four different packages was collected
-on the EPP newsgroup. Currently the packages contain the following
-features:</p>
-
-<div class="homeitem">
-<h3>Eclipse Tools for Java Developer</h3>
-<p>Contains the basic features that are essential to a Java Programmer, including
-the Java Development Tools, a CVS client, XML Editor and the Mylyn tools.</p>
-<p><a href="http://dev.eclipse.org/newslists/news.eclipse.technology.packaging/msg00042.html">Newsgroup thread</a></p>
-<p>
- org.eclipse.platform<br />
- org.eclipse.cvs<br />
- org.eclipse.jdt<br />
- org.eclipse.xsd<br />
- org.eclipse.emf.common<br />
- org.eclipse.emf.common.ui<br />
- org.eclipse.emf.ecore<br />
- org.eclipse.emf.ecore.edit<br />
- org.eclipse.emf.edit<br />
- org.eclipse.emf.edit.ui<br />
- org.eclipse.xsd.edit<br />
- org.eclipse.wst.xml_ui.feature<br />
- org.eclipse.wst.common_ui.feature<br />
- org.eclipse.gef<br />
- org.eclipse.mylyn_feature<br />
- org.eclipse.mylyn.context_feature<br />
- org.eclipse.mylyn.ide_feature<br />
- org.eclipse.mylyn.java_feature<br />
- org.eclipse.mylyn.bugzilla_feature<br />
-</p>
-</div>
-
-<div class="homeitem">
-<h3>Eclipse Tools for Java Enterprise Developer</h3>
-<p>A huge set of tooling with enterprise features, starting with Java Development 
-Tools, including Webtools, JSF, Mylyn andfor other features.</p>
-<p><a href="http://dev.eclipse.org/newslists/news.eclipse.technology.packaging/msg00040.html">Newsgroup thread</a></p>
-<p>
- org.eclipse.pde<br />
- org.eclipse.platform<br />
- org.eclipse.cvs<br />
- org.eclipse.jdt<br />
- org.eclipse.emf<br />
- org.eclipse.emf.ecore.sdo<br />
- org.eclipse.xsd<br />
- org.eclipse.emf.common<br />
- org.eclipse.emf.common.ui<br />
- org.eclipse.emf.ecore<br />
- org.eclipse.emf.ecore.edit<br />
- org.eclipse.emf.edit<br />
- org.eclipse.emf.edit.ui<br />
- org.eclipse.xsd.edit<br />
- org.eclipse.wst.xml_ui.feature<br />
- org.eclipse.wst<br />
- org.eclipse.jst<br />
- org.eclipse.jpt.feature<br />
- org.eclipse.gef<br />
- org.eclipse.datatools.connectivity.feature<br />
- org.eclipse.datatools.connectivity.oda.designer.feature<br />
- org.eclipse.datatools.connectivity.oda.feature<br />
- org.eclipse.datatools.doc.user<br />
- org.eclipse.datatools.enablement.apache.derby.feature<br />
- org.eclipse.datatools.enablement.feature<br />
- org.eclipse.datatools.enablement.hsqldb.feature<br />
- org.eclipse.datatools.enablement.ibm.feature<br />
- org.eclipse.datatools.enablement.jdbc.feature<br />
- org.eclipse.datatools.enablement.msft.feature<br />
- org.eclipse.datatools.enablement.mysql.feature<br />
- org.eclipse.datatools.enablement.oda.designer.feature<br />
- org.eclipse.datatools.enablement.oda.feature<br />
- org.eclipse.datatools.enablement.oracle.feature<br />
- org.eclipse.datatools.enablement.postgresql.feature<br />
- org.eclipse.datatools.enablement.sybase.feature<br />
- org.eclipse.datatools.modelbase.feature<br />
- org.eclipse.datatools.sqldevtools.data.feature<br />
- org.eclipse.datatools.sqldevtools.ddl.feature<br />
- org.eclipse.datatools.sqldevtools.feature<br />
- org.eclipse.datatools.sqldevtools.parsers.feature<br />
- org.eclipse.datatools.sqldevtools.results.feature<br />
- org.eclipse.mylyn_feature<br />
- org.eclipse.mylyn.context_feature<br />
- org.eclipse.mylyn.ide_feature<br />
- org.eclipse.mylyn.java_feature<br />
- org.eclipse.mylyn.pde_feature<br />
- org.eclipse.mylyn.bugzilla_feature<br />
-</p>
-</div>
-
-<div class="homeitem">
-<h3>Eclipse for RCP Plugin Developer</h3>
-<p>This packages contains a complete set of tools for developers who want to create 
-plug-ins and Rich Client Applications based on Eclipse. It includes a complete SDK 
-with source code and additionally an XML editor and helpful features from the Mylyn 
-project.</p>
-<p><a href="http://dev.eclipse.org/newslists/news.eclipse.technology.packaging/msg00043.html">Newsgroup thread</a></p>
-<p>
- org.eclipse.platform<br />
- org.eclipse.sdk<br />
- org.eclipse.xsd<br />
- org.eclipse.emf.common<br />
- org.eclipse.emf.common.ui<br />
- org.eclipse.emf.ecore<br />
- org.eclipse.emf.ecore.edit<br />
- org.eclipse.emf.edit<br />
- org.eclipse.emf.edit.ui<br />
- org.eclipse.xsd.edit<br />
- org.eclipse.wst.xml_ui.feature<br />
- org.eclipse.wst.common_ui.feature<br />
- org.eclipse.gef<br />
- org.eclipse.mylyn_feature<br />
- org.eclipse.mylyn.context_feature<br />
- org.eclipse.mylyn.ide_feature<br />
- org.eclipse.mylyn.java_feature<br />
- org.eclipse.mylyn.pde_feature<br />
- org.eclipse.mylyn.bugzilla_feature<br />
-</p>
-</div>
-
-<div class="homeitem">
-<h3>Eclipse Tools for C and C++ Developer</h3>
-<p>You need this package for C or C++ programming. The package does <it>not</it>
-contain the compiler itself. If you are using Windows, please install cygwin or 
-MinGW. Linux users can use it with the GNU toolchain that is already available
-on most Linux systems.</p>
-<p><a href="http://dev.eclipse.org/newslists/news.eclipse.technology.packaging/msg00080.html">Newsgroup thread</a></p>
-<p>
-org.eclipse.platform<br />
-org.eclipse.cdt<br />
-org.eclipse.cvs<br />
-</p>
-</div>
-
-<hr class="clearer" />
-</div>
-<!-- MIDCOLUMN END -->
-
-<!-- RIGHTCOLUMN START -->
-<div id="rightcolumn">
-<div class="sideitem">
-</div>
-<!-- RIGHTCOLUMN END -->
-
-</div>
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
diff --git a/description.html b/description.html
deleted file mode 100755
index 90a0562..0000000
--- a/description.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<p>The objectives of the Eclipse Packaging project are to</p>
-<ul>
-	<li><b>Create entry level downloads based on defined user
-	profiles.</b> The project defined and created the EPP downloads of
-    Java Developer,	Java EE Developer, C/C++ Developer and RCP Developer.
-    These downloads are available from the main Eclipse download page.</li>
-	
-	<li><b>Provide an installer that improves the install experience 
-    of new users of Eclipse.</b></li>
-
-	<li><b>Provide a platform that allows the creation of packages
-	(zip/tar downloads) from an update site.</b> The core technology of the
-	project will enable the creation of download packages that are created
-	by bundling Eclipse features from one or multiple Eclipse update sites.</li>
-</ul>
diff --git a/faq.php b/faq.php
deleted file mode 100644
index d83189b..0000000
--- a/faq.php
+++ /dev/null
@@ -1,104 +0,0 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-
-	#*****************************************************************************
-	#
-	# index.php
-	#
-	# Author: 		Markus Knauer
-	# Date:			2007-02-20
-	#
-	# Description: Download page of the Eclipse Packaging Project
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "EPP FAQ / Known Issues";
-	$pageKeywords	= "eclipse, download, packages, packaging, features, content";
-	$pageAuthor		= "Markus Knauer";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 3);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);
-
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
-
-<div id="maincontent">
-
-
-<!-- MIDCOLUMN START -->
-<div id="midcolumn">
-
-<h1>$pageTitle</h1>
-
-<h3>Running the EPP package XY breaks with an out of memory exception?</h3>
-<p>There is an error in the Eclipse launcher that prevents setting the correct
-MaxPermSize automatically to the Java VM launch options. This results in many VM
-crashes, especially in the large JEE package.
-See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=203325">bug 203325</a>
-for further information.</p>
-<p>As a workaround one can add <tt>-XX:MaxPermSize=128m</tt> manually to the 
-<tt>-vmargs</tt> section of the <tt>eclipse.ini</tt>.</p>
-
-<h3>Do the new Eclipse Europa Fall packages contain Eclipse Platform 3.3.0 or 3.3.1?</h3>
-<p>If you download one of the new Eclipse Europa Fall packages 
-('eclipse-XXX-europa-fall-YYY') and you open the about dialog, it still shows up with
-Eclipse version 3.3.0, but it is based on Eclipse Platform 3.3.1.
-See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=205020">bug 205020</a>
-for further information.</p>
-
-<h3>Feature XYZ does not work</h3>
-<p>Please check the version of your Java Runtime Environment. It is highly 
-recommended to use version 1.5 or higher with the EPP packages! While the 
-Eclipse Platform is 
-<a href="http://www.eclipse.org/downloads/moreinfo/jre.php">known to run 
-with version 1.4</a>, some features of the EPP packages will be disabled
-silently. 
-See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=191597">bug 191597</a>
-for further information.</p>
-
-<h3>Using the Eclipse Update Manager with Eclipse IDE for Java EE Developers</h3>
-<p>Because of a missing dependency it is not possible to use the Eclipse Update
-Manager with the 20070628 version of this package. The bug has been reported as
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=194959">bug 194959:
-Pieces missing from Eclipse IDE for Java EE Developers distribution</a>. Packages
-downloaded after 2007-07-02 are fixed.</p>
-<p><strong>Workaround:</strong> Download the fixed package or add the features 
-<strong>Data Tools Platform Enablement</strong> and <strong>Data Tools Platform 
-Documentation</strong> manually from the Europa Discovery Update Site.</p>
-
-<h3>Eclipse does not start</h3>
-<p>In some rare environments the Eclipse Packages do not start on Windows. This
-has been reported in bug 
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=194943">194943</a> and
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=194929">194929</a>. Windows 
-packages downloaded after 2007-07-02 do not contain the 
-<code>-Dosgi.bundlefile.limit=100</code> parameter any more and should work.</p>
-<p><strong>Workaround:</strong> Download a fixed package or remove the line
-<strong><code>-Dosgi.bundlefile.limit=100</code></strong> from the 
-<code>eclipse.ini</code> file.</p>
-
-<hr class="clearer" />
-</div>
-<!-- MIDCOLUMN END -->
-
-<!-- RIGHTCOLUMN START -->
-<div id="rightcolumn">
-</div>
-<!-- RIGHTCOLUMN END -->
-
-</div>
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
diff --git a/index.php b/index.php
index 9483f6d..84584e6 100644
--- a/index.php
+++ b/index.php
@@ -1,115 +1 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-
-	#*****************************************************************************
-	#
-	# index.php
-	#
-	# Author: 		Markus Knauer
-	# Date:			2007-02-20
-	#
-	# Description: Entry page of the Eclipse Packaging Project
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Eclipse Packaging Project (EPP)";
-	$pageKeywords	= "eclipse, download, packages, packaging, udc";
-	$pageAuthor		= "Markus Knauer";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 3);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);
-
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
-
-<div id="maincontent">
-
-
-<!-- MIDCOLUMN START -->
-<div id="midcolumn">
-
-<h1>$pageTitle</h1>
-
-<h2>Project Scope</h2>
-
-<ul>
-	<li><b>Create entry level downloads based on defined user
-	profiles.</b> The project defined and created the EPP downloads of
-  Java Developer,	Java EE Developer, C/C++ Developer and RCP Developer.
-  These downloads are available from the main Eclipse download page.
-  Please follow 
-  <a href="http://wiki.eclipse.org/EPP/How_to_create_a_package">this</a> 
-  description if you want to be a package maintainer.</li>
-
-  <li>Provide the <a href="https://wiki.eclipse.org/EPP/Logging">logging component</a>
-  that aims to host various utility bundles related to logging in the Eclipse IDE.
-  At the moment, logging contains the <b>Automated Error Reporting utility</b> but will
-  likely offer a utility plugin that offers an Eclipse-wide configuration for Logback and
-  maybe Apache Log4J in the future.</li>
-	
-	<li><b>Provide and integrate the EPP Usage Data Collector.</b> (deprecated)
-	The <a href="usagedata">Usage Data Collector</a> collects information about how individuals 
-	are using the Eclipse platform. The intent is to use this data to help 
-	committers and organizations better understand how developers are 
-	using Eclipse.</li>
-
-	<li><b>Provide a platform that allows the creation of packages
-	(zip/tar downloads) from an update site.</b> The core technology of the
-	project will enable the creation of download packages that are created
-	by bundling Eclipse features from one or multiple Eclipse update sites.</li>
-</ul>
-
-<hr class="clearer" />
-
-<table border="0" width="100%">
-  <tr>
-    <td align="center" valign="middle" width="33%">
-      <a class="btn btn-primary btn-lg" href="http://www.eclipse.org/downloads/">Download Release</a>
-    </td>
-    <td align="center" valign="middle" width="33%">
-    <a class="btn btn-primary btn-lg" href="http://www.eclipse.org/downloads/index-developer.php">Download Milestones</a>
-    </td>
-    <td align="center" valign="middle" width="33%">
-      <a class="btn btn-primary btn-lg" href="https://ci.eclipse.org/packaging/job/simrel.epp-tycho-build/lastSuccessfulBuild//artifact/org.eclipse.epp.packages/archive/">Download CI Build</a>
-    </td>
-  </tr>
-</table>
-
-<hr class="clearer" />
-</div>
-<!-- MIDCOLUMN END -->
-
-<!-- RIGHTCOLUMN START -->
-<div id="rightcolumn">
-<div class="sideitem">
-<h6>Project Links</h6>
-<ul>
-	<li><a href="/proposals/packaging/">Project Proposal</a></li>
-</ul>
-</div>
-<div class="sideitem">
-<h6>Active Contributors</h6>
-<ul>
-	<li><a href="http://www.eclipsesource.com">EclipseSource</a></li>
-	<li><a href="http://www.codetrails.com">Codetrails</a></li>
-</ul>
-</div>
-</div>
-<!-- RIGHTCOLUMN END -->
-
-</div>
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+<?php header('Location: https://projects.eclipse.org/projects/technology.packaging'); ?>
diff --git a/members.php b/members.php
deleted file mode 100755
index 4d993fd..0000000
--- a/members.php
+++ /dev/null
@@ -1,95 +0,0 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-
-	#*****************************************************************************
-	#
-	# members.php
-	#
-	# Author: 		Markus Knauer
-	# Date:			2007-02-20
-	#
-	# Description: Listing of the Eclipse Packaging Project members
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "EPP Project Members";
-	$pageKeywords	= "eclipse, download, packages, packaging, installer, archive";
-	$pageAuthor		= "Markus Knauer";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 3);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);
-
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
-
-<div id="maincontent">
-
-<!-- MIDCOLUMN START -->
-<div id="midcolumn">
-<h1>$pageTitle</h1>
-
-<div class="homeitem">
-<h3>Eclipse Packaging Project Committers</h3>
-<ul>
-	<li><span>Markus Knauer (project lead)<br><a href="http://www.innoopract.com">Innoopract Informationssysteme GmbH</a></span></li>
-	<li><span>Dan Rubel (co-project lead)<br><a href="http://www.instantiations.com">Instantiations, Inc.</a></span></li>
-	<li><span>Wayne Beaton<br><a href="http://www.eclipse.org">Eclipse Foundation</a></span></li>
-	<li><span>Jordi B&ouml;hme L&oacute;pez<br><a href="http://www.innoopract.com">Innoopract Informationssysteme GmbH</a></span></li>
-	<li><span>Alexander Kazantsev<br><a href="http://www.xored.com">xored software</a></span></li>
-	<li><span>Henrik Lindberg<br><a href="http://www.cloudsmith.com">Cloudsmith</a></span></li>
-	<li><span>Jeff McAffer<br><a href="http://www.code9.com">Code 9</a></span></li>
-	<li><span>Mark Russell<br><a href="http://www.instantiations.com">Instantiations, Inc.</a></span></li>
-</ul>
-</div>
-
-<div class="homeitem">
-<h3>Eclipse Packaging Project Contributors</h3>
-<ul>
-	<li><span>Andrey Platov<br><a href="http://www.xored.com">xored software</a></span></li>
-</ul>
-</div>
-
-</div>
-
-<!-- MIDCOLUMN END -->
-
-<!-- RIGHTCOLUMN START -->
-<div id="rightcolumn">
-<div class="sideitem">
-<h6>Project Links</h6>
-<ul>
-	<li><a href="http://www.eclipse.org/newsportal/thread.php?group=eclipse.technology.packaging">Newsgroup</a></li>
-	<li><a href="http://dev.eclipse.org/mhonarc/lists/epp-dev/maillist.html">Mailing list</a></li>
-	<li><a href="https://dev.eclipse.org/mailman/listinfo/epp-dev">Subscribe to mailing list</a></li>
-	<li><a href="/proposals/packaging/">Project Proposal</a></li>
-</ul>
-</div>
-<div class="sideitem">
-<h6>Active Contributors</h6>
-<ul>
-  <li><a href="http://www.innoopract.com">INNOOPRACT, Inc.</a></li>
-  <li><a href="http://www.cloudsmith.com">Cloudsmith</a></li>
-  <li><a href="http://www.code9.com">Code 9</a></li>
-  <li><a href="http://www.instantiations.com">Instantiations, Inc.</a></li>
-  <li><a href="http://www.xored.com">xored software</a></li>
-</ul>
-</div>
-</div>
-<!-- RIGHTCOLUMN END -->
-
-</div>
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
diff --git a/plan.php b/plan.php
deleted file mode 100644
index eeff47b..0000000
--- a/plan.php
+++ /dev/null
@@ -1,111 +0,0 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-
-	#*****************************************************************************
-	#
-	# index.php
-	#
-	# Author: 		Markus Knauer
-	# Date:			2007-06-10
-	#
-	# Description: Plan of the Eclipse Packaging Project
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "EPP Project Plan";
-	$pageKeywords	= "eclipse, download, packages, packaging, installer, plan, planning";
-	$pageAuthor		= "Markus Knauer";
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 3);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);
-
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
-
-<div id="maincontent">
-
-
-<!-- MIDCOLUMN START -->
-<div id="midcolumn">
-
-<h1>$pageTitle</h1>
-
-<h2>Europa Timeframe</h2>
-
-<p>Within the Europa timeframe the EPP will</p>
-<ul>
- <li>define initial packages for the Eclipse download page</li>
- <li>build these packages for Windows, Linux-GTK, MacOSX-Carbon</li>
- <li>building packages depends on working update sites; therefore EPP will run its 
-     builds when the <a href="http://dash.eclipse.org/~bfreeman/europa/">Europa build 
-     status</a> is green; package updates will be available for release candidates
-     about one day after its release (see 
-     <a href="http://wiki.eclipse.org/index.php/Europa_Simultaneous_Release#Milestones_and_Release_Candidates">
-     Europa wiki page</a>)</li>
-</ul>
-
-<h2>Ganymede Timeframe</h2>
-
-<ul>
- <li>Create a package eco system where package maintainer can add new packages.</li>
- <li>Integrate the EPP Usaged Data Collector in all packages.</li>
- <li>Deliver milestone builds and nightly build based on the Ganymede Update Site in time.</li>
- <li>Set up an automated build process and integrate it with the Ganymatic build.</li>
-</ul>
-
-<h2>Planning</h2>
-
-<table border="1">
-<tr><th>Dates</th><th></th></tr>
-
-<tr><td>Feb 22</td><td>Ganymede M5 (EPP)</td></tr>
-<tr><td>Feb 22</td><td>EclipseCon Memory Sticks (EPP)</td></tr>
-<tr><td>Feb 27</td><td>Europa Winter (EPP)</td></tr>
-<tr><td>Feb 29</td><td>Europa Winter (Public Access)</td></tr>
-
-<tr><td>Mar 17</td><td>EclipseCon</td></tr>
-<tr><td>Mar 20</td><td>EclipseCon end</td></tr>
-<tr><td style="background-color: rgb(255, 204, 204);">Mar 31</td><td style="background-color: rgb(255, 204, 204);">EPP new packages must be announced on bugzilla by package maintainer</td></tr>
-
-<tr><td>Apr 11</td><td>Ganymede M6 API Freeze (EPP)</td></tr>
-<tr><td style="background-color: rgb(255, 204, 204);">Apr 11</td><td style="background-color: rgb(255, 204, 204);">EPP new packages and working configuration files available</td></tr>
-
-<tr><td>May 09</td><td>Ganymede M7 (EPP)</td></tr>
-<tr><td style="background-color: rgb(255, 204, 204);">May 09</td><td style="background-color: rgb(255, 204, 204);">EPP package content feature freeze</td></tr>
-<tr><td style="background-color: rgb(255, 204, 204);">May 09</td><td style="background-color: rgb(255, 204, 204);">EPP package build system feature freeze</td></tr>
-<tr><td style="background-color: rgb(255, 204, 204);">May 20</td><td style="background-color: rgb(255, 204, 204);">EPP release review (UDC)</td></tr>
-<tr><td>May 23</td><td>Ganymede RC1 (EPP)</td></tr>
-<tr><td>May 30</td><td>Ganymede RC2 (EPP)</td></tr>
-
-<tr><td>Jun 06</td><td>Ganymede RC3 (EPP)</td></tr>
-<tr><td>Jun 13</td><td>Ganymede RC4 (EPP)</td></tr>
-<tr><td>Jun 23</td><td>Ganymede Final (EPP)</td></tr>
-<tr><td>Jun 25</td><td>Ganymede Final (Public Access)</td></tr>
-
-</table>
-
-<hr class="clearer" />
-</div>
-<!-- MIDCOLUMN END -->
-
-<!-- RIGHTCOLUMN START -->
-<div id="rightcolumn">
-</div>
-<!-- RIGHTCOLUMN END -->
-
-</div>
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
diff --git a/project-info/eclipse-project-ip-log-1.1.html b/project-info/eclipse-project-ip-log-1.1.html
deleted file mode 100644
index 315b9b0..0000000
--- a/project-info/eclipse-project-ip-log-1.1.html
+++ /dev/null
@@ -1,195 +0,0 @@
-<!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">
-<title>IP Log for technology.packaging</title>
-</head>
-<body>
-
-
-<div id="midcolumn">
-<h1>IP Log for technology.packaging</h1>
-
-<h2>Licenses</h2>
-  <ul>
-      <li>Eclipse Public License, 1.0</li>
-    </ul>
-
-<h2>Third-Party Code</h2>
-<table border="1" cellpadding="3" cellspacing="0">
-<tbody><tr>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">CQ</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">Third-Party Code</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">License</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">Use</th>
-</tr>
-<tr>
-  <td><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=1395">1395</a></td>
-
-  <td>installer Version: 2.5.1</td>
-  <td>Eclipse Public License</td>
-  <td></td>
-  </tr>
-  <tr>
-  <td><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=1536">1536</a></td>
-  <td>registry Version: 3.1.3</td>
-
-  <td>Public Domain </td>
-  <td></td>
-  </tr>
-  <tr>
-  <td><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=1898">1898</a></td>
-  <td>Usage Data Collector - technology.packaging initial contribution</td>
-  <td>Eclipse Public License</td>
-
-  <td></td>
-  </tr>
-  <tr>
-  <td><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=1913">1913</a></td>
-  <td>org.apache.commons.httpclient Version: 3.0.1 (PB CQ1073)</td>
-  <td>Apache License, 2.0</td>
-  <td>unmodified binary </td>
-
-  </tr>
-  <tr>
-  <td><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=1914">1914</a></td>
-  <td>org.apache.commons.logging Version: 1.0.4 (PB CQ1576)</td>
-  <td>Apache License, 2.0</td>
-  <td>unmodified binary </td>
-  </tr>
-
-  <tr>
-  <td><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=1915">1915</a></td>
-  <td>org.apache.commons.codec Version: 1.3.0 (PB 1562)</td>
-  <td>Apache License, 2.0</td>
-  <td>unmodified binary </td>
-  </tr>
-  <tr>
-
-  <td><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2587">2587</a></td>
-  <td>P2 integration for EPP Wizard</td>
-  <td>Eclipse Public License</td>
-  <td></td>
-  </tr>
-  <tr>
-  <td><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2670">2670</a></td>
-
-  <td>log4j 1.2.13  Version: 1.2.13 (ATO CQ1593) (using Orbit CQ2168)</td>
-  <td>Apache License, 2.0</td>
-  <td></td>
-  </tr>
-  </tbody></table>
-<p>
-</p><p><em>No pre-req dependencies</em></p>
-<h2>Committers</h2>
-
-
-<table border="1" cellpadding="3" cellspacing="0">
-<tbody><tr><th colspan="3" bordercolor="#7A79A7" bgcolor="#7a79a7">Past and Present Active</th></tr>
-<tr><th bordercolor="#7A79A7" bgcolor="#7a79a7">Name</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">Organization</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">&nbsp;</th>
-</tr>
-<tr>
-  <td>Wayne Beaton</td>
-  <td>Eclipse Foundation </td>
-
-    <td></td>
-    </tr>
-  <tr>
-  <td>Jordi Böhme López</td>
-  <td>Innoopract </td>
-    <td></td>
-    </tr>
-  <tr>
-
-  <td>Alexander Kazantsev</td>
-  <td>Xored Software, Inc. </td>
-    <td></td>
-    </tr>
-  <tr>
-  <td>Markus Knauer</td>
-  <td>Innoopract </td>
-
-    <td></td>
-    </tr>
-  <tr>
-  <td>Dan Rubel</td>
-  <td>Instantiations, Inc. </td>
-    <td></td>
-    </tr>
-  <tr>
-
-  <td>Mark Russell</td>
-  <td>Instantiations, Inc. </td>
-    <td></td>
-    </tr>
-  </tbody></table>
-<p>
-
-
-</p><table border="1" cellpadding="3" cellspacing="0">
-<tbody><tr><th colspan="3" bordercolor="#7A79A7" bgcolor="#7a79a7">Never Active</th></tr>
-
-<tr><th bordercolor="#7A79A7" bgcolor="#7a79a7">Name</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">Organization</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">&nbsp;</th>
-</tr>
-<tr>
-    <td>Leif Frenzel</td>
-    <td>Innoopract </td>
-        <td></td>
-        </tr>
-
-    <tr>
-    <td>Henrik Lindberg</td>
-    <td>Cloudsmith Inc. </td>
-        <td></td>
-        </tr>
-    <tr>
-    <td>Jeff McAffer</td>
-
-    <td>Code 9 </td>
-        <td></td>
-        </tr>
-    <tr>
-    <td>Elias Volanakis</td>
-    <td>Innoopract </td>
-        <td></td>
-
-        </tr>
-      </tbody></table>
-  <p>
-  </p><h2>Contributors and Their Contributions</h2>
-<table border="1" cellpadding="3" cellspacing="0">
-<tbody><tr>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">Bug</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">Size</th>
-<th bordercolor="#7A79A7" bgcolor="#7a79a7">Description</th>
-
-</tr>
-<tr><td colspan="3" style="background-color: rgb(221, 221, 221);">Manuel&nbsp;Woelker (eclipsesource.com)</td>
-    </tr>
-  <tr>
-    <td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=244666">244666</a></td>
-    <td>463</td>
-    <td>[Patch] Better P2 integration for EPP Wizard<br>comment #0</td>
-
-        </tr>
-  <tr>
-    <td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=244666">244666</a></td>
-    <td>87</td>
-    <td>[Patch] Better P2 integration for EPP Wizard<br>comment #1</td>
-        </tr>
-  </tbody></table>
-
-<h2>Repositories</h2>
-<p>The information contained in this log was generated by using commit information from the following repositories:</p>
-<div style="padding-left: 2em;">/cvsroot/technology/org.eclipse.epp</div>
-<p>
-</p></div>
-
-
-
-</body>
-</html>
\ No newline at end of file
diff --git a/project-info/eclipse-project-ip-log.csv b/project-info/eclipse-project-ip-log.csv
deleted file mode 100644
index e402822..0000000
--- a/project-info/eclipse-project-ip-log.csv
+++ /dev/null
@@ -1,26 +0,0 @@
-"Section 1 (Committers)",,,,
-,,,,
-"Name","dev.eclise.org Login","Status",,
-"Wayne Beaton","wbeaton","committer since 12/2007",,
-"Alexander Kazantsev","akazantse","initial committer",,
-"Markus Knauer","mknauer","initial committer",,
-"Dan Rubel","drubel","initial committer",,
-"Mark Russell","mrussell","initial committer",,
-"Elias Volanakis","evolanaki","initial committer",,
-,,,,
-,,,,
-"Section 2 (Developers)",,,,
-,,,,
-"Component","Bug #","Contributor","Size (LOC)","Committer"
-"Usage Data Collector (org.eclipse.epp.udc.[gathering,recording,ui])",212169,"Wayne Beaton",1426,"Markus Knauer"
-,,,,
-,,,,
-"Section 3 (Third Party Software)",,,,
-,,,,
-"Name including version","IPzilla #","directory location or jar file","license name and version","usage (e.g. modified/unmodified, source, object, derivative work, entire package or which subset)"
-"Installer 2.5.1 Contribution",1395,"plugins/org.eclipse.epp.installer.*","EPL","unmodified source, not distributed, not part of the Ganymede Release"
-"Installer Registry 3.1.3",1536,"plugins/org.eclipse.epp.installer.core.win32/registry/com/ice/jni/registry","Non-EPL Public Domain","unmodified source, not distributed, not part of the Ganymede Release"
-"Usage Data Collector",1898,"plugins/org.eclipse.epp.udc.*","EPL","unmodified source"
-"org.apache.commons.httpclient Version: 3.0.1 (PB CQ1073)",1913,"from Orbit","APL 2.0","from Orbit"
-"org.apache.commons.logging Version: 1.0.4 (PB CQ1576)",1914,"from Orbit","APL 2.0","from Orbit"
-"org.apache.commons.codec Version: 1.3.0 (PB 1562)",1915,"from Orbit","APL 2.0","from Orbit"
diff --git a/project-info/executive-summary.html b/project-info/executive-summary.html
deleted file mode 100755
index f6cd4ea..0000000
--- a/project-info/executive-summary.html
+++ /dev/null
@@ -1,13 +0,0 @@
-<p>The Eclipse Packaging Project is a sub-project of the Eclipse
-Technology Project. It has been initiated by Innoopract and 
-Instantiations, both companies are long term members of the Eclipse
-Foundation.</p>
-<p>The project is building specialised Eclipse packages for the 
-Europa Release and for the Ganymede Release.</p>
-<p>The next steps will include:</p>
-<ul>
-	<li>Package builds for Europa Winter Maintenance Release</li>
-	<li>Package builds for Ganymede Milestones</li>
-  <li>Inclusion of the EPP Usage Data Collector</li>
-	<li>Rework of tooling to reflect changes in Ganymede and in P2</li>
-</ul>
diff --git a/project-info/home-page-one-liner.html b/project-info/home-page-one-liner.html
deleted file mode 100755
index bd60677..0000000
--- a/project-info/home-page-one-liner.html
+++ /dev/null
@@ -1 +0,0 @@
-The Eclipse Packaging Project (EPP)
\ No newline at end of file
diff --git a/project-info/maillist b/project-info/maillist
deleted file mode 100644
index 2ef8cfa..0000000
--- a/project-info/maillist
+++ /dev/null
@@ -1 +0,0 @@
-::epp-dev::Developers Mailing list for the EPP project.
diff --git a/project-info/newsgroup b/project-info/newsgroup
deleted file mode 100644
index 0b7d94a..0000000
--- a/project-info/newsgroup
+++ /dev/null
@@ -1 +0,0 @@
-::eclipse.technology.packaging::Discussions about the content of the EPP packages, the technical infrastructure, and the installer.
\ No newline at end of file
diff --git a/project-info/plan-v1.2.xml b/project-info/plan-v1.2.xml
deleted file mode 100755
index a96f077..0000000
--- a/project-info/plan-v1.2.xml
+++ /dev/null
@@ -1,147 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
-  <!--  Use this to test local rendering in firefox -->
-  <!--  <?xml-stylesheet type="text/xsl" href="project-plan-render.xsl"?>  -->
-<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
-<plan
-  xmlns="http://www.eclipse.org/project/plan"
-  xmlns:html="http://www.w3.org/1999/xhtml"
-  name="EPP"
-  plan-format="1.0">
-  <release
-    projectid="technology.packaging"
-    version="1.2"></release>
-  <introduction>
-    <html:p>The Eclipse Packaging Project (EPP) is responsible for creating technology that makes
-      it easier for new users to consume the output of other Eclipse projects and for coordinating
-      the package releases together with the yearly release train. In order to achieve this goal,
-      EPP is active on different levels since the Europa Release 2007:</html:p>
-    <html:ul>
-      <html:li>
-        <html:b>Create entry level downloads based on defined user profiles.</html:b>
-        The project defined and created the EPP downloads of Java Developer, Java EE Developer,
-        C/C++ Developer and RCP Developer. These downloads are available from the main Eclipse
-        download page. In addition to that, EPP coordinates with other package maintainers the
-        creation of new package definitions and ensures that the packages are tested.
-      </html:li>
-      <html:li>
-        <html:b>Provide and integrate the EPP Usage Data Collector (UDC).</html:b>
-        The Usage Data Collector collects information about how individuals are using the Eclipse
-        platform. The intent is to use this data to help committers and organizations better
-        understand how developers are using Eclipse.
-      </html:li>
-      <html:li>
-        <html:b>Provide and integrate the Eclipse Marketplace Client (MPC).</html:b>
-        The MPC provides tight install integration between the Eclipse workspace and Eclipse Marketplace, 
-        plus other third party solution listings. 
-      </html:li>
-      <html:li>
-        <html:b>Provide a platform that allows the creation of packages (zip/tar downloads)
-          from an update site.</html:b>
-        The core technology of the project will enable the creation of download packages that are
-        created by bundling Eclipse features from one or multiple Eclipse update sites.
-      </html:li>
-      <html:li>
-        <html:b>Create and manage a new dynamic installer.</html:b>
-        EPP creates a new RAP-based wizard that enables a user to choose and pick software
-        components from other Eclipse projects. The output is a customized p2-installer that guides
-        the user through the initial install process and downloads the necessary software
-        components.
-      </html:li>
-    </html:ul>
-  </introduction>
-  <release_deliverables/>
-  <release_milestones>
-    <preamble>
-      <html:p>All EPP releases appear simultaneously with the release train releases (here:
-        Helios).</html:p>
-    </preamble>
-    <milestone
-      milestone="Helios M6"
-      date="2010-03-19"/>
-    <milestone
-      milestone="Helios M7"
-      date="2010-05-07">
-      <html:p>All packages must be defined and their content must be specified.</html:p>
-    </milestone>
-    <milestone
-      milestone="Helios RC1"
-      date="2010-05-21"/>
-    <milestone
-      milestone="Helios RC2"
-      date="2010-05-28"/>
-    <milestone
-      milestone="Helios RC3"
-      date="2010-06-04"/>
-    <milestone
-      milestone="Helios RC4"
-      date="2010-06-11"/>
-    <milestone
-      milestone="Helios RC5"
-      date="2010-06-23"/>
-    <postamble/>
-  </release_milestones>
-  <target_environments>
-    <html:p>EPP creates its packages for Windows 32-bit, Windows 64-bit, Linux 32-bit, Linux 64-bit and Mac OSX.
-      All of the packages require at least a JVM 1.5 because of the software components that are
-      included in the packages.</html:p>
-    <html:p>Source code used and developed within the project needs a JVM 1.5 or higher.
-    </html:p>
-    <internationalization>
-    <html:div><html:p>All outputs produced are prepared for internationalization via Babel.</html:p></html:div>
-    </internationalization>
-  </target_environments>
-  <compatibility_with_previous_releases>
-  <html:div><html:p>All frameworks and APIs produced with this release are compatible with previous releases</html:p></html:div>
-  </compatibility_with_previous_releases>
-  <themes_and_priorities>
-    <preamble/>
-    <theme
-      name="Helios Packages">
-      <description>
-        <html:p>EPP will create and deliver the packages for the next release train. The exact
-          content and the number of packages are subject to change and depend on the community
-          feedback and help.</html:p>
-      </description>
-      <committed>
-        <html:ul>
-          <html:li>Eclipse IDE for Java EE Developers</html:li>
-          <html:li>Eclipse IDE for Java Developers</html:li>
-          <html:li>Eclipse IDE for C/C++ Developers</html:li>
-          <html:li>Eclipse Modeling Tools</html:li>
-          <html:li>Eclipse for RCP/Plug-in Developers</html:li>
-          <html:li>Eclipse IDE for Java and Report Developers</html:li>
-          <html:li>Eclipse IDE for PHP Developers</html:li>
-          <html:li>Pulsar for Mobile Java Developers</html:li>
-          <html:li>Eclipse SOA Platform for Java and SOA Developers</html:li>
-        </html:ul><html:div>Some xhtml content here.  Make sure to use the prefix before the elements</html:div>
-        
-      </committed>
-    </theme>
-    <theme
-      name="Dynamic Package Delivery Component">
-      <description>
-        <html:p> The dynamic package delivery component provides an extensible framework for, and an
-          exemplary implementation of, a service for dynamically selecting and
-          downloading/installing installable units.</html:p>
-      </description>
-      <committed>
-        <html:p>Preview available for Friends-of-Eclipse.</html:p>
-      </committed>
-    </theme>
-        <theme
-      name="Usage Data Collector (UDC)">
-      <description>
-        <html:p>Bug fixes only are planned for this release.</html:p>
-      </description>
-      <committed/>
-    </theme>
-        <theme
-      name="Marketplace Client (MPC)">
-      <description>
-        <html:p>The Marketplace Client will be introduced with this release.</html:p>
-      </description>
-      <committed/>
-    </theme>
-  </themes_and_priorities>
-  <appendix/>
-</plan>
\ No newline at end of file
diff --git a/project-info/plan-v1.3.xml b/project-info/plan-v1.3.xml
deleted file mode 100755
index c6bc7dd..0000000
--- a/project-info/plan-v1.3.xml
+++ /dev/null
@@ -1,149 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
-  <!--  Use this to test local rendering in firefox -->
-  <!--  <?xml-stylesheet type="text/xsl" href="project-plan-render.xsl"?>  -->
-<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
-<plan
-  xmlns="http://www.eclipse.org/project/plan"
-  xmlns:html="http://www.w3.org/1999/xhtml"
-  name="EPP"
-  plan-format="1.0">
-  <release
-    projectid="technology.packaging"
-    version="1.3"></release>
-  <introduction>
-    <html:p>The Eclipse Packaging Project (EPP) is responsible for creating technology that makes
-      it easier for new users to consume the output of other Eclipse projects and for coordinating
-      the package releases together with the yearly release train. In order to achieve this goal,
-      EPP is active on different levels since the Europa Release 2007:</html:p>
-    <html:ul>
-      <html:li>
-        <html:b>Create entry level downloads based on defined user profiles.</html:b>
-        The project defined and created the EPP downloads of Java Developer, Java EE Developer,
-        C/C++ Developer and RCP Developer. These downloads are available from the main Eclipse
-        download page. In addition to that, EPP coordinates with other package maintainers the
-        creation of new package definitions and ensures that the packages are tested.
-      </html:li>
-      <html:li>
-        <html:b>Provide and integrate the EPP Usage Data Collector (UDC).</html:b>
-        The Usage Data Collector collects information about how individuals are using the Eclipse
-        platform. The intent is to use this data to help committers and organizations better
-        understand how developers are using Eclipse.
-      </html:li>
-      <html:li>
-        <html:b>Provide and integrate the Eclipse Marketplace Client (MPC).</html:b>
-        The MPC provides tight install integration between the Eclipse workspace and Eclipse Marketplace, 
-        plus other third party solution listings. 
-      </html:li>
-      <html:li>
-        <html:b>Provide a platform that allows the creation of packages (zip/tar downloads)
-          from an update site.</html:b>
-        The core technology of the project will enable the creation of download packages that are
-        created by bundling Eclipse features from one or multiple Eclipse update sites.
-      </html:li>
-      <html:li>
-        <html:b>Create and manage a new dynamic installer.</html:b>
-        EPP creates a new RAP-based wizard that enables a user to choose and pick software
-        components from other Eclipse projects. The output is a customized p2-installer that guides
-        the user through the initial install process and downloads the necessary software
-        components.
-      </html:li>
-    </html:ul>
-  </introduction>
-  <release_deliverables/>
-  <release_milestones>
-    <preamble>
-      <html:p>All EPP releases appear simultaneously with the release train releases (here:
-        Helios).</html:p>
-    </preamble>
-    <milestone
-      milestone="Helios M6"
-      date="2010-03-19"/>
-    <milestone
-      milestone="Helios M7"
-      date="2010-05-07">
-      <html:p>All packages must be defined and their content must be specified.</html:p>
-    </milestone>
-    <milestone
-      milestone="Helios RC1"
-      date="2010-05-21"/>
-    <milestone
-      milestone="Helios RC2"
-      date="2010-05-28"/>
-    <milestone
-      milestone="Helios RC3"
-      date="2010-06-04"/>
-    <milestone
-      milestone="Helios RC4"
-      date="2010-06-11"/>
-    <milestone
-      milestone="Helios RC5"
-      date="2010-06-23"/>
-    <postamble/>
-  </release_milestones>
-  <target_environments>
-    <html:p>EPP creates its packages for Windows 32-bit, Windows 64-bit, Linux 32-bit, Linux 64-bit and Mac OSX.
-      All of the packages require at least a JVM 1.5 because of the software components that are
-      included in the packages.</html:p>
-    <html:p>Source code used and developed within the project needs a JVM 1.5 or higher.
-    </html:p>
-    <internationalization>
-    <html:div><html:p>All outputs produced are prepared for internationalization via Babel.</html:p></html:div>
-    </internationalization>
-  </target_environments>
-  <compatibility_with_previous_releases>
-  <html:div><html:p>All frameworks and APIs produced with this release are compatible with previous releases</html:p></html:div>
-  </compatibility_with_previous_releases>
-  <themes_and_priorities>
-    <preamble/>
-    <theme
-      name="Helios Packages">
-      <description>
-        <html:p>EPP will create and deliver the packages for the next release train. The exact
-          content and the number of packages are subject to change and depend on the community
-          feedback and help.</html:p>
-      </description>
-      <committed>
-        <html:ul>
-          <html:li>Eclipse IDE for Java EE Developers</html:li>
-          <html:li>Eclipse IDE for Java Developers</html:li>
-          <html:li>Eclipse IDE for C/C++ Developers</html:li>
-          <html:li>Eclipse Modeling Tools</html:li>
-          <html:li>Eclipse for RCP/Plug-in Developers</html:li>
-          <html:li>Eclipse IDE for Java and Report Developers</html:li>
-          <html:li>Eclipse IDE for PHP Developers</html:li>
-          <html:li>Pulsar for Mobile Java Developers</html:li>
-          <html:li>Eclipse SOA Platform for Java and SOA Developers</html:li>
-        </html:ul><html:div>Some xhtml content here.  Make sure to use the prefix before the elements</html:div>
-        
-      </committed>
-    </theme>
-    <theme
-      name="Dynamic Package Delivery Component">
-      <description>
-        <html:p> The dynamic package delivery component provides an extensible framework for, and an
-          exemplary implementation of, a service for dynamically selecting and
-          downloading/installing installable units.</html:p>
-      </description>
-      <committed>
-        <html:p>Preview available for Friends-of-Eclipse.</html:p>
-      </committed>
-    </theme>
-        <theme
-      name="Usage Data Collector (UDC)">
-      <description>
-        <html:p>Bug fixes only are planned for this release.</html:p>
-      </description>
-      <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?keywords=plan&amp;query_format=advanced&amp;keywords_type=allwords&amp;component=Usage%20Data%20Collector&amp;product=EPP&amp;target_milestone=1.3.0"/>
-    </theme>
-        <theme
-      name="Marketplace Client (MPC)">
-      <description>
-        <html:p>The Marketplace Client will be introduced with this release.</html:p>
-      </description>
-      <committed>      
-        <html:p>New code.</html:p>
-      </committed>
-    </theme>
-  </themes_and_priorities>
-  <appendix/>
-</plan>
\ No newline at end of file
diff --git a/project-info/plan.xml b/project-info/plan.xml
deleted file mode 100644
index 720d248..0000000
--- a/project-info/plan.xml
+++ /dev/null
@@ -1,136 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
-  <!--  Use this to test local rendering in firefox -->
-  <!--  <?xml-stylesheet type="text/xsl" href="project-plan-render.xsl"?>  -->
-<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
-<plan
-  xmlns="http://www.eclipse.org/project/plan"
-  xmlns:html="http://www.w3.org/1999/xhtml"
-  name="EPP"
-  plan-format="1.0">
-  <release
-    projectid="technology.packaging"
-    version="1.1"></release>
-  <introduction>
-    <html:p>The Eclipse Packaging Project (EPP) is responsible for creating technology that makes
-      it easier for new users to consume the output of other Eclipse projects and for coordinating
-      the package releases together with the yearly release train. In order to achieve this goal,
-      EPP is active on different levels since the Europa Release 2007:</html:p>
-    <html:ul>
-      <html:li>
-        <html:b>Create entry level downloads based on defined user profiles.</html:b>
-        The project defined and created the EPP downloads of Java Developer, Java EE Developer,
-        C/C++ Developer and RCP Developer. These downloads are available from the main Eclipse
-        download page. In addition to that, EPP coordinates with other package maintainers the
-        creation of new package definitions and ensures that the packages are tested.
-      </html:li>
-      <html:li>
-        <html:b>Provide and integrate the EPP Usage Data Collector.</html:b>
-        The Usage Data Collector collects information about how individuals are using the Eclipse
-        platform. The intent is to use this data to help committers and organizations better
-        understand how developers are using Eclipse.
-      </html:li>
-      <html:li>
-        <html:b>Provide a platform that allows the creation of packages (zip/tar downloads)
-          from an update site.</html:b>
-        The core technology of the project will enable the creation of download packages that are
-        created by bundling Eclipse features from one or multiple Eclipse update sites.
-      </html:li>
-      <html:li>
-        <html:b>Create and manage a new dynamic installer.</html:b>
-        EPP creates a new RAP-based wizard that enables a user to choose and pick software
-        components from other Eclipse projects. The output is a customized p2-installer that guides
-        the user through the initial install process and downloads the necessary software
-        components.
-      </html:li>
-    </html:ul>
-  </introduction>
-  <release_deliverables/>
-  <release_milestones>
-    <preamble>
-      <html:p>All EPP releases appear simultaneously with the release train releases (here:
-        Galileo).</html:p>
-    </preamble>
-    <milestone
-      milestone="Galileo M1 - no EPP builds"
-      date="n/a"/>
-    <milestone
-      milestone="Galileo M2 - no EPP builds"
-      date="n/a"/>
-    <milestone
-      milestone="Galileo M3 - to be discussed: EPP builds necessary?"
-      date="n/a"/>
-    <milestone
-      milestone="Galileo M4"
-      date="2009-01-08"/>
-    <milestone
-      milestone="Galileo M5"
-      date="2009-02-12"/>
-    <milestone
-      milestone="Galileo M6"
-      date="2009-03-20"/>
-    <milestone
-      milestone="Galileo M7"
-      date="2009-05-08">
-      <html:p>All packages must be defined and their content must be specified.</html:p>
-    </milestone>
-    <milestone
-      milestone="Galileo RC1"
-      date="2009-05-21"/>
-    <milestone
-      milestone="Galileo RC2"
-      date="2009-05-28"/>
-    <milestone
-      milestone="Galileo RC3"
-      date="2009-06-04"/>
-    <milestone
-      milestone="Galileo RC4"
-      date="2009-06-11"/>
-    <milestone
-      milestone="Galileo RC5"
-      date="2009-06-18"/>
-    <postamble/>
-  </release_milestones>
-  <target_environments>
-    <html:p>EPP creates its packages for Windows 32-bit, Linux 32-bit, Linux 64-bit and Mac OSX.
-      All of the packages require at least a JVM 1.5 because of the software components that are
-      included in the packages.</html:p>
-    <html:p>Source code used and developed within the project needs a JVM 1.5 or higher.
-    </html:p>
-    <internationalization/>
-  </target_environments>
-  <compatibility_with_previous_releases/>
-  <themes_and_priorities>
-    <preamble/>
-    <theme
-      name="Galileo Packages">
-      <description>
-        <html:p>EPP will create and deliver the packages for the next release train. The exact
-          content and the number of packages are subject to change and depend on the community
-          feedback and help.</html:p>
-      </description>
-      <committed>
-        <html:p>Galileo Packages</html:p>
-        <html:ul>
-          <html:li>Eclipse IDE for Java EE Developers</html:li>
-          <html:li>Eclipse IDE for Java Developers</html:li>
-          <html:li>Eclipse IDE for C/C++ Developers</html:li>
-          <html:li>Eclipse Modeling Tools</html:li>
-          <html:li>Eclipse for RCP/Plug-in Developers</html:li>
-          <html:li>Eclipse IDE for Java and Report Developers</html:li>
-        </html:ul>
-      </committed>
-    </theme>
-    <theme
-      name="Dynamic Package Delivery Component">
-      <description>
-        <html:p> The dynamic package delivery component provides an extensible framework for, and an
-          exemplary implementation of, a service for dynamically selecting and
-          downloading/installing installable units.</html:p>
-      </description>
-      <committed>
-        <html:p>Preview available for Friends-of-Eclipse.</html:p>
-      </committed>
-    </theme>
-  </themes_and_priorities>
-  <appendix/>
-</plan>
\ No newline at end of file
diff --git a/project-info/project-info.xml b/project-info/project-info.xml
deleted file mode 100644
index ed56799..0000000
--- a/project-info/project-info.xml
+++ /dev/null
@@ -1,134 +0,0 @@
-<?xml version='1.0' encoding='iso-8859-1'?>
-<project>
-	<!--
-		- Unless otherwise specified, all URLs are to be specified using rooted relative
-		- paths. In other words:
-		-    CORRECT: "/webtools/foo/bar.php"
-		-    INCORRECT: "foo/bar.php"
-		-    INCORRECT: "http://www.eclipse.org/webtools/foo/bar.php"
-	-->
-
-	<name>Eclipse Packaging Project</name>
-	<short-name>EPP</short-name>
-
-	<bugzilla>
-		<product name="EPP" />
-	</bugzilla>
-
-	<cvs repository="/cvsroot/technology/">
-		<module path="org.eclipse.epp" />
-	</cvs>
-
-	<description url="/epp/index.php"
-		paragraph-url="/epp/project-info/project-page-paragraph.html" />
-
-	<leaders url="/epp/members.php" />
-    <team url="/epp/members.php"/>
-
-	<!--
-		- In addition to the description, each Eclipse project is also required to/
-		- provide an up-to-date status summary. "Up to date" means revised at least
-		- quarterly. 
-		- The required <summary paragraph-url="..."> points to a file
-		- containing a number of simple HTML paragraphs with an executive summary
-		- of the project status.
-		- This file is often stored in the /project-info/ directory, thus the
-		- url would be something like "/technology/project-info/executive-summary.html".
-		-
-		-
-		- Please provide the URL of the project summary paragraph
-	-->
-	<summary
-		paragraph-url="/technology/project-info/executive-summary.html" />
-
-	<!--
-		- It is important to help new users get started with an Eclipse project
-		- because most Eclipse projects are solving some difficult technical
-		- problem and thus are somewhat complex. The <getting-started> element
-		- points to a web page on the project's site that describes how to
-		- get started using and extending the project's tools and frameworks.
-		-
-		-
-		- Please provide the URL of the project getting started guide     
-	-->
-	<getting-started url="http://wiki.eclipse.org/index.php/Category:EPP" />
-
-	<!--
-		- It is also important to help new contributors get started with an Eclipse project.
-		- Most Eclipse projects have interesting/complex development environment
-		- setups or to-do lists. The <contributing> element
-		- points to a web page on the project's site that describes how to
-		- get started developing on, and contributing to, the project.
-		-
-		- Please provide the URL of the project getting started guide     
-	-->
-	<contributing url="http://wiki.eclipse.org/index.php/Category:EPP" />
-
-	<!--
-		- Each Eclipse project is required to maintain a current Project IP Log.
-		- See http://www.eclipse.org/projects/dev_process/project-log.php
-		- The <ip-log> contains the URL of that log.  If the project has
-		- other legal information as well, it can use the <legal> element
-		- instead and then include the IP Log information on the Legal web page.
-	-->
-	<!--
-		<ip-log url="" />
-		<legal url="" />
-	-->
-
-	<mailing-lists>
-		<list name="epp-dev" />
-		<list name="provisioning-dev" />
-	</mailing-lists>
-
-	<newsgroups>
-		<newsgroup name="eclipse.technology.packaging" />
-	</newsgroups>
-
-	<!--
-		- The dashboard attempts to measure the liveness of a project in many
-		- ways including the traffic on the mailing lists and newsgroups. There
-		- are other places where significant project-related traffic can occur
-		- including blogs and articles. When listed here, the dashboard incorporates
-		- them into the liveness measure (or rather, "will incorporate").
-	-->
-	<!--
-		<articles />
-		<blogs />
-	-->
-
-	<!--
-		- Each Eclipse project needs to have a plan both for its internal purposes
-		- (to guide development and resource allocation) and for the larger Eclipse
-		- community and ecosystem to understand what will be delivered and when
-		- it will be delivered.
-	-->
-	<project-plan url="/epp/plan.php" />
-
-	<!--
-		- Each Eclipse project creates (optional) nightly builds and milestone builds,
-		- but the important builds of a project are the releases. This section of the
-		- status file records the completed (past) and scheduled (future) releases of
-		- the project. 
-		- The status, name, and date are required attributes. The download is optional
-		- and only valid for completed releases; the plan is optional and valid for
-		- all releases.  The three valid types of releases are, in order of ascending 
-		- uncertainity: "completed", "scheduled", and "tentative".  Dates can be
-		- specified as particular day DD/MM/YYYY (e.g., 22/03/2005) or a particular
-		- month MM/YYYY (e.g., 10/2005), or a quarter NQYYYY (e.g., 3Q2005). Obviously
-		- completed releases should include the exact day the release was completed.
-		-
-		- In the following example, we have three completed, two scheduled, and one 
-		- tentative release.
-	-->
-	<releases>
- 		<release 
-       		status="completed"
-       		name="0.5.0"
-       		date="29/06/2007"
-       		download="/epp/download.php" />
-	</releases>
-	<!--
-		<source></source>
-	-->
-</project>
diff --git a/project-info/project-page-paragraph.html b/project-info/project-page-paragraph.html
deleted file mode 100755
index a092ccf..0000000
--- a/project-info/project-page-paragraph.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<p>
-<b><a href="/epp/">Eclipse Packaging</a></b>
-</p>
-<p>
-The Eclipse Packaging project aims to build a framework to build ready-to-install 
-Eclipse packages that may contain a platform specific installer in the future, and
-it provides the EPP Usage Data Collector.
-</p>
\ No newline at end of file
diff --git a/project-info/project-plan-bugzilla.xsl b/project-info/project-plan-bugzilla.xsl
deleted file mode 100644
index 1c8d75a..0000000
--- a/project-info/project-plan-bugzilla.xsl
+++ /dev/null
@@ -1,69 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    /*******************************************************************************
-     * Copyright (c) 2008 Standards for Technology in Automotive Retail and others
-     * All rights reserved. This program and the accompanying materials
-     * are made available under the terms of the Eclipse Public License v1.0 
-     * which accompanies this distribution, and is available at 
-     * http://www.eclipse.org/legal/epl-v10.html
-     *
-     * Contributors:
-     *    David Carver (STAR) - bug 243303 - initial API and implementation
-     *******************************************************************************/
--->
-<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-                xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-                xmlns:bz="http://www.bugzilla.org/rdf#"
-                xmlns:nc="http://home.netscape.com/NC-rdf#"
-                xmlns="http://www.w3.org/1999/xhtml"
-                exclude-result-prefixes="rdf bz nc">
-    <!-- 
-        This process the RDF file returned from the bugzilla query when ctype=rdf is
-        specified.    
-     -->
-     
-	<xsl:template match="bz:bugs">
-        <xsl:choose>
-            <xsl:when test="rdf:Seq/rdf:li/bz:bug">
-                <ul>
-                    <xsl:apply-templates select="rdf:Seq/rdf:li/bz:bug"/>
-                </ul>            
-            </xsl:when>
-            <xsl:otherwise>
-               <ul>
-                   <li>
-                        <div>
-                            <xsl:text>No items.</xsl:text>
-                        </div>
-                    </li>
-               </ul>
-            </xsl:otherwise>
-        </xsl:choose>
-	</xsl:template>
-    
-    <xsl:template match="bz:bug">
-        <li>
-            <xsl:value-of select="bz:short_desc"/>
-            <xsl:text> [</xsl:text>
-            <a href="http://bugs.eclipse.org/{bz:id}">
-                <xsl:value-of select="bz:id"/>
-            </a>
-            <xsl:text>] </xsl:text>
-            <xsl:choose>
-                <xsl:when test="bz:bug_status = 'RESOLVED' or bz:bug_status = 'VERIFIED' or bz:bug_status = 'CLOSED'">
-                    <strike>
-                        <xsl:text>(target milestone: </xsl:text>
-                        <xsl:value-of select="bz:target_milestone"/>
-                        <xsl:text>)</xsl:text>
-                    </strike>    
-                </xsl:when>
-                <xsl:otherwise>
-                    <xsl:text>(target milestone: </xsl:text>
-                    <xsl:value-of select="bz:target_milestone"/>
-                    <xsl:text>)</xsl:text>
-                </xsl:otherwise>
-            </xsl:choose>
-       </li>            
-    </xsl:template>
-    
-</xsl:stylesheet>
\ No newline at end of file
diff --git a/project-info/project-plan-render.xsl b/project-info/project-plan-render.xsl
deleted file mode 100644
index 0580101..0000000
--- a/project-info/project-plan-render.xsl
+++ /dev/null
@@ -1,714 +0,0 @@
-
-
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<!-- ViewVC :: http://www.viewvc.org/ -->
-<head>
-<title>[Eclipse_Website] Log of /www/projects/project-plan-render.xsl</title>
-<meta name="author" content="Eclipse Foundation, Inc." />
-<link rel="stylesheet" href="/viewcvs/index.cgi/*docroot*/styles.css" type="text/css" />
-<link rel="stylesheet" type="text/css" href="/eclipse.org-common/themes/Phoenix/css/small.css" title="small" />
-<link rel="stylesheet" type="text/css" href="/eclipse.org-common/themes/Phoenix/css/visual.css" media="screen" />
-<link rel="stylesheet" type="text/css" href="/eclipse.org-common/themes/Phoenix/css/layout.css" media="screen" />
-<link rel="stylesheet" type="text/css" href="/eclipse.org-common/themes/Phoenix/css/print.css" media="print" />
-<link rel="stylesheet" type="text/css" href="/eclipse.org-common/themes/Phoenix/css/header.css" media="screen" />
-
-</head>
-<body>
-<div id="header">
-<div id="header-graphic" class="eclipse-main"><a href="/"><img src="/eclipse.org-common/themes/Phoenix/images/eclipse_home_header.jpg" alt="" /></a><h1>Eclipse</h1></div>
-<div id="header-global-holder" class="eclipse-main-global">
-<div id="header-global-links">
-<ul><li><a href="http://www.eclipse.org/org/foundation/contact.php" class="first_one">Contact</a></li><li><a href="http://www.eclipse.org/legal/">Legal</a></li> </ul>
-</div>
-<div id="header-icons">
-<a href="http://live.eclipse.org"><img src="/eclipse.org-common/themes/Phoenix/images/Icon_Live.png" width="28" height="28" alt="Eclipse Live" title="Eclipse Live" /></a>
-<a href="http://www.eclipseplugincentral.com"><img src="/eclipse.org-common/themes/Phoenix/images/Icon_plugin.png" width="28" height="28" alt="Eclipse Plugin Central" title="Eclipse Plugin Central" /></a>
-<a href="http://www.planeteclipse.org"><img src="/eclipse.org-common/themes/Phoenix/images/Icon_planet.png" width="28" height="28" alt="Planet Eclipse" title="Planet Eclipse" /></a>
-</div>
-</div>
-</div><div id="header-menu">
-<div id="header-nav">
-<ul><li><a class="first_one" href="http://www.eclipse.org/" target="_self">Home</a></li>
-<li><a href="http://www.eclipse.org/community/" target="_self">Community</a></li>
-<li><a href="http://www.eclipse.org/membership/" target="_self">Membership</a></li>
-<li><a href="http://wiki.eclipse.org/index.php/Development_Resources" target="_self">Committers</a></li>
-<li><a href="http://www.eclipse.org/downloads/" target="_self">Downloads</a></li>
-<li><a href="http://www.eclipse.org/resources/" target="_self">Resources</a></li>
-<li><a href="http://www.eclipse.org/projects/" target="_self">Projects</a></li>
-<li><a href="http://www.eclipse.org/org/" target="_self">About Us</a></li></ul>
-</div>
-<div id="header-utils">
-<form action="http://www.eclipse.org/search/search.cgi" method="get">
-<input type="hidden" value="Source" name="t"/>
-<input type="hidden" value="extended" name="Source"/>
-<input type="hidden" value="574a74" name="wf"/>
-<input class="input" type="text" value="" name="q"/>
-<input class="button" type="image" onclick="this.submit();" alt="Search" title="Search" src="/eclipse.org-common/themes/Phoenix/images/search_btn.gif" width="54" height="18" />
-</form>
-</div>
-</div>
-<div id="maincontent">
-<div id="midcolumn">
-<h1>www/projects/project-plan-render.xsl</h1>
-
-<p style="margin:0;">
-
-<a href="/viewcvs/index.cgi/www/projects/?root=Eclipse_Website"><img src="/viewcvs/index.cgi/*docroot*/images/back_small.png" width="16" height="16" alt="Parent Directory" /> Parent Directory</a>
-
-
-
-
-</p>
-
-<hr />
-<table class="auto">
-
-
-
-<tr>
-<td>Links to HEAD:</td>
-<td>
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;view=markup">view</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;view=co">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;content-type=text%2Fplain&amp;view=co">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=annotate&amp;root=Eclipse_Website">annotate</a>)
-</td>
-</tr>
-
-
-
-<tr>
-<td>Sticky Tag:</td>
-<td><form method="get" action="/viewcvs/index.cgi/www/projects/project-plan-render.xsl" style="display: inline">
-<input type="hidden" name="view" value="log" /><input type="hidden" name="root" value="Eclipse_Website" />
-
-
-<select name="pathrev" onchange="submit()">
-<option value=""></option>
-
-<optgroup label="Branches">
-
-
-<option>MAIN</option>
-
-
-</optgroup>
-
-<optgroup label="Non-branch tags">
-
-
-<option>HEAD</option>
-
-
-</optgroup>
-
-</select>
-
-<input type="submit" value="Set" />
-</form>
-
-</td>
-</tr>
-</table>
- 
-
-
-
-
-
-
-
-
-<div>
-<hr />
-
-<a name="rev1.8"></a>
-<a name="HEAD"></a>
-
-
-Revision <strong>1.8</strong> -
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.8&amp;root=Eclipse_Website&amp;view=markup">view</a>)
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.8&amp;root=Eclipse_Website">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;revision=1.8&amp;content-type=text%2Fplain">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?annotate=1.8&amp;root=Eclipse_Website">annotate</a>)
-
-
-
-- <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.8&amp;view=log">[select for diffs]</a>
-
-
-
-
-<br />
-
-<em>Tue Sep 16 18:28:25 2008 UTC</em> (2 weeks ago) by <em>bfreeman</em>
-
-
-<br />Branch:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=MAIN"><strong>MAIN</strong></a>
-
-
-
-<br />CVS Tags:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=HEAD"><strong>HEAD</strong></a>
-
-
-
-
-
-
-<br />Changes since <strong>1.7: +1 -1 lines</strong>
-
-
-
-
-
-
-
-<br />Diff to <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.7&amp;r2=1.8">previous 1.7</a>
-
-
-
-
-
-
-
-
-
-
-<pre class="vc_log">REOPENED - bug 241822: XML projectplan renderer should generate a table of contents, and &lt;a name&gt; tags for headings
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=241822">https://bugs.eclipse.org/bugs/show_bug.cgi?id=241822</a>
-</pre>
-</div>
-
-
-
-<div>
-<hr />
-
-<a name="rev1.7"></a>
-
-
-Revision <strong>1.7</strong> -
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.7&amp;root=Eclipse_Website&amp;view=markup">view</a>)
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.7&amp;root=Eclipse_Website">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;revision=1.7&amp;content-type=text%2Fplain">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?annotate=1.7&amp;root=Eclipse_Website">annotate</a>)
-
-
-
-- <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.7&amp;view=log">[select for diffs]</a>
-
-
-
-
-<br />
-
-<em>Tue Sep 16 18:07:30 2008 UTC</em> (2 weeks ago) by <em>bfreeman</em>
-
-
-<br />Branch:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=MAIN"><strong>MAIN</strong></a>
-
-
-
-
-
-
-
-<br />Changes since <strong>1.6: +4 -2 lines</strong>
-
-
-
-
-
-
-
-<br />Diff to <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.6&amp;r2=1.7">previous 1.6</a>
-
-
-
-
-
-
-
-
-
-
-<pre class="vc_log">ASSIGNED - bug 241822: XML projectplan renderer should generate a table of contents, and &lt;a name&gt; tags for headings
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=241822">https://bugs.eclipse.org/bugs/show_bug.cgi?id=241822</a>
-</pre>
-</div>
-
-
-
-<div>
-<hr />
-
-<a name="rev1.6"></a>
-
-
-Revision <strong>1.6</strong> -
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.6&amp;root=Eclipse_Website&amp;view=markup">view</a>)
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.6&amp;root=Eclipse_Website">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;revision=1.6&amp;content-type=text%2Fplain">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?annotate=1.6&amp;root=Eclipse_Website">annotate</a>)
-
-
-
-- <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.6&amp;view=log">[select for diffs]</a>
-
-
-
-
-<br />
-
-<em>Fri Sep  5 20:39:43 2008 UTC</em> (3 weeks, 3 days ago) by <em>bfreeman</em>
-
-
-<br />Branch:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=MAIN"><strong>MAIN</strong></a>
-
-
-
-
-
-
-
-<br />Changes since <strong>1.5: +69 -6 lines</strong>
-
-
-
-
-
-
-
-<br />Diff to <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.5&amp;r2=1.6">previous 1.5</a>
-
-
-
-
-
-
-
-
-
-
-<pre class="vc_log">ASSIGNED - bug 241822: XML projectplan renderer should generate a table of contents, and &lt;a name&gt; tags for headings
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=241822">https://bugs.eclipse.org/bugs/show_bug.cgi?id=241822</a>
-</pre>
-</div>
-
-
-
-<div>
-<hr />
-
-<a name="rev1.5"></a>
-
-
-Revision <strong>1.5</strong> -
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.5&amp;root=Eclipse_Website&amp;view=markup">view</a>)
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.5&amp;root=Eclipse_Website">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;revision=1.5&amp;content-type=text%2Fplain">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?annotate=1.5&amp;root=Eclipse_Website">annotate</a>)
-
-
-
-- <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.5&amp;view=log">[select for diffs]</a>
-
-
-
-
-<br />
-
-<em>Thu Sep  4 15:35:39 2008 UTC</em> (3 weeks, 5 days ago) by <em>bfreeman</em>
-
-
-<br />Branch:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=MAIN"><strong>MAIN</strong></a>
-
-
-
-
-
-
-
-<br />Changes since <strong>1.4: +2 -2 lines</strong>
-
-
-
-
-
-
-
-<br />Diff to <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.4&amp;r2=1.5">previous 1.4</a>
-
-
-
-
-
-
-
-
-
-
-<pre class="vc_log">[245273]
-</pre>
-</div>
-
-
-
-<div>
-<hr />
-
-<a name="rev1.4"></a>
-
-
-Revision <strong>1.4</strong> -
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.4&amp;root=Eclipse_Website&amp;view=markup">view</a>)
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.4&amp;root=Eclipse_Website">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;revision=1.4&amp;content-type=text%2Fplain">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?annotate=1.4&amp;root=Eclipse_Website">annotate</a>)
-
-
-
-- <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.4&amp;view=log">[select for diffs]</a>
-
-
-
-
-<br />
-
-<em>Fri Aug 29 16:46:27 2008 UTC</em> (4 weeks, 4 days ago) by <em>bfreeman</em>
-
-
-<br />Branch:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=MAIN"><strong>MAIN</strong></a>
-
-
-
-
-
-
-
-<br />Changes since <strong>1.3: +0 -7 lines</strong>
-
-
-
-
-
-
-
-<br />Diff to <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.3&amp;r2=1.4">previous 1.3</a>
-
-
-
-
-
-
-
-
-
-
-<pre class="vc_log">NEW - bug 245273: XML Project Plan doesn't render
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=245273">https://bugs.eclipse.org/bugs/show_bug.cgi?id=245273</a>
-</pre>
-</div>
-
-
-
-<div>
-<hr />
-
-<a name="rev1.3"></a>
-
-
-Revision <strong>1.3</strong> -
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.3&amp;root=Eclipse_Website&amp;view=markup">view</a>)
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.3&amp;root=Eclipse_Website">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;revision=1.3&amp;content-type=text%2Fplain">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?annotate=1.3&amp;root=Eclipse_Website">annotate</a>)
-
-
-
-- <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.3&amp;view=log">[select for diffs]</a>
-
-
-
-
-<br />
-
-<em>Fri Aug 22 19:34:04 2008 UTC</em> (5 weeks, 3 days ago) by <em>bfreeman</em>
-
-
-<br />Branch:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=MAIN"><strong>MAIN</strong></a>
-
-
-
-
-
-
-
-<br />Changes since <strong>1.2: +26 -4 lines</strong>
-
-
-
-
-
-
-
-<br />Diff to <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.2&amp;r2=1.3">previous 1.2</a>
-
-
-
-
-
-
-
-
-
-
-<pre class="vc_log">ASSIGNED - bug 243303: Project Plan XML should have Namespaces
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=243303">https://bugs.eclipse.org/bugs/show_bug.cgi?id=243303</a>
-</pre>
-</div>
-
-
-
-<div>
-<hr />
-
-<a name="rev1.2"></a>
-
-
-Revision <strong>1.2</strong> -
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.2&amp;root=Eclipse_Website&amp;view=markup">view</a>)
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.2&amp;root=Eclipse_Website">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;revision=1.2&amp;content-type=text%2Fplain">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?annotate=1.2&amp;root=Eclipse_Website">annotate</a>)
-
-
-
-- <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.2&amp;view=log">[select for diffs]</a>
-
-
-
-
-<br />
-
-<em>Thu Aug 21 20:09:40 2008 UTC</em> (5 weeks, 4 days ago) by <em>bfreeman</em>
-
-
-<br />Branch:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=MAIN"><strong>MAIN</strong></a>
-
-
-
-
-
-
-
-<br />Changes since <strong>1.1: +24 -12 lines</strong>
-
-
-
-
-
-
-
-<br />Diff to <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.1&amp;r2=1.2">previous 1.1</a>
-
-
-
-
-
-
-
-
-
-
-<pre class="vc_log">ASSIGNED - bug 243303: Project Plan XML should have Namespaces
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=243303">https://bugs.eclipse.org/bugs/show_bug.cgi?id=243303</a>
-</pre>
-</div>
-
-
-
-<div>
-<hr />
-
-<a name="rev1.1"></a>
-
-
-Revision <strong>1.1</strong> -
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.1&amp;root=Eclipse_Website&amp;view=markup">view</a>)
-
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?revision=1.1&amp;root=Eclipse_Website">download</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;revision=1.1&amp;content-type=text%2Fplain">as text</a>)
-(<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?annotate=1.1&amp;root=Eclipse_Website">annotate</a>)
-
-
-
-- <a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?root=Eclipse_Website&amp;r1=1.1&amp;view=log">[select for diffs]</a>
-
-
-
-
-<br />
-
-<em>Tue Aug 19 17:20:34 2008 UTC</em> (6 weeks ago) by <em>bfreeman</em>
-
-
-<br />Branch:
-
-<a href="/viewcvs/index.cgi/www/projects/project-plan-render.xsl?view=log&amp;root=Eclipse_Website&amp;pathrev=MAIN"><strong>MAIN</strong></a>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-<pre class="vc_log">ASSIGNED - bug 243303: Project Plan XML should have Namespaces
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=243303">https://bugs.eclipse.org/bugs/show_bug.cgi?id=243303</a>
-</pre>
-</div>
-
- 
-
-
-
- <hr />
-<p><a name="diff"></a>
-This form allows you to request diffs between any two revisions of this file.
-For each of the two "sides" of the diff,
-
-select a symbolic revision name using the selection box, or choose
-'Use Text Field' and enter a numeric revision.
-
-</p>
-<form method="get" action="/viewcvs/index.cgi/www/projects/project-plan-render.xsl" name="diff_select">
-<table cellpadding="2" cellspacing="0" class="auto">
-<tr>
-<td>&nbsp;</td>
-<td>
-<input type="hidden" name="root" value="Eclipse_Website" /><input type="hidden" name="view" value="diff" />
-Diffs between
-
-<select name="r1">
-<option value="text" selected="selected">Use Text Field</option>
-
-<option value="1.8:MAIN">MAIN</option>
-
-<option value="1.8:HEAD">HEAD</option>
-
-</select>
-<input type="text" size="12" name="tr1"
-value="1.8"
-onchange="document.diff_select.r1.selectedIndex=0" />
-
-and
-
-<select name="r2">
-<option value="text" selected="selected">Use Text Field</option>
-
-<option value="1.8:MAIN">MAIN</option>
-
-<option value="1.8:HEAD">HEAD</option>
-
-</select>
-<input type="text" size="12" name="tr2"
-value="1.1"
-onchange="document.diff_select.r1.selectedIndex=0" />
-
-</td>
-</tr>
-<tr>
-<td>&nbsp;</td>
-<td>
-Type of Diff should be a
-<select name="diff_format" onchange="submit()">
-<option value="h" selected="selected">Colored Diff</option>
-<option value="l" >Long Colored Diff</option>
-<option value="u" >Unidiff</option>
-<option value="c" >Context Diff</option>
-<option value="s" >Side by Side</option>
-</select>
-<input type="submit" value=" Get Diffs " />
-</td>
-</tr>
-</table>
-</form>
-
-
-<form method="get" action="/viewcvs/index.cgi/www/projects/project-plan-render.xsl">
-<div>
-<hr />
-<a name="logsort"></a>
-<input type="hidden" name="root" value="Eclipse_Website" /><input type="hidden" name="view" value="log" />
-Sort log by:
-<select name="logsort" onchange="submit()">
-<option value="cvs" >Not sorted</option>
-<option value="date" selected="selected">Commit date</option>
-<option value="rev" >Revision</option>
-</select>
-<input type="submit" value=" Sort " />
-</div>
-</form>
-
-
-<div id="midcolumn">
-<hr />
-<table>
-<tr>
-<td><address><a href="mailto:webmaster@eclipse.org">help@eclipse.org</a></address></td>
-<td style="text-align: right;"><strong><a href="/viewcvs/index.cgi/*docroot*/help_log.html">ViewVC Help</a></strong></td>
-</tr>
-<tr>
-<td>Powered by <a href="http://viewvc.tigris.org/">ViewVC 1.0.3</a></td>
-<td style="text-align: right;">&nbsp;</td>
-</tr>
-</table>
-</div>
-</body>
-</html>
-
-
diff --git a/project-info/url-encode.xsl b/project-info/url-encode.xsl
deleted file mode 100644
index e8c2f94..0000000
--- a/project-info/url-encode.xsl
+++ /dev/null
@@ -1,69 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-
-  <xsl:output method="xml" indent="yes" encoding="iso-8859-1"/>
-
-  <!-- ISO-8859-1 based URL-encoding demo
-       Written by Mike J. Brown, mike@skew.org.
-       Updated 2002-05-20.
-
-       No license; use freely, but credit me if reproducing in print.
-
-       Also see http://skew.org/xml/misc/URI-i18n/ for a discussion of
-       non-ASCII characters in URIs.
-  -->
-
-  <!-- The string to URL-encode.
-       Note: By "iso-string" we mean a Unicode string where all
-       the characters happen to fall in the ASCII and ISO-8859-1
-       ranges (32-126 and 160-255) -->
-  <xsl:param name="iso-string" select="'&#161;Hola, C&#233;sar!'"/>
-
-  <!-- Characters we'll support.
-       We could add control chars 0-31 and 127-159, but we won't. -->
-  <xsl:variable name="ascii"> !?"#$%'()*+,-./0123456789:;&lt;=&gt;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~</xsl:variable>
-  <xsl:variable name="latin1">&#160;&#161;&#162;&#163;&#164;&#165;&#166;&#167;&#168;&#169;&#170;&#171;&#172;&#173;&#174;&#175;&#176;&#177;&#178;&#179;&#180;&#181;&#182;&#183;&#184;&#185;&#186;&#187;&#188;&#189;&#190;&#191;&#192;&#193;&#194;&#195;&#196;&#197;&#198;&#199;&#200;&#201;&#202;&#203;&#204;&#205;&#206;&#207;&#208;&#209;&#210;&#211;&#212;&#213;&#214;&#215;&#216;&#217;&#218;&#219;&#220;&#221;&#222;&#223;&#224;&#225;&#226;&#227;&#228;&#229;&#230;&#231;&#232;&#233;&#234;&#235;&#236;&#237;&#238;&#239;&#240;&#241;&#242;&#243;&#244;&#245;&#246;&#247;&#248;&#249;&#250;&#251;&#252;&#253;&#254;&#255;</xsl:variable>
-
-  <!-- Characters that usually don't need to be escaped -->
-  <xsl:variable name="safe">+,[]&amp;=?/!'()*-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~</xsl:variable>
-
-  <xsl:variable name="hex" >0123456789ABCDEF</xsl:variable>
-
-  <xsl:template name="url-encode">
-    <xsl:param name="str"/>   
-    <xsl:if test="$str">
-      <xsl:variable name="first-char" select="substring($str,1,1)"/>
-      <xsl:choose>
-        <xsl:when test="contains($safe,$first-char)">
-          <xsl:value-of select="$first-char"/>
-        </xsl:when>
-        <xsl:otherwise>
-          <xsl:variable name="codepoint">
-            <xsl:choose>
-              <xsl:when test="contains($ascii,$first-char)">
-                <xsl:value-of select="string-length(substring-before($ascii,$first-char)) + 32"/>
-              </xsl:when>
-              <xsl:when test="contains($latin1,$first-char)">
-                <xsl:value-of select="string-length(substring-before($latin1,$first-char)) + 160"/>
-              </xsl:when>
-              <xsl:otherwise>
-                <xsl:message terminate="no">Warning: string contains a character that is out of range! Substituting "?".</xsl:message>
-                <xsl:text>63</xsl:text>
-              </xsl:otherwise>
-            </xsl:choose>
-          </xsl:variable>
-        <xsl:variable name="hex-digit1" select="substring($hex,floor($codepoint div 16) + 1,1)"/>
-        <xsl:variable name="hex-digit2" select="substring($hex,$codepoint mod 16 + 1,1)"/>
-        <xsl:value-of select="concat('%',$hex-digit1,$hex-digit2)"/>
-        </xsl:otherwise>
-      </xsl:choose>
-      <xsl:if test="string-length($str) &gt; 1">
-        <xsl:call-template name="url-encode">
-          <xsl:with-param name="str" select="substring($str,2)"/>
-        </xsl:call-template>
-      </xsl:if>
-    </xsl:if>
-  </xsl:template>
-
-</xsl:stylesheet>
-
diff --git a/usagedata/.htaccess b/usagedata/.htaccess
deleted file mode 100755
index 6d9c4a2..0000000
--- a/usagedata/.htaccess
+++ /dev/null
@@ -1,2 +0,0 @@
-Redirect permanent "/epp/usagedata/terms.php" http://www.eclipse.org/org/usagedata/terms.php
-Redirect permanent "/epp/usagedata/results.php" http://www.eclipse.org/org/usagedata/results.php
diff --git a/usagedata/UsageData.psf b/usagedata/UsageData.psf
deleted file mode 100644
index ce28ce0..0000000
--- a/usagedata/UsageData.psf
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<psf version="2.0">
-<provider id="org.eclipse.team.cvs.core.cvsnature">
-<project reference="1.0,:pserver:dev.eclipse.org:/cvsroot/tools,org.eclipse.orbit/org.apache.commons.codec,org.apache.commons.codec,v1_3"/>
-<project reference="1.0,:pserver:dev.eclipse.org:/cvsroot/tools,org.eclipse.orbit/org.apache.commons.httpclient,org.apache.commons.httpclient,v3_0_1"/>
-<project reference="1.0,:pserver:dev.eclipse.org:/cvsroot/technology,org.eclipse.epp/features/org.eclipse.epp.usagedata.feature,org.eclipse.epp.usagedata.feature"/>
-<project reference="1.0,:pserver:dev.eclipse.org:/cvsroot/technology,org.eclipse.epp/plugins/org.eclipse.epp.usagedata.gathering,org.eclipse.epp.usagedata.gathering"/>
-<project reference="1.0,:pserver:dev.eclipse.org:/cvsroot/technology,org.eclipse.epp/plugins/org.eclipse.epp.usagedata.recording,org.eclipse.epp.usagedata.recording"/>
-<project reference="1.0,:pserver:dev.eclipse.org:/cvsroot/technology,org.eclipse.epp/plugins/org.eclipse.epp.usagedata.ui,org.eclipse.epp.usagedata.ui"/>
-</provider>
-</psf>
\ No newline at end of file
diff --git a/usagedata/_projectCommon.php b/usagedata/_projectCommon.php
deleted file mode 100644
index f3943e8..0000000
--- a/usagedata/_projectCommon.php
+++ /dev/null
@@ -1,12 +0,0 @@
-<?php
-
-	# Set the theme for your project's web pages.
-	# See the Committer Tools "How Do I" for list of themes
-	# https://dev.eclipse.org/committers/
-	# Optional: defaults to system theme 
-	$theme = "Nova";
-	$App->setOutDated();
-	
-
-	$Nav->addNavSeparator("Project Home", 	"../index.php");
-?>
diff --git a/usagedata/faq.php b/usagedata/faq.php
deleted file mode 100755
index 7f44a95..0000000
--- a/usagedata/faq.php
+++ /dev/null
@@ -1,140 +0,0 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-/*******************************************************************************
- * Copyright (c) 2006 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Wayne Beaton (Eclipse Foundation)- initial API and implementation
- *******************************************************************************/
-
-#*****************************************************************************
-#
-# faq.php
-#
-# Author: 		Wayne Beaton
-# Date:			June 5, 2006
-#
-# Description:
-#
-#
-#****************************************************************************
-
-# Begin: page-specific settings.  Change these.
-$pageTitle 		= "UDC Technical FAQ";
-$pageKeywords	= "Eclipse, usage data, usagedata, cortez";
-$pageAuthor		= "Wayne Beaton";
-
-$tempdir = "./.metadata/.plugins/org.eclipse.epp.usagedata.recording";
-
-ob_start();
-?>
-<link
-	rel="stylesheet" type="text/css" href="layout.css" media="screen" />
-<div id="maincontent">
-
-<div id="midcolumn">
-<h1><?= $pageTitle ?></h1>
-<p>This FAQ is concerned with questions of technical nature. Questions
-concerning the capture and use of the data by The Eclipse Foundation can
-be found <a href="/org/usagedata/faq.php">UDC Data Capture and Use FAQ</a>.</p>
-
-
-	<h4>What releases of Eclipse does the Usage Data Collector support?</h4>
-	<dd>
-	<p>The Usage Data Collector can be installed into the Europa (Eclipse
-	Top Level Project SDK 3.3.x) or Ganymede (Eclipse Top Level Project SDK
-	3.4.x) Eclipse releases and milestone builds.</p>
-	
-
-	<h4>How do I install the Usage Data Collector?</h4>
-	<dd>
-	<p>The Usage Data Collector is included as part of the &quot;UDC&quot;
-	packages produced by the EPP. An automated build process generates a
-	new build that can be installed into Eclipse by pointing the update
-	manager to:</p>
-
-	<pre>http://download.eclipse.org/technology/epp/updates/1.0</pre>
-
-	<p>For more information about the build process and status, please see
-	<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=215060">Bug
-	215060</a>.</p>
-	
-
-	<h4>How do I get the code?</h4>
-	<dd>
-	<p>If you want to load the code as projects into your workspace, it is
-	available in the Technology Project's CVS repository. Use this <a
-		href="UsageData.psf">Team Project Set</a> to add the Usage Data
-	Monitor to your workspace.</p>
-
-	<p>You can also <a
-		href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.epp/?root=Technology_Project">browse
-	the code online</a>.</p>
-	
-
-	<h4>How do I turn off the Usage Data Collector?</h4>
-	<dd>
-	<p>There is an option on the &quot;Usage Data Collection&quot;
-	preferences page labeled &quot;Enable Capture&quot;. Turn this option <em>off</em>.</p>
-	
-
-	<h4>Where is the information stored?</h4>
-	<dd>
-	<p>As the usage data is collected, it is stored locally in the <em><?= $tempdir ?></em>
-	directory of the Eclipse workspace. After data has been successfully
-	uploaded and the data has been transferred into the Eclipse
-	Foundation's database, the local files are deleted.</p>
-	
-
-	<h4>What information is captured?</h4>
-	<dd>
-	<p>The UDC captures the the following information:</p>
-	<ol>
-		<li>Bundles (also known as plug-ins) that are started by the system.</li>
-		<li>Commands accessed via keyboard shortcuts, and actions invoked via
-		menus or toolbars.</li>
-		<li>Perspective changes</li>
-		<li>View and editor open, close, and activation events (activations
-		occur when a view or editor is given focus).</li>
-		<li>System information, such as JVM name and version, operating
-		system, and window system (new with version 1.1.0).</li>
-		<li>The description of internal errors (exceptions logged with
-		a severity of &quot;ERROR&quot;).</li>
-	</ol>
-	<p>For each item captured, we also capture the idenfier and version of
-	the bundle that contributes the item. When information is uploaded, we
-	further capture the country from which the upload originated.</p>
-
-	<p>It's valuable to also note what we <em>do not</em> capture. We <em>do
-	not capture any personal information</em>. We <em>do not capture IP
-	addresses</em>. We <em>do not capture any information that will allows
-	us to identify the source of the information</em>.</p>
-
-	<p>Two different keys are used to identify the source of the uploaded
-	data. The first key identifies the workstation; this key is stored
-	locally in your &quot;user home&quot; directory. The second key
-	identifies the workspace; this key is stored in the <em><?= $tempdir ?></em>
-	directory for the workspace. These keys are uploaded along with the
-	usage data. These keys allow us to correlate data.</p>
-	
-
-	<h4>How do we change the upload target?</h4>
-	<dd>
-	<p>The server to which the UDC uploads data can be configured using the
-	<code>org.eclipse.epp.usagedata.recording.upload-url</code> system
-	property. This property can be set either on the command-line for
-	Eclipse, or in the <code>eclipse.ini</code> file. For example:</p>
-	<pre>-Dorg.eclipse.epp.usagedata.recording.upload-url=http://myserver/...</pre>
-	<p>Note that &quot;-D&quot; parameters should follow &quot;-vmargs&quot; on the
-	command-line.</p>
-</div>
-
-<? include "rightcol.php"; ?></div>
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
diff --git a/usagedata/images/UploadWiz.png b/usagedata/images/UploadWiz.png
deleted file mode 100644
index 84a3704..0000000
--- a/usagedata/images/UploadWiz.png
+++ /dev/null
Binary files differ
diff --git a/usagedata/images/UploadingPrefs.png b/usagedata/images/UploadingPrefs.png
deleted file mode 100644
index 876bc97..0000000
--- a/usagedata/images/UploadingPrefs.png
+++ /dev/null
Binary files differ
diff --git a/usagedata/index.php b/usagedata/index.php
deleted file mode 100755
index 6429589..0000000
--- a/usagedata/index.php
+++ /dev/null
@@ -1,90 +0,0 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-/*******************************************************************************
- * Copyright (c) 2006 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Wayne Beaton (Eclipse Foundation)- initial API and implementation
- *******************************************************************************/
-
-#*****************************************************************************
-#
-# template.php
-#
-# Author: 		Wayne Beaton
-# Date:			February 16, 2006
-#
-# Description:
-#
-#
-#****************************************************************************
-
-# Begin: page-specific settings.  Change these.
-$pageTitle 		= "Usage Data Collector";
-$pageKeywords	= "Eclipse, usage data, usagedata, cortez";
-$pageAuthor		= "Wayne Beaton";
-
-$tempdir = "./.metadata/.plugins/org.eclipse.epp.usagedata.recording";
-
-ob_start();
-?>
-<link
-	rel="stylesheet" type="text/css" href="layout.css" media="screen" />
-<div id="maincontent">
-<div id="midcolumn">
-
-<h1><?= $pageTitle ?></h1>
-<style>
-.homeitem li {
-	border-style: none
-}
-</style>
-
-<p>The Usage Data Collector (UDC) is a framework for collecting usage data information.
-It is a lightweight framework that installs listeners on various aspects of the Eclipse
-workbench, and&mdash;from those listeners&mdash;gathers information about the kinds of 
-things that the user is doing (i.e. activating views, editors, etc.).</p>
-
-<p>At present, the UDC does not expose any official APIs, though there are several under
-consideration. The UDC has a notion of <em>monitors</em>. Monitors are Java classes that
-install various listeners, make sense of what they're listening do and post <em>events</em> 
-to the UDC (which currently manifests as an OSGi service). We have three different
-monitors: one monitors bundle events, one monitors workbench events, and a third monitors
-commands. None of the included monitors captures information that we consider private
-or personal. These monitors do capture the identifiers (ids) of the commands, views, editors, bundles,
-etc. that are the source of the various events.</p>
-
-<p>The Eclipse Foundation is making use of the UDC to gather information
-about how the community is making use of Eclipse technology. The Foundation's immediate interest is to
-provide feedback to the project teams about the use of their technology in the field. The
-UDC is currently implemented with this purpose in mind (i.e. the exemplary application of the
-UDC technology is concerned with providing data to the Foundation).</p>
-
-<p>This site is concerned with the technical aspects of the UDC. The Eclipse Foundation has
-a <a href="/org/usagedata">separate site</a> that is concerned with the issues of data collection, 
-storage on Foundation servers, terms of use, etc.</p>
-
-<p>Please post any questions you have about the UDC on the 
-<a href="news://news.eclipse.org/eclipse.technology.packaging">EPP newsgroup</a>.
-Open bugs raised against the UDC can be found in 
-<a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&classification=Technology&product=EPP&component=Usage+Data+Collector&bug_status=NEW&bug_status=REOPENED">Eclipse Bugzilla</a>.
-Or you can <a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=EPP&component=Usage+Data+Collector">open a new bug</a> 
-(or better yet, use <a href="/mylyn">Mylyn</a> to do it!).</p>
-
-<p>If you'd like to help out with the UDC, please join the 
-<a href="http://dev.eclipse.org/mailman/listinfo/epp-dev">EPP mailing list</a>.
-Links to the right (which are better described in the <a href="faq.php">FAQ</a>) 
-will help find the code.</p>
-</div>
-
-<? include "rightcol.php"; ?>
-
-</div>
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
diff --git a/usagedata/layout.css b/usagedata/layout.css
deleted file mode 100755
index c105d91..0000000
--- a/usagedata/layout.css
+++ /dev/null
@@ -1,3 +0,0 @@
-.homeitem3col li {
-	border:none;
-}
\ No newline at end of file
diff --git a/usagedata/new_and_noteworthy.php b/usagedata/new_and_noteworthy.php
deleted file mode 100755
index 2a41aa9..0000000
--- a/usagedata/new_and_noteworthy.php
+++ /dev/null
@@ -1,81 +0,0 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-/*******************************************************************************
- * Copyright (c) 2006 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Wayne Beaton (Eclipse Foundation)- initial API and implementation
- *******************************************************************************/
-
-#*****************************************************************************
-#
-# faq.php
-#
-# Author: 		Wayne Beaton
-# Date:			June 5, 2006
-#
-# Description:
-#
-#
-#****************************************************************************
-
-# Begin: page-specific settings.  Change these.
-$pageTitle 		= "UDC New and Noteworthy";
-$pageKeywords	= "Eclipse, usage data, usagedata";
-$pageAuthor		= "Wayne Beaton";
-
-
-ob_start();
-?>
-<link
-	rel="stylesheet" type="text/css" href="layout.css" media="screen" />
-<div id="maincontent">
-
-<div id="midcolumn">
-<h1><?= $pageTitle ?></h1>
-
-<div class="homeitem3col">
-<a name="1.1.0M7"></a>
-<h3>1.1.0M7</h3>
-
-<h4>System Information</h4>
-<p>The Usage Data Collector now collects information about the user's
-environment. 
-
-<ul>
-	<li>Operating System</li>
-	<li>System Architecture</li>
-	<li>Window System</li>
-	<li>Locale</li>
-	<li>Number of processors available</li>
-	<li>And a number of system properties:
-	<ul>
-		<li>java.runtime.name</li>
-		<li>java.runtime.version</li>
-		<li>java.specification.name</li>
-		<li>java.specification.vendor</li>
-		<li>java.specification.version</li>
-		<li>java.vendor</li>
-		<li>java.version</li>
-		<li>java.vm.info</li>
-		<li>java.vm.name</li>
-		<li>java.vm.specification.name</li>
-		<li>java.vm.specification.vendor</li>
-		<li>java.vm.specification.version</li>
-		<li>java.vm.vendor</li>
-		<li>java.vm.version</li>
-	</ul>
-	</li>
-</ul>
-</div>
-</div>
-
-<? include "rightcol.php"; ?></div>
-<?php
-$html = ob_get_contents();
-ob_end_clean();
-$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
\ No newline at end of file
diff --git a/usagedata/rightcol.php b/usagedata/rightcol.php
deleted file mode 100755
index 70c9606..0000000
--- a/usagedata/rightcol.php
+++ /dev/null
@@ -1,50 +0,0 @@
-<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
-/*******************************************************************************
- * Copyright (c) 2006 Eclipse Foundation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Wayne Beaton (Eclipse Foundation)- initial API and implementation
- *******************************************************************************/
-
-#*****************************************************************************
-#
-# rightcol.php
-#
-# Author: 		Wayne Beaton
-# Date:			June 5, 2008
-#
-# Description: Provides a right-column for pages that care to import this file
-#
-#
-#****************************************************************************
-?>
-
-<div id="rightcolumn">
-
-<div class="sideitem">
-<h6>More information</h6>
-<ul>
-<li><a href="faq.php">Technical FAQ</a></li>
-</ul>
-<p>The following pages are hosted by The Eclipse Foundation</p>
-<ul>
-<li><a href="/org/usagedata/userguide.php">User Guide</a></li>
-<li><a href="/org/usagedata/terms.php">Terms of Use</a></li>
-<li><a href="/org/usagedata/faq.php">Data Capture and Use FAQ</a></li>
-</ul>
-</div>
-
-<div class="sideitem">
-<h6>Code</h6>
-<ul>
-<li><a href="/epp/usagedata/new_and_noteworthy.php">New and Noteworthy</a></li>
-<li><a href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.epp/?root=Technology_Project">Browse the code online</a></li>
-<li><a href="/epp/usagedata/UsageData.psf">Add the code to your workspace</a></li>
-</ul>
-</div>
-
-</div>
\ No newline at end of file
