diff --git a/assembly/features/org.eclipse.jpt.assembly.feature/.cvsignore b/assembly/features/org.eclipse.jpt.assembly.feature/.cvsignore
deleted file mode 100644
index de8b73f..0000000
--- a/assembly/features/org.eclipse.jpt.assembly.feature/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-build.xml
-org.eclipse.jpt_1.0.0.*
diff --git a/assembly/features/org.eclipse.jpt.assembly.feature/.project b/assembly/features/org.eclipse.jpt.assembly.feature/.project
deleted file mode 100644
index 1e211af..0000000
--- a/assembly/features/org.eclipse.jpt.assembly.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.assembly.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jpt.assembly.feature/build.properties b/assembly/features/org.eclipse.jpt.assembly.feature/build.properties
deleted file mode 100644
index 470b4bc..0000000
--- a/assembly/features/org.eclipse.jpt.assembly.feature/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
-               
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.assembly.feature/eclipse_update_120.jpg b/assembly/features/org.eclipse.jpt.assembly.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jpt.assembly.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jpt.assembly.feature/epl-v10.html b/assembly/features/org.eclipse.jpt.assembly.feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/assembly/features/org.eclipse.jpt.assembly.feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.assembly.feature/feature.properties b/assembly/features/org.eclipse.jpt.assembly.feature/feature.properties
deleted file mode 100644
index 5771e26..0000000
--- a/assembly/features/org.eclipse.jpt.assembly.feature/feature.properties
+++ /dev/null
@@ -1,144 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools 
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Dali Java Persistence Tools - Runtime
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-March 17, 2005\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jpt.assembly.feature/feature.xml b/assembly/features/org.eclipse.jpt.assembly.feature/feature.xml
deleted file mode 100644
index 2cc63b6..0000000
--- a/assembly/features/org.eclipse.jpt.assembly.feature/feature.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.assembly.feature"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName"
-      image="eclipse_update_120.jpg">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <url>
-      <update label="%updateSiteName" url="http://download.eclipse.org/webtools/updates"/>
-      <discovery label="Web Tools Platform (WTP) Updates" url="http://download.eclipse.org/webtools/updates"/>
-   </url>
-
-   <includes
-         id="org.eclipse.jpt.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jpt.eclipselink.feature"
-         version="0.0.0"/>
-
-</feature>
diff --git a/assembly/features/org.eclipse.jpt.assembly.feature/license.html b/assembly/features/org.eclipse.jpt.assembly.feature/license.html
deleted file mode 100644
index 2347060..0000000
--- a/assembly/features/org.eclipse.jpt.assembly.feature/license.html
+++ /dev/null
@@ -1,93 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>January 28, 2005</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI></UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/assembly/features/org.eclipse.jpt.patch/.project b/assembly/features/org.eclipse.jpt.patch/.project
deleted file mode 100644
index b7a2bf5..0000000
--- a/assembly/features/org.eclipse.jpt.patch/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.patch</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jpt.patch/build.properties b/assembly/features/org.eclipse.jpt.patch/build.properties
deleted file mode 100644
index c381fb2..0000000
--- a/assembly/features/org.eclipse.jpt.patch/build.properties
+++ /dev/null
@@ -1,10 +0,0 @@
-bin.includes = feature.xml,\
-               license.html,\
-               feature.properties,\
-               epl-v10.html,\
-               eclipse_update_120.jpg
-src.includes = eclipse_update_120.jpg,\
-               epl-v10.html,\
-               feature.properties,\
-               feature.xml,\
-               license.html
diff --git a/assembly/features/org.eclipse.jpt.patch/buildnotes_org.eclipse.jpt.patch.html b/assembly/features/org.eclipse.jpt.patch/buildnotes_org.eclipse.jpt.patch.html
deleted file mode 100644
index 0d115f4..0000000
--- a/assembly/features/org.eclipse.jpt.patch/buildnotes_org.eclipse.jpt.patch.html
+++ /dev/null
@@ -1,20 +0,0 @@
-<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
-<html>
-
-<head>
-   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-   <meta name="Build" content="Build">
-   <title>Java Persistence Tools (JTP) 1.0.2 Patches</title>
-</head>
-
-<body>
-
-<h1>JTP 2.0.2 Patches</h1>
-
-<h2>Feature Patched: org.eclipse.jpt.patch</h2>
-<h3>Plugin(s) replaced:</h3>
-<ul><li>org.eclipse.jpt.gen</li></ul>
-<p>Bug <a href='https://bugs.eclipse.org/220297'>220297</a>. Entity generation creates Embeddables with compile errors in some cases.</p>
-
-
-</body></html>
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.patch/eclipse_update_120.jpg b/assembly/features/org.eclipse.jpt.patch/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jpt.patch/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jpt.patch/epl-v10.html b/assembly/features/org.eclipse.jpt.patch/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/assembly/features/org.eclipse.jpt.patch/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.patch/feature.properties b/assembly/features/org.eclipse.jpt.patch/feature.properties
deleted file mode 100644
index a8457ea..0000000
--- a/assembly/features/org.eclipse.jpt.patch/feature.properties
+++ /dev/null
@@ -1,143 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-
-# "featureName" property - name of the feature
-featureName=Java Persistence Tools (JTP) Patches
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=\
-Patch(s) for Java Persistence API (JPA) Tools. \n\
-See bug 220297 (https://bugs.eclipse.org/bugs/220297) Entity generation creates Embeddables with compile errors in some cases \n\
-
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006-08 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jpt.patch/feature.xml b/assembly/features/org.eclipse.jpt.patch/feature.xml
deleted file mode 100644
index 4fae92b..0000000
--- a/assembly/features/org.eclipse.jpt.patch/feature.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.patch"
-      label="%featureName"
-      version="1.0.2.qualifier"
-      provider-name="%providerName">
-
-   <description url="http://download.eclipse.org/webtools/patches/">
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="%licenseURL">
-      %license
-   </license>
-
-   <url>
-      <update label="Web Tools Platform (WTP) Patches" url="http://download.eclipse.org/webtools/patches/"/>
-   </url>
-
-   <requires>
-      <import feature="org.eclipse.jpt.feature" version="1.0.2.v200802140100-77-7_CYQCD2CaLYCHCD" patch="true"/>
-   </requires>
-
-   <plugin
-         id="org.eclipse.jpt.gen"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/assembly/features/org.eclipse.jpt.patch/license.html b/assembly/features/org.eclipse.jpt.patch/license.html
deleted file mode 100644
index 2347060..0000000
--- a/assembly/features/org.eclipse.jpt.patch/license.html
+++ /dev/null
@@ -1,93 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>January 28, 2005</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI></UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/assembly/features/org.eclipse.jpt.sdk/.cvsignore b/assembly/features/org.eclipse.jpt.sdk/.cvsignore
deleted file mode 100644
index bc2abf7..0000000
--- a/assembly/features/org.eclipse.jpt.sdk/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-*.bin.dist.zip
-build.xml
-features
-plugins
diff --git a/assembly/features/org.eclipse.jpt.sdk/.project b/assembly/features/org.eclipse.jpt.sdk/.project
deleted file mode 100644
index 821d453..0000000
--- a/assembly/features/org.eclipse.jpt.sdk/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.sdk</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jpt.sdk/build.properties b/assembly/features/org.eclipse.jpt.sdk/build.properties
deleted file mode 100644
index 7200939..0000000
--- a/assembly/features/org.eclipse.jpt.sdk/build.properties
+++ /dev/null
@@ -1,15 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
diff --git a/assembly/features/org.eclipse.jpt.sdk/eclipse_update_120.jpg b/assembly/features/org.eclipse.jpt.sdk/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jpt.sdk/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jpt.sdk/epl-v10.html b/assembly/features/org.eclipse.jpt.sdk/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/assembly/features/org.eclipse.jpt.sdk/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.sdk/feature.properties b/assembly/features/org.eclipse.jpt.sdk/feature.properties
deleted file mode 100644
index f9e4474..0000000
--- a/assembly/features/org.eclipse.jpt.sdk/feature.properties
+++ /dev/null
@@ -1,145 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools project SDK
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Dali Java Persistence Tools project SDK
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jpt.sdk/feature.xml b/assembly/features/org.eclipse.jpt.sdk/feature.xml
deleted file mode 100644
index 1edd8c9..0000000
--- a/assembly/features/org.eclipse.jpt.sdk/feature.xml
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.sdk"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName"
-      plugin="org.eclipse.jpt"
-      image="eclipse_update_120.jpg">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <url>
-      <update label="%updateSiteName" url="http://download.eclipse.org/webtools/updates"/>
-      <discovery label="Web Tools Platform (WTP) Updates" url="http://download.eclipse.org/webtools/updates"/>
-   </url>
-
-   <includes
-         id="org.eclipse.jpt_sdk.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jpt.eclipselink_sdk.feature"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.jpt"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/assembly/features/org.eclipse.jpt.sdk/license.html b/assembly/features/org.eclipse.jpt.sdk/license.html
deleted file mode 100644
index 76abfb4..0000000
--- a/assembly/features/org.eclipse.jpt.sdk/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-   
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/.cvsignore b/assembly/features/org.eclipse.jpt.tests.assembly.feature/.cvsignore
deleted file mode 100644
index 2544693..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/.cvsignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*.bin.dist.zip
-build.xml
-org.eclipse.jpt.tests_1.0.0.*
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/.project b/assembly/features/org.eclipse.jpt.tests.assembly.feature/.project
deleted file mode 100644
index f34899c..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.tests.assembly.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/.settings/org.eclipse.core.resources.prefs b/assembly/features/org.eclipse.jpt.tests.assembly.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 17acb65..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:11:05 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/build.properties b/assembly/features/org.eclipse.jpt.tests.assembly.feature/build.properties
deleted file mode 100644
index 7f47694..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/build.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/eclipse_update_120.jpg b/assembly/features/org.eclipse.jpt.tests.assembly.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/epl-v10.html b/assembly/features/org.eclipse.jpt.tests.assembly.feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/feature.properties b/assembly/features/org.eclipse.jpt.tests.assembly.feature/feature.properties
deleted file mode 100644
index c98fef2..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/feature.properties
+++ /dev/null
@@ -1,145 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools Tests
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Dali Java Persistence Tools project Tests
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/feature.xml b/assembly/features/org.eclipse.jpt.tests.assembly.feature/feature.xml
deleted file mode 100644
index ef543d1..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/feature.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.tests.assembly.feature"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <url>
-      <update label="%updateSiteName" url="http://download.eclipse.org/webtools/updates/"/>
-   </url>
-
-   <includes
-         id="org.eclipse.jpt.tests.feature"
-         version="0.0.0"/>
-
-</feature>
diff --git a/assembly/features/org.eclipse.jpt.tests.assembly.feature/license.html b/assembly/features/org.eclipse.jpt.tests.assembly.feature/license.html
deleted file mode 100644
index 5644598..0000000
--- a/assembly/features/org.eclipse.jpt.tests.assembly.feature/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-    
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/assembly/features/org.eclipse.jpt.tests/.cvsignore b/assembly/features/org.eclipse.jpt.tests/.cvsignore
deleted file mode 100644
index 2544693..0000000
--- a/assembly/features/org.eclipse.jpt.tests/.cvsignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*.bin.dist.zip
-build.xml
-org.eclipse.jpt.tests_1.0.0.*
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.tests/.project b/assembly/features/org.eclipse.jpt.tests/.project
deleted file mode 100644
index 3d1dde6..0000000
--- a/assembly/features/org.eclipse.jpt.tests/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.tests</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jpt.tests/.settings/org.eclipse.core.resources.prefs b/assembly/features/org.eclipse.jpt.tests/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 17acb65..0000000
--- a/assembly/features/org.eclipse.jpt.tests/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:11:05 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/assembly/features/org.eclipse.jpt.tests/build.properties b/assembly/features/org.eclipse.jpt.tests/build.properties
deleted file mode 100644
index 7f47694..0000000
--- a/assembly/features/org.eclipse.jpt.tests/build.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
diff --git a/assembly/features/org.eclipse.jpt.tests/eclipse_update_120.jpg b/assembly/features/org.eclipse.jpt.tests/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jpt.tests/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jpt.tests/epl-v10.html b/assembly/features/org.eclipse.jpt.tests/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/assembly/features/org.eclipse.jpt.tests/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt.tests/feature.properties b/assembly/features/org.eclipse.jpt.tests/feature.properties
deleted file mode 100644
index 6b58fe6..0000000
--- a/assembly/features/org.eclipse.jpt.tests/feature.properties
+++ /dev/null
@@ -1,145 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence API (JPA) project Tests
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Dali Java Persistence API (JPA) project Tests
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jpt.tests/feature.xml b/assembly/features/org.eclipse.jpt.tests/feature.xml
deleted file mode 100644
index 020fa44..0000000
--- a/assembly/features/org.eclipse.jpt.tests/feature.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.tests"
-      label="%featureName"
-      version="2.1.0.qualifier"
-      provider-name="%providerName">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <url>
-      <update label="%updateSiteName" url="http://download.eclipse.org/webtools/updates/"/>
-   </url>
-
-   <includes
-         id="org.eclipse.jpt.tests.feature"
-         version="0.0.0"/>
-
-</feature>
diff --git a/assembly/features/org.eclipse.jpt.tests/license.html b/assembly/features/org.eclipse.jpt.tests/license.html
deleted file mode 100644
index 5644598..0000000
--- a/assembly/features/org.eclipse.jpt.tests/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-    
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/assembly/features/org.eclipse.jpt/.cvsignore b/assembly/features/org.eclipse.jpt/.cvsignore
deleted file mode 100644
index de8b73f..0000000
--- a/assembly/features/org.eclipse.jpt/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-build.xml
-org.eclipse.jpt_1.0.0.*
diff --git a/assembly/features/org.eclipse.jpt/.project b/assembly/features/org.eclipse.jpt/.project
deleted file mode 100644
index b7aaec2..0000000
--- a/assembly/features/org.eclipse.jpt/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jpt/build.properties b/assembly/features/org.eclipse.jpt/build.properties
deleted file mode 100644
index 470b4bc..0000000
--- a/assembly/features/org.eclipse.jpt/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
-               
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt/eclipse_update_120.jpg b/assembly/features/org.eclipse.jpt/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jpt/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jpt/epl-v10.html b/assembly/features/org.eclipse.jpt/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/assembly/features/org.eclipse.jpt/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt/feature.properties b/assembly/features/org.eclipse.jpt/feature.properties
deleted file mode 100644
index 4b8dfd7..0000000
--- a/assembly/features/org.eclipse.jpt/feature.properties
+++ /dev/null
@@ -1,144 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform Project
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Eclipse Web Tools Platform Project Tools - Runtime
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006-2009 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-March 17, 2005\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jpt/feature.xml b/assembly/features/org.eclipse.jpt/feature.xml
deleted file mode 100644
index da72f9f..0000000
--- a/assembly/features/org.eclipse.jpt/feature.xml
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName"
-      plugin="org.eclipse.jpt"
-      image="eclipse_update_120.jpg">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <url>
-      <update label="%updateSiteName" url="http://download.eclipse.org/webtools/updates"/>
-      <discovery label="Web Tools Platform (WTP) Updates" url="http://download.eclipse.org/webtools/updates"/>
-   </url>
-
-   <includes
-         id="org.eclipse.jpt.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jpt.eclipselink.feature"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.jpt"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/assembly/features/org.eclipse.jpt/license.html b/assembly/features/org.eclipse.jpt/license.html
deleted file mode 100644
index 2347060..0000000
--- a/assembly/features/org.eclipse.jpt/license.html
+++ /dev/null
@@ -1,93 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>January 28, 2005</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI></UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/.cvsignore b/assembly/features/org.eclipse.jpt_sdk.assembly.feature/.cvsignore
deleted file mode 100644
index bc2abf7..0000000
--- a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-*.bin.dist.zip
-build.xml
-features
-plugins
diff --git a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/.project b/assembly/features/org.eclipse.jpt_sdk.assembly.feature/.project
deleted file mode 100644
index e901372..0000000
--- a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt_sdk.assembly.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/build.properties b/assembly/features/org.eclipse.jpt_sdk.assembly.feature/build.properties
deleted file mode 100644
index 7200939..0000000
--- a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/build.properties
+++ /dev/null
@@ -1,15 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
diff --git a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/eclipse_update_120.jpg b/assembly/features/org.eclipse.jpt_sdk.assembly.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/epl-v10.html b/assembly/features/org.eclipse.jpt_sdk.assembly.feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/feature.properties b/assembly/features/org.eclipse.jpt_sdk.assembly.feature/feature.properties
deleted file mode 100644
index 1f4dd69..0000000
--- a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/feature.properties
+++ /dev/null
@@ -1,145 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools SDK
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Dali Java Persistence Tools project SDK
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/feature.xml b/assembly/features/org.eclipse.jpt_sdk.assembly.feature/feature.xml
deleted file mode 100644
index 7055cde..0000000
--- a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/feature.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt_sdk.assembly.feature"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName"
-      image="eclipse_update_120.jpg">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <url>
-      <update label="%updateSiteName" url="http://download.eclipse.org/webtools/updates"/>
-      <discovery label="Web Tools Platform (WTP) Updates" url="http://download.eclipse.org/webtools/updates"/>
-   </url>
-
-   <includes
-         id="org.eclipse.jpt_sdk.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jpt.eclipselink_sdk.feature"
-         version="0.0.0"/>
-
-</feature>
diff --git a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/license.html b/assembly/features/org.eclipse.jpt_sdk.assembly.feature/license.html
deleted file mode 100644
index 76abfb4..0000000
--- a/assembly/features/org.eclipse.jpt_sdk.assembly.feature/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-   
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/assembly/plugins/org.eclipse.jpt/.cvsignore b/assembly/plugins/org.eclipse.jpt/.cvsignore
deleted file mode 100644
index c9401a2..0000000
--- a/assembly/plugins/org.eclipse.jpt/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-build.xml
-org.eclipse.jpt_1.0.0.*
\ No newline at end of file
diff --git a/assembly/plugins/org.eclipse.jpt/.project b/assembly/plugins/org.eclipse.jpt/.project
deleted file mode 100644
index f51b04c..0000000
--- a/assembly/plugins/org.eclipse.jpt/.project
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/plugins/org.eclipse.jpt/.settings/org.eclipse.core.resources.prefs b/assembly/plugins/org.eclipse.jpt/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 4aec29d..0000000
--- a/assembly/plugins/org.eclipse.jpt/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:10:09 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/assembly/plugins/org.eclipse.jpt/META-INF/MANIFEST.MF b/assembly/plugins/org.eclipse.jpt/META-INF/MANIFEST.MF
deleted file mode 100644
index faac80f..0000000
--- a/assembly/plugins/org.eclipse.jpt/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,7 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jpt; singleton:=true
-Bundle-Version: 2.3.0.qualifier
-Bundle-Localization: plugin
-Bundle-Vendor: %providerName
diff --git a/assembly/plugins/org.eclipse.jpt/about.html b/assembly/plugins/org.eclipse.jpt/about.html
deleted file mode 100644
index ca606b1..0000000
--- a/assembly/plugins/org.eclipse.jpt/about.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<HTML>
-
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-
-<BODY lang="EN-US">
-
-<H3>About This Content</H3>
-
-<P>June 06, 2007</P>
-
-<H3>License</H3>
-
-<P>The Eclipse Foundation makes available all content in this plug-in 
-("Content"). Unless otherwise indicated below, the Content is provided to you 
-under the terms and conditions of the Eclipse Public License Version 1.0 
-("EPL"). A copy of the EPL is available at
-<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-
-<P>If you did not receive this Content directly from the Eclipse Foundation, the 
-Content is being redistributed by another party ("Redistributor") and different 
-terms and conditions may apply to your use of any object code in the Content. 
-Check the Redistributor's license that was provided with the Content. If no such 
-license exists, contact the Redistributor. Unless otherwise indicated below, the 
-terms and conditions of the EPL still apply to any source code in the Content 
-and such source code may be obtained at
-<A href="http://www.eclipse.org/">http://www.eclipse.org/</A>.</P>
-
-</BODY>
-</HTML>
\ No newline at end of file
diff --git a/assembly/plugins/org.eclipse.jpt/about.ini b/assembly/plugins/org.eclipse.jpt/about.ini
deleted file mode 100644
index 588a325..0000000
--- a/assembly/plugins/org.eclipse.jpt/about.ini
+++ /dev/null
@@ -1,44 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-# Property "tipsAndTricksHref" contains the Help topic href to a tips and tricks page 
-# optional
-tipsAndTricksHref=/org.eclipse.jpt.doc.user/tips_and_tricks.htm
-
-
diff --git a/assembly/plugins/org.eclipse.jpt/about.mappings b/assembly/plugins/org.eclipse.jpt/about.mappings
deleted file mode 100644
index bddaab4..0000000
--- a/assembly/plugins/org.eclipse.jpt/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
\ No newline at end of file
diff --git a/assembly/plugins/org.eclipse.jpt/about.properties b/assembly/plugins/org.eclipse.jpt/about.properties
deleted file mode 100644
index c74a186..0000000
--- a/assembly/plugins/org.eclipse.jpt/about.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-
-blurb=Dali Java Persistence Tools\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2006.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
diff --git a/assembly/plugins/org.eclipse.jpt/build.properties b/assembly/plugins/org.eclipse.jpt/build.properties
deleted file mode 100644
index 0ccfb0e..0000000
--- a/assembly/plugins/org.eclipse.jpt/build.properties
+++ /dev/null
@@ -1,19 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2007 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = META-INF/,\
-               about.ini,\
-               about.html,\
-               about.mappings,\
-               about.properties,\
-               eclipse32.gif,\
-               eclipse32.png,\
-               plugin.properties,\
-               component.xml
diff --git a/assembly/plugins/org.eclipse.jpt/component.xml b/assembly/plugins/org.eclipse.jpt/component.xml
deleted file mode 100644
index 11f133f..0000000
--- a/assembly/plugins/org.eclipse.jpt/component.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<component  xmlns="http://eclipse.org/wtp/releng/tools/component-model" name="org.eclipse.jpt">
-<description url=""></description>
-<component-depends unrestricted="true"></component-depends>
-<plugin id="org.eclipse.jpt" fragment="false"/>
-<plugin id="org.eclipse.jpt.core" fragment="false"/>
-<plugin id="org.eclipse.jpt.db" fragment="false"/>
-<plugin id="org.eclipse.jpt.db.ui" fragment="false"/>
-<plugin id="org.eclipse.jpt.gen" fragment="false"/>
-<plugin id="org.eclipse.jpt.ui" fragment="false"/>
-<plugin id="org.eclipse.jpt.utility" fragment="false"/>
-</component>
\ No newline at end of file
diff --git a/assembly/plugins/org.eclipse.jpt/eclipse32.gif b/assembly/plugins/org.eclipse.jpt/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/assembly/plugins/org.eclipse.jpt/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/assembly/plugins/org.eclipse.jpt/eclipse32.png b/assembly/plugins/org.eclipse.jpt/eclipse32.png
deleted file mode 100644
index 568fac1..0000000
--- a/assembly/plugins/org.eclipse.jpt/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/assembly/plugins/org.eclipse.jpt/plugin.properties b/assembly/plugins/org.eclipse.jpt/plugin.properties
deleted file mode 100644
index c3c055a..0000000
--- a/assembly/plugins/org.eclipse.jpt/plugin.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-pluginName = Dali Java Persistence Tools
-providerName = Eclipse.org
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/.cvsignore b/jpa/features/org.eclipse.jpt.eclipselink.feature/.cvsignore
deleted file mode 100644
index c14487c..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-build.xml
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/.project b/jpa/features/org.eclipse.jpt.eclipselink.feature/.project
deleted file mode 100644
index 93f19b1..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.eclipselink.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/.settings/org.eclipse.core.resources.prefs b/jpa/features/org.eclipse.jpt.eclipselink.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index dab5837..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:10:47 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/build.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/build.properties
deleted file mode 100644
index 7200939..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/build.properties
+++ /dev/null
@@ -1,15 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.eclipselink.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/epl-v10.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/feature.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/feature.properties
deleted file mode 100644
index 1e14e38..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/feature.properties
+++ /dev/null
@@ -1,140 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools - EclipseLink Support (Optional)
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Dali Java Persistence Tools - EclipseLink Support
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006, 2009 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/feature.xml b/jpa/features/org.eclipse.jpt.eclipselink.feature/feature.xml
deleted file mode 100644
index ff9898b..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/feature.xml
+++ /dev/null
@@ -1,66 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.eclipselink.feature"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName"
-      plugin="org.eclipse.jpt.eclipselink.branding">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <url>
-      <update label="Web Tools Platform (WTP) Updates" url="http://download.eclipse.org/webtools/updates"/>
-      <discovery label="Web Tools Platform (WTP) Updates" url="http://download.eclipse.org/webtools/updates"/>
-      <discovery label="Dali Java Persistence Tools Updates" url="http://download.eclipse.org/webtools/updates/"/>
-   </url>
-
-   <requires>
-      <import feature="org.eclipse.jpt.feature" version="2.3.0"/>
-   </requires>
-
-   <plugin
-         id="org.eclipse.jpt.eclipselink.core"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.eclipselink.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.eclipselink.jaxb.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.eclipselink.core.ddlgen"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.eclipselink.branding"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/license.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/license.html
deleted file mode 100644
index fc77372..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.html
deleted file mode 100644
index d4916df..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<p>June 06, 2007</p>	
-<h3>License</h3>
-
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
-apply to your use of any object code in the Content.  Check the Redistributor's license that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
-indicated below, the terms and conditions of the EPL still apply to any source code in the Content.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.ini b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.mappings b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.properties
deleted file mode 100644
index 50c0a9e..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/about.properties
+++ /dev/null
@@ -1,26 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=Java Persistence API Tools - EclipseLink Support Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2005.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/build.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/build.properties
deleted file mode 100644
index 6dcfcd6..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/build.properties
+++ /dev/null
@@ -1,21 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-bin.includes = \
-               about.html,\
-               about.ini,\
-               about.mappings,\
-               about.properties,\
-               eclipse32.gif,\
-               plugin.properties,\
-               plugin.xml,\
-               src/**,\
-               META-INF/
-sourcePlugin = true
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse32.gif b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse32.png b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/epl-v10.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/epl-v10.html
deleted file mode 100644
index 022ad29..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/license.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/license.html
deleted file mode 100644
index 14b1d50..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/license.html
+++ /dev/null
@@ -1,83 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>June 06, 2007</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/plugin.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/plugin.properties
deleted file mode 100644
index d0d5f1c..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateBundle/plugin.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-pluginName = Java Persistence API Tools - EclipseLink Support
-providerName = Eclipse.org
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/build.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/build.properties
deleted file mode 100644
index 53abe66..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-bin.includes = \
-               epl-v10.html,\
-               eclipse_update_120.jpg,\
-               feature.xml,\
-               feature.properties,\
-               license.html
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/epl-v10.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/epl-v10.html
deleted file mode 100644
index 022ad29..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/feature.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/feature.properties
deleted file mode 100644
index 3eab125..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/feature.properties
+++ /dev/null
@@ -1,145 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools - EclipseLink Support (Optional)
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Source code zips for JPA EclipseLink Support
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006, 2008 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/license.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/license.html
deleted file mode 100644
index fec4a48..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplateFeature/license.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>June 06, 2007</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.html
deleted file mode 100644
index d4916df..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<p>June 06, 2007</p>	
-<h3>License</h3>
-
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
-apply to your use of any object code in the Content.  Check the Redistributor's license that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
-indicated below, the terms and conditions of the EPL still apply to any source code in the Content.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.ini b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.mappings b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.properties
deleted file mode 100644
index 50c0a9e..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/about.properties
+++ /dev/null
@@ -1,26 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=Java Persistence API Tools - EclipseLink Support Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2005.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/build.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/build.properties
deleted file mode 100644
index 6dcfcd6..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/build.properties
+++ /dev/null
@@ -1,21 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-bin.includes = \
-               about.html,\
-               about.ini,\
-               about.mappings,\
-               about.properties,\
-               eclipse32.gif,\
-               plugin.properties,\
-               plugin.xml,\
-               src/**,\
-               META-INF/
-sourcePlugin = true
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse32.gif b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse32.png b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/epl-v10.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/epl-v10.html
deleted file mode 100644
index 022ad29..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/license.html b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/license.html
deleted file mode 100644
index 14b1d50..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/license.html
+++ /dev/null
@@ -1,83 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>June 06, 2007</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/plugin.properties b/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/plugin.properties
deleted file mode 100644
index d0d5f1c..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink.feature/sourceTemplatePlugin/plugin.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-pluginName = Java Persistence API Tools - EclipseLink Support
-providerName = Eclipse.org
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.cvsignore b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.cvsignore
deleted file mode 100644
index 6365d3d..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.cvsignore
+++ /dev/null
@@ -1,3 +0,0 @@
-feature.temp.folder
-build.xml
-org.eclipse.jpt_sdk.feature_1.0.1.*
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.project b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.project
deleted file mode 100644
index 15f9157..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.eclipselink_sdk.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.settings/org.eclipse.core.resources.prefs b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 6cc7d4b..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:09:59 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/build.properties b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/build.properties
deleted file mode 100644
index b479ccb..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/build.properties
+++ /dev/null
@@ -1,7 +0,0 @@
-bin.includes = feature.xml,\
-               license.html,\
-               feature.properties,\
-               epl-v10.html,\
-               eclipse_update_120.jpg
-
-generate.feature@org.eclipse.jpt.eclipselink.feature.source=org.eclipse.jpt.eclipselink.feature
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/epl-v10.html b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/feature.properties b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/feature.properties
deleted file mode 100644
index afca039..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/feature.properties
+++ /dev/null
@@ -1,140 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools - EclipseLink Support SDK (Optional)
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform Project
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Source code archives for Dali Java Persistence - EclipseLink Support
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006-09 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/feature.xml b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/feature.xml
deleted file mode 100644
index 0b387f6..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/feature.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.eclipselink_sdk.feature"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <includes
-         id="org.eclipse.jpt.eclipselink.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jpt.eclipselink.feature.source"
-         version="0.0.0"/>
-
-</feature>
diff --git a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/license.html b/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/license.html
deleted file mode 100644
index fc77372..0000000
--- a/jpa/features/org.eclipse.jpt.eclipselink_sdk.feature/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/jpa/features/org.eclipse.jpt.feature/.cvsignore b/jpa/features/org.eclipse.jpt.feature/.cvsignore
deleted file mode 100644
index c14487c..0000000
--- a/jpa/features/org.eclipse.jpt.feature/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-build.xml
diff --git a/jpa/features/org.eclipse.jpt.feature/.project b/jpa/features/org.eclipse.jpt.feature/.project
deleted file mode 100644
index c8eb2f0..0000000
--- a/jpa/features/org.eclipse.jpt.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/features/org.eclipse.jpt.feature/.settings/org.eclipse.core.resources.prefs b/jpa/features/org.eclipse.jpt.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index dab5837..0000000
--- a/jpa/features/org.eclipse.jpt.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:10:47 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/features/org.eclipse.jpt.feature/build.properties b/jpa/features/org.eclipse.jpt.feature/build.properties
deleted file mode 100644
index 7200939..0000000
--- a/jpa/features/org.eclipse.jpt.feature/build.properties
+++ /dev/null
@@ -1,15 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
diff --git a/jpa/features/org.eclipse.jpt.feature/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.feature/epl-v10.html b/jpa/features/org.eclipse.jpt.feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/jpa/features/org.eclipse.jpt.feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/jpa/features/org.eclipse.jpt.feature/feature.properties b/jpa/features/org.eclipse.jpt.feature/feature.properties
deleted file mode 100644
index b8df909..0000000
--- a/jpa/features/org.eclipse.jpt.feature/feature.properties
+++ /dev/null
@@ -1,140 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Dali Java Persistence Tools
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006, 2009 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/jpa/features/org.eclipse.jpt.feature/feature.xml b/jpa/features/org.eclipse.jpt.feature/feature.xml
deleted file mode 100644
index 3da7cbd..0000000
--- a/jpa/features/org.eclipse.jpt.feature/feature.xml
+++ /dev/null
@@ -1,131 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.feature"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName"
-      plugin="org.eclipse.jpt.branding">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <url>
-      <update label="Web Tools Platform (WTP) Updates" url="http://download.eclipse.org/webtools/updates"/>
-      <discovery label="Web Tools Platform (WTP) Updates" url="http://download.eclipse.org/webtools/updates"/>
-      <discovery label="Dali Java Persistence Tools Updates" url="http://download.eclipse.org/webtools/updates/"/>
-   </url>
-
-   <requires>
-      <import feature="org.eclipse.datatools.enablement.feature" version="1.7.0"/>
-      <import feature="org.eclipse.datatools.sqldevtools.feature" version="1.7.0"/>
-      <import feature="org.eclipse.datatools.connectivity.feature" version="1.7.0"/>
-   </requires>
-
-   <plugin
-         id="org.eclipse.jpt.utility"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.db"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.db.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.gen"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.core"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.jaxb.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.doc.user"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.apache.commons.collections"
-         download-size="0"
-         install-size="0"
-         version="3.2.0.qualifier"
-         unpack="false"/>
-
-   <plugin
-         id="org.apache.commons.lang"
-         download-size="0"
-         install-size="0"
-         version="2.1.0.qualifier"
-         unpack="false"/>
-
-   <plugin
-         id="org.apache.oro"
-         download-size="0"
-         install-size="0"
-         version="2.0.8.qualifier"
-         unpack="false"/>
-
-   <plugin
-         id="org.jdom"
-         download-size="0"
-         install-size="0"
-         version="1.0.0.qualifier"
-         unpack="false"/>
-
-   <plugin
-         id="org.apache.velocity"
-         download-size="0"
-         install-size="0"
-         version="1.5.0.qualifier"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jpt.branding"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/jpa/features/org.eclipse.jpt.feature/license.html b/jpa/features/org.eclipse.jpt.feature/license.html
deleted file mode 100644
index fc77372..0000000
--- a/jpa/features/org.eclipse.jpt.feature/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.html b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.html
deleted file mode 100644
index d4916df..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<p>June 06, 2007</p>	
-<h3>License</h3>
-
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
-apply to your use of any object code in the Content.  Check the Redistributor's license that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
-indicated below, the terms and conditions of the EPL still apply to any source code in the Content.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.ini b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.mappings b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.properties b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.properties
deleted file mode 100644
index 15417ff..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/about.properties
+++ /dev/null
@@ -1,26 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=Dali Java Persistence API (JPA) Tools Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2008.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/build.properties b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/build.properties
deleted file mode 100644
index ce9529b..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/build.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
-sourcePlugin = true
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse32.gif b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse32.png b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/epl-v10.html b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/epl-v10.html
deleted file mode 100644
index 022ad29..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/license.html b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/license.html
deleted file mode 100644
index 14b1d50..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/license.html
+++ /dev/null
@@ -1,83 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>June 06, 2007</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/plugin.properties b/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/plugin.properties
deleted file mode 100644
index f948547..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateBundle/plugin.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-
-pluginName = Dali Java Persistence API (JPA) Tools
-providerName = Eclipse.org
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/build.properties b/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/build.properties
deleted file mode 100644
index f60dad3..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-bin.includes = \
-               epl-v10.html,\
-               eclipse_update_120.jpg,\
-               feature.xml,\
-               feature.properties,\
-               license.html
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/epl-v10.html b/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/epl-v10.html
deleted file mode 100644
index 022ad29..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/feature.properties b/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/feature.properties
deleted file mode 100644
index 215a046..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/feature.properties
+++ /dev/null
@@ -1,145 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Dali Java Persistence API (JPA) Tools
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 2008 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/license.html b/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/license.html
deleted file mode 100644
index fec4a48..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplateFeature/license.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>June 06, 2007</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.html b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.html
deleted file mode 100644
index d4916df..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<p>June 06, 2007</p>	
-<h3>License</h3>
-
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
-apply to your use of any object code in the Content.  Check the Redistributor's license that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
-indicated below, the terms and conditions of the EPL still apply to any source code in the Content.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.ini b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.mappings b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.properties b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.properties
deleted file mode 100644
index 15417ff..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/about.properties
+++ /dev/null
@@ -1,26 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=Dali Java Persistence API (JPA) Tools Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2008.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/build.properties b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/build.properties
deleted file mode 100644
index ce9529b..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/build.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
-sourcePlugin = true
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse32.gif b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse32.png b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/epl-v10.html b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/epl-v10.html
deleted file mode 100644
index 022ad29..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/license.html b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/license.html
deleted file mode 100644
index 14b1d50..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/license.html
+++ /dev/null
@@ -1,83 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>June 06, 2007</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/plugin.properties b/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/plugin.properties
deleted file mode 100644
index f948547..0000000
--- a/jpa/features/org.eclipse.jpt.feature/sourceTemplatePlugin/plugin.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-
-pluginName = Dali Java Persistence API (JPA) Tools
-providerName = Eclipse.org
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/.cvsignore b/jpa/features/org.eclipse.jpt.tests.feature/.cvsignore
deleted file mode 100644
index c14487c..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-build.xml
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/.project b/jpa/features/org.eclipse.jpt.tests.feature/.project
deleted file mode 100644
index 91760f2..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.tests.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/.settings/org.eclipse.core.resources.prefs b/jpa/features/org.eclipse.jpt.tests.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 235b84a..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:11:17 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/build.properties b/jpa/features/org.eclipse.jpt.tests.feature/build.properties
deleted file mode 100644
index d6a4dce..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/build.properties
+++ /dev/null
@@ -1,10 +0,0 @@
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               epl-v10.html,\
-               license.html,\
-               feature.properties
-src.includes = license.html,\
-               feature.xml,\
-               epl-v10.html,\
-               eclipse_update_120.jpg,\
-               build.properties
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt.tests.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/epl-v10.html b/jpa/features/org.eclipse.jpt.tests.feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/feature.properties b/jpa/features/org.eclipse.jpt.tests.feature/feature.properties
deleted file mode 100644
index 46a4c43..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/feature.properties
+++ /dev/null
@@ -1,145 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-# "updateSiteName" property - label for the update site
-# TOREVIEW - updateSiteName
-updateSiteName=Web Tools Platform (WTP) Updates
-
-# "description" property - description of the feature
-description=Dali Java Persistence Tools Tools
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/feature.xml b/jpa/features/org.eclipse.jpt.tests.feature/feature.xml
deleted file mode 100644
index b15bf8d..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/feature.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt.tests.feature"
-      label="Dali Java Persistence Tools JUnit Tests"
-      version="2.3.0.qualifier"
-      provider-name="Eclipse.org">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <plugin
-         id="org.eclipse.jpt.utility.tests"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.jpt.core.tests"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.jpt.core.tests.extension.resource"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.jpt.eclipselink.core.tests"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"/>
-
-</feature>
diff --git a/jpa/features/org.eclipse.jpt.tests.feature/license.html b/jpa/features/org.eclipse.jpt.tests.feature/license.html
deleted file mode 100644
index 5644598..0000000
--- a/jpa/features/org.eclipse.jpt.tests.feature/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-    
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/.cvsignore b/jpa/features/org.eclipse.jpt_sdk.feature/.cvsignore
deleted file mode 100644
index 6365d3d..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/.cvsignore
+++ /dev/null
@@ -1,3 +0,0 @@
-feature.temp.folder
-build.xml
-org.eclipse.jpt_sdk.feature_1.0.1.*
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/.project b/jpa/features/org.eclipse.jpt_sdk.feature/.project
deleted file mode 100644
index 33da750..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt_sdk.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/.settings/org.eclipse.core.resources.prefs b/jpa/features/org.eclipse.jpt_sdk.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 6cc7d4b..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:09:59 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/build.properties b/jpa/features/org.eclipse.jpt_sdk.feature/build.properties
deleted file mode 100644
index 2d7ab8d..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/build.properties
+++ /dev/null
@@ -1,7 +0,0 @@
-bin.includes = feature.xml,\
-               license.html,\
-               feature.properties,\
-               epl-v10.html,\
-               eclipse_update_120.jpg
-
-generate.feature@org.eclipse.jpt.feature.source=org.eclipse.jpt.feature
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/eclipse_update_120.jpg b/jpa/features/org.eclipse.jpt_sdk.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/epl-v10.html b/jpa/features/org.eclipse.jpt_sdk.feature/epl-v10.html
deleted file mode 100644
index ed4b196..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
\ No newline at end of file
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/feature.properties b/jpa/features/org.eclipse.jpt_sdk.feature/feature.properties
deleted file mode 100644
index 5db5536..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/feature.properties
+++ /dev/null
@@ -1,140 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-# "featureName" property - name of the feature
-featureName=Dali Java Persistence Tools Plug-in SDK
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform Project
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-description=Source code archives for Dali Java Persistence Tools
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006-09 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-licenseURL=license.html
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-license=\
-ECLIPSE FOUNDATION SOFTWARE USER AGREEMENT\n\
-June 06, 2007\n\
-\n\
-Usage Of Content\n\
-\n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW. BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
-\n\
-Applicable Licenses\n\
-\n\
-Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
-is provided to you under the terms and conditions of the Eclipse Public\n\
-License Version 1.0 ("EPL"). A copy of the EPL is provided with this\n\
-Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
-\n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse.org CVS\n\
-repository ("Repository") in CVS modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
-\n\
-   - Content may be structured and packaged into modules to facilitate delivering,\n\
-     extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-     plug-in fragments ("Fragments"), and features ("Features").\n\
-   - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java? ARchive)\n\
-     in a directory named "plugins".\n\
-   - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-     Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-     Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-     numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-   - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-     named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
-\n\
-Features may also include other Features ("Included Features"). Files named\n\
-"feature.xml" may contain a list of the names and version numbers of\n\
-Included Features.\n\
-\n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
-\n\
-   - The top-level (root) directory\n\
-   - Plug-in and Fragment directories\n\
-   - Inside Plug-ins and Fragments packaged as JARs\n\
-   - Sub-directories of the directory named "src" of certain Plug-ins\n\
-   - Feature directories\n\
-\n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Eclipse Update Manager, you must agree to a license ("Feature Update\n\
-License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties". Such Abouts,\n\
-Feature Licenses and Feature Update Licenses contain the terms and\n\
-conditions (or references to such terms and conditions) that govern your\n\
-use of the associated Content in that directory.\n\
-\n\
-THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
-\n\
-    - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-    - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-    - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-    - IBM Public License 1.0 (available at http://oss.software.ibm.com/developerworks/opensource/license10.html)\n\
-    - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-    - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
-    - Common Development and Distribution License (CDDL) Version 1.0 (available at http://www.sun.com/cddl/cddl.html)\n\
-\n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
-\n\
-Cryptography\n\
-\n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use,\n\
-and re-export of encryption software, to see if this is permitted.\n\
-\n\
-Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.\n
-########### end of license property ##########################################
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/feature.xml b/jpa/features/org.eclipse.jpt_sdk.feature/feature.xml
deleted file mode 100644
index 3023f9b..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/feature.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jpt_sdk.feature"
-      label="%featureName"
-      version="2.3.0.qualifier"
-      provider-name="%providerName">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <includes
-         id="org.eclipse.jpt.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jpt.feature.source"
-         version="0.0.0"/>
-
-   <plugin
-         id="org.eclipse.jpt.doc.isv"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/jpa/features/org.eclipse.jpt_sdk.feature/license.html b/jpa/features/org.eclipse.jpt_sdk.feature/license.html
deleted file mode 100644
index fc77372..0000000
--- a/jpa/features/org.eclipse.jpt_sdk.feature/license.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
-<!-- saved from url=(0044)http://www.eclipse.org/legal/epl/notice.html -->
-<HTML><HEAD><TITLE>Eclipse.org Software User Agreement</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 6.00.2800.1479" name=GENERATOR></HEAD>
-<BODY lang=EN-US vLink=purple link=blue>
-<H2>Eclipse Foundation Software User Agreement</H2>
-<P>June 06, 2007</P>
-<H3>Usage Of Content</H3>
-<P>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION 
-AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF 
-THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE 
-TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED 
-BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED 
-BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE 
-AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE 
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY 
-APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU 
-MAY NOT USE THE CONTENT.</P>
-<H3>Applicable Licenses</H3>
-<P>Unless otherwise indicated, all Content made available by the Eclipse 
-Foundation is provided to you under the terms and conditions of the Eclipse 
-Public License Version 1.0 ("EPL"). A copy of the EPL is provided with this 
-Content and is also available at <A 
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-<P>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse.org CVS repository 
-("Repository") in CVS modules ("Modules") and made available as downloadable 
-archives ("Downloads").</P>
-<P>Content may be apportioned into plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features"). A Feature is a bundle of one or more 
-Plug-ins and/or Fragments and associated material. Files named "feature.xml" may 
-contain a list of the names and version numbers of the Plug-ins and/or Fragments 
-associated with a Feature. Plug-ins and Fragments are located in directories 
-named "plugins" and Features are located in directories named "features".</P>
-<P>Features may also include other Features ("Included Features"). Files named 
-"feature.xml" may contain a list of the names and version numbers of Included 
-Features.</P>
-<P>The terms and conditions governing Plug-ins and Fragments should be contained 
-in files named "about.html" ("Abouts"). The terms and conditions governing 
-Features and Included Features should be contained in files named "license.html" 
-("Feature Licenses"). Abouts and Feature Licenses may be located in any 
-directory of a Download or Module including, but not limited to the following 
-locations:</P>
-<UL>
-  <LI>The top-level (root) directory 
-  <LI>Plug-in and Fragment directories 
-  <LI>Subdirectories of the directory named "src" of certain Plug-ins 
-  <LI>Feature directories </LI></UL>
-<P>Note: if a Feature made available by the Eclipse Foundation is installed 
-using the Eclipse Update Manager, you must agree to a license ("Feature Update 
-License") during the installation process. If the Feature contains Included 
-Features, the Feature Update License should either provide you with the terms 
-and conditions governing the Included Features or inform you where you can 
-locate them. Feature Update Licenses may be found in the "license" property of 
-files named "feature.properties". Such Abouts, Feature Licenses and Feature 
-Update Licenses contain the terms and conditions (or references to such terms 
-and conditions) that govern your use of the associated Content in that 
-directory.</P>
-<P>THE ABOUTS, FEATURE LICENSES AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL 
-OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE 
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</P>
-<UL>
-  <LI>Common Public License Version 1.0 (available at <A 
-  href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</A>) 
-
-  <LI>Apache Software License 1.1 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</A>) 
-
-  <LI>Apache Software License 2.0 (available at <A 
-  href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</A>) 
-
-  <LI>IBM Public License 1.0 (available at <A 
-  href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</A>) 
-
-  <LI>Metro Link Public License 1.00 (available at <A 
-  href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</A>) 
-
-  <LI>Mozilla Public License Version 1.1 (available at <A 
-  href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</A>) 
-  </LI>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-<P>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR 
-TO USE OF THE CONTENT. If no About, Feature License or Feature Update License is 
-provided, please contact the Eclipse Foundation to determine what terms and 
-conditions govern that particular Content.</P>
-<H3>Cryptography</H3>
-<P>Content may contain encryption software. The country in which you are 
-currently may have restrictions on the import, possession, and use, and/or 
-re-export to another country, of encryption software. BEFORE using any 
-encryption software, please check the country's laws, regulations and policies 
-concerning the import, possession, or use, and re-export of encryption software, 
-to see if this is permitted.</P></BODY></HTML>
diff --git a/jpa/plugins/org.eclipse.jpt.branding/.cvsignore b/jpa/plugins/org.eclipse.jpt.branding/.cvsignore
deleted file mode 100644
index c9401a2..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-build.xml
-org.eclipse.jpt_1.0.0.*
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.branding/.project b/jpa/plugins/org.eclipse.jpt.branding/.project
deleted file mode 100644
index e1a9bed..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/.project
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.branding</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/plugins/org.eclipse.jpt.branding/.settings/org.eclipse.core.resources.prefs b/jpa/plugins/org.eclipse.jpt.branding/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 4aec29d..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:10:09 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/plugins/org.eclipse.jpt.branding/META-INF/MANIFEST.MF b/jpa/plugins/org.eclipse.jpt.branding/META-INF/MANIFEST.MF
deleted file mode 100644
index b6ff08b..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,7 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jpt.branding;singleton:=true
-Bundle-Version: 2.3.0.qualifier
-Bundle-Localization: plugin
-Bundle-Vendor: %providerName
diff --git a/jpa/plugins/org.eclipse.jpt.branding/about.html b/jpa/plugins/org.eclipse.jpt.branding/about.html
deleted file mode 100644
index ca606b1..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/about.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<HTML>
-
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-
-<BODY lang="EN-US">
-
-<H3>About This Content</H3>
-
-<P>June 06, 2007</P>
-
-<H3>License</H3>
-
-<P>The Eclipse Foundation makes available all content in this plug-in 
-("Content"). Unless otherwise indicated below, the Content is provided to you 
-under the terms and conditions of the Eclipse Public License Version 1.0 
-("EPL"). A copy of the EPL is available at
-<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-
-<P>If you did not receive this Content directly from the Eclipse Foundation, the 
-Content is being redistributed by another party ("Redistributor") and different 
-terms and conditions may apply to your use of any object code in the Content. 
-Check the Redistributor's license that was provided with the Content. If no such 
-license exists, contact the Redistributor. Unless otherwise indicated below, the 
-terms and conditions of the EPL still apply to any source code in the Content 
-and such source code may be obtained at
-<A href="http://www.eclipse.org/">http://www.eclipse.org/</A>.</P>
-
-</BODY>
-</HTML>
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.branding/about.ini b/jpa/plugins/org.eclipse.jpt.branding/about.ini
deleted file mode 100644
index 7d88b9d..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/about.ini
+++ /dev/null
@@ -1,44 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=icons/WTP_icon_x32_v2.png
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-# Property "tipsAndTricksHref" contains the Help topic href to a tips and tricks page 
-# optional
-tipsAndTricksHref=/org.eclipse.jpt.doc.user/tips_and_tricks.htm
-
-
diff --git a/jpa/plugins/org.eclipse.jpt.branding/about.mappings b/jpa/plugins/org.eclipse.jpt.branding/about.mappings
deleted file mode 100644
index bddaab4..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.branding/about.properties b/jpa/plugins/org.eclipse.jpt.branding/about.properties
deleted file mode 100644
index 4b821e2..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/about.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-
-blurb=Dali Java Persistence Tools\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Oracle contributors and others 2006, 2009.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
diff --git a/jpa/plugins/org.eclipse.jpt.branding/build.properties b/jpa/plugins/org.eclipse.jpt.branding/build.properties
deleted file mode 100644
index 4e089bb..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/build.properties
+++ /dev/null
@@ -1,18 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = META-INF/,\
-               about.ini,\
-               about.html,\
-               about.mappings,\
-               about.properties,\
-               icons/,\
-               plugin.properties,\
-               component.xml
diff --git a/jpa/plugins/org.eclipse.jpt.branding/component.xml b/jpa/plugins/org.eclipse.jpt.branding/component.xml
deleted file mode 100644
index 622c26c..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/component.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<component  xmlns="http://eclipse.org/wtp/releng/tools/component-model" name="org.eclipse.jpt.branding">
-<description url=""></description>
-<component-depends unrestricted="true"></component-depends>
-<plugin id="org.eclipse.jpt.branding" fragment="false"/>
-<plugin id="org.eclipse.jpt.core" fragment="false"/>
-<plugin id="org.eclipse.jpt.db" fragment="false"/>
-<plugin id="org.eclipse.jpt.db.ui" fragment="false"/>
-<plugin id="org.eclipse.jpt.gen" fragment="false"/>
-<plugin id="org.eclipse.jpt.ui" fragment="false"/>
-<plugin id="org.eclipse.jpt.jaxb.ui" fragment="false"/>
-<plugin id="org.eclipse.jpt.utility" fragment="false"/>
-</component>
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.branding/icons/WTP_icon_x32_v2.png b/jpa/plugins/org.eclipse.jpt.branding/icons/WTP_icon_x32_v2.png
deleted file mode 100644
index 6f09c2a..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/icons/WTP_icon_x32_v2.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.branding/plugin.properties b/jpa/plugins/org.eclipse.jpt.branding/plugin.properties
deleted file mode 100644
index 0cadd22..0000000
--- a/jpa/plugins/org.eclipse.jpt.branding/plugin.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-pluginName = Dali Java Persistence Tools
-providerName = Eclipse Web Tools Platform
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/.project b/jpa/plugins/org.eclipse.jpt.doc.user/.project
deleted file mode 100644
index 61670ff..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/.project
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.doc.user</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/META-INF/MANIFEST.MF b/jpa/plugins/org.eclipse.jpt.doc.user/META-INF/MANIFEST.MF
deleted file mode 100644
index 1aff0ce..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,9 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-Vendor: %providerName
-Bundle-SymbolicName: org.eclipse.jpt.doc.user;singleton:=true
-Bundle-Version: 1.2.0.qualifier
-Bundle-Localization: plugin
-Require-Bundle: org.eclipse.help;bundle-version="[3.3.100,4.0.0)",
- org.eclipse.ui.cheatsheets;bundle-version="[3.3.100,4.0.0)"
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/about.htm b/jpa/plugins/org.eclipse.jpt.doc.user/about.htm
deleted file mode 100644
index e52430c..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/about.htm
+++ /dev/null
@@ -1,43 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>About this content</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="About this content" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<div class="sect1"><!-- infolevel="all" infotype="General" --><a id="sthref290" name="sthref290"></a>
-<h1>About this content</h1>
-<p>November, 2009</p>
-<a id="sthref291" name="sthref291"></a>
-<p class="subhead2">License</p>
-<p>The Eclipse Foundation makes available all content in this plug-in ("Content"). Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is available at <code><a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a></code>. For purposes of the EPL, "Program" will mean the Content.</p>
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party ("Redistributor") and different terms and conditions may apply to your use of any object code in the Content. Check the Redistributor's license that was provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at <code><a href="http://www.eclipse.org">http://www.eclipse.org</a></code>.</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/about.html b/jpa/plugins/org.eclipse.jpt.doc.user/about.html
deleted file mode 100644
index 54a84ef..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/about.html
+++ /dev/null
@@ -1,43 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>About this content</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2009-11-16T9:56:23Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="About this content" />
-<meta name="relnum" content="Release 3.0" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<div class="sect1"><!-- infolevel="all" infotype="General" --><a id="sthref290" name="sthref290"></a>
-<h1>About this content</h1>
-<p>November, 2009</p>
-<a id="sthref291" name="sthref291"></a>
-<p class="subhead2">License</p>
-<p>The Eclipse Foundation makes available all content in this plug-in ("Content"). Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is available at <code><a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a></code>. For purposes of the EPL, "Program" will mean the Content.</p>
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party ("Redistributor") and different terms and conditions may apply to your use of any object code in the Content. Check the Redistributor's license that was provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at <code><a href="http://www.eclipse.org">http://www.eclipse.org</a></code>.</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2009,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/build.properties b/jpa/plugins/org.eclipse.jpt.doc.user/build.properties
deleted file mode 100644
index e2c8808..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/build.properties
+++ /dev/null
@@ -1,127 +0,0 @@
-bin.includes = cheatsheets/,\
-               dcommon/,\
-               img/,\
-               META-INF/,\
-               about.html,\
-               build.properties,\
-               concept_mapping.htm,\
-               concept_persistence.htm,\
-               concepts.htm,\
-               concepts001.htm,\
-               concepts002.htm,\
-               concepts003.htm,\
-               contexts.xml,\
-               getting_started.htm,\
-               getting_started001.htm,\
-               getting_started002.htm,\
-               getting_started003.htm,\
-               getting_started004.htm,\
-               index.xml,\
-               legal.htm,\
-               plugin.properties,\
-               plugin.xml,\
-               ref_details_orm.htm,\
-               ref_jpa_facet.htm,\
-               ref_mapping_general.htm,\
-               ref_new_jpa_project.htm,\
-               ref_new_jpa_project_wizard.htm,\
-               ref_persistence_map_view.htm,\
-               ref_persistence_outline.htm,\
-               ref_persistence_perspective.htm,\
-               ref_persistence_prop_view.htm,\
-               ref_primary_key.htm,\
-               ref_project_properties.htm,\
-               reference.htm,\
-               reference001.htm,\
-               reference002.htm,\
-               reference003.htm,\
-               reference004.htm,\
-               reference005.htm,\
-               reference006.htm,\
-               reference007.htm,\
-               reference008.htm,\
-               reference009.htm,\
-               reference010.htm,\
-               reference011.htm,\
-               reference012.htm,\
-               reference013.htm,\
-               reference014.htm,\
-               reference015.htm,\
-               reference016.htm,\
-               reference017.htm,\
-               reference018.htm,\
-               task_add_persistence.htm,\
-               task_additonal_tables.htm,\
-               task_create_new_project.htm,\
-               task_inheritance.htm,\
-               task_manage_orm.htm,\
-               task_manage_persistence.htm,\
-               task_mapping.htm,\
-               tasks.htm,\
-               tasks001.htm,\
-               tasks002.htm,\
-               tasks003.htm,\
-               tasks004.htm,\
-               tasks005.htm,\
-               tasks006.htm,\
-               tasks007.htm,\
-               tasks008.htm,\
-               tasks009.htm,\
-               tasks010.htm,\
-               tasks011.htm,\
-               tasks012.htm,\
-               tasks013.htm,\
-               tasks014.htm,\
-               tasks015.htm,\
-               tasks016.htm,\
-               tasks017.htm,\
-               tasks018.htm,\
-               tasks019.htm,\
-               tasks020.htm,\
-               tasks021.htm,\
-               tasks022.htm,\
-               tips_and_tricks.htm,\
-               toc.xml,\
-               whats_new.htm,\
-               whats_new001.htm,\
-               whats_new002.htm,\
-               whats_new003.htm,\
-               about.htm,\
-               reference019.htm,\
-               reference020.htm,\
-               reference021.htm,\
-               reference022.htm,\
-               reference023.htm,\
-               reference024.htm,\
-               reference025.htm,\
-               reference026.htm,\
-               reference027.htm,\
-               reference028.htm,\
-               reference030.htm,\
-               reference029.htm,\
-               reference031.htm,\
-               reference032.htm,\
-               tasks023.htm,\
-               tasks024.htm,\
-               whats_new004.htm,\
-               whats_new005.htm,\
-               ref_persistence_xmll_editor.htm,\
-               ref_EntityClassPage.htm,\
-               ref_EntityPropertiesPage.htm,\
-               ref_add_converter.htm,\
-               ref_association_cardinality.htm,\
-               ref_association_table.htm,\
-               ref_create_custom_entities_wizard.htm,\
-               ref_create_jpa_entity_wizard.htm,\
-               ref_create_new_association_wizard.htm,\
-               ref_customizIndividualEntities.htm,\
-               ref_customizeDefaultEntityGeneration.htm,\
-               ref_eclipselink_mapping_file.htm,\
-               ref_java_page.htm,\
-               ref_join_columns.htm,\
-               ref_persistence_general.htm,\
-               ref_selectTables.htm,\
-               ref_select_cascade_dialog.htm,\
-               ref_tableAssociations.htm,\
-               task_create_jpa_entity.htm
-generateSourceBundle=false
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/add_persistence.xml b/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/add_persistence.xml
deleted file mode 100644
index 33b9d32..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/add_persistence.xml
+++ /dev/null
@@ -1,63 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<cheatsheet title="Create a JPA Project">
-   <intro href="/org.eclipse.platform.doc.user/reference/ref-cheatsheets.htm">
-      <description>
-         This cheat sheet will automatically launch wizards, perform actions, and guide you through the steps to create a JPA project. 
-
-To learn more about using cheat sheets, or to see a list of available cheat sheets, click Help (?). 
-To start work working on this cheat sheet click the &quot;Click to Begin&quot; button below. 
-
-Let&apos;s get started!
-      </description>
-   </intro>
-   <item title="Setup the Environment" dialog="false" skip="true" href="/org.eclipse.datatools.connectivity.doc.user/doc/html/asc1229700343352.html">
-      <description>
-         Your environment must be set up before you can perform the steps in this cheat sheet. 
-
-Create a database profile and connect to the database.
-
-The Database Connection dialog automatically appears when you click the &quot;Click to Perform&quot; button.
-      </description>
-      <command serialization="org.eclipse.datatools.sqltools.sqleditor.attachProfileAction" confirm="false">
-      </command>
-   </item>
-   <item title="Create a JPA Project" dialog="false" skip="false" href="/org.eclipse.jpt.doc.user/task_create_new_project.htm">
-      <description>
-         Use the New Project Wizard to create a JPA project. 
-Select <b>File-&gt;New-&gt;Project...</b> and choose <b>JPA-&gt;JPA Project</b> in the list. 
-
-On the first page of the wizard, enter a project name and location, select your target runtime, and select a predefined project configuration.
-
-Click <b>Next</b> to display the next page of the wizard.
-
-The &quot;New JPA Project&quot; wizard is automatically displayed when you click the &quot;Click to Perform&quot; button.
-      </description>
-      <action class="org.eclipse.jdt.internal.ui.wizards.OpenProjectWizardAction" pluginId="org.eclipse.jdt.ui" confirm="false">
-      </action>
-   </item>
-   <item title="Select Project Facet" dialog="false" skip="false" href="/org.eclipse.jst.j2ee.doc.user/topics/ph-projects.html">
-      <description>
-         Use the Project Facet page to select a predefined project configuration or specific specific facets to include in the project. 
-
-Click &quot;Next&quot; to display the next page of the wizard.
-      </description>
-   </item>
-   <item title="Specify the JPA Facet" dialog="false" skip="false" href="/org.eclipse.jdt.doc.user/ref_jpa_facet.htm">
-      <description>
-         Use the JPA Facet page to specify the the vendor-specific JPA platform, the database connection to use, and the specific JPA implementation library. 
-
-You can also specify if Dali should create an orm.xml file.
-
-If you do not have an active database connection, click <b>Add Connections</b> to create one. 
-
-If you do not have a defined JPA implementation library, click <b>Configure default JPA implementation library</b> or <b>Configure user libraries</b> to define one. 
-
-Click <b>Finish</b> to complete the wizard and open the open the project.
-      </description>
-   </item>
-   <item title="Finish" dialog="false" skip="false">
-      <description>
-         Congratulations! You have successfully created a JPA project. Complete the additional cheat sheets to add Java persistent entities and map those entities to database tables.
-      </description>
-   </item>
-</cheatsheet>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/create_entity.xml b/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/create_entity.xml
deleted file mode 100644
index b64e8af..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/create_entity.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<cheatsheet title="Create a Persistent Entity">
-	<intro href="/org.eclipse.platform.doc.user/reference/ref-cheatsheets.htm">
-		<description>
-This cheat sheet will automatically launch wizards, perform actions, and guide you through the steps to add a Java persistent entity to your Java project. 
-To learn more about using cheat sheets or to see a list of available cheat sheets, click Help (?). 
-To start work working on this cheat sheet, click the <b>Click to Begin</b> button below. 
-Let's get started!
-  </description>
-	</intro>
-	<item title="Create a JPA Project" skip="true">
-		<description>
-To create a Persistent entity, you must create a JPA project. If you already have a JPA project, you may skip this step by clicking the "Click to Skip" button.
-If not, select <b>File->New->Project...</b> and choose <b>JPA->JPA Project</b> in the list. Complete each page of the Create JPA Project wizard to create a new JPA project.
-      </description>
-	</item>
-	<item title="Open the JPA Development Perspective" skip="true" href="/org.eclipse.jpt.doc.user/ref_persistence_perspective.htm">
-		<action pluginId="org.eclipse.ui.cheatsheets" class="org.eclipse.ui.internal.cheatsheets.actions.OpenPerspective" param1="org.eclipse.jpt.ui.PersistencePerspective"/>
-		<description>
-When working with JPA  persistence, you should use the Persistence perspective. If you already have the Persistence perspective active, you may skip this step by clicking the "Click to Skip" button. 
-If not, select <b>Window->Open Perspective->Other</b> in the menubar at the top of the workbench. In the Select Perspectives dialog, select <b>JPA Development</b> and click OK. This step changes the perspective to set up the Eclipse workbench for JPA development.
-You can click the "Click to Perform" button to have the "Persistence" perspective opened automatically.
-   </description>
-	</item>
-	<item title="Create a Java Class">
-		<description>
-The next step is to create a new Java class. In the main toolbar again, click on <b>New Java Class</b> button (or the link below).
-The Java editor will automatically open showing your new class.      
-     </description>
-	</item>
-	<item title="Create a Persistent Entity">
-		<description>
-Finally we will make the Java class a persistent entity.
-In the JPA Structure view select the Java class. 
-In the JPA Details view, use the "Map As" field to select <b>Entity</b>. Dali automatically adds the @Entity annotation to the class in the Java editor. 
-Use the Table, Catalog, and Schema fields to associate the entity with a specific table in the database.
-     </description>
-	</item>
-	<item title="Finish">
-		<description>
-Congratulations! You have successfully added a JPA entity to your JPA project. Complete the additional cheat sheets to map the entity's fields to database tables.
-  </description>
-	</item>
-</cheatsheet>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/map_entity.xml b/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/map_entity.xml
deleted file mode 100644
index 7521914..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/cheatsheets/map_entity.xml
+++ /dev/null
@@ -1,88 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<cheatsheet title="Map a Java Persistent Entity">
-   <intro href="/org.eclipse.platform.doc.user/reference/ref-cheatsheets.htm">
-      <description>
-         This cheat sheet will automatically launch wizards, perform actions, and guide you through the steps to map the fields of a JPA entity entity to your database.
-
-To learn more about using cheat sheets or to see a list of available cheat sheets, click Help (?). 
-To start work working on this cheat sheet, click the &quot;Click to Begin&quot; button below. 
-
-Let&apos;s get started!
-      </description>
-   </intro>
-   <item title="Setup the Environment" dialog="false" skip="true" href="/org.eclipse.datatools.connectivity.doc.user/doc/html/asc1229700343352.html">
-      <description>
-         Your environment must be set up before you can perform the steps in this cheat sheet. 
-
-Create a database profile and connect to the database.
-
-If you already have (and are connected to) a database connection, you  may skip this step by clicking the &quot;Click to Skip&quot; button.
-
-The Database Connection dialog automatically appears when you click the &quot;Click to Perform&quot; button.
-      </description>
-      <command serialization="org.eclipse.datatools.sqltools.sqleditor.attachProfileAction" confirm="false">
-      </command>
-   </item>
-   <item title="Create a JPA Project" dialog="false" skip="true" href="/org.eclipse.jpt.doc.user/task_create_new_project.htm">
-      <description>
-         Use the New Project Wizard to create a JPA project. 
-Select <b>File-&gt;New-&gt;Project...</b> and choose <b>JPA-&gt;JPA Project</b> in the list. 
-
-Complete each page of the wizard to create a new JPA project.
-
-The &quot;New JPA Project&quot; wizard is automatically displayed when you click the &quot;Click to Perform&quot; button.
-
-If you already have a JPA project, you  may skip this step by clicking the &quot;Click to Skip&quot; button.
-      </description>
-      <action class="org.eclipse.jdt.internal.ui.wizards.OpenProjectWizardAction" pluginId="org.eclipse.jdt.ui" confirm="false">
-      </action>
-   </item>
-   <item title="Open the JPA Development Perspective" dialog="false" skip="true" href="/org.eclipse.jpt.doc.user/ref_persistence_perspective.htm">
-      <description>
-         When working with JPA  persistence, you should use the Persistence perspective. If you already have the Persistence perspective active, you may skip this step by clicking the &quot;Click to Skip&quot; button. 
-If not, select <b>Window-&gt;Open Perspective-&gt;Other</b> in the menubar at the top of the workbench. In the Select Perspectives dialog, select <b>JPA Development</b> and click OK. This step changes the perspective to set up the Eclipse workbench for JPA development.
-You can click the &quot;Click to Perform&quot; button to have the &quot;Persistence&quot; perspective opened automatically.
-      </description>
-      <action class="org.eclipse.ui.internal.cheatsheets.actions.OpenPerspective" pluginId="org.eclipse.ui.cheatsheets" confirm="false" param1="org.eclipse.jpt.ui.PersistencePerspective">
-      </action>
-   </item>
-   <item title="Create a Java Class" dialog="false" skip="false">
-      <description>
-         The next step is to create a new Java class. In the main toolbar again, click on <b>New Java Class</b> button (or the link below).
-The Java editor will automatically open showing your new class.
-      </description>
-   </item>
-   <item title="Create a Persistent Entity" dialog="false" skip="false">
-      <description>
-         Finally we will make the Java class a persistent entity.
-In the JPA Structure view select the Java class. 
-In the JPA Details view, use the &quot;Map As&quot; field to select <b>Entity</b>. Dali automatically adds the @Entity annotation to the class in the Java editor. 
-Use the Table, Catalog, and Schema fields to associate the entity with a specific table in the database.
-      </description>
-   </item>
-   <item title="Add Fields to the Class" dialog="false" skip="true">
-      <description>
-         Now you will add some fields to the entity to map to rows in the database table.   
-
-If your persistent entity already has fields to map, you may skip this step by clicking the &quot;Click to Skip&quot; button. If not, use the Java editor to add fields to the entity.
-      </description>
-      <action class="org.eclipse.ui.internal.cheatsheets.actions.OpenPerspective" pluginId="org.eclipse.ui.cheatsheets" confirm="false" param1="org.eclipse.dali.ui.PersistencePerspective">
-      </action>
-   </item>
-   <item title="Create the Mapping" dialog="false" skip="false" href="/org.eclipse.dali.doc.user/ref_entity_page.htm">
-      <description>
-         Now you are ready to map the entity fields to columns in the database table. In the Package Explorer, select the Java class. 
-
-In the JPA Structure view, expand the persistent entity to display the fields. Select a field. 
-
-The JPA Details view displays the information for the field. Use the Map As field to select the Basic mapping. Use the Column field to select a column from the database table.
-      </description>
-      <action class="org.eclipse.ui.internal.cheatsheets.actions.OpenPerspective" pluginId="org.eclipse.ui.cheatsheets" confirm="false" param1="org.eclipse.dali.ui.PersistencePerspective">
-      </action>
-   </item>
-   <item title="Finish" dialog="false" skip="false">
-      <description>
-         Congratulations! You have successfully mapped the fields from a Java persistent entity to a column in a database table.
-      </description>
-   </item>
-</cheatsheet>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/concept_mapping.htm b/jpa/plugins/org.eclipse.jpt.doc.user/concept_mapping.htm
deleted file mode 100644
index 618b53f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/concept_mapping.htm
+++ /dev/null
@@ -1,46 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Understanding OR mappings</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Understanding OR mappings" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABBDJFI" name="BABBDJFI"></a></p>
-<div class="sect1">
-<h1>Understanding OR mappings</h1>
-<p><a id="sthref21" name="sthref21"></a><a id="sthref22" name="sthref22"></a>The Dali OR (object-relational) Mapping Tool allows you to describe how your entity objects <span class="italic">map</span> to the data source (or other objects). This approach isolates persistence information from the object model&ndash;developers are free to design their ideal object model, and DBAs are free to design their ideal schema.</p>
-<p>These mappings transform an object data member type to a corresponding relational database data source representation. These OR mappings can also transform object data members that reference other domain objects stored in other tables in the database and are related through foreign keys.</p>
-<p>You can use these mappings to map simple data types including primitives (such as <code>int</code>), JDK classes (such as <code>String</code>), and large object (LOB) values. You can also use them to transform object data members that reference other domain objects by way of association where data source representations require object identity maintenance (such as sequencing and back references) and possess various types of multiplicity and navigability. The appropriate mapping class is chosen primarily by the cardinality of the relationship.</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/concept_persistence.htm b/jpa/plugins/org.eclipse.jpt.doc.user/concept_persistence.htm
deleted file mode 100644
index 5595347..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/concept_persistence.htm
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Understanding Java persistence</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Understanding Java persistence" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABCAHIC" name="BABCAHIC"></a></p>
-<div class="sect1">
-<h1>Understanding Java persistence</h1>
-<p><a id="sthref19" name="sthref19"></a><span class="italic">Persistence</span> refers to the ability to store objects in a database and use those objects with transactional integrity. In a J2EE application, data is typically stored and persisted in the data tier, in a relational database.</p>
-<p><a id="sthref20" name="sthref20"></a><span class="italic">Entity beans</span> are enterprise beans that contain persistent data and that can be saved in various persistent data stores. The entity beans represent data from a database; each entity bean carries its own identity. Entity beans can be deployed using <span class="italic">application-managed persistence</span> or <span class="italic">container-managed persistence</span>.</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/concepts.htm b/jpa/plugins/org.eclipse.jpt.doc.user/concepts.htm
deleted file mode 100644
index 548049b..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/concepts.htm
+++ /dev/null
@@ -1,63 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Concepts</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content=" Concepts" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="sthref18" name="sthref18"></a></p>
-<h1>Concepts</h1>
-<p>This section contains an overview of concepts you should be familiar with when using Dali to create mappings for Java persistent entities.</p>
-<ul>
-<li>
-<p><a href="concept_persistence.htm#BABCAHIC">Understanding Java persistence</a></p>
-</li>
-<li>
-<p><a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a></p>
-</li>
-<li>
-<p><a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></p>
-</li>
-</ul>
-<p>In addition to these sections, you should review the following resources for additional information:</p>
-<ul>
-<li>
-<p>Eclipse Dali project: <code><a href="http://www.eclipse.org/webtools/dali">http://www.eclipse.org/webtools/dali</a></code></p>
-</li>
-<li>
-<p>Eclipse Web Tools Platform project: <code><a href="http://www.eclipse.org/webtools">http://www.eclipse.org/webtools</a></code></p>
-</li>
-<li>
-<p>JSR 220 EJB 3.0 specification: <code><a href="http://www.jcp.org/en/jsr/detail?id=220">http://www.jcp.org/en/jsr/detail?id=220</a></code></p>
-</li>
-<li>
-<p>EclipseLink project: <code><a href="http://www.eclipse.org/eclipselink">http://www.eclipse.org/eclipselink</a></code></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/concepts001.htm b/jpa/plugins/org.eclipse.jpt.doc.user/concepts001.htm
deleted file mode 100644
index 1a31988..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/concepts001.htm
+++ /dev/null
@@ -1,43 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Understanding EJB 3.0 Java Persistence API</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Understanding EJB 3.0 Java Persistence API" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABBGFJG" name="BABBGFJG"></a></p>
-<div class="sect1">
-<h1>Understanding EJB 3.0 Java Persistence API</h1>
-<p>The Java 2 Enterprise Edition(J2EE) Enterprise JavaBeans (EJB) are a component architecture that you use to develop and deploy object-oriented, distributed, enterprise-scale applications. An application written according to the Enterprise JavaBeans architecture is scalable, transactional, and secure.</p>
-<p>The EJB 3.0 Java Persistence API (JPA) improves the EJB architecture by reducing its complexity through the use of metadata (annotations) and specifying programmatic defaults of that metadata.</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/concepts002.htm b/jpa/plugins/org.eclipse.jpt.doc.user/concepts002.htm
deleted file mode 100644
index d78d0b0..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/concepts002.htm
+++ /dev/null
@@ -1,58 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>The persistence.xml file</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="The persistence.xml file" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CHDHAGIH" name="CHDHAGIH"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1><a id="sthref23" name="sthref23"></a>The persistence.xml file</h1>
-<p>The JPA specification requires the use of a <code>persistence.xml</code> file for deployment. This file defines the database and entity manager options, and may contain more than one persistence unit. To enable you to easily edit this information, Dali provides the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>. Alternatively, you can use the Eclipse XML Editor to create and maintain this information. See <a href="task_manage_persistence.htm#CIHDAJID">"Managing the persistence.xml file"</a> for more information.</p>
-<div align="center">
-<div class="inftblnotealso"><br />
-<table class="NoteAlso oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Tip:</p>
-To work with multiple persistence units, comment out all but one persistence unit in <code>persistence.xml</code>.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnotealso" --></div>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_manage_persistence.htm#CIHDAJID">Managing the persistence.xml file</a><br />
-<a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a>
-<p>&nbsp;</p>
-</div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/concepts003.htm b/jpa/plugins/org.eclipse.jpt.doc.user/concepts003.htm
deleted file mode 100644
index 1cf9ee5..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/concepts003.htm
+++ /dev/null
@@ -1,60 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>The orm.xml file</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="The orm.xml file" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CHDBIJAC" name="CHDBIJAC"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1><a id="sthref24" name="sthref24"></a>The orm.xml file</h1>
-<p>Although the JPA specification emphasizes the use of annotations to specify persistence, you can also use the <code>orm.xml</code> file to store this metadata. Dali enables you to create a stub <code>orm.xml</code> file for a JPA project using the <a href="reference002.htm#CIAIJCCE">Mapping File Wizard</a>. See <a href="task_manage_orm.htm#CIHDGDCD">"Managing the orm.xml file"</a> for more information.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-The metadata must match the XSD specification of your selected JPA implementation.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-<p>Dali provides comprehensive support for configuring XML mapping files through the <a href="ref_details_orm.htm#CACGDGHC">JPA Details view (for orm.xml)</a> that is nearly identical to the annotation-based configuration in the Java source. Alternatively, you can also use the Eclipse XML Editor to create and maintain the metadata information in <code>orm.xml</code>.</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_manage_orm.htm#CIHDGDCD">Managing the orm.xml file</a><br />
-<a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a><br />
-<p>&nbsp;</p>
-</div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/contexts.xml b/jpa/plugins/org.eclipse.jpt.doc.user/contexts.xml
deleted file mode 100644
index 4d0ab01..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/contexts.xml
+++ /dev/null
@@ -1,619 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?NLS TYPE="org.eclipse.help.contexts"?>
-<contexts>
-	<context id="entity_accessType">
-		<description>Specify how the variable is accessed: Property (default) or Field.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_name">
-		<description>The name of this entity. By default, the class name is used as the entity name.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_table">
-		<description>The database table assigned to this entity. By default, the class name is used as the database table name.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_attributeOverrides">
-		<description>Specify a property or field to be overridden (from the default mappings).</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_attributeOverridesName">
-		<description>Name of the database column.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_attributeOverridesColumn">
-		<description>The database column that overrides a property or field.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_attributeOverridesInsertable">
-		<description>Specifies if the column is always included in SQL INSERT statements.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_attributeOverridesUpdatable">
-		<description>Specifies if the column is always included in SQL UPDATE statements.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="mapping_mapAs">
-		<description>Specify how this attribute maps to the database.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_column">
-		<description>The database column that contains the value for the attribute.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_columnTable">
-		<description>Name of the database table that contains the selected column.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_columnInsertable">
-		<description>Specifies if the column is always included in SQL INSERT statements.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_columnUpdatable">
-		<description>Specifies if the column is always included in SQL UPDATE statements.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_fetchType">
-		<description>Defines how data is loaded from the database: Eager (default) or Lazy</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_optional">
-		<description>Specifies if this field is can be null.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_generatedValueStrategy">
-		<description>Determines how the primary key is generated: Auto (default), Sequence, Identity, or Table.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_generatedValueGeneratorName">
-		<description>Unique name of the generator.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_targetEntity">
-		<description>The entity to which this attribute is mapped. </description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_cascadeType">
-		<description>Specify which operations are propagated throughout the entity: All, Persist, Merge, or Move.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_mappedBy">
-		<description>The field in the database table that owns the relationship.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_joinColumnName">
-		<description>The name of the database column that contains the foreign key reference for the entity association.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_joinReferencedColumn">
-		<description>Name of the join table that contains the foreign key column.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_embeddedAttributeOverrides">
-		<description>Specify to override the default  mapping of an entity’s attribute.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="mapping_embeddedAttributeOverridesColumn">
-		<description>The database column that is being mapped to the entity’s attribute.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="entity_mapAs">
-		<description>Specify the type of persistent domain object for the Java class: Persistent, Embedded, or Mapped Superclass.</description>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_inheritanceStrategy">
-		<description>Specify how an entity may inherit properties from other entities: Single table, One table per class, or Joined tables.</description>
-		<topic label="Specifying inheritance" href="task_inheritance.htm"/>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-	</context>
-	<context id="entity_inheritanceDiscriminatorColumn">
-		<description>Use to specify the name of the discriminator column when using a Single or Joined inheritance strategy.</description>
-		<topic label="Specifying inheritance" href="task_inheritance.htm"/>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-	</context>
-	<context id="entity_inheritanceDiscriminatorType">
-		<description>Use this field to set the discriminator type to CHAR or INTEGER (instead of its default: String). The discriminator value must conform to this type.</description>
-		<topic label="Specifying inheritance" href="task_inheritance.htm"/>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-	</context>
-	<context id="entity_inheritanceDiscriminatorValue">
-		<description>Specify the discriminator value used to differentiate an entity in this inheritance hierarchy. The value must conform to the specified discriminator type.</description>
-		<topic label="Specifying inheritance" href="task_inheritance.htm"/>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-	</context>
-	<context id="mapping_orderBy">
-		<description>Specify the default order for objects returned from a query.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Mapping an Entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_joinTableName">
-		<description>Specify the  name of the database table that defines the foreign key for a many-to-many or a unidirectional one-to-many association. You can configure the join table with a specific catalog or schema, configure one or more join table columns with a unique constraint, and use multiple join columns per entity.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_joinTableJoinColumns">
-		<description>Specify  two or more join columns (that is, a composite primary key).</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_joinTableInverseJoinColumns">
-		<description>Specify the join column on the owned (or inverse side) of the association: the owned entity's primary key column. </description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="properties_javaPersistence">
-		<description>Use the Java Persistence options on the Properties page to select the database connection to use with the project.</description>
-		<topic label="Project properties" href="ref_project_properties"/>
-		<topic label="Adding persistence" href="ref_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="properties_javaPersistenceConnection">
-		<description>The database connection used to map the persistent entities.</description>
-		<topic label="Project properties" href="ref_project_properties"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="properties_javaPersistenceSchema">
-		<description>The database schema used to map the persistent entities.</description>
-		<topic label="Project properties" href="ref_project_properties"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="dialog_addPersistence">
-		<description>Use the Add Persistence dialog to define the database connection use to store the persistence entities.</description>
-		<topic label="Adding persistence" href="ref_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="persistenceOutline">
-		<description>The JPA Structure view displays an outline of the structure (its attributes and mappings) of the entity that is currently selected or opened in the editor.</description>
-		<topic label="JPA Structure view" href="ref_persistence_outline.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="dialog_generateEntities">
-		<description>Use the Generate Entities dialog to create Java persistent entities based on your database tables.</description>
-		<topic label="Generating entities from tables" href="task_generate_entities.htm.htm" />
-		<topic label="Project properties" href="ref_project_properties"/>
-	</context>
-	<context id="dialog_generateEntities_source">
-		<description>The project folder name in which to generate the Java persistent entities. Click Browse to select an existing folder.</description>
-		<topic label="Generating entities from tables" href="task_generate_entities.htm"/>
-	</context>
-	<context id="dialog_generateEntities_package">
-		<description>The package in which to generate the Java persistent entities, or click Browse to select an existing package.</description>
-		<topic label="Generating entities from tables" href="task_generate_entities.htm"/>
-	</context>
-	<context id="dialog_generateEntities_tables">
-		<description>Select the tables from which to create Java persistent entities.</description>
-		<topic label="Generating entities from tables" href="task_generate_entities.htm"/>
-		<topic label="Project properties" href="ref_project_properties"/>
-	</context>
-	<context id="dialog_addJavaPersistence">
-		<description>Use this dialog to define the database connection used to store the persistence entities and to create the persistence.xml file.</description>
-		<topic label="Add Persistence dialog" href="ref_add_persistence.htm" />
-		<topic label="Adding persistence to a project" href="task_add_persistence" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence.htm" />
-	</context>
-	<context id="dialog_newJPAProject">
-		<description>Use this dialog to define the new JPA project name, its location, target runtime, and other configuration settings.</description>
-		<topic label="New JPA Project page" href="ref_new_jpa_project.htm" />
-		<topic label="New JPA Project wizard" href="ref_new_jpa_project_wizard" />
-		<topic label="Adding persistence to a project" href="task_add_persistence" />
-		<topic label="Creating a new JPA project" href="task_create_new_project.htm" />
-	</context>
-	<context id="dialog_addJavaPersistence_database">
-		<description>Use these fields to define the database connection used to store the persistent entities.</description>
-		<topic label="Add Persistence dialog" href="ref_add_persistence.htm" />
-		<topic label="Adding persistence to a project" href="task_add_persistence" />
-	</context>
-	<context id="dialog_addJavaPersistence_classpath">
-		<description>Use this option to add libraries or JARs that contain the Java Persistence API (JPA) and entities to the project’s Java Build Path.</description>
-		<topic label="Add Persistence dialog" href="ref_add_persistence.htm" />
-		<topic label="Adding persistence to a project" href="task_add_persistence" />
-	</context>
-	<context id="dialog_addJavaPersistence_packaging">
-		<description>Use these fields to create the persistence.xml file. Select the persistence version, the name of the JPA provider, and a unique name to identify the persistence unit.</description>
-		<topic label="Add Persistence dialog" href="ref_add_persistence.htm" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence.htm" />
-	</context>
-	<context id="wizard_generateDDL_options ">
-		<description>Use this page to select which script options will be included in the generated script.</description>
-		<topic label="Generating tables (DDL) from entities " href="task_generate_ddl.htm" />
-		<topic label="Options page " href="ref_options.htm" />
-	</context>
-	<context id="wizard_generateDDL_objects ">
-		<description>Use this page to select which elements will be included in the generated script.</description>
-		<topic label="Generating tables (DDL) from entities " href="task_generate_ddl.htm" />
-		<topic label="Objects page " href="ref_objects.htm" />
-	</context>
-	<context id="wizard_generateDDL_save ">
-		<description>Use this page to select the filename and location of the generated script. You can also preview the script and specify to run or continue editing the script after generation.</description>
-		<topic label="Generating tables (DDL) from entities " href="task_generate_ddl.htm" />
-		<topic label="Save and Run DDL page " href="ref_save_and_run.htm" />
-	</context>
-	<context id="wizard_generateDDL_summary ">
-		<description>This page shows the settings that you selected for the generated DDL. To change any option click "Back" or click "Finish" to continue.</description>
-		<topic label="Generating tables (DDL) from entities " href="task_generate_ddl.htm" />
-	</context>
-	<context id="mapping_tableGeneratorName">
-		<description>The name of the table sequence generator. This name is global to to the persistence unit (across all generator types).</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_tableGeneratorTable">
-		<description>The database table that stores the generated ID values. </description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_tableGeneratorPrimaryKeyColumn">
-		<description>The database column of the generator table that stores the generated ID values.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_tableGeneratorValueColumn">
-		<description>The name for the column that stores the generated ID values.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_tableGeneratorPrimaryKeyColumnValue">
-		<description>The database column of the generator table that defines the primary key value.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="dialog_databaseAuthorization">
-		<description>Use to connect (log in) to a database connection to use with your Java persistent entities. 
-		You must have a defined database connection (and be connected) to add persistence. </description>
-		<topic label="Add persistence to a Java project" href="task_add_persistence_project.htm"/>
-	</context>
-	<context id="mapping_temporal">
-		<description>Specify if the mapped field contains a Date (java.sql.Date), Time (java.sql.Time), or Timestamp (java.sql.Timestamp) value.</description>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_primaryKeyGeneration">
-		<description>Define how the primary key is generated</description>
-		<topic label="Primary Key Generation information" href="ref_primary_key.htm"/>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_tableGenerator">
-		<description>Specify to use a specific database table for generating the primary key.</description>
-		<topic label="Primary Key Generation information" href="ref_primary_key.htm"/>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_sequenceGenerator">
-		<description>Specify to use a specific sequence for generating the primary key.</description>
-		<topic label="Primary Key Generation information" href="ref_primary_key.htm"/>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_sequenceGeneratorName">
-		<description>Name of the sequence.</description>
-		<topic label="Primary Key Generation information" href="ref_primary_key.htm"/>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_sequenceGeneratorSequence">
-		<description> </description>
-		<topic label="Primary Key Generation information" href="ref_primary_key.htm"/>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_lob">
-		<description>Specify if the field is mapped to java.sql.Clob or java.sql.Blob.</description>
-		<topic label="General information" href="ref_mapping_general.htm"/>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="mapping_enumerated">
-		<description>Specify how to persist enumerated constraints if the String value suits your application requirements or to match an existing database schema.</description>
-		<topic label="General information" href="ref_mapping_general.htm"/>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="dialog_editInverseJoinColumn">
-		<description>.</description>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-	</context>
-	<context id="entity_catalog">
-		<description>The database catalog that contains the Table. This field overrides the defaults in the orm.xml file.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="entity_schema">
-		<description>The database schema that contains the Table. This field overrides the defaults in the orm.xml file.</description>
-		<topic label="JPA Details" href="ref_persistence_prop_view.htm"/>
-		<topic label="Adding persistence to a class" href="task_add_persistence.htm"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	<context id="orm_package">
-		<description>The Java package that contains the persistent entities to which the orm.xml file applies.</description>
-		<topic label="Managing the orm.xml file" href="task_manage_orm.htm"/>
-		<topic label="JPA Details" href="ref_details_orm.htm"/>
-	</context>
-	<context id="orm_schema">
-		<description>The database schema to use as the default for all entities managed by this persistence unit.</description>
-		<topic label="Managing the orm.xml file" href="task_manage_orm.htm"/>
-		<topic label="JPA Details" href="ref_details_orm.htm"/>
-	</context>
-	<context id="orm_catalog">
-		<description>The database catalog to use as the default for all entities managed by this persistence unit.</description>
-		<topic label="Managing the orm.xml file" href="task_manage_orm.htm"/>
-		<topic label="JPA Details" href="ref_details_orm.htm"/>
-	</context>
-	<context id="orm_access">
-		<description>The default access method for variables in this project: Property or Field.</description>
-		<topic label="Managing the orm.xml file" href="task_manage_orm.htm"/>
-		<topic label="JPA Details" href="ref_details_orm.htm"/>
-	</context>
-	<context id="orm_cascade">
-		<description>Adds cascade-persist to the set of cascade options in entity relationships of the persistence unit.</description>
-		<topic label="Managing the orm.xml file" href="task_manage_orm.htm"/>
-		<topic label="JPA Details" href="ref_details_orm.htm"/>
-	</context>
-	<context id="orm_xml">
-		<description>Specifies that the Java classes in this persistence unit are fully specified by their metadata. Any annotations will be ignored.</description>
-		<topic label="Managing the orm.xml file" href="task_manage_orm.htm"/>
-		<topic label="JPA Details" href="ref_details_orm.htm"/>
-	</context>
-	<context id="dialog_JPAPlatform">
-		<description>Specify the vendor-specific JPA implementation.Default is Generic..</description>
-		<topic label="JPA Facet page" href="ref_jpa_facet.htm"/>
-	</context>
-	<context id="dialog_createORM">
-		<description>Create an initial orm.xml file. Use this file to specify project and persistence unit defaults.</description>
-		<topic label="Managing the orm.xml file" href="task_manage_orm.htm"/>
-		<topic label="JPA Facet page" href="ref_jpa_facet.htm"/>
-	</context>
-
-	<context id="caching_defaultType">
-		<description>Select the default caching strategy for the project. The default is Weak with Soft Subcache.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="caching_defaultSize">
-		<description>Select the default size of the cache. The default is 100 items.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="caching_defaultShared">
-		<description>Specify if cached instances should be in the shared cache or in a client isolated cache.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="logging_level">
-		<description>Specifies the amount and detail of log output by selecting the log level. Default is Info level.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="logging_timeStamp">
-		<description>Control whether the timestamp is logged in each log entry. Default is True.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="logging_thread">
-		<description>Control whether a thread identifier is logged in each log entry. Default is True.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="logging_session">
-		<description>Control whether an EclipseLink session identifier is logged in each log entry. Default is True.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="logging_exceptions">
-		<description>Control whether the exceptions thrown from within the code are logged prior to returning the exception to the calling application. Ensures that all exceptions are logged and not masked by the application code.. Default is False.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="options_sessionName">
-		<description>Specify the name by which the EclipseLink session is stored in the static session manager.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="options_sessionsXml">
-		<description>Specify persistence information loaded from the EclipseLink session configuration file. You can use this option as an alternative to annotations and deployment XML.</description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="options_targetDatabase">
-		<description></description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="options_targetServer">
-		<description> </description>
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="dialog_newJPAProjectJava">
-		<description>Use this dialog to include existing Java source files in this project.</description>
-		<topic label="Java page" href="ref_java_page.htm" />
-		<topic label="New JPA Project wizard" href="ref_new_jpa_project_wizard" />
-		<topic label="Creating a new JPA project" href="task_create_new_project.htm" />
-	</context>
-	<context id="dialog_newJPAProjectFacet">
-		<description>Use this dialog to specify your vender-specific platform, JPA implementation library, and database connection.</description>
-		<topic label="JPA Facet page" href="ref_jpa_facet.htm" />
-		<topic label="New JPA Project wizard" href="ref_new_jpa_project_wizard" />
-		<topic label="Creating a new JPA project" href="task_create_new_project.htm" />
-	</context>
-	<context id="dialog_entityClassPage">
-		<description>Use this dialog to specify package, class name, and inheritance properties of the entity to create.</description>
-		<topic label="Entity Class page" href="ref_EntityClassPage.htm" />
-		<topic label="New JPA Entity wizard" href="ref_create_jpa_entity_wizard.htm" />
-		<topic label="Creating a new JPA entity" href="task_create_jpa_entity.htm" />
-	</context>
-	<context id="dialog_entityPropertiesPage">
-		<description>Use this dialog to specify the entity name, associated table, and mapped fields.</description>
-		<topic label="Entity Properties page" href="ref_EntityPropertiesPage.htm" />
-		<topic label="New JPA Entity wizard" href="ref_create_jpa_entity_wizard.htm" />
-		<topic label="Creating a new JPA entity" href="task_create_jpa_entity.htm" />
-	</context>
-	<context id="dialog_selectTablesPage">
-		<description>Use this dialog to specify the database tables from which to generate entities.</description>
-		<topic label="Select Tables page" href="ref_selectTables.htm" />
-		<topic label="Generate Custom Entities wizard" href="ref_create_custom_entities_wizard.htm" />
-	</context>	
-	<context id="dialog_tableAssociationsPage">
-		<description>Use this dialog to create or edit the association between the database table and entity.</description>
-		<topic label="Table Associations page" href="ref_tableAssociations.htm" />
-		<topic label="Generate Custom Entities wizard" href="ref_create_custom_entities_wizard.htm" />
-	</context>	
-	<context id="dialog_customizeDefaultEntityGeneration">
-		<description>Use this dialog to specify the table mapping and domain class information for the generated entity.</description>
-		<topic label="Customize Default Entity Generation page" href="ref_customizeDefaultEntityGeneration.htm" />
-		<topic label="Generate Custom Entities wizard" href="ref_create_custom_entities_wizard.htm" />
-	</context>	
-	<context id="dialog_customizeIndividualEntities">
-		<description>Use this dialog to specify the table mapping and domain class information for the generated entity.</description>
-		<topic label="Customize Individual Entities page" href="ref_customizIndividualEntities.htm" />
-		<topic label="Generate Custom Entities wizard" href="ref_create_custom_entities_wizard.htm" />
-	</context>	
-
-	<context id="dialog_associationTablesPage">
-		<description>Use this dialog to specify the association tables for an entity.</description>
-		<topic label="Association Tables page" href="ref_association_tables.htm" />
-		<topic label="Create New Association wizard" href="ref_create_new_association_wizard.htm" />
-	</context>	
-	<context id="dialog_joinColumnsPage">
-		<description>Use this dialog to specify the join columns of an association table.</description>
-		<topic label="Join Columns page" href="ref_join_columns.htm" />
-		<topic label="Create New Association wizard" href="ref_create_new_association_wizard.htm" />
-	</context>	
-	<context id="dialog_associationCardinalityPage">
-		<description>Use this dialog to specify cardinality of an association table.</description>
-		<topic label="Association Cardinality page" href="ref_association_cardinality.htm" />
-		<topic label="Create New Association wizard" href="ref_create_new_association_wizard.htm" />
-	</context>	
-	<context id="dialog_selectCascade">
-		<description>Specify which operations are propagated throughout the association: All, Persist, Merge, Remove, or Refresh.</description>
-		<topic label="Select Cascade page" href="ref_select_cascade_dialog.htm"/>
-		<topic label="JPA Details" href="ref_persistence_map_view.htm"/>
-		<topic label="Mapping an entity" href="task_mapping.htm"/>
-		<topic label="Understanding OR mappings" href="concept_mapping.htm"/>
-	</context>
-	<context id="persistence_general">
-		<description>Specify the general persistence options.</description>
-		<topic label="General page" href="ref_persistence_general" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="persistence_connection">
-		<description>Specify the data source or JDBC connection properties.</description>
-		<topic label="Connection page" href="ref_persistence_connection" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="persistence_customization">
-		<description>Specify the default or entity specific EclipseLink customization and validation properties.</description>
-		<topic label="Customization page" href="ref_persistence_connection" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="persistence_caching">
-		<description>Configure the session or entity specific EclipseLink caching properties.</description>
-		<topic label="Caching page" href="ref_persistence_caching" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="persistence_logging">
-		<description>Configure the EclipseLink logging properties.</description>
-		<topic label="Logging page" href="ref_persistence_logging" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="persistence_options">
-		<description>Configure the EclipseLink session and miscellanous options.</description>
-		<topic label="Options page" href="ref_persistence_options" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="persistence_schemaGeneration">
-		<description>Configure the schema generation properties.</description>
-		<topic label="Schema Generation page" href="ref_persistence_schemaGeneration" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-	<context id="persistence_properties">
-		<description>Configure the properties defined for the persistence unit.</description>
-		<topic label="Properties page" href="ref_persistence_properties" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>
-		<context id="persistence_source">
-		<description>Configure the properties defined for the persistence unit.</description>
-		<topic label="Properties page" href="ref_persistence_properties" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the persistence.xml file" href="task_manage_persistence" />
-	</context>	
-	<context id="dialog_eclipselink_mapping_file">
-		<description>Configure the properties defined for the persistence unit.</description>
-		<topic label="New EclipseLink Mapping File page" href="ref_eclipselink_mapping_file" />
-		<topic label="persistence.xml editor" href="ref_persistence_xml_editor" />
-		<topic label="Managing the orm.xml file" href="task_manage_orm" />
-	</context>
-	<context id="dialog_create_new_converters">
-		<description>Use this dialog to create a new EclipseLink conveter.</description>
-		<topic label="Add Converter dialog" href="ref_add_converter" />
-		<topic label="Managing the orm.xml file" href="task_manage_orm" />
-	</context>
-
-<!-- Added for 3.0 -->
-	<context id="properties_canonicalMetamodel">
-		<description>                               </description>
-		<topic label="Project properties" href="ref_project_properties"/>
-		<topic label="Understanding persistence" href="concept_persistence.htm"/>
-	</context>
-	
-</contexts>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/dcommon/css/blafdoc.css b/jpa/plugins/org.eclipse.jpt.doc.user/dcommon/css/blafdoc.css
deleted file mode 100644
index baf6127..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/dcommon/css/blafdoc.css
+++ /dev/null
@@ -1,21 +0,0 @@
-@import "../../../PRODUCT_PLUGIN/book.css";
-
-span.control, span.gui-object-action, p.subhead2, span.bold, p.notep1 {
-  font-weight: bold;
-}
-
-span.name, p.titleinfigure, span.italic {
-  font-style: italic;
-}
-
-p.titleinfigure, p.subhead2 {
-  padding-top: 10px;
-}
-
-span.code {
-  font-family: monospace;
-}
-
-span.copyrightlogo {font-size: 0.8em}
-
-.footer {margin-top: 2em;border-top:1px solid #cccccc;padding-top:1em;}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/dcommon/html/cpyr.htm b/jpa/plugins/org.eclipse.jpt.doc.user/dcommon/html/cpyr.htm
deleted file mode 100644
index 46ec49b..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/dcommon/html/cpyr.htm
+++ /dev/null
@@ -1,11 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
-</head>
-<body>
-<p><a href="../../legal.htm">License Information</a></p>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started.htm b/jpa/plugins/org.eclipse.jpt.doc.user/getting_started.htm
deleted file mode 100644
index c2904db..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started.htm
+++ /dev/null
@@ -1,47 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Getting started</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content=" Getting started" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="sthref2" name="sthref2"></a></p>
-<h1>Getting started</h1>
-<p>This section provides information on getting started with the Java Persistence Tools.</p>
-<ul>
-<li>
-<p><a href="getting_started001.htm#BABEFHCD">Requirements and installation</a></p>
-</li>
-<li>
-<p><a href="getting_started002.htm#BABIGCJA">Dali quick start</a></p>
-</li>
-</ul>
-<p>For additional information, please visit the Dali home page at:</p>
-<p><code><a href="http://www.eclipse.org/webtools/dali/main.php">http://www.eclipse.org/webtools/dali/main.php</a></code>.</p>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started001.htm b/jpa/plugins/org.eclipse.jpt.doc.user/getting_started001.htm
deleted file mode 100644
index d9ccff9..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started001.htm
+++ /dev/null
@@ -1,80 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Requirements and installation</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Requirements and installation" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABEFHCD" name="BABEFHCD"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Requirements and installation<a id="sthref3" name="sthref3"></a><a id="sthref4" name="sthref4"></a></h1>
-<p>Before installing Dali, ensure that your environment meets the following <span class="italic">minimum</span> requirements:</p>
-<ul>
-<li>
-<p>Eclipse 3.5 (<code><a href="http://www.eclipse.org/downloads">http://www.eclipse.org/downloads</a></code>)</p>
-</li>
-<li>
-<p>Java Runtime Environment (JRE) 1.5 (<code><a href="http://java.com">http://java.com</a></code>)</p>
-</li>
-<li>
-<p>Eclipse Web Tools Platform (WTP) 3.1 (<code><a href="http://www.eclipse.org/webtools">http://www.eclipse.org/webtools</a></code>)</p>
-</li>
-<li>
-<p>Java Persistence API (JPA) for Java EE 5. For example, the EclipseLink implementation for JPA can be obtained from: <code><a href="http://www.eclipse.org/eclipselink/">http://www.eclipse.org/eclipselink/</a></code></p>
-</li>
-</ul>
-<p>Refer to <code><a href="http://www.eclipse.org/webtools/dali/gettingstarted_main.html">http://www.eclipse.org/webtools/dali/gettingstarted_main.html</a></code> for additional installation information.</p>
-<p><a id="sthref5" name="sthref5"></a>Dali is included as part of WTP 3.1. No additional installation or configuration is required.</p>
-<a id="sthref6" name="sthref6"></a>
-<p class="subhead2">Accessibility Features</p>
-<p>Dali supports the standard accessibility features in Eclipse, including the following:</p>
-<ul>
-<li>
-<p>Navigating the user interface using the keyboard.</p>
-</li>
-<li>
-<p>Specifying general accessibility preferences for the editor.</p>
-</li>
-</ul>
-<p>See <a href="../org.eclipse.platform.doc.user/concepts/accessibility/accessmain.htm">Accessibility Features in Eclipse</a> in the <span class="italic">Workbench User Guide</span> for details.</p>
-<a id="sthref7" name="sthref7"></a>
-<p class="subhead2">Help Accessibility</p>
-<p>The documentation and help contains markup to facilitate access by the disabled community. See <a href="../org.eclipse.platform.doc.user/tasks/help_accessibility.htm">Help Accessibility</a> in the <span class="italic">Workbench User Guide</span> for details.</p>
-<p>When using the help, be aware of the following:</p>
-<ul>
-<li>
-<p>Screen readers may not always correctly read the code examples in this document. The conventions for writing code require that closing braces should appear on an otherwise empty line; however, some screen readers may not always read a line of text that consists solely of a bracket or brace.</p>
-</li>
-<li>
-<p>This documentation may contain links to Web sites of other companies or organizations that we do not control. We neither evaluate nor make any representations regarding the accessibility of these Web sites.</p>
-</li>
-</ul>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started002.htm b/jpa/plugins/org.eclipse.jpt.doc.user/getting_started002.htm
deleted file mode 100644
index 5d4430d..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started002.htm
+++ /dev/null
@@ -1,49 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Dali quick start</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Dali quick start" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABIGCJA" name="BABIGCJA"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Dali quick start</h1>
-<p><a id="sthref8" name="sthref8"></a>This section includes information to help you quickly start using Dali to create relational mappings between Java persistent entities and database tables.</p>
-<ul>
-<li>
-<p><a href="getting_started003.htm#BABDFHDA">Creating a new JPA project</a></p>
-</li>
-<li>
-<p><a href="getting_started004.htm#BABFGDDG">Creating a Java persistent entity with persistent fields</a></p>
-</li>
-</ul>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="tips_and_tricks.htm#CHDHGHBF">Tips and tricks</a><br />
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started003.htm b/jpa/plugins/org.eclipse.jpt.doc.user/getting_started003.htm
deleted file mode 100644
index 5a90492..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started003.htm
+++ /dev/null
@@ -1,105 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Creating a new JPA project</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Creating a new JPA project" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABDFHDA" name="BABDFHDA"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Creating a new JPA project</h1>
-<p><a id="sthref9" name="sthref9"></a>This quick start shows how to create a new JPA project.</p>
-<ol>
-<li>
-<p><span class="bold">Select File &gt; New &gt; Project</span>. The Select a Wizard dialog appears.</p>
-<div align="center">
-<div class="inftblnotealso"><br />
-<table class="NoteAlso oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Tip:</p>
-You can also select the JPA perspective and then select <span class="bold">File &gt; New &gt; JPA Project</span>.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnotealso" --></div>
-</li>
-<li>
-<p>Select <span class="bold">JPA Project</span> and then click <span class="bold">Next</span>. The <a href="ref_new_jpa_project.htm#CACBJAGC">New JPA Project page</a> appears.</p>
-</li>
-<li>
-<p>Enter a <span class="gui-object-action">Project name</span> (such as <code>QuickStart</code>).</p>
-</li>
-<li>
-<p>If needed, select the <span class="bold">Target Runtime</span> (such as <code>Apache Tomcat</code>) and configuration, such as <span class="bold">Utility JPA Project with Java 5.0</span> and then click <span class="bold">Next</span>. The Java source page appears.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-The Target Runtime is not required for Java SE development.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</li>
-<li>
-<p>If you have existing Java source files, add them to your classpath and then click <span class="bold">Next</span>. The <a href="ref_jpa_facet.htm#CACIFDIF">JPA Facet page</a> appears.</p>
-</li>
-<li>
-<p>On the JPA Facet dialog, select your vendor-specific JPA platform (or select <span class="bold">Generic</span>), database connection (or create a new connection), JPA implementation library (such as EclipseLink), define how Dali should manage persistent classes, and then click <span class="bold">Finish</span>.</p>
-<div align="center">
-<div class="inftblnotealso"><br />
-<table class="NoteAlso oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Tip:</p>
-Select <span class="bold">Override the Default Schema for Connection</span> if you require a schema other than the one that Dali derives from the connection information, which may be incorrect in some cases. Using this option, you can select a development time schema for defaults and validation.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnotealso" --></div>
-</li>
-</ol>
-<p>Eclipse adds the project to the workbench and opens the JPA perspective.</p>
-<div class="figure"><a id="sthref10" name="sthref10"></a>
-<p class="titleinfigure">JPA Project in Project Explorer</p>
-<img src="img/quickstart_project.png" alt="Package Explorer showing the JPA project." title="Package Explorer showing the JPA project." /><br /></div>
-<!-- class="figure" -->
-<p>Now that you have created a project with persistence, you can continue with <a href="getting_started004.htm#BABFGDDG">Creating a Java persistent entity with persistent fields</a>.</p>
-</div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started004.htm b/jpa/plugins/org.eclipse.jpt.doc.user/getting_started004.htm
deleted file mode 100644
index 89078e9..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/getting_started004.htm
+++ /dev/null
@@ -1,204 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Creating a Java persistent entity with persistent fields</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Creating a Java persistent entity with persistent fields" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABFGDDG" name="BABFGDDG"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Creating a Java persistent entity with persistent fields</h1>
-<p><a id="sthref11" name="sthref11"></a>This quick start shows how to create a new persistent Java entity. We will create an entity to associate with a database table. You will also need to add the ADDRESS table to your database.</p>
-<ol>
-<li>
-<p>Select the JPA project in the Navigator or Project Explorer and then click <span class="bold">New &gt; Other</span>. The Select a Wizard dialog appears.</p>
-</li>
-<li>
-<p>Select <span class="bold">JPA &gt; Entity</span> and then click <span class="bold">Next</span>. The <a href="ref_EntityClassPage.htm#CIAFEIGF">Entity Class page</a> appears.</p>
-</li>
-<li>
-<p>Enter the package name (such as <code>quickstart.demo.model</code>), the class name (such as <code>Address</code>) and then click <span class="bold">Next</span>. The <a href="ref_EntityPropertiesPage.htm#CIADECIA">Entity Properties page</a> appears, which enables you to define the persistence fields, which you will map to the columns of a database table.</p>
-</li>
-<li>
-<p><a id="sthref12" name="sthref12"></a><a id="sthref13" name="sthref13"></a>Use the Entity Fields dialog (invoked by clicking <span class="bold">Add</span>) to add persistence fields to the Address class:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-private Long id;
-private String city;
-private String country;
-private String stateOrProvince;
-private String postalCode;
-private String street;
-</pre>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-You will also need to add the following columns to the ADDRESS database table:
-<pre xml:space="preserve" class="oac_no_warn">
-NUMBER(10,0) ADDRESS_ID (primary key)
-VARCHAR2(80) PROVINCE
-VARCHAR2(80) COUNTRY
-VARCHAR2(20) P_CODE
-VARCHAR2(80) STREET
-VARCHAR2(80) CITY
-</pre>
-<pre xml:space="preserve" class="oac_no_warn">
-</pre></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</li>
-<li>
-<p>Click <span class="bold">Finish</span>. With the Create JPA Entity completed, Eclipse displays the <span class="bold">Address</span> entity in the JPA Structure view.</p>
-<p>Address.java includes the <code>@Entity</code> annotation, the persistence fields, as well as <code>getter</code> and <code>setter</code> methods for each of the fields.</p>
-</li>
-</ol>
-<div class="figure"><a id="sthref14" name="sthref14"></a>
-<p class="titleinfigure">Address Entity in Address.java</p>
-<img src="img/java_editor_address.png" alt="Java editor with the Address entity." title="Java editor with the Address entity." /><br /></div>
-<!-- class="figure" -->
-<p>Eclipse also displays the <span class="bold">Address</span> entity in the JPA Structure view:</p>
-<div class="figure"><a id="sthref15" name="sthref15"></a>
-<p class="titleinfigure">Address Entity in the JPA Structure View</p>
-<img src="img/address_java_JPA_structure_quickstart.png" alt="Address.java in the JPA Structure View." title="Address.java in the JPA Structure View." /><br /></div>
-<!-- class="figure" -->
-<ol>
-<li>
-<p>Select the <span class="gui-object-action">Address</span> class in the Project Explorer view.</p>
-</li>
-<li>
-<p>In the <span class="gui-object-title">JPA Details</span> view, notice that Dali has automatically associated the ADDRESS database table with the entity because they are named identically.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-Depending on your database connection type, you may need to specify the <span class="bold">Schema</span>.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-<div class="figure"><a id="sthref16" name="sthref16"></a>
-<p class="titleinfigure">JPA Details View for Address Entity</p>
-<img src="img/address.java_jpa_details.png" alt="Address.java in the JPA Details view." title="Address.java in the JPA Details view." /><br /></div>
-<!-- class="figure" --></li>
-</ol>
-<div align="center">
-<div class="inftblnotealso"><br />
-<table class="NoteAlso oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Tip:</p>
-After associating the entity with the database table, you should update the <code>persistence.xml</code> file to include this JPA entity.
-<p>Right-click the <code>persistence.xml</code> file in the Project Explorer and select <span class="bold">JPA Tools &gt; Synchronize Class List</span>. Dali adds the following to the <code>persistence.xml</code> file:</p>
-<p><code>&lt;class&gt;quickstart.demo.model.Address&lt;/class&gt;</code></p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnotealso" --></div>
-<p>Now we are ready to map each fields in the Address class to a column in the database table.</p>
-<ol>
-<li>
-<p>Select the <span class="gui-object-action">id</span> field in the JPA Details view.</p>
-</li>
-<li>
-<p>Right click id and then select <span class="bold">Map As &gt; id</span>.</p>
-</li>
-<li>
-<p>In the JPA Details view, select <span class="bold">ADDRESS_ID</span> in the Name field:</p>
-<div class="figure"><a id="sthref17" name="sthref17"></a>
-<p class="titleinfigure">JPA Details View for the addressId Field</p>
-<img src="img/address_id_details_quickstart.png" alt="The JPA Details view for the Address entity&rsquo;s id attribute." title="The JPA Details view for the Address entity&rsquo;s id attribute." /><br /></div>
-<!-- class="figure" -->
-<p>Eclipse adds the following annotations to the Address entity:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@Id
-@Column(name="ADDRESS_ID")
-</pre></li>
-<li>
-<p>Map each of the following fields (as <span class="bold">Basic</span> mappings) to the appropriate database column:</p>
-<div class="inftblhruleinformal">
-<table class="HRuleInformal" title="This table describes the mappings for each of the fields in the Address entity." summary="This table describes the mappings for each of the fields in the Address entity." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="*" />
-<col width="33%" />
-<col width="33%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t8">Field</th>
-<th align="left" valign="bottom" id="r1c2-t8">Map As</th>
-<th align="left" valign="bottom" id="r1c3-t8">Database Column</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t8" headers="r1c1-t8">city</td>
-<td align="left" headers="r2c1-t8 r1c2-t8">Basic</td>
-<td align="left" headers="r2c1-t8 r1c3-t8">CITY</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t8" headers="r1c1-t8">country</td>
-<td align="left" headers="r3c1-t8 r1c2-t8">Basic</td>
-<td align="left" headers="r3c1-t8 r1c3-t8">COUNTRY</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t8" headers="r1c1-t8">postalCode</td>
-<td align="left" headers="r4c1-t8 r1c2-t8">Basic</td>
-<td align="left" headers="r4c1-t8 r1c3-t8">P_CODE</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t8" headers="r1c1-t8">provinceOrState</td>
-<td align="left" headers="r5c1-t8 r1c2-t8">Basic</td>
-<td align="left" headers="r5c1-t8 r1c3-t8">PROVINCE</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t8" headers="r1c1-t8">street</td>
-<td align="left" headers="r6c1-t8 r1c2-t8">Basic</td>
-<td align="left" headers="r6c1-t8 r1c3-t8">STREET</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblhruleinformal" --></li>
-</ol>
-<p>Dali automatically maps some fields to the correct database column (such as the city field to the City column) if the names are identical.</p>
-</div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/address.java_jpa_details.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/address.java_jpa_details.png
deleted file mode 100644
index bdcf008..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/address.java_jpa_details.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/address_id_details_quickstart.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/address_id_details_quickstart.png
deleted file mode 100644
index 7ef40cf..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/address_id_details_quickstart.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/address_java_JPA_structure_quickstart.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/address_java_JPA_structure_quickstart.png
deleted file mode 100644
index 1af51a9..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/address_java_JPA_structure_quickstart.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/create_jpa_entity_wizard.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/create_jpa_entity_wizard.png
deleted file mode 100644
index 0360e0a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/create_jpa_entity_wizard.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/create_jpa_fields.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/create_jpa_fields.png
deleted file mode 100644
index 69797a8..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/create_jpa_fields.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/customize_default_entity_generation.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/customize_default_entity_generation.png
deleted file mode 100644
index 9567616..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/customize_default_entity_generation.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/customize_individual_entities.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/customize_individual_entities.png
deleted file mode 100644
index 237bdee..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/customize_individual_entities.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/details_entitymappings.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/details_entitymappings.png
deleted file mode 100644
index d66300e..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/details_entitymappings.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/error_sample.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/error_sample.png
deleted file mode 100644
index 3a49646..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/error_sample.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/generate_entities.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/generate_entities.png
deleted file mode 100644
index 4daa25c..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/generate_entities.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/icon_basicmapmappings.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/icon_basicmapmappings.png
deleted file mode 100644
index 86eef3a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/icon_basicmapmappings.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/icon_basicmapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/icon_basicmapping.png
deleted file mode 100644
index b193753..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/icon_basicmapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_join.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_join.png
deleted file mode 100644
index 22b6875..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_join.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_single.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_single.png
deleted file mode 100644
index 3146482..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_single.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_tab.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_tab.png
deleted file mode 100644
index b76dd9f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/inheritance_tab.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/java_editor_address.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/java_editor_address.png
deleted file mode 100644
index 4742890..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/java_editor_address.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/jpa_wizard_create_fields.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/jpa_wizard_create_fields.png
deleted file mode 100644
index 30550ea..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/jpa_wizard_create_fields.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapped_entity_type_link.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/mapped_entity_type_link.png
deleted file mode 100644
index 2b61603..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapped_entity_type_link.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_file_new.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_file_new.png
deleted file mode 100644
index 3355741..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_file_new.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_embed.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_embed.png
deleted file mode 100644
index 086ea6e..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_embed.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_entity.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_entity.png
deleted file mode 100644
index 2604fd9..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_entity.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_superclass.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_superclass.png
deleted file mode 100644
index e28e8fa..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/mapping_type_selection_superclass.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/modify_faceted_project.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/modify_faceted_project.png
deleted file mode 100644
index f4c7968..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/modify_faceted_project.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_basicmappings.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_basicmappings.png
deleted file mode 100644
index 1b0b7ff..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_basicmappings.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddableentitymapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddableentitymapping.png
deleted file mode 100644
index 48294ed..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddableentitymapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddedidmapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddedidmapping.png
deleted file mode 100644
index abe9dc8..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddedidmapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddedmapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddedmapping.png
deleted file mode 100644
index 44d52b8..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_embeddedmapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_idmapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_idmapping.png
deleted file mode 100644
index fdefb5d..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_idmapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_manytomanymapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_manytomanymapping.png
deleted file mode 100644
index eb8022e..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_manytomanymapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_manytoonemapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_manytoonemapping.png
deleted file mode 100644
index ccacc19..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_manytoonemapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_mappedentity.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_mappedentity.png
deleted file mode 100644
index 398ea2c..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_mappedentity.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_mappedsuperclass.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_mappedsuperclass.png
deleted file mode 100644
index fc97ceb..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_mappedsuperclass.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_onetomanymapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_onetomanymapping.png
deleted file mode 100644
index 5ddc989..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_onetomanymapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_onetoonemapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_onetoonemapping.png
deleted file mode 100644
index 74d9bbd..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_onetoonemapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_transientmapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_transientmapping.png
deleted file mode 100644
index 750488f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_transientmapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_versionmapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_versionmapping.png
deleted file mode 100644
index a873712..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_icon_versionmapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_facet_task.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_facet_task.png
deleted file mode 100644
index 7607808..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_facet_task.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_perspective_button.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_perspective_button.png
deleted file mode 100644
index 07425ad..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_perspective_button.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_project_task.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_project_task.png
deleted file mode 100644
index ab079c2..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/new_jpa_project_task.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelc.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelc.png
deleted file mode 100644
index 88381a5..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelc.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelr.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelr.png
deleted file mode 100644
index 4bbc744..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelr.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelt.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelt.png
deleted file mode 100644
index 60af21f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/ngrelt.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/persistence_outline_view.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/persistence_outline_view.png
deleted file mode 100644
index 769aa82..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/persistence_outline_view.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/project_properties_tasks.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/project_properties_tasks.png
deleted file mode 100644
index 97557ee..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/project_properties_tasks.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/quickstart_project.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/quickstart_project.png
deleted file mode 100644
index 48ca050..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/quickstart_project.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/secondary_tables.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/secondary_tables.png
deleted file mode 100644
index a41f9f5..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/secondary_tables.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_entity.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_entity.png
deleted file mode 100644
index 2cebe90..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_entity.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_jpa_project.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_jpa_project.png
deleted file mode 100644
index 1823502..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_jpa_project.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_mapping.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_mapping.png
deleted file mode 100644
index 049c9d1..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/select_a_wizard_mapping.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/select_tables.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/select_tables.png
deleted file mode 100644
index a57c931..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/select_tables.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/synchornize_classes.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/synchornize_classes.png
deleted file mode 100644
index a359f64..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/synchornize_classes.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/table_associations.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/table_associations.png
deleted file mode 100644
index b5b40be..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/table_associations.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/table_entity.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/table_entity.png
deleted file mode 100644
index 1aa1dbe..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/table_entity.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/img/task_entering_query.png b/jpa/plugins/org.eclipse.jpt.doc.user/img/task_entering_query.png
deleted file mode 100644
index e8beaceb..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/img/task_entering_query.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/index.xml b/jpa/plugins/org.eclipse.jpt.doc.user/index.xml
deleted file mode 100644
index 86b7d10..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/index.xml
+++ /dev/null
@@ -1,315 +0,0 @@
-<?xml version='1.0' encoding='iso-8859-1'?>
-<index version="1.0">
-<entry keyword="@Basic, Basic mapping"><topic href="tasks009.htm#sthref115" /></entry>
-<entry keyword="@Column, General information"><topic href="ref_mapping_general.htm#sthref230" /></entry>
-  <entry keyword="@DiscriminatorColumn">
-<entry keyword="Specifying entity inheritance"><topic href="task_inheritance.htm#sthref95" /></entry>
-<entry keyword="Inheritance information"><topic href="reference009.htm#sthref224" /></entry>
-  </entry>
-  <entry keyword="@DiscriminatorValue">
-<entry keyword="Specifying entity inheritance"><topic href="task_inheritance.htm#sthref97" /></entry>
-<entry keyword="Inheritance information"><topic href="reference009.htm#sthref222" /></entry>
-  </entry>
-<entry keyword="@Embeddable, Embeddable"><topic href="tasks006.htm#sthref80" /></entry>
-<entry keyword="@Embedded, Embedded mapping"><topic href="tasks010.htm#sthref119" /></entry>
-<entry keyword="@EmbeddedId, Embedded ID mapping"><topic href="tasks011.htm#sthref123" /></entry>
-<entry keyword="@Entity, Entity"><topic href="tasks005.htm#sthref73" /></entry>
-<entry keyword="@Enumerated, General information"><topic href="ref_mapping_general.htm#sthref240" /></entry>
-<entry keyword="@GeneratedValue, Primary Key Generation information"><topic href="ref_primary_key.htm#sthref249" /></entry>
-<entry keyword="@Id, ID mapping"><topic href="tasks012.htm#sthref127" /></entry>
-<entry keyword="@Inheritance, Specifying entity inheritance"><topic href="task_inheritance.htm#sthref93" /></entry>
-  <entry keyword="@JoinColumn">
-<entry keyword="Many-to-one mapping"><topic href="tasks014.htm#sthref138" /></entry>
-<entry keyword="One-to-one mapping"><topic href="tasks016.htm#sthref148" /></entry>
-<entry keyword="Join Table Information"><topic href="reference011.htm#sthref245" /></entry>
-<entry keyword="Join Columns Information"><topic href="reference012.htm#sthref248" /></entry>
-  </entry>
-<entry keyword="@Lob, General information"><topic href="ref_mapping_general.htm#sthref235" /></entry>
-<entry keyword="@ManyToMany, Many-to-many mapping"><topic href="tasks013.htm#sthref131" /></entry>
-<entry keyword="@ManyToOne, Many-to-one mapping"><topic href="tasks014.htm#sthref136" /></entry>
-<entry keyword="@MappedSuperclass, Mapped superclass"><topic href="tasks007.htm#sthref87" /></entry>
-<entry keyword="@NamedQuery, Creating Named Queries"><topic href="tasks008.htm#sthref107" /></entry>
-<entry keyword="@OneToMany, One-to-many mapping"><topic href="tasks015.htm#sthref141" /></entry>
-<entry keyword="@OneToOne, One-to-one mapping"><topic href="tasks016.htm#sthref145" /></entry>
-<entry keyword="@OrderBy, General information"><topic href="ref_mapping_general.htm#sthref243" /></entry>
-<entry keyword="@SequenceGenerator, Primary Key Generation information"><topic href="ref_primary_key.htm#sthref251" /></entry>
-<entry keyword="@Temporal, General information"><topic href="ref_mapping_general.htm#sthref237" /></entry>
-<entry keyword="@Transient, Transient mapping"><topic href="tasks017.htm#sthref151" /></entry>
-<entry keyword="@Version, Version mapping"><topic href="tasks018.htm#sthref155" /></entry>
-<entry keyword="architecture of Dali feature, Dali Developer Documentation"><topic href="reference032.htm#sthref283" /></entry>
-<entry keyword="association tables, Create New Association"><topic href="ref_create_new_association_wizard.htm#sthref206" /></entry>
-<entry keyword="attribute overrides, Attribute overrides"><topic href="reference007.htm#sthref213" /></entry>
-<entry keyword="Attribute Overrides - in Java Details view, Attribute overrides"><topic href="reference007.htm#sthref215" /></entry>
-  <entry keyword="attributes">
-<entry keyword="JPA Details view, JPA Details view (for attributes)"><topic href="ref_persistence_map_view.htm#sthref229" /></entry>
-<entry keyword="mapping, Understanding OR mappings"><topic href="concept_mapping.htm#sthref21" /></entry>
-  </entry>
-  <entry keyword="basic mapping">
-<entry keyword="@Basic, Basic mapping"><topic href="tasks009.htm#sthref116" /></entry>
-<entry keyword="about, Basic mapping"><topic href="tasks009.htm#sthref114" /></entry>
-    <entry keyword="(See also mappings)"></entry>
-  </entry>
-<entry keyword="caching, Caching"><topic href="reference020.htm#sthref262" /></entry>
-<entry keyword="cardinality - association tables, Association Cardinality"><topic href="ref_association_cardinality.htm#sthref209" /></entry>
-  <entry keyword="classes">
-<entry keyword="adding persistence to, Adding persistence to a class"><topic href="task_add_persistence.htm#sthref68" /></entry>
-<entry keyword="embeddable, Embeddable"><topic href="tasks006.htm#sthref79" /></entry>
-<entry keyword="entity, Entity"><topic href="tasks005.htm#sthref71" /></entry>
-<entry keyword="managed, Managing the persistence.xml file"><topic href="task_manage_persistence.htm#sthref50" /></entry>
-<entry keyword="managing persistent classes, JPA Facet page"><topic href="ref_jpa_facet.htm#sthref192" /></entry>
-<entry keyword="mapped superclass, Mapped superclass"><topic href="tasks007.htm#sthref85" /></entry>
-<entry keyword="synchronizing, Synchronizing classes"><topic href="tasks002.htm#sthref53" /></entry>
-  </entry>
-  <entry keyword="columns">
-    <entry keyword="discriminator">
-<entry keyword="Specifying entity inheritance"><topic href="task_inheritance.htm#sthref96" /></entry>
-<entry keyword="Inheritance information"><topic href="reference009.htm#sthref225" /></entry>
-    </entry>
-    <entry keyword="join">
-<entry keyword="Many-to-one mapping"><topic href="tasks014.htm#sthref137" /></entry>
-<entry keyword="One-to-one mapping"><topic href="tasks016.htm#sthref147" /></entry>
-<entry keyword="Join Table Information"><topic href="reference011.htm#sthref244" /></entry>
-<entry keyword="Join Columns Information"><topic href="reference012.htm#sthref247" /></entry>
-    </entry>
-<entry keyword="mapping to, General information"><topic href="ref_mapping_general.htm#sthref231" /></entry>
-    <entry keyword="value">
-<entry keyword="Specifying entity inheritance"><topic href="task_inheritance.htm#sthref98" /></entry>
-<entry keyword="Inheritance information"><topic href="reference009.htm#sthref223" /></entry>
-    </entry>
-  </entry>
-<entry keyword="connection pool, Managing the persistence.xml file"><topic href="task_manage_persistence.htm#sthref52" /></entry>
-<entry keyword="converting Java project to JPA, Converting a Java Project to a JPA Project"><topic href="tasks001.htm#sthref37" /></entry>
-<entry keyword="Create a JPA Project Wizard, Creating a new JPA project"><topic href="task_create_new_project.htm#sthref29" /></entry>
-<entry keyword="Create New JPA Project wizard, Create New JPA Project wizard"><topic href="ref_new_jpa_project_wizard.htm#sthref189" /></entry>
-  <entry keyword="database tables">
-<entry keyword="generating entities from, Generating entities from tables"><topic href="tasks019.htm#sthref160" /></entry>
-  </entry>
-  <entry keyword="database - persistence">
-<entry keyword="connection, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref275" /></entry>
-<entry keyword="schema, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref277" /></entry>
-  </entry>
-<entry keyword="developer documentation - Dali, Dali Developer Documentation"><topic href="reference032.htm#sthref282" /></entry>
-<entry keyword="eager fetch, General information"><topic href="ref_mapping_general.htm#sthref233" /></entry>
-<entry keyword="EclipseLink XML mapping file, Managing the persistence.xml file"><topic href="task_manage_persistence.htm#sthref51" /></entry>
-  <entry keyword="embeddable class">
-<entry keyword="@Embeddable, Embeddable"><topic href="tasks006.htm#sthref81" /></entry>
-<entry keyword="about, Embeddable"><topic href="tasks006.htm#sthref78" /></entry>
-  </entry>
-  <entry keyword="embedded ID mapping">
-<entry keyword="@EmbeddedId, Embedded ID mapping"><topic href="tasks011.htm#sthref124" /></entry>
-<entry keyword="about, Embedded ID mapping"><topic href="tasks011.htm#sthref122" /></entry>
-  </entry>
-  <entry keyword="embedded mapping">
-<entry keyword="@Embedded, Embedded mapping"><topic href="tasks010.htm#sthref120" /></entry>
-<entry keyword="about, Embedded mapping"><topic href="tasks010.htm#sthref118" /></entry>
-  </entry>
-  <entry keyword="entities">
-<entry keyword="@Entity annotation, Entity"><topic href="tasks005.htm#sthref74" /></entry>
-<entry keyword="about, Understanding Java persistence"><topic href="concept_persistence.htm#sthref20" /></entry>
-<entry keyword="creating, Creating a JPA Entity"><topic href="task_create_jpa_entity.htm#sthref40" /></entry>
-<entry keyword="customizing, Customize Individual Entities"><topic href="ref_customizIndividualEntities.htm#sthref205" /></entry>
-<entry keyword="embeddable, Embeddable"><topic href="tasks006.htm#sthref82" /></entry>
-    <entry keyword="from tables">
-<entry keyword="Generating entities from tables"><topic href="tasks019.htm#sthref157" /></entry>
-<entry keyword="Select Tables"><topic href="ref_selectTables.htm#sthref201" /></entry>
-    </entry>
-<entry keyword="generating, Customize Default Entity Generation"><topic href="ref_customizeDefaultEntityGeneration.htm#sthref204" /></entry>
-<entry keyword="JPA Details view, JPA Details view (for entities)"><topic href="ref_persistence_prop_view.htm#sthref212" /></entry>
-<entry keyword="mapped superclass, Mapped superclass"><topic href="tasks007.htm#sthref88" /></entry>
-<entry keyword="mapping, Creating a Java persistent entity with persistent fields"><topic href="getting_started004.htm#sthref13" /></entry>
-<entry keyword="persistence, Creating a Java persistent entity with persistent fields"><topic href="getting_started004.htm#sthref11" /></entry>
-    <entry keyword="persistent">
-<entry keyword="Entity"><topic href="tasks005.htm#sthref69" /></entry>
-<entry keyword="Entity"><topic href="tasks005.htm#sthref75" /></entry>
-    </entry>
-<entry keyword="secondary tables, Secondary table information"><topic href="reference008.htm#sthref218" /></entry>
-  </entry>
-<entry keyword="Entity Class page, Selecting the Create a JPA Entity Wizard"><topic href="task_create_jpa_entity.htm#sthref43" /></entry>
-<entry keyword="Entity Properties page, &lt;a id=&quot;sthref43&quot; name=&quot;sthref43&quot;&gt;&lt;/a&gt;The Entity Class Page"><topic href="task_create_jpa_entity.htm#sthref45" /></entry>
-  <entry keyword="enumerated">
-<entry keyword="General information"><topic href="ref_mapping_general.htm#sthref239" /></entry>
-<entry keyword="General information"><topic href="ref_mapping_general.htm#sthref241" /></entry>
-  </entry>
-  <entry keyword="error messages - Dali">
-<entry keyword="Validating mappings and reporting problems"><topic href="tasks021.htm#sthref166" /></entry>
-<entry keyword="Error messages"><topic href="tasks022.htm#sthref171" /></entry>
-  </entry>
-<entry keyword="extension points - Dali feature, Dali Developer Documentation"><topic href="reference032.htm#sthref284" /></entry>
-<entry keyword="fetch type, General information"><topic href="ref_mapping_general.htm#sthref232" /></entry>
-  <entry keyword="Generate Entities from Tables dialog">
-<entry keyword="Generating entities from tables"><topic href="tasks019.htm#sthref159" /></entry>
-<entry keyword="Select Tables"><topic href="ref_selectTables.htm#sthref200" /></entry>
-  </entry>
-  <entry keyword="generated values">
-<entry keyword="ID mappings, Primary Key Generation information"><topic href="ref_primary_key.htm#sthref250" /></entry>
-<entry keyword="sequence, Primary Key Generation information"><topic href="ref_primary_key.htm#sthref252" /></entry>
-  </entry>
-<entry keyword="hints - query, Creating Named Queries"><topic href="tasks008.htm#sthref109" /></entry>
-  <entry keyword="ID mapping">
-<entry keyword="@Id, ID mapping"><topic href="tasks012.htm#sthref128" /></entry>
-<entry keyword="about, ID mapping"><topic href="tasks012.htm#sthref126" /></entry>
-  </entry>
-  <entry keyword="inheritance">
-    <entry keyword="entity">
-<entry keyword="Specifying entity inheritance"><topic href="task_inheritance.htm#sthref92" /></entry>
-<entry keyword="Entity Class page"><topic href="ref_EntityClassPage.htm#sthref194" /></entry>
-<entry keyword="Inheritance information"><topic href="reference009.htm#sthref221" /></entry>
-    </entry>
-<entry keyword="joined tables, Single Table Inheritance"><topic href="task_inheritance.htm#sthref104" /></entry>
-<entry keyword="single table, Specifying entity inheritance"><topic href="task_inheritance.htm#sthref99" /></entry>
-  </entry>
-<entry keyword="Inheritance - in Java Details view, Inheritance information"><topic href="reference009.htm#sthref220" /></entry>
-<entry keyword="installation - Dali, Requirements and installation"><topic href="getting_started001.htm#sthref3" /></entry>
-<entry keyword="Java project - converting to JPA, Converting a Java Project to a JPA Project"><topic href="tasks001.htm#sthref35" /></entry>
-  <entry keyword="join columns">
-<entry keyword="Join Columns"><topic href="ref_join_columns.htm#sthref208" /></entry>
-<entry keyword="Join Columns Information"><topic href="reference012.htm#sthref246" /></entry>
-  </entry>
-<entry keyword="joined tables - inheritance, Single Table Inheritance"><topic href="task_inheritance.htm#sthref105" /></entry>
-  <entry keyword="JPA Details view">
-<entry keyword="attributes, JPA Details view (for attributes)"><topic href="ref_persistence_map_view.htm#sthref227" /></entry>
-<entry keyword="entities, JPA Details view (for entities)"><topic href="ref_persistence_prop_view.htm#sthref210" /></entry>
-  </entry>
-<entry keyword="JPA Development perspective, JPA Development perspective"><topic href="ref_persistence_perspective.htm#sthref280" /></entry>
-<entry keyword="JPA Facet page, The Java Source Page"><topic href="task_create_new_project.htm#sthref34" /></entry>
-  <entry keyword="JPA project">
-<entry keyword="converting from Java, Converting a Java Project to a JPA Project"><topic href="tasks001.htm#sthref36" /></entry>
-<entry keyword="creating new, Creating a new JPA project"><topic href="task_create_new_project.htm#sthref27" /></entry>
-<entry keyword="implementation, JPA Facet page"><topic href="ref_jpa_facet.htm#sthref190" /></entry>
-<entry keyword="page, &lt;a id=&quot;sthref29&quot; name=&quot;sthref29&quot;&gt;&lt;/a&gt;Selecting the Create a JPA Project wizard"><topic href="task_create_new_project.htm#sthref31" /></entry>
-<entry keyword="platform, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref274" /></entry>
-  </entry>
-<entry keyword="JPA Structure view, JPA Structure view"><topic href="ref_persistence_outline.htm#sthref254" /></entry>
-<entry keyword="lazy fetch, General information"><topic href="ref_mapping_general.htm#sthref234" /></entry>
-<entry keyword="library - JPA, JPA Facet page"><topic href="ref_jpa_facet.htm#sthref191" /></entry>
-  <entry keyword="many-to-many mapping">
-<entry keyword="@ManyToMany, Many-to-many mapping"><topic href="tasks013.htm#sthref132" /></entry>
-<entry keyword="about, Many-to-many mapping"><topic href="tasks013.htm#sthref130" /></entry>
-  </entry>
-  <entry keyword="many-to-one mapping">
-<entry keyword="@ManyToOne, Many-to-one mapping"><topic href="tasks014.htm#sthref135" /></entry>
-<entry keyword="about, Many-to-one mapping"><topic href="tasks014.htm#sthref134" /></entry>
-  </entry>
-  <entry keyword="mapped superclass">
-<entry keyword="@MappedSuperclass, Mapped superclass"><topic href="tasks007.htm#sthref86" /></entry>
-<entry keyword="about, Mapped superclass"><topic href="tasks007.htm#sthref84" /></entry>
-  </entry>
-<entry keyword="mapping entities, Creating a Java persistent entity with persistent fields"><topic href="getting_started004.htm#sthref12" /></entry>
-  <entry keyword="mapping file">
-<entry keyword="&lt;a id=&quot;sthref57&quot; name=&quot;sthref57&quot;&gt;&lt;/a&gt;Managing the orm.xml file"><topic href="tasks003.htm#sthref60" /></entry>
-<entry keyword="Entity Class page"><topic href="ref_EntityClassPage.htm#sthref195" /></entry>
-  </entry>
-  <entry keyword="mappings">
-<entry keyword="about, Understanding OR mappings"><topic href="concept_mapping.htm#sthref22" /></entry>
-<entry keyword="basic, Basic mapping"><topic href="tasks009.htm#sthref113" /></entry>
-<entry keyword="embedded, Embedded mapping"><topic href="tasks010.htm#sthref117" /></entry>
-<entry keyword="embedded ID, Embedded ID mapping"><topic href="tasks011.htm#sthref121" /></entry>
-<entry keyword="ID, ID mapping"><topic href="tasks012.htm#sthref125" /></entry>
-<entry keyword="many-to-many, Many-to-many mapping"><topic href="tasks013.htm#sthref129" /></entry>
-<entry keyword="many-to-one, Many-to-one mapping"><topic href="tasks014.htm#sthref133" /></entry>
-<entry keyword="one-to-many, One-to-many mapping"><topic href="tasks015.htm#sthref139" /></entry>
-<entry keyword="one-to-one, One-to-one mapping"><topic href="tasks016.htm#sthref143" /></entry>
-<entry keyword="problems, Validating mappings and reporting problems"><topic href="tasks021.htm#sthref169" /></entry>
-<entry keyword="transient, Transient mapping"><topic href="tasks017.htm#sthref149" /></entry>
-<entry keyword="version, Version mapping"><topic href="tasks018.htm#sthref153" /></entry>
-  </entry>
-  <entry keyword="named queries">
-<entry keyword="entity, Creating Named Queries"><topic href="tasks008.htm#sthref106" /></entry>
-<entry keyword="hints, Creating Named Queries"><topic href="tasks008.htm#sthref110" /></entry>
-  </entry>
-<entry keyword="native queries, Creating Named Queries"><topic href="tasks008.htm#sthref111" /></entry>
-  <entry keyword="nonpersistent">
-<entry keyword="classes, Adding persistence to a class"><topic href="task_add_persistence.htm#sthref67" /></entry>
-    <entry keyword="fields. See transient"></entry>
-  </entry>
-  <entry keyword="one-to-many mapping">
-<entry keyword="@OneToMany, One-to-many mapping"><topic href="tasks015.htm#sthref142" /></entry>
-<entry keyword="about, One-to-many mapping"><topic href="tasks015.htm#sthref140" /></entry>
-  </entry>
-  <entry keyword="one-to-one mapping">
-<entry keyword="@OneToOne, One-to-one mapping"><topic href="tasks016.htm#sthref146" /></entry>
-<entry keyword="about, One-to-one mapping"><topic href="tasks016.htm#sthref144" /></entry>
-  </entry>
-<entry keyword="ordering, General information"><topic href="ref_mapping_general.htm#sthref242" /></entry>
-  <entry keyword="orm.xml file">
-<entry keyword="about, The orm.xml file"><topic href="concepts003.htm#sthref24" /></entry>
-<entry keyword="creating, JPA Facet page"><topic href="ref_jpa_facet.htm#sthref193" /></entry>
-<entry keyword="managing, Managing the orm.xml file"><topic href="task_manage_orm.htm#sthref57" /></entry>
-<entry keyword="sample, Managing the orm.xml file"><topic href="task_manage_orm.htm#sthref58" /></entry>
-  </entry>
-<entry keyword="overrides - JPA attributes, Attribute overrides"><topic href="reference007.htm#sthref214" /></entry>
-  <entry keyword="persistence">
-<entry keyword="about, Understanding Java persistence"><topic href="concept_persistence.htm#sthref19" /></entry>
-<entry keyword="database connection, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref276" /></entry>
-<entry keyword="database schema, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref279" /></entry>
-<entry keyword="entity class, Adding persistence to a class"><topic href="task_add_persistence.htm#sthref66" /></entry>
-<entry keyword="options, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref271" /></entry>
-<entry keyword="provider, Managing the persistence.xml file"><topic href="task_manage_persistence.htm#sthref49" /></entry>
-  </entry>
-  <entry keyword="persistence.xml file">
-<entry keyword="about, The persistence.xml file"><topic href="concepts002.htm#sthref23" /></entry>
-    <entry keyword="managing">
-<entry keyword="Managing the persistence.xml file"><topic href="task_manage_persistence.htm#sthref47" /></entry>
-<entry keyword="Working with orm.xml file"><topic href="tasks004.htm#sthref64" /></entry>
-    </entry>
-<entry keyword="sample, Managing the persistence.xml file"><topic href="task_manage_persistence.htm#sthref48" /></entry>
-<entry keyword="synchronizing with classes, Synchronizing classes"><topic href="tasks002.htm#sthref54" /></entry>
-  </entry>
-<entry keyword="persistent entity, Entity"><topic href="tasks005.htm#sthref70" /></entry>
-<entry keyword="perspective - JPA Development, JPA Development perspective"><topic href="ref_persistence_perspective.htm#sthref281" /></entry>
-<entry keyword="platform - JPA, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref273" /></entry>
-<entry keyword="problems, Validating mappings and reporting problems"><topic href="tasks021.htm#sthref168" /></entry>
-  <entry keyword="projects - JPA">
-    <entry keyword="creating new">
-<entry keyword="Creating a new JPA project"><topic href="getting_started003.htm#sthref9" /></entry>
-<entry keyword="Creating a new JPA project"><topic href="task_create_new_project.htm#sthref26" /></entry>
-    </entry>
-<entry keyword="options, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref272" /></entry>
-  </entry>
-<entry keyword="query hints, Creating Named Queries"><topic href="tasks008.htm#sthref108" /></entry>
-<entry keyword="quick start - Dali, Dali quick start"><topic href="getting_started002.htm#sthref8" /></entry>
-  <entry keyword="requirements">
-<entry keyword="Dali Java Persistence Tools, Requirements and installation"><topic href="getting_started001.htm#sthref4" /></entry>
-<entry keyword="persistent entities, Entity"><topic href="tasks005.htm#sthref72" /></entry>
-  </entry>
-<entry keyword="schema - database, Project Properties page - Java Persistence Options"><topic href="ref_project_properties.htm#sthref278" /></entry>
-<entry keyword="secondary tables, Secondary table information"><topic href="reference008.htm#sthref216" /></entry>
-<entry keyword="Secondary Tables - in Java Details view, Secondary table information"><topic href="reference008.htm#sthref219" /></entry>
-<entry keyword="single table inheritance, Specifying entity inheritance"><topic href="task_inheritance.htm#sthref100" /></entry>
-<entry keyword="superclass, Mapped superclass"><topic href="tasks007.htm#sthref89" /></entry>
-<entry keyword="synchronizing classes with persistence.xml file, Synchronizing classes"><topic href="tasks002.htm#sthref55" /></entry>
-  <entry keyword="tables">
-    <entry keyword="associations">
-<entry keyword="Table Associations"><topic href="ref_tableAssociations.htm#sthref203" /></entry>
-<entry keyword="Create New Association"><topic href="ref_create_new_association_wizard.htm#sthref207" /></entry>
-    </entry>
-    <entry keyword="creating entities from">
-<entry keyword="Generating entities from tables"><topic href="tasks019.htm#sthref158" /></entry>
-<entry keyword="Select Tables"><topic href="ref_selectTables.htm#sthref202" /></entry>
-    </entry>
-<entry keyword="inheritance, Specifying entity inheritance"><topic href="task_inheritance.htm#sthref101" /></entry>
-<entry keyword="secondary, Secondary table information"><topic href="reference008.htm#sthref217" /></entry>
-  </entry>
-  <entry keyword="temporal">
-<entry keyword="General information"><topic href="ref_mapping_general.htm#sthref236" /></entry>
-<entry keyword="General information"><topic href="ref_mapping_general.htm#sthref238" /></entry>
-  </entry>
-  <entry keyword="transient mapping">
-<entry keyword="@Transient, Transient mapping"><topic href="tasks017.htm#sthref152" /></entry>
-<entry keyword="about, Transient mapping"><topic href="tasks017.htm#sthref150" /></entry>
-  </entry>
-  <entry keyword="version mapping">
-<entry keyword="@Version, Version mapping"><topic href="tasks018.htm#sthref156" /></entry>
-<entry keyword="about, Version mapping"><topic href="tasks018.htm#sthref154" /></entry>
-  </entry>
-  <entry keyword="views">
-    <entry keyword="JPA Details view">
-<entry keyword="JPA Details view (for entities)"><topic href="ref_persistence_prop_view.htm#sthref211" /></entry>
-<entry keyword="JPA Details view (for attributes)"><topic href="ref_persistence_map_view.htm#sthref228" /></entry>
-    </entry>
-<entry keyword="JPA Structure view, JPA Structure view"><topic href="ref_persistence_outline.htm#sthref253" /></entry>
-  </entry>
-<entry keyword="warning messages - Dali, Validating mappings and reporting problems"><topic href="tasks021.htm#sthref167" /></entry>
-<entry keyword="Web Tools Platform (WTP), Requirements and installation"><topic href="getting_started001.htm#sthref5" /></entry>
-<entry keyword="XML editor, Working with orm.xml file"><topic href="tasks004.htm#sthref63" /></entry>
-</index>
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/legal.htm b/jpa/plugins/org.eclipse.jpt.doc.user/legal.htm
deleted file mode 100644
index f9f56b5..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/legal.htm
+++ /dev/null
@@ -1,40 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Legal</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content=" Legal" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="sthref289" name="sthref289"></a></p>
-<h1>Legal</h1>
-<p>Copyright &copy; 2006, 2010, Oracle. All rights reserved.</p>
-<p>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:</p>
-<p><code><a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a></code></p>
-<p><a href="about.htm">Terms and conditions regarding the use of this guide.</a></p>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/plugin.properties b/jpa/plugins/org.eclipse.jpt.doc.user/plugin.properties
deleted file mode 100644
index 865c082..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/plugin.properties
+++ /dev/null
@@ -1,32 +0,0 @@
-###############################################################################
-# Copyright (c) 2007 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-# ====================================================================
-# To code developer:
-#   Do NOT change the properties between this line and the
-#   "%%% END OF TRANSLATED PROPERTIES %%%" line.
-#   Make a new property name, append to the end of the file and change
-#   the code to use the new property.
-# ====================================================================
-
-# ====================================================================
-# %%% END OF TRANSLATED PROPERTIES %%%
-# ====================================================================
-
-pluginName = Java Persistence Documentation - Doc
-providerName = Eclipse.org
-
-jpaDevelopment=JPA Development
-createAJpaProject=Create a JPA project
-createAJpaProjectDescription=This cheat sheet helps you create a JPA project.
-createAPersistentEntity=Create a persistent entity
-createAPersistentEntityDescription=This cheat sheet helps you create a Java persistent entity.
-MapAPersistentEntity=Map a persistent entity
-MapAPersistentEntityDescription=This cheat sheet helps you map the a Java persistent entity to a database table.
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/plugin.xml b/jpa/plugins/org.eclipse.jpt.doc.user/plugin.xml
deleted file mode 100644
index 342c519..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/plugin.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<plugin>
-	<!-- =========== -->
-	<!-- Define TOC  -->
-	<!-- =========== -->
-	<extension point="org.eclipse.help.toc">
-		<toc file="toc.xml" primary="true"/>
-	</extension>
-	<!-- =========== -->
-	<!-- Define F1   -->
-	<!-- =========== -->
-	<extension point="org.eclipse.help.contexts">
-		<contexts file="contexts.xml" plugin="org.eclipse.jpt.ui"/>
-	</extension>
-	<!-- ==================== -->
-	<!-- Define Keyword Index -->
-	<!-- ==================== -->
-	<extension point="org.eclipse.help.index">
-		<index file="index.xml"/>
-	</extension>
-	<!-- =========== -->
-	<!-- Cheatsheets -->
-	<!-- =========== -->
-	<extension point="org.eclipse.ui.cheatsheets.cheatSheetContent">
-		<category name="%jpaDevelopment" id="com.jpa.category"/>
-		<cheatsheet name="%createAJpaProject" category="com.jpa.category" contentFile="$nl$/cheatsheets/add_persistence.xml" id="org.eclipse.jpa.cheatsheet.createproject1">
-			<description>%createAJpaProjectDescription</description>
-		</cheatsheet>
-		<cheatsheet name="%createAPersistentEntity" category="com.jpa.category" contentFile="$nl$/cheatsheets/create_entity.xml" id="org.eclipse.jpa.cheatsheet.addentity">
-			<description>%createAPersistentEntityDescription</description>
-		</cheatsheet>
-		<cheatsheet name="%MapAPersistentEntity" category="com.jpa.category" contentFile="$nl$/cheatsheets/map_entity.xml" id="org.eclipse.jpa.cheatsheet.mapentity">
-			<description>%MapAPersistentEntityDescription</description>
-		</cheatsheet>
-	</extension>
-</plugin>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_EntityClassPage.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_EntityClassPage.htm
deleted file mode 100644
index d756128..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_EntityClassPage.htm
+++ /dev/null
@@ -1,115 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Entity Class page</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Entity Class page" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAFEIGF" name="CIAFEIGF"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Entity Class page</h1>
-<p>This table lists the properties of the Entity Class page of the <a href="ref_create_jpa_entity_wizard.htm#CIAGGGDF">Create JPA Entity wizard</a>.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" summary="This table lists the properties of the Entity Class page of the Create JPA Entity wizard." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="22%" />
-<col width="*" />
-<col width="17%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t5">Property</th>
-<th align="left" valign="bottom" id="r1c2-t5">Description</th>
-<th align="left" valign="bottom" id="r1c3-t5">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t5" headers="r1c1-t5">Project</td>
-<td align="left" headers="r2c1-t5 r1c2-t5">The name of the JPA project.</td>
-<td align="left" headers="r2c1-t5 r1c3-t5"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t5" headers="r1c1-t5">Source Folder</td>
-<td align="left" headers="r3c1-t5 r1c2-t5">The location of the JPA project's src folder.</td>
-<td align="left" headers="r3c1-t5 r1c3-t5"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t5" headers="r1c1-t5">Java Package</td>
-<td align="left" headers="r4c1-t5 r1c2-t5">The name of the class package.</td>
-<td align="left" headers="r4c1-t5 r1c3-t5"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t5" headers="r1c1-t5">Class name</td>
-<td align="left" headers="r5c1-t5 r1c2-t5">The name of the Java class.</td>
-<td align="left" headers="r5c1-t5 r1c3-t5"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t5" headers="r1c1-t5">Superclass</td>
-<td align="left" headers="r6c1-t5 r1c2-t5">Select the superclass.</td>
-<td align="left" headers="r6c1-t5 r1c3-t5"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t5" headers="r1c1-t5"><a id="sthref193" name="sthref193"></a>Inheritance</td>
-<td align="left" headers="r7c1-t5 r1c2-t5">Because the wizard creates a Java class with an <code>@Entity</code> notation, the <span class="bold">Entity</span> option is selected by default.
-<p>Select <span class="bold">Mapped Superclass</span> if you defined a superclass.</p>
-<p>To add an <code>@Inheritance</code> notation to the entity, select <span class="bold">Inheritance</span> and then select one of the inheritance mapping strategies (described in JSR 220):</p>
-<ul>
-<li>
-<p>SINGLE_TABLE -- All classes in a hierarchy as mapped to a single table. This annotation is without an attribute for the inheritance strategy.</p>
-</li>
-<li>
-<p>TABLE_PER_CLASS -- Each class is mapped to a separate table.</p>
-</li>
-<li>
-<p>JOINED -- The root of the class hierarchy is represented by a single table. Each subclass is represented by a separate table that contains those fields that are specific to the subclass (not inherited from its superclass), as well as the column(s) that represent its primary key. The primary key column(s) of the subclass table serves as a foreign key to the primary key of the superclass table.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r7c1-t5 r1c3-t5">Entity</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t5" headers="r1c1-t5"><a id="sthref194" name="sthref194"></a>XML Entity Mappings</td>
-<td align="left" headers="r8c1-t5 r1c2-t5">Select <span class="bold">Add to entity mappings in XML</span> to create XML mappings in <code>orm.xml</code>, rather than annotations.
-<p>Use the <span class="bold">Mapping file</span> field to specify the file to use. By default, mappings are stored in the <code>META-INF/orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r8c1-t5 r1c3-t5"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_create_jpa_entity_wizard.htm#CIAGGGDF">Create JPA Entity wizard</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_EntityPropertiesPage.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_EntityPropertiesPage.htm
deleted file mode 100644
index 356004a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_EntityPropertiesPage.htm
+++ /dev/null
@@ -1,117 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Entity Properties page</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Entity Properties page" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIADECIA" name="CIADECIA"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Entity Properties page</h1>
-<p>This table lists the properties of the Entity Properties page of the <a href="ref_create_jpa_entity_wizard.htm#CIAGGGDF">Create JPA Entity wizard</a>.</p>
-<div class="tblformal"><a id="sthref195" name="sthref195"></a><a id="sthref196" name="sthref196"></a>
-<p class="titleintable">&nbsp;</p>
-<table class="Formal" title="" summary="This table to be converted to informal." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="24%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t6">Property</th>
-<th align="left" valign="bottom" id="r1c2-t6">Description</th>
-<th align="left" valign="bottom" id="r1c3-t6">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t6" headers="r1c1-t6">
-<p>Entity Name</p>
-</td>
-<td align="left" headers="r2c1-t6 r1c2-t6">
-<p>The name of the entity. By default, this value is the same as the one entered as the class name. If the entity name differs from the class name, then the entity name is added as an attribute. For example: <code>@Entity(name="EntityName")</code>.</p>
-</td>
-<td align="left" headers="r2c1-t6 r1c3-t6">
-<p>Determined by server.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t6" headers="r1c1-t6">
-<p>Table Name</p>
-</td>
-<td align="left" headers="r3c1-t6 r1c2-t6">
-<p>Select <span class="bold">Use default</span> to match the name of the mapped table name to the entity name. Otherwise, clear the <span class="bold">Use default</span> option and enter the name in the <span class="italic">Table Name</span> field. These options result in the addition of the <code>@Table</code> option to the Java class file.</p>
-</td>
-<td align="left" headers="r3c1-t6 r1c3-t6">
-<p>Use default.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t6" headers="r1c1-t6">
-<p>Entity Fields</p>
-</td>
-<td align="left" headers="r4c1-t6 r1c2-t6">
-<p>Click the <span class="bold">Add</span> button to add persistence fields using the Entity Fields dialog. This dialog enable you to build a field by entering a field name and selecting among persistence types. The <span class="bold">Key</span> option enables you to mark a field as a primary key. The dialog's <span class="bold">Browse</span> function enables you to add other persistence types described in the JPA specification. The <span class="bold">Edit</span> button enables you to change the name or type set for a persistent field.</p>
-</td>
-<td align="left" headers="r4c1-t6 r1c3-t6"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t6" headers="r1c1-t6">
-<p>Access Type</p>
-</td>
-<td align="left" headers="r5c1-t6 r1c2-t6">
-<p>Select whether the entity's access to instance variables is field-based or property-based, as defined in the JPA specification.</p>
-<ul>
-<li>
-<p><span class="bold">Field</span> &ndash; Instance variables are accessed directly. All non-transient instance variables are persistent.</p>
-</li>
-<li>
-<p><span class="bold">Property</span> &ndash; Persistent state accessed through the property accessor methods. The property accessor methods must be <span class="bold">public</span> or <span class="bold">private</span>.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r5c1-t6 r1c3-t6">
-<p>Field</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a><br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_add_converter.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_add_converter.htm
deleted file mode 100644
index 48822c6..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_add_converter.htm
+++ /dev/null
@@ -1,78 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Add Converter dialog</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Add Converter dialog" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAGCGIJ" name="CIAGCGIJ"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Add Converter dialog</h1>
-<p>Use this dialog to create a new EclipseLink converter.</p>
-<div class="inftblhruleinformalmax">
-<table class="HRuleInformalMax" summary="This table lists the options on the New EclipseLink Mapping File dialog." dir="ltr" border="1" width="100%" frame="hsides" rules="rows" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t39">Property</th>
-<th align="left" valign="bottom" id="r1c2-t39">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t39" headers="r1c1-t39">Name</td>
-<td align="left" headers="r2c1-t39 r1c2-t39">Enter the name for this converter</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t39" headers="r1c1-t39">Type</td>
-<td align="left" headers="r3c1-t39 r1c2-t39">Select the converter type:
-<ul>
-<li>
-<p>Custom</p>
-</li>
-<li>
-<p>Object type</p>
-</li>
-<li>
-<p>Struct</p>
-</li>
-<li>
-<p>Type</p>
-</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblhruleinformalmax" --></div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_association_cardinality.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_association_cardinality.htm
deleted file mode 100644
index 2776c3f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_association_cardinality.htm
+++ /dev/null
@@ -1,65 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Association Cardinality</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Association Cardinality" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAFIIFH" name="CIAFIIFH"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Association Cardinality</h1>
-<p><a id="sthref208" name="sthref208"></a>Use this dialog to specify cardinality of an association table. Depending on the <span class="bold">Association Kind</span> and <span class="bold">Join Columns</span> that you selected previously, some associations may not be available.</p>
-<ul>
-<li>
-<p>Many to one</p>
-</li>
-<li>
-<p>One to many</p>
-</li>
-<li>
-<p>One to one</p>
-</li>
-<li>
-<p>Many to many</p>
-</li>
-</ul>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_create_new_association_wizard.htm#CIAFGHIF">Create New Association</a><br />
-<a href="tasks019.htm#BABBAGFI">Generating entities from tables</a><br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_create_custom_entities_wizard.htm#CIAGBFJE">Generate Entities from Tables Wizard</a></div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_association_table.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_association_table.htm
deleted file mode 100644
index 1509afe..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_association_table.htm
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Association Tables</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Association Tables" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAGJHDC" name="CIAGJHDC"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Association Tables</h1>
-<p>Use this page to specify the association tables for an entity.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Association Tables dialog." summary="This table describes the options on the Association Tables dialog." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="32%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t12">Property</th>
-<th align="left" valign="bottom" id="r1c2-t12">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t12" headers="r1c1-t12">Association kind</td>
-<td align="left" headers="r2c1-t12 r1c2-t12">Specify if the association is <span class="bold">Simple</span> (1:M) or <span class="bold">Many to Many</span> (M:M).</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t12" headers="r1c1-t12">Association tables</td>
-<td align="left" headers="r3c1-t12 r1c2-t12">Click <span class="bold">Table Selection</span>, then select the two tables to associate.
-<p>When creating a <span class="bold">Many to Many</span> association, you can select a <span class="bold">Join Table</span> for the association.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_create_new_association_wizard.htm#CIAFGHIF">Create New Association</a><br />
-<a href="tasks019.htm#BABBAGFI">Generating entities from tables</a><br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_create_custom_entities_wizard.htm#CIAGBFJE">Generate Entities from Tables Wizard</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_custom_entities_wizard.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_custom_entities_wizard.htm
deleted file mode 100644
index 88e015d..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_custom_entities_wizard.htm
+++ /dev/null
@@ -1,53 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Generate Entities from Tables Wizard</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Generate Entities from Tables Wizard" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAGBFJE" name="CIAGBFJE"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Generate Entities from Tables Wizard</h1>
-<p>Use the Generate Custom Entities Wizard to create entities from your database tables.</p>
-<p>The wizard consists of the following pages:</p>
-<ul>
-<li>
-<p><a href="ref_selectTables.htm#CIAHCGEE">Select Tables</a></p>
-</li>
-<li>
-<p><a href="ref_tableAssociations.htm#CIACDICB">Table Associations</a></p>
-</li>
-<li>
-<p><a href="ref_customizeDefaultEntityGeneration.htm#CIAEJDBE">Customize Default Entity Generation</a></p>
-</li>
-<li>
-<p><a href="ref_customizIndividualEntities.htm#CIACIGEE">Customize Individual Entities</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_jpa_entity_wizard.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_jpa_entity_wizard.htm
deleted file mode 100644
index 6b67a4d..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_jpa_entity_wizard.htm
+++ /dev/null
@@ -1,46 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Create JPA Entity wizard</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Create JPA Entity wizard" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAGGGDF" name="CIAGGGDF"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Create JPA Entity wizard</h1>
-<p>The Create JPA wizard enables you to quickly add an entity and also add persistence fields to that entity. In addition, this wizard adds the accessor methods (<code>getter</code> and <code>setter</code>) in the class file. The wizard consists of the following pages:</p>
-<ul>
-<li>
-<p><a href="ref_EntityClassPage.htm#CIAFEIGF">Entity Class page</a></p>
-</li>
-<li>
-<p><a href="ref_EntityPropertiesPage.htm#CIADECIA">Entity Properties page</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_new_association_wizard.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_new_association_wizard.htm
deleted file mode 100644
index 99ed19f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_create_new_association_wizard.htm
+++ /dev/null
@@ -1,50 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Create New Association</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Create New Association" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAFGHIF" name="CIAFGHIF"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Create New Association</h1>
-<p><a id="sthref205" name="sthref205"></a><a id="sthref206" name="sthref206"></a>Use the Create New Association wizard to specify association tables when generating an entity.</p>
-<p>The wizard consists of the following pages:</p>
-<ul>
-<li>
-<p><a href="ref_association_table.htm#CIAGJHDC">Association Tables</a></p>
-</li>
-<li>
-<p><a href="ref_join_columns.htm#CIAEGEEG">Join Columns</a></p>
-</li>
-<li>
-<p><a href="ref_association_cardinality.htm#CIAFIIFH">Association Cardinality</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_customizIndividualEntities.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_customizIndividualEntities.htm
deleted file mode 100644
index d7bdb7e..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_customizIndividualEntities.htm
+++ /dev/null
@@ -1,89 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Customize Individual Entities</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Customize Individual Entities" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIACIGEE" name="CIACIGEE"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Customize Individual Entities</h1>
-<p><a id="sthref204" name="sthref204"></a>Use this page to customize each generated entity. Select an item in the Table and columns area, then complete the following fields for each item.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Individual Entities dialog." summary="This table describes the options on the Individual Entities dialog." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="32%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t11">Property</th>
-<th align="left" valign="bottom" id="r1c2-t11">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t11" headers="r1c1-t11">Table Mapping</td>
-<td align="left" headers="r2c1-t11 r1c2-t11">Use these options to define the table mapping information for the entity.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t11" headers="r1c1-t11">&nbsp;&nbsp;Key&nbsp;generator</td>
-<td align="left" headers="r3c1-t11 r1c2-t11">Select the generator used for this mapping.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t11" headers="r1c1-t11">&nbsp;&nbsp;Sequence&nbsp;name</td>
-<td align="left" headers="r4c1-t11 r1c2-t11">Enter a name for the sequence.
-<p>You can use <span class="bold">$table</span> and <span class="bold">$pk</span> as variables in the name. These will be replaced by the table name and primary key column name (respectively) when Dali generates a table mapping.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t11" headers="r1c1-t11">&nbsp;&nbsp;Entity&nbsp;access</td>
-<td align="left" headers="r5c1-t11 r1c2-t11">Specify the default entity access method: <span class="bold">Field</span> (default) or <span class="bold">Property</span>.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t11" headers="r1c1-t11">Domain Java Class</td>
-<td align="left" headers="r6c1-t11 r1c2-t11">Use these options to define the class information (<span class="bold">Superclass</span> and <span class="bold">Interfaces</span>) for the entity.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a><br />
-<a href="tasks019.htm#BABBAGFI">Generating entities from tables</a><br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_create_custom_entities_wizard.htm#CIAGBFJE">Generate Entities from Tables Wizard</a>
-<p>&nbsp;</p>
-</div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_customizeDefaultEntityGeneration.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_customizeDefaultEntityGeneration.htm
deleted file mode 100644
index eecb018..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_customizeDefaultEntityGeneration.htm
+++ /dev/null
@@ -1,96 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Customize Default Entity Generation</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Customize Default Entity Generation" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAEJDBE" name="CIAEJDBE"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Customize Default Entity Generation</h1>
-<p><a id="sthref203" name="sthref203"></a>Use this page to specify the default information Dali will use when generating the entities from the database tables. You will be able to override this information for specific entities.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Generate Entities dialog." summary="This table describes the options on the Custom Default Entity Generation dialog." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="32%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t10">Property</th>
-<th align="left" valign="bottom" id="r1c2-t10">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t10" headers="r1c1-t10">Table Mapping</td>
-<td align="left" headers="r2c1-t10 r1c2-t10">Use these options to define the table mapping information for the entity.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t10" headers="r1c1-t10">&nbsp;&nbsp;Key&nbsp;generator</td>
-<td align="left" headers="r3c1-t10 r1c2-t10">Select the generator used for this mapping.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t10" headers="r1c1-t10">&nbsp;&nbsp;Sequence&nbsp;name</td>
-<td align="left" headers="r4c1-t10 r1c2-t10">Enter a name for the sequence.
-<p>You can use <span class="bold">$table</span> and <span class="bold">$pk</span> as variables in the name. These will be replaced by the table name and primary key column name (respectively) when Dali generates a table mapping.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t10" headers="r1c1-t10">&nbsp;&nbsp;Entity&nbsp;access</td>
-<td align="left" headers="r5c1-t10 r1c2-t10">Specify the default entity access method: <span class="bold">Field</span> (default) or <span class="bold">Property</span>.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t10" headers="r1c1-t10">&nbsp;&nbsp;Associations&nbsp;fetch</td>
-<td align="left" headers="r6c1-t10 r1c2-t10">Specify the default fetch mode for associations: <span class="bold">Default</span>, as defined by the application (default), or <span class="bold">Lazy</span>.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t10" headers="r1c1-t10">&nbsp;&nbsp;Collection&nbsp;type</td>
-<td align="left" headers="r7c1-t10 r1c2-t10">Specify if the collection properties are a <span class="bold">Set</span> or <span class="bold">List</span>.
-<p>Enable the <span class="bold">Always generate optional JPA annotations and DDL parameters</span> option to have Dali include this information in the entity.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t10" headers="r1c1-t10">Domain Java Class</td>
-<td align="left" headers="r8c1-t10 r1c2-t10">Use these options to define the class information (<span class="bold">Package</span>, <span class="bold">Superclass</span>, and <span class="bold">Interfaces</span>) for the entity.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a><br />
-<a href="tasks019.htm#BABBAGFI">Generating entities from tables</a><br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_create_custom_entities_wizard.htm#CIAGBFJE">Generate Entities from Tables Wizard</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_details_orm.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_details_orm.htm
deleted file mode 100644
index f4a75c3..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_details_orm.htm
+++ /dev/null
@@ -1,56 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>JPA Details view (for orm.xml)</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:53Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="JPA Details view (for orm.xml)" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACGDGHC" name="CACGDGHC"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>JPA Details view (for orm.xml)</h1>
-<p>The <span class="gui-object-title">JPA Details</span> view displays the default mapping and persistence information for the project and contains the following areas:</p>
-<ul>
-<li>
-<p><a href="reference013.htm#CACCACGH">General information</a></p>
-</li>
-<li>
-<p><a href="reference014.htm#CACEAGBG">Persistence Unit information</a></p>
-</li>
-<li>
-<p><a href="reference015.htm#CIAFGAIJ">Generators</a></p>
-</li>
-<li>
-<p><a href="reference016.htm#CIAIBAAJ">Queries</a></p>
-</li>
-<li>
-<p><a href="reference017.htm#CIADGCID">Converters</a> (when using EclipseLink)</p>
-</li>
-</ul>
-<p>These defaults can be overridden by the settings on a specific entity or mapping.</p>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_eclipselink_mapping_file.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_eclipselink_mapping_file.htm
deleted file mode 100644
index 1335a56..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_eclipselink_mapping_file.htm
+++ /dev/null
@@ -1,81 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>New EclipseLink Mapping File dialog</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="New EclipseLink Mapping File dialog" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAEDEJF" name="CIAEDEJF"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>New EclipseLink Mapping File dialog</h1>
-<p>Specify the location and properties of the EclipseLink mapping file (<code>eclispelink-orm.xml</code>).</p>
-<div class="inftblhruleinformalmax">
-<table class="HRuleInformalMax" summary="This table lists the options on the New EclipseLink Mapping File dialog." dir="ltr" border="1" width="100%" frame="hsides" rules="rows" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t38">Property</th>
-<th align="left" valign="bottom" id="r1c2-t38">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t38" headers="r1c1-t38">Project</td>
-<td align="left" headers="r2c1-t38 r1c2-t38">Select the project in which to add the mapping file.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t38" headers="r1c1-t38">Source folder</td>
-<td align="left" headers="r3c1-t38 r1c2-t38">Click <span class="bold">Browse</span> and select the source file in which to add the mapping file. The default is <code>../</code><code><span class="codeinlineitalic">&lt;PROJECT&gt;</span></code><code>/src</code>.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t38" headers="r1c1-t38">File path</td>
-<td align="left" headers="r4c1-t38 r1c2-t38">Enter the filename and path of the mapping file. The default is <code>META-INF/eclipselink-orm.xml</code>.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t38" headers="r1c1-t38">Default access</td>
-<td align="left" headers="r5c1-t38 r1c2-t38">Select whether the entity's access to instance variables is <span class="bold">field</span>-based or <span class="bold">property</span>-based, as defined in the JPA specification.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t38" headers="r1c1-t38">Add to persistence unit</td>
-<td align="left" headers="r6c1-t38 r1c2-t38">Specify if this mapping file should be added to the persistence unit (<code>persistence.xml</code>).</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t38" headers="r1c1-t38">&nbsp;&nbsp;Persistence&nbsp;Unit</td>
-<td align="left" headers="r7c1-t38 r1c2-t38">Select the persistence unit in which to add the mapping file.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblhruleinformalmax" -->
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="reference003.htm#CIAJEIDJ">Mapping File</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_java_page.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_java_page.htm
deleted file mode 100644
index 60893af..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_java_page.htm
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Java Page</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Java Page" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAGEBAA" name="CIAGEBAA"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Java Page</h1>
-<p>This table lists the properties available on the Java page of the <a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a>.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Generate DDL - Objects page." summary="This table describes the options on the Generate DDL - Objects page." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="25%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t3">Property</th>
-<th align="left" valign="bottom" id="r1c2-t3">Description</th>
-<th align="left" valign="bottom" id="r1c3-t3">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t3" headers="r1c1-t3">Source folders on build path</td>
-<td align="left" headers="r2c1-t3 r1c2-t3">Click <span class="bold">Add Folder</span> to select an existing Java source folder to add to this project.</td>
-<td align="left" headers="r2c1-t3 r1c3-t3">EclipseLink</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t3" headers="r1c1-t3">Default output folder</td>
-<td align="left" headers="r3c1-t3 r1c2-t3">Specify the location of the&nbsp;<code>.class</code> files.</td>
-<td align="left" headers="r3c1-t3 r1c3-t3">build\classes</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_join_columns.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_join_columns.htm
deleted file mode 100644
index 5f77e3b..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_join_columns.htm
+++ /dev/null
@@ -1,50 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Join Columns</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Join Columns" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAEGEEG" name="CIAEGEEG"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Join Columns</h1>
-<p><a id="sthref207" name="sthref207"></a>Use this dialog to specify the join columns of an association table.</p>
-<p>Click Add to specify the join columns between the two tables.</p>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_create_new_association_wizard.htm#CIAFGHIF">Create New Association</a><br />
-<a href="tasks019.htm#BABBAGFI">Generating entities from tables</a><br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_create_custom_entities_wizard.htm#CIAGBFJE">Generate Entities from Tables Wizard</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_jpa_facet.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_jpa_facet.htm
deleted file mode 100644
index 15f2aec..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_jpa_facet.htm
+++ /dev/null
@@ -1,122 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>JPA Facet page</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="JPA Facet page" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACIFDIF" name="CACIFDIF"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>JPA Facet page</h1>
-<p>This table lists the properties available on the JPA Facet page of the <a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a>.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Generate DDL - Objects page." summary="This table describes the options on the Generate DDL - Objects page." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="25%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t4">Property</th>
-<th align="left" valign="bottom" id="r1c2-t4">Description</th>
-<th align="left" valign="bottom" id="r1c3-t4">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t4" headers="r1c1-t4">Platform</td>
-<td align="left" headers="r2c1-t4 r1c2-t4">Vendor-specific JPA implementation.</td>
-<td align="left" headers="r2c1-t4 r1c3-t4">EclipseLink</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t4" headers="r1c1-t4"><a id="sthref189" name="sthref189"></a><a id="sthref190" name="sthref190"></a>JPA Implementation</td>
-<td align="left" headers="r3c1-t4 r1c2-t4">Select a specific JPA library configuration.
-<p>Click <span class="bold">Manage libraries</span> to create or update a user library.</p>
-<p>Click <span class="bold">Download libraries</span> to download a specific library configuration.</p>
-</td>
-<td align="left" headers="r3c1-t4 r1c3-t4"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t4" headers="r1c1-t4">&nbsp;&nbsp;Type</td>
-<td align="left" headers="r4c1-t4 r1c2-t4">Select <span class="bold">User Library</span> to select from the available user-defined or downloaded libraries.
-<p>If you select Disable, you must manually include the JPA implementation library on the project classpath.</p>
-</td>
-<td align="left" headers="r4c1-t4 r1c3-t4">User Library</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t4" headers="r1c1-t4">&nbsp;&nbsp;Include libraries with this application</td>
-<td align="left" headers="r5c1-t4 r1c2-t4">Specify if the selected libraries are included when deploying the application.</td>
-<td align="left" headers="r5c1-t4 r1c3-t4">Selected</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t4" headers="r1c1-t4">Connection</td>
-<td align="left" headers="r6c1-t4 r1c2-t4">Select the database connection to use with the project. Dali requires an active database connection to use and validate the persistent entities and mappings.
-<p>Click <span class="bold">Add connection</span> to create a new database connection.</p>
-</td>
-<td align="left" headers="r6c1-t4 r1c3-t4"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t4" headers="r1c1-t4">&nbsp;&nbsp;Override&nbsp;default schema from connection</td>
-<td align="left" headers="r7c1-t4 r1c2-t4">Select a schema other than the default one that is derived from the connection information. Use this option if the default schema cannot be used. For example, use this option when the deployment login differs from the design-time login.</td>
-<td align="left" headers="r7c1-t4 r1c3-t4">The value calculated by Dali.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t4" headers="r1c1-t4">JPA Implementation</td>
-<td align="left" headers="r8c1-t4 r1c2-t4">Select to use the <span class="bold">JPA implementation provided by the server at runtime</span>, or select a specific <span class="bold">implementation library</span> that contain the Java Persistence API (JPA) and entities to be added to the project's Java Build Path.
-<p>Click <span class="bold">Configure default JPA implementation library</span> to create a default library for the project or click <span class="bold">Configure user libraries</span> to define additional libraries.</p>
-<p>Depending on your JPA implementation (for example, Generic or EclipseLink), different options may be available when working with JPA projects.</p>
-</td>
-<td align="left" headers="r8c1-t4 r1c3-t4">Determined by server.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t4" headers="r1c1-t4"><a id="sthref191" name="sthref191"></a>Persistent class management</td>
-<td align="left" headers="r9c1-t4 r1c2-t4">Specify if Dali will <span class="bold">discover annotated classes automatically</span>, or if the <span class="bold">annotated classes must be listed in the persistence.xml</span> file.
-<p><span class="bold">Note</span>: To insure application portability, you should explicitly list the managed persistence classes that are included in the persistence unit.</p>
-</td>
-<td align="left" headers="r9c1-t4 r1c3-t4">Determined by server.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r10c1-t4" headers="r1c1-t4"><a id="sthref192" name="sthref192"></a>Create <code>orm.xml</code></td>
-<td align="left" headers="r10c1-t4 r1c2-t4">Specify if Dali should create a default <code>orm.xml</code> file for your entity mappings and persistence unit defaults.</td>
-<td align="left" headers="r10c1-t4 r1c3-t4">Selected</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a></div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_mapping_general.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_mapping_general.htm
deleted file mode 100644
index a220aba..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_mapping_general.htm
+++ /dev/null
@@ -1,266 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>General information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="General information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACBHFIJ" name="CACBHFIJ"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>General information</h1>
-<p>This table lists the General properties available in the <span class="gui-object-title">Java Details view</span> for each mapping type.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Persistence Properties view." summary="This table describes the options on the Persistence Properties view." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="21%" />
-<col width="*" />
-<col width="27%" />
-<col width="21%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t16">Property</th>
-<th align="left" valign="bottom" id="r1c2-t16">Description</th>
-<th align="left" valign="bottom" id="r1c3-t16">Default</th>
-<th align="left" valign="bottom" id="r1c4-t16">Available for Mapping Type</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t16" headers="r1c1-t16">Mapping Type Hyperlink</td>
-<td align="left" headers="r2c1-t16 r1c2-t16">Clicking the name of the mapping type, which is represented as a hyperlink, invokes the Mapping Type Selection dialog. Use this dialog to specify the type of attribute.</td>
-<td align="left" headers="r2c1-t16 r1c3-t16">Basic</td>
-<td align="left" headers="r2c1-t16 r1c4-t16">All mapping types</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t16" headers="r1c1-t16"><a id="CACGCBHB" name="CACGCBHB"></a>Column</td>
-<td align="left" headers="r3c1-t16 r1c2-t16"><a id="sthref229" name="sthref229"></a><a id="sthref230" name="sthref230"></a>The database column that contains the value for the attribute. This field corresponds to the <code>@Column</code> annotation.</td>
-<td align="left" headers="r3c1-t16 r1c3-t16">By default, the Column is assumed to be named identically to the attribute.</td>
-<td align="left" headers="r3c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a>, <a href="tasks018.htm#BABHIBII">Version mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Name</td>
-<td align="left" headers="r4c1-t16 r1c2-t16">Name of the database column.
-<p>This field corresponds to the <code>@Column</code> annotation.</p>
-</td>
-<td align="left" headers="r4c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r4c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Table</td>
-<td align="left" headers="r5c1-t16 r1c2-t16">Name of the database table that contains the selected column.</td>
-<td align="left" headers="r5c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r5c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Insertable</td>
-<td align="left" headers="r6c1-t16 r1c2-t16">Specifies if the column is always included in <code>SQL INSERT</code> statements.</td>
-<td align="left" headers="r6c1-t16 r1c3-t16">True</td>
-<td align="left" headers="r6c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Updatable</td>
-<td align="left" headers="r7c1-t16 r1c2-t16">Specifies if this column is always included in <code>SQL UPDATE</code> statements.</td>
-<td align="left" headers="r7c1-t16 r1c3-t16">True</td>
-<td align="left" headers="r7c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Unique</td>
-<td align="left" headers="r8c1-t16 r1c2-t16">Sets the <code>UNIQUE</code> constraint for the column.</td>
-<td align="left" headers="r8c1-t16 r1c3-t16">False</td>
-<td align="left" headers="r8c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Nullable</td>
-<td align="left" headers="r9c1-t16 r1c2-t16">Specifies if the column allows null values.</td>
-<td align="left" headers="r9c1-t16 r1c3-t16">True</td>
-<td align="left" headers="r9c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r10c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Length</td>
-<td align="left" headers="r10c1-t16 r1c2-t16">Sets the column length.</td>
-<td align="left" headers="r10c1-t16 r1c3-t16">255</td>
-<td align="left" headers="r10c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r11c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Precision</td>
-<td align="left" headers="r11c1-t16 r1c2-t16">Sets the precision for the column values.</td>
-<td align="left" headers="r11c1-t16 r1c3-t16">0</td>
-<td align="left" headers="r11c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r12c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Scale</td>
-<td align="left" headers="r12c1-t16 r1c2-t16">Sets the number of digits that appear to the right of the decimal point.</td>
-<td align="left" headers="r12c1-t16 r1c3-t16">0</td>
-<td align="left" headers="r12c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r13c1-t16" headers="r1c1-t16">&nbsp;&nbsp;Column Definition</td>
-<td align="left" headers="r13c1-t16 r1c2-t16">Define the DDL for a column. This is used when a table is being generated.</td>
-<td align="left" headers="r13c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r13c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks010.htm#BABCBHDF">Embedded mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r14c1-t16" headers="r1c1-t16"><a id="CACGGGHB" name="CACGGGHB"></a><a id="sthref231" name="sthref231"></a><a id="sthref232" name="sthref232"></a><a id="sthref233" name="sthref233"></a>Fetch Type</td>
-<td align="left" headers="r14c1-t16 r1c2-t16">Defines how data is loaded from the database:
-<ul>
-<li>
-<p>Eager &ndash; Data is loaded in before it is actually needed.</p>
-</li>
-<li>
-<p>Lazy &ndash; Data is loaded only when required by the transaction.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r14c1-t16 r1c3-t16">Eager</td>
-<td align="left" headers="r14c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks016.htm#BABFHBCJ">One-to-one mapping</a>, <a href="tasks013.htm#BABEIEGD">Many-to-many mapping</a>, <a href="tasks014.htm#BABHFAFJ">Many-to-one mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r15c1-t16" headers="r1c1-t16">Optional</td>
-<td align="left" headers="r15c1-t16 r1c2-t16">Specifies if this field is can be null.</td>
-<td align="left" headers="r15c1-t16 r1c3-t16">Yes</td>
-<td align="left" headers="r15c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks016.htm#BABFHBCJ">One-to-one mapping</a>, <a href="tasks014.htm#BABHFAFJ">Many-to-one mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r16c1-t16" headers="r1c1-t16"><a id="CACBBIBI" name="CACBBIBI"></a><a id="sthref234" name="sthref234"></a>Lob</td>
-<td align="left" headers="r16c1-t16 r1c2-t16">Specify if the field is mapped to <code>java.sql.Clob</code> or <code>java.sql.Blob</code>.
-<p>This field corresponds to the <code>@Lob</code> annotation.</p>
-</td>
-<td align="left" headers="r16c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r16c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r17c1-t16" headers="r1c1-t16"><a id="CACEAJGD" name="CACEAJGD"></a><a id="sthref235" name="sthref235"></a><a id="sthref236" name="sthref236"></a><a id="sthref237" name="sthref237"></a>Temporal</td>
-<td align="left" headers="r17c1-t16 r1c2-t16">Specifies if this field is one of the following:
-<ul>
-<li>
-<p>Date &ndash; <code>java.sql.Date</code></p>
-</li>
-<li>
-<p>Time &ndash; <code>java.sql.Time</code></p>
-</li>
-<li>
-<p>Timestamp &ndash; <code>java.sql.Timestamp</code></p>
-</li>
-</ul>
-<p>This field corresponds to the <code>@Temporal</code> annotation.</p>
-</td>
-<td align="left" headers="r17c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r17c1-t16 r1c4-t16"><a href="tasks009.htm#BABBABCE">Basic mapping</a>, <a href="tasks012.htm#BABGCBHG">ID mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r18c1-t16" headers="r1c1-t16"><a id="sthref238" name="sthref238"></a><a id="sthref239" name="sthref239"></a><a id="sthref240" name="sthref240"></a>Enumerated</td>
-<td align="left" headers="r18c1-t16 r1c2-t16">Specify how to persist enumerated constraints if the <code>String</code> value suits your application requirements or to match an existing database schema.
-<ul>
-<li>
-<p>ordinal</p>
-</li>
-<li>
-<p><code>String</code></p>
-</li>
-</ul>
-<p>This field corresponds to the <code>@Enumerated</code> annotation.</p>
-</td>
-<td align="left" headers="r18c1-t16 r1c3-t16">Ordinal</td>
-<td align="left" headers="r18c1-t16 r1c4-t16"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r19c1-t16" headers="r1c1-t16">Target Entity</td>
-<td align="left" headers="r19c1-t16 r1c2-t16">The persistent entity to which the attribute is mapped.</td>
-<td align="left" headers="r19c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r19c1-t16 r1c4-t16"><a href="tasks016.htm#BABFHBCJ">One-to-one mapping</a>, <a href="tasks015.htm#BABHGEBD">One-to-many mapping</a> <a href="tasks013.htm#BABEIEGD">Many-to-many mapping</a>, <a href="tasks014.htm#BABHFAFJ">Many-to-one mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r20c1-t16" headers="r1c1-t16"><a id="CACJAIHB" name="CACJAIHB"></a>Cascade Type</td>
-<td align="left" headers="r20c1-t16 r1c2-t16">Specify which operations are propagated throughout the entity.
-<ul>
-<li>
-<p>All &ndash; All operations</p>
-</li>
-<li>
-<p>Persist</p>
-</li>
-<li>
-<p>Merge</p>
-</li>
-<li>
-<p>Move</p>
-</li>
-<li>
-<p>Remove</p>
-</li>
-<li>
-<p>Refresh</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r20c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r20c1-t16 r1c4-t16"><a href="tasks016.htm#BABFHBCJ">One-to-one mapping</a>, <a href="tasks015.htm#BABHGEBD">One-to-many mapping</a>, <a href="tasks013.htm#BABEIEGD">Many-to-many mapping</a>, <a href="tasks014.htm#BABHFAFJ">Many-to-one mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r21c1-t16" headers="r1c1-t16"><a id="CACJDJJA" name="CACJDJJA"></a>Mapped By</td>
-<td align="left" headers="r21c1-t16 r1c2-t16">The field in the database table that "owns" the relationship. This field is required only on the non-owning side of the relationship.</td>
-<td align="left" headers="r21c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r21c1-t16 r1c4-t16"><a href="tasks016.htm#BABFHBCJ">One-to-one mapping</a>, <a href="tasks015.htm#BABHGEBD">One-to-many mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r22c1-t16" headers="r1c1-t16"><a id="CACDADIH" name="CACDADIH"></a><a id="sthref241" name="sthref241"></a><a id="sthref242" name="sthref242"></a>Order By</td>
-<td align="left" headers="r22c1-t16 r1c2-t16">Specify the default order for objects returned from a query:
-<ul>
-<li>
-<p>No ordering</p>
-</li>
-<li>
-<p>Primary key</p>
-</li>
-<li>
-<p>Custom ordering</p>
-</li>
-</ul>
-<p>This field corresponds to the <code>@OrderBy</code> annotation.</p>
-</td>
-<td align="left" headers="r22c1-t16 r1c3-t16">Primary key</td>
-<td align="left" headers="r22c1-t16 r1c4-t16"><a href="tasks015.htm#BABHGEBD">One-to-many mapping</a>. <a href="tasks013.htm#BABEIEGD">Many-to-many mapping</a>, <a href="tasks014.htm#BABHFAFJ">Many-to-one mapping</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r23c1-t16" headers="r1c1-t16">Attribute Overrides</td>
-<td align="left" headers="r23c1-t16 r1c2-t16">Overrides <span class="bold">Basic</span> mappings of a mapped superclass (for example, if the inherited column name is incompatible with a pre-existing data model, or invalid as a column name in your database).</td>
-<td align="left" headers="r23c1-t16 r1c3-t16"><br /></td>
-<td align="left" headers="r23c1-t16 r1c4-t16"><a href="tasks010.htm#BABCBHDF">Embedded mapping</a>
-<p><a href="tasks010.htm#BABCBHDF">Embedded mapping</a></p>
-<br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_new_jpa_project.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_new_jpa_project.htm
deleted file mode 100644
index ac32e6f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_new_jpa_project.htm
+++ /dev/null
@@ -1,104 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>New JPA Project page</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="New JPA Project page" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACBJAGC" name="CACBJAGC"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>New JPA Project page</h1>
-<p>This table lists the properties available on the New JPA Project page of the <a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a>.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Generate DDL - Objects page." summary="This table describes the options on the Generate DDL - Objects page." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="25%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t2">Property</th>
-<th align="left" valign="bottom" id="r1c2-t2">Description</th>
-<th align="left" valign="bottom" id="r1c3-t2">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t2" headers="r1c1-t2">Project name</td>
-<td align="left" headers="r2c1-t2 r1c2-t2">Name of the Eclipse JPA project.</td>
-<td align="left" headers="r2c1-t2 r1c3-t2"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t2" headers="r1c1-t2">Project contents</td>
-<td align="left" headers="r3c1-t2 r1c2-t2">Location of the workspace in which to save the project.
-<p>Unselect The <span class="bold">Use Default</span> option and click <span class="bold">Browse</span> to select a new location.</p>
-</td>
-<td align="left" headers="r3c1-t2 r1c3-t2">Current workspace</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t2" headers="r1c1-t2">Target runtime</td>
-<td align="left" headers="r4c1-t2 r1c2-t2">Select a pre-defined target for the project.
-<p>Click <span class="bold">New</span> to create a new environment with the New Server Runtime wizard.</p>
-</td>
-<td align="left" headers="r4c1-t2 r1c3-t2"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t2" headers="r1c1-t2">Configurations</td>
-<td align="left" headers="r5c1-t2 r1c2-t2">Select a project configuration with pre-defined facets.
-<p>Select <span class="bold">&lt;custom&gt;</span> to manually select the facets for this project.</p>
-</td>
-<td align="left" headers="r5c1-t2 r1c3-t2">Utility JPA project with Java 5.0</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t2" headers="r1c1-t2">EAR membership</td>
-<td align="left" headers="r6c1-t2 r1c2-t2">Specify if this project should be included in an EAR file for deployment.
-<p>Select the <span class="bold">EAR Project Name</span>, or click <span class="bold">New</span> to create a new EAR project.</p>
-</td>
-<td align="left" headers="r6c1-t2 r1c3-t2"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t2" headers="r1c1-t2">Working sets</td>
-<td align="left" headers="r7c1-t2 r1c2-t2">Specify if this project should be included in an existing working set. The drop down field shows a list of previous selected working sets.
-<p>Select <span class="bold">Add project to working sets</span>, then select a working set in which to add this project.</p>
-</td>
-<td align="left" headers="r7c1-t2 r1c3-t2"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_new_jpa_project_wizard.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_new_jpa_project_wizard.htm
deleted file mode 100644
index 9122979..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_new_jpa_project_wizard.htm
+++ /dev/null
@@ -1,49 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Create New JPA Project wizard</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Create New JPA Project wizard" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACBJGBG" name="CACBJGBG"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Create New JPA Project wizard</h1>
-<p><a id="sthref188" name="sthref188"></a>The Create New JPA Project wizard allows you to create a new Java project using JPA. The wizard consists of the following pages:</p>
-<ul>
-<li>
-<p><a href="ref_new_jpa_project.htm#CACBJAGC">New JPA Project page</a></p>
-</li>
-<li>
-<p><a href="ref_java_page.htm#CIAGEBAA">Java Page</a></p>
-</li>
-<li>
-<p><a href="ref_jpa_facet.htm#CACIFDIF">JPA Facet page</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_general.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_general.htm
deleted file mode 100644
index 2bc5e79..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_general.htm
+++ /dev/null
@@ -1,126 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>General</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="General" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIACIFGJ" name="CIACIFGJ"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>General</h1>
-<p>The following table lists properties available in the General page of the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>.</p>
-<div class="tblformal"><a id="sthref255" name="sthref255"></a><a id="sthref256" name="sthref256"></a>
-<p class="titleintable">Properties of the General Page</p>
-<table class="Formal" title="Properties of the General Page" summary="This table describes the properties of the persistence.xml&rsquo;s General page." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="24%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t24">Property</th>
-<th align="left" valign="bottom" id="r1c2-t24">Description</th>
-<th align="left" valign="bottom" id="r1c3-t24">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t24" headers="r1c1-t24">
-<p>Name</p>
-</td>
-<td align="left" headers="r2c1-t24 r1c2-t24">
-<p>Enter the name of the persistence unit.</p>
-</td>
-<td align="left" headers="r2c1-t24 r1c3-t24">
-<p>The project name.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t24" headers="r1c1-t24">
-<p>Persistence Provider</p>
-</td>
-<td align="left" headers="r3c1-t24 r1c2-t24">
-<p>Enter the name of the persistence provider.</p>
-</td>
-<td align="left" headers="r3c1-t24 r1c3-t24">
-<p>Determined by the server.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t24" headers="r1c1-t24">
-<p>Description</p>
-</td>
-<td align="left" headers="r4c1-t24 r1c2-t24">
-<p>Enter a description for this persistence unit. This is an optional property.</p>
-</td>
-<td align="left" headers="r4c1-t24 r1c3-t24"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t24" headers="r1c1-t24">
-<p>Managed Classes</p>
-</td>
-<td align="left" headers="r5c1-t24 r1c2-t24">
-<p>Add or remove the classes managed through the persistence unit.</p>
-</td>
-<td align="left" headers="r5c1-t24 r1c3-t24"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t24" headers="r1c1-t24">
-<p>Exclude Unlisted Classes</p>
-</td>
-<td align="left" headers="r6c1-t24 r1c2-t24">
-<p>Select to include all annotated entity classes in the root of the persistence unit.</p>
-</td>
-<td align="left" headers="r6c1-t24 r1c3-t24">
-<p>False</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t24" headers="r1c1-t24">
-<p>XML Mapping Files</p>
-</td>
-<td align="left" headers="r7c1-t24 r1c2-t24">
-<p>Add or remove the object/relational mapping XML files that define the classes to be managed by the persistence unit.</p>
-</td>
-<td align="left" headers="r7c1-t24 r1c3-t24">
-<p>Meta-INF\orm.xml</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t24" headers="r1c1-t24">
-<p>JAR Files</p>
-</td>
-<td align="left" headers="r8c1-t24 r1c2-t24"><br /></td>
-<td align="left" headers="r8c1-t24 r1c3-t24"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" --></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_map_view.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_map_view.htm
deleted file mode 100644
index 5d1c246..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_map_view.htm
+++ /dev/null
@@ -1,52 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>JPA Details view (for attributes)</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="JPA Details view (for attributes)" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABIFBAF" name="BABIFBAF"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>JPA Details view (for attributes)</h1>
-<p><a id="sthref226" name="sthref226"></a><a id="sthref227" name="sthref227"></a><a id="sthref228" name="sthref228"></a>The <span class="gui-object-title">JPA Details</span> view displays the persistence information for the currently selected mapped attribute and contains the following areas:</p>
-<ul>
-<li>
-<p><a href="ref_mapping_general.htm#CACBHFIJ">General information</a></p>
-</li>
-<li>
-<p><a href="reference011.htm#CACBAEBC">Join Table Information</a></p>
-</li>
-<li>
-<p><a href="reference012.htm#CACFCEJC">Join Columns Information</a></p>
-</li>
-<li>
-<p><a href="ref_primary_key.htm#CACFCCAB">Primary Key Generation information</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_outline.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_outline.htm
deleted file mode 100644
index c98fe2c..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_outline.htm
+++ /dev/null
@@ -1,49 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>JPA Structure view</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:53Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="JPA Structure view" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABEGGFE" name="BABEGGFE"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>JPA Structure view</h1>
-<p><a id="sthref252" name="sthref252"></a><a id="sthref253" name="sthref253"></a>The <span class="gui-object-title">JPA Structure</span> view displays an outline of the structure (its attributes and mappings) of the entity that is currently selected or opened in the editor. The structural elements shown in the outline are the entity and its fields.</p>
-<div class="figure"><a id="sthref254" name="sthref254"></a>
-<p class="titleinfigure">Sample JPA Structure View</p>
-<img src="img/persistence_outline_view.png" alt="Sample JPA Structure view for an entity." title="Sample JPA Structure view for an entity." /><br /></div>
-<!-- class="figure" -->
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_perspective.htm#BABIFBDB">JPA Development perspective</a>
-<p>&nbsp;</p>
-</div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_perspective.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_perspective.htm
deleted file mode 100644
index 28cc063..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_perspective.htm
+++ /dev/null
@@ -1,56 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>JPA Development perspective</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="JPA Development perspective" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABIFBDB" name="BABIFBDB"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>JPA Development perspective</h1>
-<p><a id="sthref281" name="sthref281"></a><a id="sthref282" name="sthref282"></a>The <span class="bold">JPA Development perspective</span> defines the initial set and layout of views in the Workbench window when using Dali. By default, the <span class="gui-object-title">JPA Development perspective</span> includes the following views:</p>
-<ul>
-<li>
-<p><a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a></p>
-</li>
-<li>
-<p><a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></p>
-</li>
-<li>
-<p><a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a></p>
-</li>
-<li>
-<p><a href="ref_details_orm.htm#CACGDGHC">JPA Details view (for orm.xml)</a></p>
-</li>
-</ul>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<p><a href="../org.eclipse.platform.doc.user/concepts/concepts-4.htm">Perspectives</a></p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_prop_view.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_prop_view.htm
deleted file mode 100644
index 8f7fe6b..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_prop_view.htm
+++ /dev/null
@@ -1,52 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>JPA Details view (for entities)</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="JPA Details view (for entities)" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABFAEBB" name="BABFAEBB"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>JPA Details view (for entities)</h1>
-<p><a id="sthref209" name="sthref209"></a><a id="sthref210" name="sthref210"></a><a id="sthref211" name="sthref211"></a>The <span class="gui-object-title">JPA Details</span> view displays the persistence information for the currently selected entity and contains the following tabs:</p>
-<ul>
-<li>
-<p><a href="reference006.htm#CACCAGGC">General information</a></p>
-</li>
-<li>
-<p><a href="reference007.htm#CACIJBGH">Attribute overrides</a></p>
-</li>
-<li>
-<p><a href="reference008.htm#CACBHIDA">Secondary table information</a></p>
-</li>
-<li>
-<p><a href="reference009.htm#CACFHGHE">Inheritance information</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_xmll_editor.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_xmll_editor.htm
deleted file mode 100644
index 9f7acea..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_persistence_xmll_editor.htm
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>persistence.xml Editor</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="persistence.xml Editor" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIACCHID" name="CIACCHID"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>persistence.xml Editor</h1>
-<p>The persistence.xml Editor provides an interface that enables you to update the persistence.xml file. For projects using the EclipseLink platform, the perisistence.xml Editor consists of the following pages:</p>
-<ul>
-<li>
-<p><a href="ref_persistence_general.htm#CIACIFGJ">General</a></p>
-</li>
-<li>
-<p><a href="reference018.htm#CIAFFJIE">Connection</a></p>
-</li>
-<li>
-<p><a href="reference019.htm#CIAJAFEG">Customization</a></p>
-</li>
-<li>
-<p><a href="reference020.htm#CIABEDCH">Caching</a></p>
-</li>
-<li>
-<p><a href="reference021.htm#CIABGHHI">Logging</a></p>
-</li>
-<li>
-<p><a href="reference022.htm#CIAFJCHE">Options</a></p>
-</li>
-<li>
-<p><a href="reference023.htm#CIACCFCB">Schema Generation</a></p>
-</li>
-<li>
-<p><a href="reference024.htm#CIAHJDFF">Properties</a></p>
-</li>
-<li>
-<p><a href="reference025.htm#CIAHCJAH">Source</a></p>
-</li>
-</ul>
-<p>For projects using the Generic platform, the following subset of these pages is available:</p>
-<ul>
-<li>
-<p><a href="ref_persistence_general.htm#CIACIFGJ">General</a></p>
-</li>
-<li>
-<p><a href="reference018.htm#CIAFFJIE">Connection</a></p>
-</li>
-<li>
-<p><a href="reference024.htm#CIAHJDFF">Properties</a></p>
-</li>
-<li>
-<p><a href="reference025.htm#CIAHCJAH">Source</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_primary_key.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_primary_key.htm
deleted file mode 100644
index 52de811..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_primary_key.htm
+++ /dev/null
@@ -1,142 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Primary Key Generation information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:53Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Primary Key Generation information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACFCCAB" name="CACFCCAB"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Primary Key Generation information</h1>
-<p>This table lists the fields available in the <span class="gui-object-title">Primary Key Generation</span> area in JPA Details view for <a href="tasks012.htm#BABGCBHG">ID mapping</a> types.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Join Columns tab." summary="This table describes the options on the Join Columns tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="26%" />
-<col width="*" />
-<col width="34%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t19">Property</th>
-<th align="left" valign="bottom" id="r1c2-t19">Description</th>
-<th align="left" valign="bottom" id="r1c3-t19">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t19" headers="r1c1-t19"><a id="CACBAJBC" name="CACBAJBC"></a>Primary Key Generation</td>
-<td align="left" headers="r2c1-t19 r1c2-t19"><a id="sthref248" name="sthref248"></a><a id="sthref249" name="sthref249"></a>These fields define how the primary key is generated. These fields correspond to the <code>@GeneratedValue</code> annotation.</td>
-<td align="left" headers="r2c1-t19 r1c3-t19">Generated Value</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t19" headers="r1c1-t19"><a id="CACJEEEC" name="CACJEEEC"></a>&nbsp;&nbsp;&nbsp;Strategy</td>
-<td align="left" headers="r3c1-t19 r1c2-t19">
-<ul>
-<li>Auto</li>
-<li>
-<p>Identity &ndash; Values are assigned by the database's <span class="bold">Identity</span> column.</p>
-</li>
-<li>
-<p>Sequence &ndash; Values are assigned by a sequence table (see <a href="#CACFFHEH">Sequence&nbsp;Generator</a>).</p>
-</li>
-<li>
-<p>Table &ndash; Values are assigned by a database table (see <a href="#CACGFEAH">Table Generator</a>).</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r3c1-t19 r1c3-t19">Auto</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t19" headers="r1c1-t19"><a id="BABEEAHJ" name="BABEEAHJ"></a>&nbsp;&nbsp;Generator Name</td>
-<td align="left" headers="r4c1-t19 r1c2-t19">Unique name of the generated value.</td>
-<td align="left" headers="r4c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t19" headers="r1c1-t19"><a id="CACGFEAH" name="CACGFEAH"></a>Table Generator</td>
-<td align="left" headers="r5c1-t19 r1c2-t19">These fields define the database table used for generating the primary key and correspond to the <code>@TableGenerator</code> annotation.
-<p>These fields apply only when <span class="bold">Strategy</span>&nbsp;=&nbsp;<span class="bold">Table</span>.</p>
-</td>
-<td align="left" headers="r5c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t19" headers="r1c1-t19">&nbsp;&nbsp;Name</td>
-<td align="left" headers="r6c1-t19 r1c2-t19">Unique name of the generator.</td>
-<td align="left" headers="r6c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t19" headers="r1c1-t19">&nbsp;&nbsp;Table</td>
-<td align="left" headers="r7c1-t19 r1c2-t19">Database table that stores the generated ID values.</td>
-<td align="left" headers="r7c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t19" headers="r1c1-t19">&nbsp;&nbsp;Primary Key Column</td>
-<td align="left" headers="r8c1-t19 r1c2-t19">The column in the table generator's <span class="bold">Table</span> that contains the primary key.</td>
-<td align="left" headers="r8c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t19" headers="r1c1-t19">&nbsp;&nbsp;Value Column</td>
-<td align="left" headers="r9c1-t19 r1c2-t19">The column that stores the generated ID values.</td>
-<td align="left" headers="r9c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r10c1-t19" headers="r1c1-t19">&nbsp;&nbsp;Primary Key Column Value</td>
-<td align="left" headers="r10c1-t19 r1c2-t19">The value for the <span class="bold">Primary Key Column</span> in the generator table.</td>
-<td align="left" headers="r10c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r11c1-t19" headers="r1c1-t19"><a id="CACFFHEH" name="CACFFHEH"></a>Sequence&nbsp;Generator</td>
-<td align="left" headers="r11c1-t19 r1c2-t19"><a id="sthref250" name="sthref250"></a><a id="sthref251" name="sthref251"></a>These fields define the specific sequence used for generating the primary key and correspond to the <code>@SequenceGenerator</code> annotation.
-<p>These fields apply only when <span class="bold">Strategy</span> = <span class="bold">Sequence</span>.</p>
-</td>
-<td align="left" headers="r11c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r12c1-t19" headers="r1c1-t19">&nbsp;&nbsp;Name</td>
-<td align="left" headers="r12c1-t19 r1c2-t19">Name of the sequence table to use for defining primary key values.</td>
-<td align="left" headers="r12c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r13c1-t19" headers="r1c1-t19">&nbsp;&nbsp;Sequence</td>
-<td align="left" headers="r13c1-t19 r1c2-t19">Unique name of the sequence.</td>
-<td align="left" headers="r13c1-t19 r1c3-t19"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="tasks012.htm#BABGCBHG">ID mapping</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a></div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_project_properties.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_project_properties.htm
deleted file mode 100644
index 3f5f54b..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_project_properties.htm
+++ /dev/null
@@ -1,112 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Project Properties page &ndash; Java Persistence Options</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Project Properties page &ndash; Java Persistence Options" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABJHBCI" name="BABJHBCI"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Project Properties page &ndash; Java Persistence Options</h1>
-<p><a id="sthref270" name="sthref270"></a><a id="sthref271" name="sthref271"></a>Use the <span class="gui-object-title">Java Persistence</span> options on the <span class="gui-object-title">Properties</span> page to select the database connection to use with the project.</p>
-<p>This table lists the properties available in the <span class="gui-object-title">JPA Details page</span>.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Persistence Properties page." summary="This table describes the options on the Persistence Properties page." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="32%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t36">Property</th>
-<th align="left" valign="bottom" id="r1c2-t36">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t36" headers="r1c1-t36"><a id="sthref272" name="sthref272"></a><a id="sthref273" name="sthref273"></a><a id="sthref274" name="sthref274"></a><a id="sthref275" name="sthref275"></a>Platform</td>
-<td align="left" headers="r2c1-t36 r1c2-t36">Select the vendor-specific platform.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t36" headers="r1c1-t36">Library</td>
-<td align="left" headers="r3c1-t36 r1c2-t36">Select a specific JPA library configuration.
-<p>Click <span class="bold">Manage libraries</span> to create or update a user library.</p>
-<p>Click <span class="bold">Download libraries</span> to download a specific library configuration.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t36" headers="r1c1-t36">&nbsp;&nbsp;Type</td>
-<td align="left" headers="r4c1-t36 r1c2-t36">Select <span class="bold">User Library</span> to select from the available user-defined or downloaded libraries.
-<p>If you select Disable, you must manually include the JPA implementation library on the project classpath.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t36" headers="r1c1-t36">&nbsp;&nbsp;Include&nbsp;libraries&nbsp;with&nbsp;this&nbsp;application</td>
-<td align="left" headers="r5c1-t36 r1c2-t36">Specify if the selected libraries are included when deploying the application.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t36" headers="r1c1-t36"><a id="sthref276" name="sthref276"></a><a id="sthref277" name="sthref277"></a><a id="sthref278" name="sthref278"></a>Connection</td>
-<td align="left" headers="r6c1-t36 r1c2-t36">The database connection used to map the persistent entities.
-<ul>
-<li>
-<p>To create a new connection, click <span class="bold">Add Connections</span>.</p>
-</li>
-<li>
-<p>To reconnect to an existing connection, click <span class="bold">Reconnect</span>.</p>
-</li>
-</ul>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t36" headers="r1c1-t36">&nbsp;&nbsp;Override&nbsp;default&nbsp;catalog&nbsp;from&nbsp;connection</td>
-<td align="left" headers="r7c1-t36 r1c2-t36">Select a catalog other than the default one derived from the connection information. Use this option if the default catalog is incorrect or cannot be used.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t36" headers="r1c1-t36">&nbsp;&nbsp;Override&nbsp;default&nbsp;schema&nbsp;from&nbsp;connection</td>
-<td align="left" headers="r8c1-t36 r1c2-t36">Select a schema other than the default one derived from the connection information. Use this option if the default schema is incorrect or cannot be used. For example, use this option when the deployment login differs from the design-time login.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t36" headers="r1c1-t36">Persistent Class Management</td>
-<td align="left" headers="r9c1-t36 r1c2-t36">Specify if Dali will <span class="bold">discover annotated classes automatically</span>, or if the <span class="bold">annotated classes must be listed in the persistence.xml</span> file.
-<p><span class="bold">Note</span>: To insure application portability, you should explicitly list the managed persistence classes that are included in the persistence unit.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r10c1-t36" headers="r1c1-t36"><a id="sthref279" name="sthref279"></a><a id="sthref280" name="sthref280"></a>Canonical Metamodel</td>
-<td align="left" headers="r10c1-t36 r1c2-t36"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="tasks024.htm#BABDBCBI">Modifying persistent project properties</a></div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_selectTables.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_selectTables.htm
deleted file mode 100644
index 72a396a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_selectTables.htm
+++ /dev/null
@@ -1,79 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Select Tables</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Select Tables" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAHCGEE" name="CIAHCGEE"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Select Tables</h1>
-<p><a id="sthref199" name="sthref199"></a><a id="sthref200" name="sthref200"></a><a id="sthref201" name="sthref201"></a>Use the <span class="gui-object-title">Select Tables</span> dialog to specify the database connection and tables from which to create entities.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Generate Entities dialog." summary="This table describes the options on the Generate Entities dialog." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="32%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t8">Property</th>
-<th align="left" valign="bottom" id="r1c2-t8">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t8" headers="r1c1-t8">Connection</td>
-<td align="left" headers="r2c1-t8 r1c2-t8">Select a database connection or click <span class="bold">Add Connection</span> to create a new connection.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t8" headers="r1c1-t8">Schema</td>
-<td align="left" headers="r3c1-t8 r1c2-t8">Select the database schema from which to select tables.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t8" headers="r1c1-t8">Tables</td>
-<td align="left" headers="r4c1-t8 r1c2-t8">Select the tables from which to create Java persistent entities. The tables shown are determined by the database connection and schema selections.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t8" headers="r1c1-t8">Synchronize Classes listed in persistence.xml</td>
-<td align="left" headers="r5c1-t8 r1c2-t8">Specify if Dali should update the <code>persistence.xml</code> file to include the generated classes.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a><br />
-<a href="tasks019.htm#BABBAGFI">Generating entities from tables</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_create_custom_entities_wizard.htm#CIAGBFJE">Generate Entities from Tables Wizard</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_select_cascade_dialog.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_select_cascade_dialog.htm
deleted file mode 100644
index 59da749..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_select_cascade_dialog.htm
+++ /dev/null
@@ -1,40 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Select Cascade dialog</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Select Cascade dialog" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAFDGIJ" name="CIAFDGIJ"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Select Cascade dialog</h1>
-<p>Specify which operations are propagated throughout the association: All, Persist, Merge, Remove, or Refresh.</p>
-</div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/ref_tableAssociations.htm b/jpa/plugins/org.eclipse.jpt.doc.user/ref_tableAssociations.htm
deleted file mode 100644
index cc39f22..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/ref_tableAssociations.htm
+++ /dev/null
@@ -1,78 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Table Associations</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Table Associations" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIACDICB" name="CIACDICB"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Table Associations</h1>
-<p><a id="sthref202" name="sthref202"></a>Use this page to create or edit the association between the database table and entity.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Generate Entities dialog." summary="This table describes the options on the Table Associations dialog." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="32%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t9">Property</th>
-<th align="left" valign="bottom" id="r1c2-t9">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t9" headers="r1c1-t9">Table associations</td>
-<td align="left" headers="r2c1-t9 r1c2-t9">Select an association to modify or click to create a new table association with the <a href="ref_create_new_association_wizard.htm#CIAFGHIF">Create New Association</a> wizard.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t9" headers="r1c1-t9">Generate this association</td>
-<td align="left" headers="r3c1-t9 r1c2-t9">Specify if Dali should create the selected association. If enabled, you can specify the Cardinality and Join table for the table association.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t9" headers="r1c1-t9">Generate a reference to <span class="italic">&lt;ROW&gt;</span> in <span class="italic">&lt;TABLE&gt;</span></td>
-<td align="left" headers="r4c1-t9 r1c2-t9">Specify if the entity should contain a reference to the specified table.
-<p>If enabled, you can also enter the <span class="bold">Property</span> name and select the <span class="bold">Cascade</span> method (all, persist, merge, remove, or refresh) for the reference.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a><br />
-<a href="tasks019.htm#BABBAGFI">Generating entities from tables</a><br />
-<a href="ref_create_new_association_wizard.htm#CIAFGHIF">Create New Association</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_create_custom_entities_wizard.htm#CIAGBFJE">Generate Entities from Tables Wizard</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference.htm
deleted file mode 100644
index 2d9f1dc..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference.htm
+++ /dev/null
@@ -1,60 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Reference</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content=" Reference" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="sthref187" name="sthref187"></a></p>
-<h1>Reference</h1>
-<p>This section includes detailed help information for each of the following elements in the Dali OR Mapping Tool:</p>
-<ul>
-<li>
-<p><a href="reference001.htm#CACJJJJH">Wizards</a></p>
-</li>
-<li>
-<p><a href="reference005.htm#CACDJIIG">Property pages</a></p>
-</li>
-<li>
-<p><a href="reference026.htm#CACDEIEE">Preferences</a></p>
-</li>
-<li>
-<p><a href="reference027.htm#CACGEJDA">Dialogs</a></p>
-</li>
-<li>
-<p><a href="ref_persistence_perspective.htm#BABIFBDB">JPA Development perspective</a></p>
-</li>
-<li>
-<p><a href="reference029.htm#CACDHCIA">Icons and buttons</a></p>
-</li>
-<li>
-<p><a href="reference032.htm#CACBBDIB">Dali Developer Documentation</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference001.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference001.htm
deleted file mode 100644
index 910f927..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference001.htm
+++ /dev/null
@@ -1,55 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Wizards</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Wizards" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACJJJJH" name="CACJJJJH"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Wizards</h1>
-<p>This section includes information on the following wizards:</p>
-<ul>
-<li>
-<p><a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a></p>
-</li>
-<li>
-<p><a href="ref_create_jpa_entity_wizard.htm#CIAGGGDF">Create JPA Entity wizard</a></p>
-</li>
-<li>
-<p><a href="reference004.htm#CIAGHCGA">Generate Tables from Entities Wizard</a></p>
-</li>
-<li>
-<p><a href="ref_create_custom_entities_wizard.htm#CIAGBFJE">Generate Entities from Tables Wizard</a></p>
-</li>
-<li>
-<p><a href="ref_create_new_association_wizard.htm#CIAFGHIF">Create New Association</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference002.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference002.htm
deleted file mode 100644
index 07c86ec..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference002.htm
+++ /dev/null
@@ -1,39 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Mapping File Wizard</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Mapping File Wizard" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAIJCCE" name="CIAIJCCE"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Mapping File Wizard</h1>
-<p>The Mapping File wizard enables you to add an <code>orm.xml</code> file to a JPA project if no object map exists at the location specified. For example, if you cleared the <span class="bold">Create orm.xml</span> option on the <a href="ref_jpa_facet.htm#CACIFDIF">JPA Facet page</a>, you can later add the <code>orm.xml</code> file to the src file of the project using this wizard.</p>
-<p>The <a href="#CIAIJCCE">Mapping File Wizard</a> consists of the Mapping File page.</p>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference003.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference003.htm
deleted file mode 100644
index f2e94f4..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference003.htm
+++ /dev/null
@@ -1,134 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Mapping File</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Mapping File" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAJEIDJ" name="CIAJEIDJ"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Mapping File</h1>
-<p>This table lists the properties of the <a href="reference002.htm#CIAIJCCE">Mapping File Wizard</a>.</p>
-<div class="tblformal"><a id="sthref197" name="sthref197"></a><a id="sthref198" name="sthref198"></a>
-<p class="titleintable">Mapping File Wizard Properties</p>
-<table class="Formal" title="Mapping File Wizard Properties" summary="This table lists the properties of the Mapping File Wizard." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="24%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t7">Property</th>
-<th align="left" valign="bottom" id="r1c2-t7">Description</th>
-<th align="left" valign="bottom" id="r1c3-t7">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t7" headers="r1c1-t7">
-<p>Project</p>
-</td>
-<td align="left" headers="r2c1-t7 r1c2-t7">
-<p>The name of the JPA project.</p>
-</td>
-<td align="left" headers="r2c1-t7 r1c3-t7">
-<p>Selected.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t7" headers="r1c1-t7">
-<p>Source folder</p>
-</td>
-<td align="left" headers="r3c1-t7 r1c2-t7">
-<p>The location of the project's src folder. If needed, click <span class="bold">Browse</span> to point the wizard to the src file's location.</p>
-</td>
-<td align="left" headers="r3c1-t7 r1c3-t7">
-<p>Selected.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t7" headers="r1c1-t7">
-<p>File Path</p>
-</td>
-<td align="left" headers="r4c1-t7 r1c2-t7">
-<p>The location for the new <code>orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r4c1-t7 r1c3-t7">
-<p>Selected.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t7" headers="r1c1-t7">
-<p>Default Access</p>
-</td>
-<td align="left" headers="r5c1-t7 r1c2-t7">
-<p>Select whether the access to the entity is field-based or property-based, as defined in JPA specification.</p>
-<ul>
-<li>
-<p>None &ndash; No access type specified.</p>
-</li>
-<li>
-<p><span class="bold">Property-based</span> &ndash; Persistent state accessed through the property accessor methods. The property accessor methods must be <span class="bold">public</span> or <span class="bold">private</span>.</p>
-</li>
-<li>
-<p><span class="bold">Field-based</span> &ndash; Instance variables are accessed directly. All non-transient instance variables are persistent.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r5c1-t7 r1c3-t7">
-<p>None</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t7" headers="r1c1-t7">
-<p>Add to persistence unit</p>
-</td>
-<td align="left" headers="r6c1-t7 r1c2-t7">
-<p>Designates the persistence unit for this object map file.</p>
-</td>
-<td align="left" headers="r6c1-t7 r1c3-t7">
-<p>Selected.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a><br />
-<a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a><br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="reference002.htm#CIAIJCCE">Mapping File Wizard</a><br /></div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference004.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference004.htm
deleted file mode 100644
index caf332a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference004.htm
+++ /dev/null
@@ -1,49 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Generate Tables from Entities Wizard</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:50Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Generate Tables from Entities Wizard" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAGHCGA" name="CIAGHCGA"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Generate Tables from Entities Wizard</h1>
-<p>Use the Generate DDL from Entities Wizard to quickly create DDL scripts from your persistent entities. Dali automatically creates the necessary primary and foreign keys, based on the entity mappings.</p>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="tasks019.htm#BABBAGFI">Generating entities from tables</a><br />
-<a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a><br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_create_jpa_entity_wizard.htm#CIAGGGDF">Create JPA Entity wizard</a><br /></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference005.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference005.htm
deleted file mode 100644
index bacef21..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference005.htm
+++ /dev/null
@@ -1,52 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Property pages</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:51Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Property pages" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACDJIIG" name="CACDJIIG"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Property pages</h1>
-<p>This section includes information on the following:</p>
-<ul>
-<li>
-<p><a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></p>
-</li>
-<li>
-<p><a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a></p>
-</li>
-<li>
-<p><a href="ref_details_orm.htm#CACGDGHC">JPA Details view (for orm.xml)</a></p>
-</li>
-<li>
-<p><a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference006.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference006.htm
deleted file mode 100644
index dd8a6b2..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference006.htm
+++ /dev/null
@@ -1,122 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>General information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="General information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACCAGGC" name="CACCAGGC"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>General information</h1>
-<p>This table lists the General information fields available in the <span class="gui-object-title">JPA Details</span> view for each entity type.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Persistence Properties view, General tab." summary="This table describes the options on the Persistence Properties view, General tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="16%" />
-<col width="*" />
-<col width="17%" />
-<col width="25%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t13">Property</th>
-<th align="left" valign="bottom" id="r1c2-t13">Description</th>
-<th align="left" valign="bottom" id="r1c3-t13">Default</th>
-<th align="left" valign="bottom" id="r1c4-t13">Available for Entity&nbsp;Type</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t13" headers="r1c1-t13">Mapping Type Hyperlink</td>
-<td align="left" headers="r2c1-t13 r1c2-t13">Clicking the name of the mapping type, which is represented as a hyperlink, invokes the Mapping Type Selection dialog. Use this dialog to specify the type of entity: Mapped Superclass, Embeddable or the default mapping type.</td>
-<td align="left" headers="r2c1-t13 r1c3-t13">Entity</td>
-<td align="left" headers="r2c1-t13 r1c4-t13"><a href="tasks005.htm#BABGBIEE">Entity</a>, <a href="tasks006.htm#BABFEICE">Embeddable</a>, and <a href="tasks007.htm#BABDAGCI">Mapped superclass</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t13" headers="r1c1-t13">Table</td>
-<td align="left" headers="r3c1-t13 r1c2-t13">The default database table information for this entity. These fields can be overridden by the information in the <a href="reference007.htm#CACIJBGH">Attribute overrides</a> area.</td>
-<td align="left" headers="r3c1-t13 r1c3-t13"><br /></td>
-<td align="left" headers="r3c1-t13 r1c4-t13"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t13" headers="r1c1-t13">&nbsp;&nbsp;Name</td>
-<td align="left" headers="r4c1-t13 r1c2-t13">The name of the primary database table associated with the entity.</td>
-<td align="left" headers="r4c1-t13 r1c3-t13"><br /></td>
-<td align="left" headers="r4c1-t13 r1c4-t13"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t13" headers="r1c1-t13">&nbsp;&nbsp;Catalog</td>
-<td align="left" headers="r5c1-t13 r1c2-t13">The database catalog that contains the <span class="bold">Table</span>.</td>
-<td align="left" headers="r5c1-t13 r1c3-t13">As defined in <code>orm.xml</code>.</td>
-<td align="left" headers="r5c1-t13 r1c4-t13"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t13" headers="r1c1-t13">&nbsp;&nbsp;Schema</td>
-<td align="left" headers="r6c1-t13 r1c2-t13">The database schema that contains the <span class="bold">Table</span>.</td>
-<td align="left" headers="r6c1-t13 r1c3-t13">As defined in <code>orm.xml</code>.</td>
-<td align="left" headers="r6c1-t13 r1c4-t13"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t13" headers="r1c1-t13">Name</td>
-<td align="left" headers="r7c1-t13 r1c2-t13">The name of this entity. By default, the class name is used as the entity name.</td>
-<td align="left" headers="r7c1-t13 r1c3-t13"><br /></td>
-<td align="left" headers="r7c1-t13 r1c4-t13"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t13" headers="r1c1-t13">Access</td>
-<td align="left" headers="r8c1-t13 r1c2-t13">The access method for this entity.</td>
-<td align="left" headers="r8c1-t13 r1c3-t13">Field</td>
-<td align="left" headers="r8c1-t13 r1c4-t13"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t13" headers="r1c1-t13">Primary&nbsp;key&nbsp;class</td>
-<td align="left" headers="r9c1-t13 r1c2-t13">Click <span class="bold">Browse</span> and select the primary key for the entity. Clicking the field name, which is represented as a hyperlink, allows you to create a new class.</td>
-<td align="left" headers="r9c1-t13 r1c3-t13"><br /></td>
-<td align="left" headers="r9c1-t13 r1c4-t13"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r10c1-t13" headers="r1c1-t13">Cachable</td>
-<td align="left" headers="r10c1-t13 r1c2-t13">Specifies if the entity is cachable.
-<p>This field corresponds to the <code>@Cachable</code> annotation.</p>
-</td>
-<td align="left" headers="r10c1-t13 r1c3-t13">@Cachable(false)</td>
-<td align="left" headers="r10c1-t13 r1c4-t13"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference007.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference007.htm
deleted file mode 100644
index a1f2acc..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference007.htm
+++ /dev/null
@@ -1,80 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Attribute overrides</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Attribute overrides" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACIJBGH" name="CACIJBGH"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Attribute overrides</h1>
-<p><a id="sthref212" name="sthref212"></a><a id="sthref213" name="sthref213"></a><a id="sthref214" name="sthref214"></a>Use the <span class="gui-object-title">Attribute Overrides</span> area in the <span class="gui-object-title">JPA Details</span> view to override the default settings specified in the <a href="reference006.htm#CACCAGGC">General information</a> area of an attribute. Attribute overrides generally override/configure attributes that are inherited or embedded.</p>
-<p>This table lists the Attribute override fields available in the <span class="gui-object-title">JPA Details</span> view for each entity type.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Persistence Properties view, General tab." summary="This table describes the options on the Persistence Properties view, General tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="16%" />
-<col width="*" />
-<col width="17%" />
-<col width="25%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t14">Property</th>
-<th align="left" valign="bottom" id="r1c2-t14">Description</th>
-<th align="left" valign="bottom" id="r1c3-t14">Default</th>
-<th align="left" valign="bottom" id="r1c4-t14">Available for Entity&nbsp;Type</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t14" headers="r1c1-t14">Attribute Overrides</td>
-<td align="left" headers="r2c1-t14 r1c2-t14">Specify a property or field to be overridden (from the default mappings). Select <span class="bold">Override Default</span>.</td>
-<td align="left" headers="r2c1-t14 r1c3-t14"><br /></td>
-<td align="left" headers="r2c1-t14 r1c4-t14"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t14" headers="r1c1-t14">Join Columns</td>
-<td align="left" headers="r3c1-t14 r1c2-t14"><br /></td>
-<td align="left" headers="r3c1-t14 r1c3-t14"><br /></td>
-<td align="left" headers="r3c1-t14 r1c4-t14"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="reference006.htm#CACCAGGC">General information</a><br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference008.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference008.htm
deleted file mode 100644
index f857457..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference008.htm
+++ /dev/null
@@ -1,48 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Secondary table information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Secondary table information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACBHIDA" name="CACBHIDA"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Secondary table information</h1>
-<p><a id="sthref215" name="sthref215"></a><a id="sthref216" name="sthref216"></a><a id="sthref217" name="sthref217"></a><a id="sthref218" name="sthref218"></a>Use the <span class="gui-object-title">Secondary Tables</span> area in the <span class="gui-object-title">JPA Details</span> view to associate additional tables with an entity. Use this area if the data associated with an entity is spread across multiple tables.</p>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_additonal_tables.htm#CIHGBIEI">Specifying additional tables</a><br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference009.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference009.htm
deleted file mode 100644
index 2d4970f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference009.htm
+++ /dev/null
@@ -1,113 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Inheritance information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Inheritance information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACFHGHE" name="CACFHGHE"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Inheritance information</h1>
-<p><a id="sthref219" name="sthref219"></a><a id="sthref220" name="sthref220"></a>This table lists the fields available on the <span class="gui-object-title">Inheritance</span> area in the <span class="gui-object-title">JPA Details</span> view for each entity type.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Persistence Properties view, Inheritance tab." summary="This table describes the options on the Persistence Properties view, Inheritance tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="23%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t15">Property</th>
-<th align="left" valign="bottom" id="r1c2-t15">Description</th>
-<th align="left" valign="bottom" id="r1c3-t15">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t15" headers="r1c1-t15">Strategy</td>
-<td align="left" headers="r2c1-t15 r1c2-t15">Specify the strategy to use when mapping a class or class hierarchy:
-<ul>
-<li>
-<p>Single table &ndash; All classes in the hierarchy are mapped to a single table.</p>
-</li>
-<li>
-<p>Joined &ndash; The root of the hierarchy is mapped to a single table; each child maps to its own table.</p>
-</li>
-<li>
-<p>Table per class &ndash; Each class is mapped to a separate table.</p>
-</li>
-</ul>
-<p>This field corresponds to the <code>@Inheritance</code> annotation.</p>
-</td>
-<td align="left" headers="r2c1-t15 r1c3-t15">Single table</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t15" headers="r1c1-t15"><a id="sthref221" name="sthref221"></a><a id="sthref222" name="sthref222"></a>Discriminator Value</td>
-<td align="left" headers="r3c1-t15 r1c2-t15">Specify the discriminator value used to differentiate an entity in this inheritance hierarchy. The value must conform to the specified <span class="bold">Discriminator Type</span>.</td>
-<td align="left" headers="r3c1-t15 r1c3-t15"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t15" headers="r1c1-t15"><a id="sthref223" name="sthref223"></a><a id="sthref224" name="sthref224"></a>Discriminator Column</td>
-<td align="left" headers="r4c1-t15 r1c2-t15">These fields are available when using a <span class="bold">Single</span> or <span class="bold">Joined</span> inheritance strategy.
-<p>This field corresponds to the <code>@DiscriminatorColumn</code> annotation.</p>
-<p>Use the <span class="bold">Details</span> area to define the <span class="bold">Length</span> and <span class="bold">Column definition</span> of this Discriminator Column.</p>
-</td>
-<td align="left" headers="r4c1-t15 r1c3-t15"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t15" headers="r1c1-t15">&nbsp;&nbsp;Name</td>
-<td align="left" headers="r5c1-t15 r1c2-t15">Name of the discriminator column</td>
-<td align="left" headers="r5c1-t15 r1c3-t15"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t15" headers="r1c1-t15">&nbsp;&nbsp;Type</td>
-<td align="left" headers="r6c1-t15 r1c2-t15">Set this field to set the discriminator type to <code>Char</code> or <code>Integer</code> (instead of its default: <code>String</code>). The <span class="bold">Discriminator Value</span> must conform to this type.</td>
-<td align="left" headers="r6c1-t15 r1c3-t15">String</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t15" headers="r1c1-t15">Primary Key Join Columns</td>
-<td align="left" headers="r7c1-t15 r1c2-t15">Use to override the default primary key join columns. Select <span class="bold">Override Default</span>, then click <span class="bold">Add</span> to select new Join Column.
-<p>This field corresponds with @PrimaryKeyJoinColumn annotation.</p>
-</td>
-<td align="left" headers="r7c1-t15 r1c3-t15"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_inheritance.htm#CIHCCCJD">Specifying entity inheritance</a><br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference010.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference010.htm
deleted file mode 100644
index 2993658..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference010.htm
+++ /dev/null
@@ -1,47 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Queries</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Queries" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<div class="sect3"><!-- infolevel="all" infotype="General" --><a id="sthref225" name="sthref225"></a>
-<h1>Queries</h1>
-<p>Use the queries area of the JPA Details view to create named queries and named native queries. Refer to <a href="tasks008.htm#BABIGBGG">"Creating Named Queries"</a> for additional information.</p>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="tasks008.htm#BABIGBGG">Creating Named Queries</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference011.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference011.htm
deleted file mode 100644
index 29121aa..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference011.htm
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Join Table Information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Join Table Information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACBAEBC" name="CACBAEBC"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Join Table Information</h1>
-<p>Use area to specify a mapped column for joining an entity association. By default, the mapping is assumed to have a single join.</p>
-<p>This table lists the fields available on the <span class="gui-object-title">Join Table</span> area in <span class="gui-object-title">the JPA Details</span> view for <a href="tasks015.htm#BABHGEBD">One-to-many mapping</a> and <a href="tasks013.htm#BABEIEGD">Many-to-many mapping</a> mapping types.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Join Table tab." summary="This table describes the options on the Join Table tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="26%" />
-<col width="*" />
-<col width="34%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t17">Property</th>
-<th align="left" valign="bottom" id="r1c2-t17">Description</th>
-<th align="left" valign="bottom" id="r1c3-t17">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t17" headers="r1c1-t17">Name</td>
-<td align="left" headers="r2c1-t17 r1c2-t17">Name of the join table that contains the foreign key column.</td>
-<td align="left" headers="r2c1-t17 r1c3-t17">By default, the name is assumed to be the primary tables associated with the entities concatenated with an underscore.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t17" headers="r1c1-t17"><a id="CACBBDFG" name="CACBBDFG"></a>Join Columns</td>
-<td align="left" headers="r3c1-t17 r1c2-t17"><a id="sthref243" name="sthref243"></a><a id="sthref244" name="sthref244"></a>Specify a mapped column for joining an entity association. This field corresponds to the <code>@JoinColum</code> attribute.
-<p>Select <span class="bold">Override Default</span>, then Add, Edit, or Remove the join columns.</p>
-</td>
-<td align="left" headers="r3c1-t17 r1c3-t17">By default, the mapping is assumed to have a single join.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t17" headers="r1c1-t17">Inverse Join Columns</td>
-<td align="left" headers="r4c1-t17 r1c2-t17">Select <span class="bold">Override Default</span>, then Add, Edit, or Remove the join columns.</td>
-<td align="left" headers="r4c1-t17 r1c3-t17"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="reference028.htm#CACCGEHC">Edit Join Columns Dialog</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference012.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference012.htm
deleted file mode 100644
index 3044cd2..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference012.htm
+++ /dev/null
@@ -1,71 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Join Columns Information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:52Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Join Columns Information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACFCEJC" name="CACFCEJC"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Join Columns Information</h1>
-<p><a id="sthref245" name="sthref245"></a>This table lists the fields available in the <span class="gui-object-title">Join Table</span> area in <span class="gui-object-title">JPA Details</span> view for <a href="tasks014.htm#BABHFAFJ">Many-to-one mapping</a> and <a href="tasks016.htm#BABFHBCJ">One-to-one mapping</a> mapping types.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Join Columns tab." summary="This table describes the options on the Join Columns tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="26%" />
-<col width="*" />
-<col width="34%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t18">Property</th>
-<th align="left" valign="bottom" id="r1c2-t18">Description</th>
-<th align="left" valign="bottom" id="r1c3-t18">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t18" headers="r1c1-t18">Join Column</td>
-<td align="left" headers="r2c1-t18 r1c2-t18"><a id="sthref246" name="sthref246"></a><a id="sthref247" name="sthref247"></a>Specify a mapped column for joining an entity association. This field corresponds to the <code>@JoinColum</code> attribute.
-<p>Select <span class="bold">Override Default</span>, then Add, Edit, or Remove the join columns.</p>
-</td>
-<td align="left" headers="r2c1-t18 r1c3-t18">By default, the mapping is assumed to have a single join.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="reference028.htm#CACCGEHC">Edit Join Columns Dialog</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference013.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference013.htm
deleted file mode 100644
index 5c497af..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference013.htm
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>General information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:53Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="General information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACCACGH" name="CACCACGH"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>General information</h1>
-<p>This table lists the General information fields available in the <span class="gui-object-title">JPA Details</span> view for each entity type.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Persistence Properties view, General tab." summary="This table describes the options on the Persistence Properties view, General tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="21%" />
-<col width="*" />
-<col width="22%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t20">Property</th>
-<th align="left" valign="bottom" id="r1c2-t20">Description</th>
-<th align="left" valign="bottom" id="r1c3-t20">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t20" headers="r1c1-t20">Package</td>
-<td align="left" headers="r2c1-t20 r1c2-t20">The Java package that contains the persistent entities. Click <span class="bold">Browse</span> and select the package</td>
-<td align="left" headers="r2c1-t20 r1c3-t20"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t20" headers="r1c1-t20">Schema</td>
-<td align="left" headers="r3c1-t20 r1c2-t20">The database schema that contains the <span class="bold">Table</span>.
-<p>This field corresponds to the <code>&lt;schema&gt;</code> element in the <code>orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r3c1-t20 r1c3-t20"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t20" headers="r1c1-t20">Catalog</td>
-<td align="left" headers="r4c1-t20 r1c2-t20">The database catalog that contains the <span class="bold">Table</span>.
-<p>This field corresponds to the <code>&lt;catalog&gt;</code> element in the <code>orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r4c1-t20 r1c3-t20"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t20" headers="r1c1-t20">Access</td>
-<td align="left" headers="r5c1-t20 r1c2-t20">Specify the default access method for the variables in the project:
-<ul>
-<li>
-<p>Property</p>
-</li>
-<li>
-<p>Field</p>
-</li>
-</ul>
-<p>This field corresponds to the <code>&lt;access&gt;</code> element in the <code>orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r5c1-t20 r1c3-t20"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference014.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference014.htm
deleted file mode 100644
index a865b91..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference014.htm
+++ /dev/null
@@ -1,106 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Persistence Unit information</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:53Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Persistence Unit information" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACEAGBG" name="CACEAGBG"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Persistence Unit information</h1>
-<p>This table lists the Persistence Unit information fields available in the <span class="gui-object-title">JPA Details</span> view for each entity type. These fields are contained in the <code>&lt;persistence-unit-metadata&gt;</code> element in the <code>orm.xml</code> file.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Persistence Properties view, General tab." summary="This table describes the options on the Persistence Properties view, General tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="21%" />
-<col width="*" />
-<col width="22%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t21">Property</th>
-<th align="left" valign="bottom" id="r1c2-t21">Description</th>
-<th align="left" valign="bottom" id="r1c3-t21">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t21" headers="r1c1-t21">XML Mapping Data Complete</td>
-<td align="left" headers="r2c1-t21 r1c2-t21">Specifies that the Java classes in this persistence unit are fully specified by their metadata. Any annotations will be ignored.
-<p>This field corresponds to the <code>&lt;xml-mapping-metadata-complete&gt;</code> element in the <code>orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r2c1-t21 r1c3-t21"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t21" headers="r1c1-t21">Cascade Persist</td>
-<td align="left" headers="r3c1-t21 r1c2-t21">Adds cascade-persist to the set of cascade options in entity relationships of the persistence unit.
-<p>This field corresponds to the <code>&lt;cascade-persist&gt;</code> element in the <code>orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r3c1-t21 r1c3-t21"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t21" headers="r1c1-t21">Schema</td>
-<td align="left" headers="r4c1-t21 r1c2-t21">The database schema that contains the <span class="bold">Table</span>.
-<p>This field corresponds to the <code>&lt;schema&gt;</code> element in the <code>orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r4c1-t21 r1c3-t21"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t21" headers="r1c1-t21">Catalog</td>
-<td align="left" headers="r5c1-t21 r1c2-t21">The database catalog that contains the <span class="bold">Table</span>.
-<p>This field corresponds to the <code>&lt;catalog&gt;</code> element in the <code>orm.xml</code> file.</p>
-</td>
-<td align="left" headers="r5c1-t21 r1c3-t21"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t21" headers="r1c1-t21">Access</td>
-<td align="left" headers="r6c1-t21 r1c2-t21">Specify how the entity its access instance variables.
-<ul>
-<li>
-<p>Property &ndash; Persistent state accessed through the property accessor methods. The property accessor methods must be <span class="bold">public</span> or <span class="bold">private</span>.</p>
-</li>
-<li>
-<p>Field &ndash; Instance variables are accessed directly. All non-transient instance variables are persistent.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r6c1-t21 r1c3-t21">Property</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference015.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference015.htm
deleted file mode 100644
index b09ee51..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference015.htm
+++ /dev/null
@@ -1,116 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Generators</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:53Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Generators" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAFGAIJ" name="CIAFGAIJ"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Generators</h1>
-<p>This table lists the Generator information fields available in the <span class="gui-object-title">JPA Details</span> view for the <code>orm.xml</code> file.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Persistence Properties view, General tab." summary="This table describes the options on the Persistence Properties view, General tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="21%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t22">Property</th>
-<th align="left" valign="bottom" id="r1c2-t22">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t22" headers="r1c1-t22">Generator</td>
-<td align="left" headers="r2c1-t22 r1c2-t22">Displays the existing Sequence and Table generators.
-<p>Click <span class="bold">Add Sequence</span> or <span class="bold">Add Table</span> to add a new generator.</p>
-<p>For sequence generators, you must complete the following fields:</p>
-<ul>
-<li>
-<p>Name</p>
-</li>
-<li>
-<p>Sequence</p>
-</li>
-<li>
-<p>Schema</p>
-</li>
-<li>
-<p>Catalog</p>
-</li>
-<li>
-<p>Allocation size</p>
-</li>
-<li>
-<p>Initial value</p>
-</li>
-</ul>
-<p>For table generators, you must complete the following fields:</p>
-<ul>
-<li>
-<p>Name</p>
-</li>
-<li>
-<p>Table</p>
-</li>
-<li>
-<p>Schema</p>
-</li>
-<li>
-<p>Catalog</p>
-</li>
-<li>
-<p>Primary key column</p>
-</li>
-<li>
-<p>Value column</p>
-</li>
-<li>
-<p>Primary key column value</p>
-</li>
-<li>
-<p>Allocation size</p>
-</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_details_orm.htm#CACGDGHC">JPA Details view (for orm.xml)</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference016.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference016.htm
deleted file mode 100644
index 757aa6f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference016.htm
+++ /dev/null
@@ -1,76 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Queries</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:53Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Queries" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAIBAAJ" name="CIAIBAAJ"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Queries</h1>
-<p>This table lists the Query information fields available in the <span class="gui-object-title">JPA Details</span> view for the <code>orm.xml</code> file.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Persistence Properties view, General tab." summary="This table describes the options on the Persistence Properties view, General tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="21%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t23">Property</th>
-<th align="left" valign="bottom" id="r1c2-t23">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t23" headers="r1c1-t23">Queries</td>
-<td align="left" headers="r2c1-t23 r1c2-t23">Displays the existing Named and Native queries.
-<p>Click <span class="bold">Add</span> to add a named query, or <span class="bold">Add Native</span> for a native query.</p>
-<p>For named queries, enter the query in the Query field.</p>
-<p>For native queries, select a result class, then enter the query in the Query field.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t23" headers="r1c1-t23">Query Hints</td>
-<td align="left" headers="r3c1-t23 r1c2-t23">Displays the existing query hints (Name and Value).
-<p>Click <span class="bold">Add</span> to add a new query hint.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="tasks008.htm#BABIGBGG">Creating Named Queries</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_details_orm.htm#CACGDGHC">JPA Details view (for orm.xml)</a></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference017.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference017.htm
deleted file mode 100644
index ead2b2d..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference017.htm
+++ /dev/null
@@ -1,46 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Converters</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:53Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Converters" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIADGCID" name="CIADGCID"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Converters</h1>
-<p>The Converters information in the JPA Details view applies only when using EclipseLink</p>
-<p>Click <span class="bold">Add</span> to create a new converter, using the <a href="ref_add_converter.htm#CIAGCGIJ">Add Converter dialog</a>.</p>
-<p>&nbsp;</p>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_details_orm.htm#CACGDGHC">JPA Details view (for orm.xml)</a></div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference018.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference018.htm
deleted file mode 100644
index 4d2d6b1..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference018.htm
+++ /dev/null
@@ -1,183 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Connection</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Connection" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAFFJIE" name="CIAFFJIE"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Connection</h1>
-<p>The following table lists the properties available in the Connection page of the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>.</p>
-<div class="tblformal"><a id="sthref257" name="sthref257"></a><a id="sthref258" name="sthref258"></a>
-<p class="titleintable">Properties of the Connection Page</p>
-<table class="Formal" title="Properties of the Connection Page" summary="This table lists the properties for the persistence.xml editor&rsquo;s connection page." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="24%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t25">Property</th>
-<th align="left" valign="bottom" id="r1c2-t25">Description</th>
-<th align="left" valign="bottom" id="r1c3-t25">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t25" headers="r1c1-t25">
-<p>Transaction Type</p>
-</td>
-<td align="left" headers="r2c1-t25 r1c2-t25">
-<p>Specify if the connection for this persistence unit uses one of the following transaction types:</p>
-<ul>
-<li>
-<p><span class="bold">Default</span> -- Select to use the container used by the container.</p>
-</li>
-<li>
-<p><span class="bold">JTA</span> (Java Transaction API) -- Transactions of the Java EE server.</p>
-</li>
-<li>
-<p><span class="bold">Resource Local</span> -- Native actions of a JDBC driver that are referenced by a persistence unit.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r2c1-t25 r1c3-t25"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t25" headers="r1c1-t25">
-<p>Batch Writing</p>
-</td>
-<td align="left" headers="r3c1-t25 r1c2-t25">
-<p>Specify the use of batch writing to optimize transactions with multiple write operations.</p>
-<p>Set the value of this property into the session at deployment time.</p>
-<p>Note: This property applies when used both in a Java SE and Java EE environment.</p>
-<p>The following are the valid values for oracle.toplink.config.BatchWriting:</p>
-<ul>
-<li>
-<p><span class="bold">JDBC</span>&ndash;Use JDBC batch writing.</p>
-</li>
-<li>
-<p><span class="bold">Buffered</span>&ndash;Do not use either JDBC batch writing nor native platform batch writing.</p>
-</li>
-<li>
-<p><span class="bold">OracleJDBC</span>&ndash;Use both JDBC batch writing and Oracle native platform batch writing.</p>
-</li>
-<li>
-<p><span class="bold">None</span>&ndash;Do not use batch writing (turn it off).</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r3c1-t25 r1c3-t25">
-<p>None</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t25" headers="r1c1-t25">
-<p>Statement caching</p>
-</td>
-<td align="left" headers="r4c1-t25 r1c2-t25"><br /></td>
-<td align="left" headers="r4c1-t25 r1c3-t25"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t25" headers="r1c1-t25">
-<p>Native SQL</p>
-</td>
-<td align="left" headers="r5c1-t25 r1c2-t25"><br /></td>
-<td align="left" headers="r5c1-t25 r1c3-t25">
-<p>False</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t25" headers="r1c1-t25">
-<p>JTA Data Source Name</p>
-</td>
-<td align="left" headers="r6c1-t25 r1c2-t25">
-<p>If you selected <span class="bold">JTA</span> as the transaction type, then enter the name of the default JTA data source for the persistence unit.</p>
-</td>
-<td align="left" headers="r6c1-t25 r1c3-t25"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t25" headers="r1c1-t25">
-<p>Non-JTA Data Source Name</p>
-</td>
-<td align="left" headers="r7c1-t25 r1c2-t25">
-<p>If you selected <span class="bold">Resource Local</span> as the transaction type, then enter the name of the non-JTA data source.</p>
-<p>This property is not available for projects using the Generic platform.</p>
-</td>
-<td align="left" headers="r7c1-t25 r1c3-t25"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t25" headers="r1c1-t25">
-<p>&nbsp;&nbsp;Bind&nbsp;Parameters</p>
-</td>
-<td align="left" headers="r8c1-t25 r1c2-t25">
-<p>Control whether or not the query uses parameter binding.</p>
-<p>Note: This property applies when used in a Java SE environment.</p>
-<p>This property is not available for projects using the Generic platform.</p>
-</td>
-<td align="left" headers="r8c1-t25 r1c3-t25"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t25" headers="r1c1-t25">
-<p>EclipseLink Connection Pool</p>
-</td>
-<td align="left" headers="r9c1-t25 r1c2-t25">
-<p>Define the connection pool driver, URL, user name and password.</p>
-<p>These properties are note available for projects using the Generic platform.</p>
-</td>
-<td align="left" headers="r9c1-t25 r1c3-t25"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r10c1-t25" headers="r1c1-t25">
-<p>&nbsp;&nbsp;Read&nbsp;Connection</p>
-</td>
-<td align="left" headers="r10c1-t25 r1c2-t25">
-<p>The maximum and minimum number of connections allowed in the JDBC read connection pool.</p>
-<p>Note: These property apply when used in a Java SE environment.</p>
-<p>These properties are not available for projects using the Generic platform</p>
-</td>
-<td align="left" headers="r10c1-t25 r1c3-t25"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r11c1-t25" headers="r1c1-t25">
-<p>&nbsp;&nbsp;Write&nbsp;Connection</p>
-</td>
-<td align="left" headers="r11c1-t25 r1c2-t25">
-<p>The maximum and minimum number of connections allowed in the JDBC read connection pool.</p>
-<p>Note: These property apply when used in a Java SE environment.</p>
-<p>These properties are not available for projects using the Generic platform</p>
-</td>
-<td align="left" headers="r11c1-t25 r1c3-t25"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" --></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference019.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference019.htm
deleted file mode 100644
index 2472d99..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference019.htm
+++ /dev/null
@@ -1,221 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Customization</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Customization" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAJAFEG" name="CIAJAFEG"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Customization</h1>
-<p>The following table lists the properties available in the Customization page of the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>.</p>
-<div class="tblformal"><a id="sthref259" name="sthref259"></a><a id="sthref260" name="sthref260"></a>
-<p class="titleintable">Properties of the Customization Page</p>
-<table class="Formal" title="Properties of the Customization Page" summary="This table lists the properties of the persistence.xml Editor&rsquo;s Customization page." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="23%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t26">Property</th>
-<th align="left" valign="bottom" id="r1c2-t26">Description</th>
-<th align="left" valign="bottom" id="r1c3-t26">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t26" headers="r1c1-t26">
-<p>Weaving</p>
-</td>
-<td align="left" headers="r2c1-t26 r1c2-t26">
-<p>Specifies if weaving of the entity classes is performed. The EclipseLink JPA persistence provider uses weaving to enhance JPA entities for such properties as lazy loading, change tracking, fetch groups, and internal optimizations. Select from the following options:</p>
-<ul>
-<li>
-<p><span class="bold">No Weaving</span></p>
-</li>
-<li>
-<p><span class="bold">Weave Dynamically</span></p>
-</li>
-<li>
-<p><span class="bold">Weave Statically</span> -- Use this option if you plan to execute your application outside of a Java EE 5 container in an environment that does not permit the use of <code>-javaagent:eclipselink.jar</code> on the JVM command line. This assumes that classes have already been statically woven. Run the static weaver on the classes before deploying them.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r2c1-t26 r1c3-t26">
-<p>Weave Dynamically</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t26" headers="r1c1-t26">
-<p>&nbsp;&nbsp;Weaving&nbsp;Lazy</p>
-</td>
-<td align="left" headers="r3c1-t26 r1c2-t26">
-<p>Select this option to enable lazy weaving.</p>
-</td>
-<td align="left" headers="r3c1-t26 r1c3-t26">
-<p>True</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t26" headers="r1c1-t26">
-<p>&nbsp;&nbsp;Weaving&nbsp;Fetch&nbsp;Groups</p>
-</td>
-<td align="left" headers="r4c1-t26 r1c2-t26">
-<p>Select this option to enable fetch groups through weaving. Set this option to false if:</p>
-<ul>
-<li>
-<p>There is no weaving.</p>
-</li>
-<li>
-<p>Classes should not be changed during weaving (for example, when debugging).</p>
-</li>
-</ul>
-<p>Set this property to false for platforms where it is not supported.</p>
-</td>
-<td align="left" headers="r4c1-t26 r1c3-t26">
-<p>True</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t26" headers="r1c1-t26">
-<p>Weaving&nbsp;internal</p>
-</td>
-<td align="left" headers="r5c1-t26 r1c2-t26"><br /></td>
-<td align="left" headers="r5c1-t26 r1c3-t26">
-<p>True</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t26" headers="r1c1-t26">
-<p>Weaving&nbsp;eager</p>
-</td>
-<td align="left" headers="r6c1-t26 r1c2-t26"><br /></td>
-<td align="left" headers="r6c1-t26 r1c3-t26">
-<p>False</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t26" headers="r1c1-t26">
-<p>&nbsp;&nbsp;Weaving&nbsp;Change&nbsp;Tracking</p>
-</td>
-<td align="left" headers="r7c1-t26 r1c2-t26">
-<p>Select this option to use weaving to detect which fields or properties of the object change.</p>
-</td>
-<td align="left" headers="r7c1-t26 r1c3-t26">
-<p>True</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t26" headers="r1c1-t26">
-<p>&nbsp;&nbsp;Throw&nbsp;Exceptions</p>
-</td>
-<td align="left" headers="r8c1-t26 r1c2-t26">
-<p>Select this option to set EclipseLink to throw an exception or log a warning when it encounters a problem with any of the files listed in a <span class="bold">persistence.xml</span> file <code>&lt;mapping-file&gt;</code> element.</p>
-</td>
-<td align="left" headers="r8c1-t26 r1c3-t26">
-<p>True</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t26" headers="r1c1-t26">
-<p>Exception handler</p>
-</td>
-<td align="left" headers="r9c1-t26 r1c2-t26">
-<p>Select (or create) a Java class to handle exceptions.</p>
-</td>
-<td align="left" headers="r9c1-t26 r1c3-t26"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r10c1-t26" headers="r1c1-t26">
-<p>Session Customizer</p>
-</td>
-<td align="left" headers="r10c1-t26 r1c2-t26">
-<p>Select a session customizer class: a Java class that implements the <code>eclipselink.tools.sessionconfiguration.SessionCustomizer</code> interface and provides a default (zero-argument) constructor. Use this class' <code>customize</code> method, which takes an <code>eclipselink.sessions.Session</code>, to programmatically access advanced EclipseLink session API.</p>
-</td>
-<td align="left" headers="r10c1-t26 r1c3-t26"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r11c1-t26" headers="r1c1-t26">
-<p>Descriptor Customizer</p>
-</td>
-<td align="left" headers="r11c1-t26 r1c2-t26">
-<p>Select an EclipseLink descriptor customizer class&ndash;a Java class that implements the <code>eclipselink.tools.sessionconfiguration.DescriptorCustomizer</code> interface and provides a default (zero-argument) constructor. Use this class's <code>customize</code> method, which takes an <code>eclipselink.descriptors.ClassDescriptor</code>, to programmatically access advanced EclipseLink descriptor and mapping API for the descriptor associated with the JPA entity named <code>&lt;ENTITY&gt;</code>.</p>
-</td>
-<td align="left" headers="r11c1-t26 r1c3-t26"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r12c1-t26" headers="r1c1-t26">
-<p>Validation only</p>
-</td>
-<td align="left" headers="r12c1-t26 r1c2-t26"><br /></td>
-<td align="left" headers="r12c1-t26 r1c3-t26">
-<p>True</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r13c1-t26" headers="r1c1-t26">
-<p>Profiler</p>
-</td>
-<td align="left" headers="r13c1-t26 r1c2-t26">
-<ul>
-<li>
-<p>No Profiler</p>
-</li>
-<li>
-<p>Performance Profiler</p>
-</li>
-<li>
-<p>Query Monitor</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r13c1-t26 r1c3-t26">
-<p>NoProfiler</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" -->
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-This page is not available for projects using the <span class="bold">Generic</span> platform.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference020.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference020.htm
deleted file mode 100644
index 38b7873..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference020.htm
+++ /dev/null
@@ -1,185 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Caching</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Caching" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIABEDCH" name="CIABEDCH"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1><a id="sthref261" name="sthref261"></a>Caching</h1>
-<p>This table lists the properties of the Caching page of the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>.</p>
-<div class="tblformal"><a id="sthref262" name="sthref262"></a><a id="sthref263" name="sthref263"></a>
-<p class="titleintable">Properties of the Caching Page</p>
-<table class="Formal" title="Properties of the Caching Page" summary="This table lists the properties of the persistence.xml&rsquo;s Caching page." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="24%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t28">Property</th>
-<th align="left" valign="bottom" id="r1c2-t28">Description</th>
-<th align="left" valign="bottom" id="r1c3-t28">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t28" headers="r1c1-t28">
-<p>Default Cache Type</p>
-</td>
-<td align="left" headers="r2c1-t28 r1c2-t28">
-<p>Select one of the following as the Default Cache Type:</p>
-<ul>
-<li>
-<p><span class="bold">Soft with Weak Subcache</span>&ndash;This option is similar to <span class="bold">Weak with Hard Subcache</span> except that it maintains a most frequently used subcache that uses soft references. The size of the subcache is proportional to the size of the identity map. The subcache uses soft references to ensure that these objects are garbage-collected only if the system is low on memory.</p>
-<p>Use this identity map in most circumstances as a means to control memory used by the cache.</p>
-</li>
-<li>
-<p><span class="bold">Week with Hard Subcache</span>&ndash;This option is similar to <span class="bold">Soft with Weak</span> subcache except that it maintains a most frequently used subcache that uses hard references. Use this identity map if soft references are not suitable for your platform.</p>
-</li>
-<li>
-<p><span class="bold">Weak</span>&ndash;This option is similar to <span class="bold">Full</span>, except that objects are referenced using weak references. This option uses less memory than <span class="bold">Full</span>, allows complete garbage collection and provides full caching and guaranteed identity.</p>
-<p>Use this identity map for transactions that, once started, stay on the server side.</p>
-</li>
-<li>
-<p><span class="bold">Soft</span>&ndash;This option is similar to <span class="bold">Weak</span> except that the map holds the objects using soft references. This identity map enables full garbage collection when memory is low. It provides full caching and guaranteed identity.</p>
-</li>
-<li>
-<p><span class="bold">Full</span>&ndash;This option provides full caching and guaranteed identity: all objects are cached and not removed.</p>
-<p>Note: This process may be memory-intensive when many objects are read.</p>
-</li>
-<li>
-<p><span class="bold">None</span>&ndash;This option does not preserve object identity and does not cache objects.This option is not recommended.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r2c1-t28 r1c3-t28">
-<p>Weak with soft subcache</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t28" headers="r1c1-t28">
-<p>Default Cache Size</p>
-</td>
-<td align="left" headers="r3c1-t28 r1c2-t28">
-<p>Set the size (maximum number of objects) of the cache.</p>
-</td>
-<td align="left" headers="r3c1-t28 r1c3-t28">
-<p>100</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t28" headers="r1c1-t28">
-<p>Default Shared Cache</p>
-</td>
-<td align="left" headers="r4c1-t28 r1c2-t28">
-<p>Specifies if cached instances should be in the shared cache or in a client isolated cache.</p>
-</td>
-<td align="left" headers="r4c1-t28 r1c3-t28">
-<p>True</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t28" headers="r1c1-t28">
-<p>Entity Caching</p>
-</td>
-<td align="left" headers="r5c1-t28 r1c2-t28">
-<p>Specify the entity-specific caching information.</p>
-</td>
-<td align="left" headers="r5c1-t28 r1c3-t28"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t28" headers="r1c1-t28">
-<p>&nbsp;&nbsp;Cache&nbsp;Type</p>
-</td>
-<td align="left" headers="r6c1-t28 r1c2-t28">
-<p>See <span class="italic">Default Cache Type.</span></p>
-</td>
-<td align="left" headers="r6c1-t28 r1c3-t28"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t28" headers="r1c1-t28">
-<p>&nbsp;&nbsp;Cache&nbsp;Size</p>
-</td>
-<td align="left" headers="r7c1-t28 r1c2-t28">
-<p>See <span class="italic">Default Cache Size.</span></p>
-</td>
-<td align="left" headers="r7c1-t28 r1c3-t28"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t28" headers="r1c1-t28">
-<p>&nbsp;&nbsp;Shared&nbsp;Cache</p>
-</td>
-<td align="left" headers="r8c1-t28 r1c2-t28">
-<p>See <span class="italic">Default Shared Cache</span>.</p>
-</td>
-<td align="left" headers="r8c1-t28 r1c3-t28"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t28" headers="r1c1-t28">
-<p>Flush clear cache</p>
-</td>
-<td align="left" headers="r9c1-t28 r1c2-t28">
-<p>Select one of the following as the Default Cache Type:</p>
-<ul>
-<li>
-<p><span class="bold">Drop</span> &ndash; This mode is the fastest and uses the least memory. However, after commit the shared cache might potentially contain stale data.</p>
-</li>
-<li>
-<p><span class="bold">Drop Invalidate</span> &ndash; Classes that have at least one object updated or deleted are invalidated in the shared cache at commit time. This mode is slower than <span class="bold">Drop</span>, but as efficient memory usage-wise, and prevents stale data.</p>
-</li>
-<li>
-<p><span class="bold">Merge</span> &ndash; Drop classes from the EntityManager's cache of objects that have not been flushed. This mode leaves the shared cache in a perfect state after commit. However, it is the least memory-efficient mode; the memory might even run out in a very large transaction.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r9c1-t28 r1c3-t28">
-<p>Drop Invalidate</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" -->
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-This page is not available for projects using the <span class="bold">Generic</span> platform.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference021.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference021.htm
deleted file mode 100644
index 9c8f31c..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference021.htm
+++ /dev/null
@@ -1,241 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Logging</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Logging" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIABGHHI" name="CIABGHHI"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Logging</h1>
-<p>This table lists the properties of the Logging page of the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-This page is not available for projects using the <span class="bold">Generic</span> platform.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-<div class="tblformal"><a id="sthref264" name="sthref264"></a><a id="sthref265" name="sthref265"></a>
-<p class="titleintable">Properties of the Logging Page</p>
-<table class="Formal" title="Properties of the Logging Page" summary="This table lists the properties of the Logging page of the persistence.xml Editor." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="24%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t31">Property</th>
-<th align="left" valign="bottom" id="r1c2-t31">Description</th>
-<th align="left" valign="bottom" id="r1c3-t31">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t31" headers="r1c1-t31">
-<p>Logging Level</p>
-</td>
-<td align="left" headers="r2c1-t31 r1c2-t31">
-<p>Specifies the amount and detail of log output by selecting the log level (in ascending order of information):</p>
-<p>The following are the valid values for the <code>java.util.logging.Level</code>:</p>
-<ul>
-<li>
-<p><span class="bold">OFF</span>&ndash;disables logging</p>
-</li>
-<li>
-<p><span class="bold">SEVERE</span>&ndash;logs exceptions indicating TopLink cannot continue, as well as any exceptions generated during login. This includes a stack trace.</p>
-</li>
-<li>
-<p><span class="bold">WARNING</span>&ndash;logs exceptions that do not force TopLink to stop, including all exceptions not logged with severe level. This does not include a stack trace.</p>
-</li>
-<li>
-<p><span class="bold">INFO</span>&ndash;logs the login/logout per sever session, including the user name. After acquiring the session, detailed information is logged.</p>
-</li>
-<li>
-<p><span class="bold">CONFIG</span>&ndash;logs only login, JDBC connection, and database information.</p>
-</li>
-<li>
-<p><span class="bold">FINE</span>&ndash;logs SQL.</p>
-</li>
-<li>
-<p><span class="bold">FINER</span>&ndash;similar to warning. Includes stack trace.</p>
-</li>
-<li>
-<p><span class="bold">FINEST</span>&ndash;includes additional low level information.</p>
-</li>
-</ul>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.logging.level" value="INFO"/&gt;
-</pre></td>
-<td align="left" headers="r2c1-t31 r1c3-t31">
-<p>Info</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t31" headers="r1c1-t31">
-<p>&nbsp;&nbsp;Timestamp</p>
-</td>
-<td align="left" headers="r3c1-t31 r1c2-t31">
-<p>Control whether the timestamp is logged in each log entry.</p>
-<p>The following are the valid values:</p>
-<ul>
-<li>
-<p><span class="bold">true</span>&ndash;log a timestamp.</p>
-</li>
-<li>
-<p><span class="bold">false</span>&ndash;do not log a timestamp.</p>
-</li>
-</ul>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.logging.timestamp" value="false"/&gt;
-</pre></td>
-<td align="left" headers="r3c1-t31 r1c3-t31">
-<p>true</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t31" headers="r1c1-t31">
-<p>&nbsp;&nbsp;Thread</p>
-</td>
-<td align="left" headers="r4c1-t31 r1c2-t31">
-<p>Control whether a thread identifier is logged in each log entry.</p>
-<p>The following are the valid values:</p>
-<ul>
-<li>
-<p><span class="bold">true</span>&ndash;log a thread identifier.</p>
-</li>
-<li>
-<p><span class="bold">false</span>&ndash;do not log a thread identifier.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r4c1-t31 r1c3-t31">
-<p>true</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t31" headers="r1c1-t31">
-<p>&nbsp;&nbsp;Session</p>
-</td>
-<td align="left" headers="r5c1-t31 r1c2-t31">
-<p>Control whether an EclipseLink session identifier is logged in each log entry.</p>
-<p>The following are the valid values:</p>
-<ul>
-<li>
-<p><span class="bold">true</span>&ndash;log a EclipseLink session identifier.</p>
-</li>
-<li>
-<p><span class="bold">false</span>&ndash;do not log a EclipseLink session identifier.</p>
-</li>
-</ul>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.logging.session" value="false"/&gt;
-</pre></td>
-<td align="left" headers="r5c1-t31 r1c3-t31">
-<p>true</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t31" headers="r1c1-t31">
-<p>&nbsp;&nbsp;Exceptions</p>
-</td>
-<td align="left" headers="r6c1-t31 r1c2-t31">
-<p>Control whether the exceptions thrown from within the EclipseLink code are logged prior to returning the exception to the calling application. Ensures that all exceptions are logged and not masked by the application code.</p>
-<p>The following are the valid values:</p>
-<ul>
-<li>
-<p><span class="bold">true</span>&ndash;log all exceptions.</p>
-</li>
-<li>
-<p><span class="bold">false</span>&ndash;do not log exceptions.</p>
-</li>
-</ul>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.logging.exceptions" value="true"/&gt;
-</pre></td>
-<td align="left" headers="r6c1-t31 r1c3-t31">
-<p>false</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t31" headers="r1c1-t31">
-<p>Log file</p>
-</td>
-<td align="left" headers="r7c1-t31 r1c2-t31">
-<p>Specify a file location for the log output (instead of the standard out).</p>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.logging.file" value="C:\myout\" /&gt;
-</pre></td>
-<td align="left" headers="r7c1-t31 r1c3-t31"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t31" headers="r1c1-t31">
-<p>Logger</p>
-</td>
-<td align="left" headers="r8c1-t31 r1c2-t31">
-<p>Select the type of logger to use:</p>
-<p>The following are the valid values:</p>
-<ul>
-<li>
-<p><span class="bold">DefaultLogger</span>&ndash;the EclipseLink native logger <code>eclipselink.logging.DefaultSessionLog</code>.</p>
-</li>
-<li>
-<p><span class="bold">JavaLogger</span>&ndash;the <code>java.util.logging</code> logger <code>eclipselink.logging.JavaLog</code>.</p>
-</li>
-<li>
-<p><span class="bold">ServerLogger</span>&ndash;the <code>java.util.logging</code> logger <code>eclipselink.platform.server.ServerLog</code>. Integrates with the application server's logging as define in the <code>eclipselink.platform.server.ServerPlatform.</code></p>
-</li>
-<li>
-<p>Fully qualified class name of a custom logger. The custom logger must implement the <code>eclipselink.logging.SessionLog</code> interface.</p>
-</li>
-</ul>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.logging.logger" value="acme.loggers.MyCustomLogger" /&gt;
-</pre></td>
-<td align="left" headers="r8c1-t31 r1c3-t31">
-<p>DefaultLogger</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" --></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference022.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference022.htm
deleted file mode 100644
index a072a40..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference022.htm
+++ /dev/null
@@ -1,170 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Options</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Options" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAFJCHE" name="CIAFJCHE"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Options</h1>
-<p>This table lists the properties of the Options page of the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-This page is not available for projects using the <span class="bold">Generic</span> platform.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-<div class="tblformal"><a id="sthref266" name="sthref266"></a><a id="sthref267" name="sthref267"></a>
-<p class="titleintable">Properties of the Options Page</p>
-<table class="Formal" title="Properties of the Options Page" summary="Properties of the Options Page" dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="24%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t33">Property</th>
-<th align="left" valign="bottom" id="r1c2-t33">Description</th>
-<th align="left" valign="bottom" id="r1c3-t33">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t33" headers="r1c1-t33">
-<p>Session Name</p>
-</td>
-<td align="left" headers="r2c1-t33 r1c2-t33">
-<p>Specify the name by which the EclipseLink session is stored in the static session manager. Use this option if you need to access the EclipseLink shared session outside of the context of the JPA or to use a pre-existing EclipseLink session configured through a EclipseLink <code>sessions.xml</code> file</p>
-<p>Valid values: a valid EclipseLink session name that is unique in a server deployment.</p>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.session-name" value="MySession"/&gt;
-</pre></td>
-<td align="left" headers="r2c1-t33 r1c3-t33"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t33" headers="r1c1-t33">
-<p>Sessions XML</p>
-</td>
-<td align="left" headers="r3c1-t33 r1c2-t33">
-<p>Specify persistence information loaded from the EclipseLink session configuration file (<code>sessions.xml</code>).</p>
-<p>You can use this option as an alternative to annotations and deployment XML. If you specify this property, EclipseLink will override all class annotation and the object relational mapping from the <code>persistence.xml</code>, as well as <code>ORM.xml</code> and other mapping files, if present.</p>
-<p>Indicate the session by setting the <code>eclipselink.session-name</code> property.</p>
-<p>Note: If you do not specify the value for this property, <code>sessions.xml</code> file will not be used.</p>
-<p>Valid values: the resource name of the sessions XML file.</p>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="toplink.session-xml" value="mysession.xml"/&gt;
-</pre></td>
-<td align="left" headers="r3c1-t33 r1c3-t33"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t33" headers="r1c1-t33">
-<p>Target Database</p>
-</td>
-<td align="left" headers="r4c1-t33 r1c2-t33">
-<p>Select the target database. You can also set the value to the fully qualified class name of a subclass of the <code>org.eclipse.persistence.platform.DatabasePlatform class</code>.</p>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.target-database" value="Oracle"/&gt;
-</pre></td>
-<td align="left" headers="r4c1-t33 r1c3-t33">
-<p>Auto</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t33" headers="r1c1-t33">
-<p>Target Server</p>
-</td>
-<td align="left" headers="r5c1-t33 r1c2-t33">
-<p>Select the target server for your JPA application.</p>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.target-server" value="OC4J_10_1_3"/&gt;
-</pre></td>
-<td align="left" headers="r5c1-t33 r1c3-t33">
-<p>None</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t33" headers="r1c1-t33">
-<p>Event Listener</p>
-</td>
-<td align="left" headers="r6c1-t33 r1c2-t33">
-<p>Specify a descriptor event listener to be added during bootstrapping.</p>
-<p>Valid values: qualified class name for a class that implements the <code>eclipselink.sessions.SessionEventListener</code> interface.</p>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.session-event-listener" value="mypackage.MyClass.class"/&gt;
-</pre></td>
-<td align="left" headers="r6c1-t33 r1c3-t33"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t33" headers="r1c1-t33">
-<p>Include Descriptor Queries</p>
-</td>
-<td align="left" headers="r7c1-t33 r1c2-t33">
-<p>Enable or disable the default copying of all named queries from the descriptors to the session. These queries include the ones defined using EclipseLink API, descriptor amendment methods, and so on.</p>
-</td>
-<td align="left" headers="r7c1-t33 r1c3-t33"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t33" headers="r1c1-t33">
-<p>Miscellaneous Options</p>
-</td>
-<td align="left" headers="r8c1-t33 r1c2-t33"><br /></td>
-<td align="left" headers="r8c1-t33 r1c3-t33"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t33" headers="r1c1-t33">
-<p>&nbsp;&nbsp;Temporal mutable</p>
-</td>
-<td align="left" headers="r9c1-t33 r1c2-t33">
-<p>Specify if all <code>Date</code> and <code>Calendar</code> persistent fields should be handled as mutable objects.</p>
-<p><span class="bold">Example</span>: <code>persistence.xml</code> file</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;property name="eclipselink.temporal.mutable" value="true"/&gt;
-</pre></td>
-<td align="left" headers="r9c1-t33 r1c3-t33">
-<p>False</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" --></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference023.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference023.htm
deleted file mode 100644
index b518149..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference023.htm
+++ /dev/null
@@ -1,143 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Schema Generation</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Schema Generation" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIACCFCB" name="CIACCFCB"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Schema Generation</h1>
-<p>This table lists the properties of the Schema Generation page of the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-This page is not available for projects using the <span class="bold">Generic</span> platform.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-<div class="tblformal"><a id="sthref268" name="sthref268"></a><a id="sthref269" name="sthref269"></a>
-<p class="titleintable">&nbsp;</p>
-<table class="Formal" title="" summary="This table lists the properties of the persistence.xml Editor&rsquo;s Schema Generation page." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="24%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t35">Property</th>
-<th align="left" valign="bottom" id="r1c2-t35">Description</th>
-<th align="left" valign="bottom" id="r1c3-t35">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t35" headers="r1c1-t35">
-<p>DDL Generation Type</p>
-</td>
-<td align="left" headers="r2c1-t35 r1c2-t35">
-<p>Select the type of DDL generation:</p>
-<ul>
-<li>
-<p><span class="bold">None</span> -- Do not generate DDL; no schema is generated.</p>
-</li>
-<li>
-<p><span class="bold">Create Tables</span> -- Create DDL for non-existent tables; leave existing tables unchanged.</p>
-</li>
-<li>
-<p><span class="bold">Drop and Create Tables</span> -- Create DDL for all tables; drop all existing tables.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r2c1-t35 r1c3-t35">
-<p>None</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t35" headers="r1c1-t35">
-<p>Output Mode</p>
-</td>
-<td align="left" headers="r3c1-t35 r1c2-t35">
-<p>Select the DDL generation target:</p>
-<ul>
-<li>
-<p><span class="bold">Both</span> -- Generate SQL files and execute them on the database.</p>
-</li>
-<li>
-<p><span class="bold">Database</span> -- Execute SQL on the database only (do not generate SQL files).</p>
-</li>
-<li>
-<p><span class="bold">SQL Script</span> -- Generate SQL files only (do not execute them on the database).</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r3c1-t35 r1c3-t35"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t35" headers="r1c1-t35">
-<p>DDL Generation Location</p>
-</td>
-<td align="left" headers="r4c1-t35 r1c2-t35">
-<p>Specify where EclipseLink writes DDL output. Specify a file specification to a directory in which you have write access. The file specification may be relative to your current working directory or absolute. If it does not end in a file separator, then EclipseLink appends one that is valid for your operating system.</p>
-</td>
-<td align="left" headers="r4c1-t35 r1c3-t35"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t35" headers="r1c1-t35">
-<p>Create DDL File Name</p>
-</td>
-<td align="left" headers="r5c1-t35 r1c2-t35">
-<p>Specify the file name of the DDL file that EclipseLink generates that contains SQL statements for creating tables for JPA entities. Specify a file name valid for your operating system.</p>
-</td>
-<td align="left" headers="r5c1-t35 r1c3-t35">
-<p>createDDL.jdbc</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t35" headers="r1c1-t35">
-<p>Drop DDL File Name</p>
-</td>
-<td align="left" headers="r6c1-t35 r1c2-t35">
-<p>Specify the file name of the DDL file that EclipseLink generates that contains SQL statements for dropping tables for JPA entities.</p>
-</td>
-<td align="left" headers="r6c1-t35 r1c3-t35">
-<p>dropDDL.jdbc</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="tblformal" --></div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference024.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference024.htm
deleted file mode 100644
index 6134b4a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference024.htm
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Properties</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Properties" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAHJDFF" name="CIAHJDFF"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Properties</h1>
-<p>This page enables you to add or remove the vendor-specific <code>&lt;properties&gt;</code> elements of <code>persistence.xml</code>.</p>
-<p>To add a property, click <span class="bold">Add</span> then enter the property <span class="bold">Name</span> and <span class="bold">Value</span>.</p>
-</div>
-<!-- class="sect3" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference025.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference025.htm
deleted file mode 100644
index b3cf12f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference025.htm
+++ /dev/null
@@ -1,46 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Source</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Source" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIAHCJAH" name="CIAHCJAH"></a></p>
-<div class="sect3"><!-- infolevel="all" infotype="General" -->
-<h1>Source</h1>
-<p>Using this page, you can manually edit the <code>persistence.xml</code> file.</p>
-<p>See <a href="task_manage_persistence.htm#CIHDAJID">"Managing the persistence.xml file"</a> for additional information.</p>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_manage_persistence.htm#CIHDAJID">Managing the persistence.xml file</a></div>
-<!-- class="sect3" -->
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference026.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference026.htm
deleted file mode 100644
index efff52b..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference026.htm
+++ /dev/null
@@ -1,43 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Preferences</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Preferences" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACDEIEE" name="CACDEIEE"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Preferences</h1>
-<p>This section includes information on the following preference pages:</p>
-<ul>
-<li>
-<p><a href="ref_project_properties.htm#BABJHBCI">Project Properties page &ndash; Java Persistence Options</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference027.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference027.htm
deleted file mode 100644
index a1cb76a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference027.htm
+++ /dev/null
@@ -1,49 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Dialogs</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Dialogs" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACGEJDA" name="CACGEJDA"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Dialogs</h1>
-<p>This section includes information on the following preference pages:</p>
-<ul>
-<li>
-<p><a href="reference028.htm#CACCGEHC">Edit Join Columns Dialog</a></p>
-</li>
-<li>
-<p><a href="ref_select_cascade_dialog.htm#CIAFDGIJ">Select Cascade dialog</a></p>
-</li>
-<li>
-<p><a href="ref_eclipselink_mapping_file.htm#CIAEDEJF">New EclipseLink Mapping File dialog</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference028.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference028.htm
deleted file mode 100644
index 9474b02..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference028.htm
+++ /dev/null
@@ -1,67 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Edit Join Columns Dialog</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Edit Join Columns Dialog" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACCGEHC" name="CACCGEHC"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Edit Join Columns Dialog</h1>
-<p>Use the <span class="gui-object-title">Join Columns</span> dialog to create or modify the join tables and columns in relationship mappings.</p>
-<p>This table lists the properties available in the <span class="gui-object-title">Join Columns</span> dialog.</p>
-<div class="inftblinformal">
-<table class="Informal" title="This table describes the options on the Join Columns dialog." summary="This table describes the options on the Join Columns dialog." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="32%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t37">Property</th>
-<th align="left" valign="bottom" id="r1c2-t37">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t37" headers="r1c1-t37">Name</td>
-<td align="left" headers="r2c1-t37 r1c2-t37">Name of the joint table column that contains the foreign key column.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t37" headers="r1c1-t37">Referenced Column Name</td>
-<td align="left" headers="r3c1-t37 r1c2-t37">Name of the database column that contains the foreign key reference for the entity relationship.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" -->
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="reference011.htm#CACBAEBC">Join Table Information</a><br />
-<a href="reference012.htm#CACFCEJC">Join Columns Information</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference029.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference029.htm
deleted file mode 100644
index 8adb5ae..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference029.htm
+++ /dev/null
@@ -1,46 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Icons and buttons</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Icons and buttons" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACDHCIA" name="CACDHCIA"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Icons and buttons</h1>
-<p>This section includes information on each of the icons and buttons used in the Dali OR Mapping Tool.</p>
-<ul>
-<li>
-<p><a href="reference030.htm#CACGEACG">Icons</a></p>
-</li>
-<li>
-<p><a href="reference031.htm#CACDJCEI">Buttons</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference030.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference030.htm
deleted file mode 100644
index fa07115..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference030.htm
+++ /dev/null
@@ -1,125 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Icons</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:54Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Icons" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACGEACG" name="CACGEACG"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Icons</h1>
-<p>The following icons are used throughout the Dali OR Mapping Tool.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the icons used in the Dali plug-in." summary="This table describes the icons used in the Dali plug-in." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="23%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t40">Icon</th>
-<th align="left" valign="bottom" id="r1c2-t40">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t40" headers="r1c1-t40"><img src="img/new_icon_mappedentity.png" alt="" title="" /><br /></td>
-<td align="left" headers="r2c1-t40 r1c2-t40"><a href="tasks005.htm#BABGBIEE">Entity</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t40" headers="r1c1-t40"><img src="img/new_icon_embeddableentitymapping.png" alt="Embeddable entity icon" title="Embeddable entity icon" /><br /></td>
-<td align="left" headers="r3c1-t40 r1c2-t40"><a href="tasks006.htm#BABFEICE">Embeddable</a> entity</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t40" headers="r1c1-t40"><img src="img/new_icon_mappedsuperclass.png" alt="Mapped superclass icon" title="Mapped superclass icon" /><br /></td>
-<td align="left" headers="r4c1-t40 r1c2-t40"><a href="tasks007.htm#BABDAGCI">Mapped superclass</a></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t40" headers="r1c1-t40"><img src="img/new_icon_basicmappings.png" alt="Basic mapping icon" title="Basic mapping icon" /><br /></td>
-<td align="left" headers="r5c1-t40 r1c2-t40"><a href="tasks009.htm#BABBABCE">Basic mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t40" headers="r1c1-t40"><img src="img/icon_basicmapmappings.png" alt="Basic mapping icon" title="Basic mapping icon" /><br /></td>
-<td align="left" headers="r6c1-t40 r1c2-t40">Basic collection mapping</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t40" headers="r1c1-t40"><img src="img/icon_basicmapping.png" alt="Basic mapping icon" title="Basic mapping icon" /><br /></td>
-<td align="left" headers="r7c1-t40 r1c2-t40">Basic map mapping</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t40" headers="r1c1-t40"><img src="img/new_icon_embeddedidmapping.png" alt="Embedded mapping icon" title="Embedded mapping icon" /><br /></td>
-<td align="left" headers="r8c1-t40 r1c2-t40"><a href="tasks010.htm#BABCBHDF">Embedded mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r9c1-t40" headers="r1c1-t40"><img src="img/new_icon_embeddedmapping.png" alt="Embedded ID mapping icon" title="Embedded ID mapping icon" /><br /></td>
-<td align="left" headers="r9c1-t40 r1c2-t40"><a href="tasks011.htm#CIHDIAEE">Embedded ID mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r10c1-t40" headers="r1c1-t40"><img src="img/new_icon_idmapping.png" alt="ID mapping icon" title="ID mapping icon" /><br /></td>
-<td align="left" headers="r10c1-t40 r1c2-t40"><a href="tasks012.htm#BABGCBHG">ID mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r11c1-t40" headers="r1c1-t40"><img src="img/new_icon_manytomanymapping.png" alt="Many-to-many mapping icon" title="Many-to-many mapping icon" /><br /></td>
-<td align="left" headers="r11c1-t40 r1c2-t40"><a href="tasks013.htm#BABEIEGD">Many-to-many mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r12c1-t40" headers="r1c1-t40"><img src="img/new_icon_manytoonemapping.png" alt="Many-to-one mapping icon." title="Many-to-one mapping icon." /><br /></td>
-<td align="left" headers="r12c1-t40 r1c2-t40"><a href="tasks014.htm#BABHFAFJ">Many-to-one mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r13c1-t40" headers="r1c1-t40"><img src="img/new_icon_onetomanymapping.png" alt="One-to-many mapping icon" title="One-to-many mapping icon" /><br /></td>
-<td align="left" headers="r13c1-t40 r1c2-t40"><a href="tasks015.htm#BABHGEBD">One-to-many mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r14c1-t40" headers="r1c1-t40"><img src="img/new_icon_onetoonemapping.png" alt="One-to-one mapping icon." title="One-to-one mapping icon." /><br /></td>
-<td align="left" headers="r14c1-t40 r1c2-t40"><a href="tasks016.htm#BABFHBCJ">One-to-one mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r15c1-t40" headers="r1c1-t40"><img src="img/icon_basicmapmappings.png" alt="Basic mapping icon" title="Basic mapping icon" /><br /></td>
-<td align="left" headers="r15c1-t40 r1c2-t40">Transformation mappings</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r16c1-t40" headers="r1c1-t40"><img src="img/new_icon_transientmapping.png" alt="Transient mapping icon." title="Transient mapping icon." /><br /></td>
-<td align="left" headers="r16c1-t40 r1c2-t40"><a href="tasks017.htm#BABHFHEI">Transient mapping</a><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r17c1-t40" headers="r1c1-t40"><img src="img/icon_basicmapmappings.png" alt="Basic mapping icon" title="Basic mapping icon" /><br /></td>
-<td align="left" headers="r17c1-t40 r1c2-t40">Variable one-to-one mappings</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r18c1-t40" headers="r1c1-t40"><img src="img/new_icon_versionmapping.png" alt="Version mapping icon." title="Version mapping icon." /><br /></td>
-<td align="left" headers="r18c1-t40 r1c2-t40"><a href="tasks018.htm#BABHIBII">Version mapping</a><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<p><a href="reference029.htm#CACDHCIA">Icons and buttons</a></p>
-</div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference031.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference031.htm
deleted file mode 100644
index 9e497bf..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference031.htm
+++ /dev/null
@@ -1,62 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Buttons</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:55Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Buttons" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACDJCEI" name="CACDJCEI"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Buttons</h1>
-<p>The following buttons are used throughout the Dali OR Mapping Tool.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the buttons used in the Dali plug-in." summary="This table describes the buttons used in the Dali plug-in." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="27%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t41">Icon</th>
-<th align="left" valign="bottom" id="r1c2-t41">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t41" headers="r1c1-t41"><img src="img/new_jpa_perspective_button.png" alt="The JPA Perspective icon" title="The JPA Perspective icon" /><br /></td>
-<td align="left" headers="r2c1-t41 r1c2-t41">JPA Development perspective</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<p><a href="reference029.htm#CACDHCIA">Icons and buttons</a></p>
-</div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/reference032.htm b/jpa/plugins/org.eclipse.jpt.doc.user/reference032.htm
deleted file mode 100644
index 3a91994..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/reference032.htm
+++ /dev/null
@@ -1,53 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Dali Developer Documentation</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Dali Developer Documentation" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CACBBDIB" name="CACBBDIB"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Dali Developer Documentation</h1>
-<p><a id="sthref283" name="sthref283"></a><a id="sthref284" name="sthref284"></a><a id="sthref285" name="sthref285"></a>Additional Dali documentation is available online at:</p>
-<p><code><a href="http://wiki.eclipse.org/index.php/Dali_Developer_Documentation">http://wiki.eclipse.org/index.php/Dali_Developer_Documentation</a></code></p>
-<p>This developer documentation includes information about:</p>
-<ul>
-<li>
-<p>Dali architecture</p>
-</li>
-<li>
-<p>Plugins that comprise the Dali JPA Eclipse feature</p>
-</li>
-<li>
-<p>Extension points</p>
-</li>
-</ul>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/task_add_persistence.htm b/jpa/plugins/org.eclipse.jpt.doc.user/task_add_persistence.htm
deleted file mode 100644
index 777f964..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/task_add_persistence.htm
+++ /dev/null
@@ -1,60 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Adding persistence to a class</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:45Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Adding persistence to a class" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABHICAI" name="BABHICAI"></a></p>
-<div class="sect1">
-<h1>Adding persistence to a class</h1>
-<p><a id="sthref65" name="sthref65"></a><a id="sthref66" name="sthref66"></a><a id="sthref67" name="sthref67"></a>You can make a Java class into one of the following persistent types:</p>
-<ul>
-<li>
-<p><a href="tasks005.htm#BABGBIEE">Entity</a></p>
-</li>
-<li>
-<p><a href="tasks006.htm#BABFEICE">Embeddable</a></p>
-</li>
-<li>
-<p><a href="tasks007.htm#BABDAGCI">Mapped superclass</a></p>
-</li>
-</ul>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related tasks" title="Related tasks" /><br />
-<br />
-<a href="task_additonal_tables.htm#CIHGBIEI">Specifying additional tables</a><br />
-<a href="task_inheritance.htm#CIHCCCJD">Specifying entity inheritance</a><br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_persistence.htm#BABCAHIC">Understanding Java persistence</a><br />
-<a href="concepts003.htm#CHDBIJAC">The orm.xml file</a><br />
-<a href="concepts002.htm#CHDHAGIH">The persistence.xml file</a> <!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/task_additonal_tables.htm b/jpa/plugins/org.eclipse.jpt.doc.user/task_additonal_tables.htm
deleted file mode 100644
index 65b9d2e..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/task_additonal_tables.htm
+++ /dev/null
@@ -1,84 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Specifying additional tables</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:45Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Specifying additional tables" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHGBIEI" name="CIHGBIEI"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Specifying additional tables</h1>
-<p>Add a secondary table annotation to an entity if its data is split across more than one table.</p>
-<p>To add a secondary table to the entity,</p>
-<ol>
-<li>
-<p>Select the entity in the <span class="gui-object-title">Project Explorer</span>.</p>
-</li>
-<li>
-<p>In the <span class="gui-object-title">JPA Details</span> view, select the <span class="gui-object-action">Secondary Tables</span> information.</p>
-<div class="figure"><a id="sthref90" name="sthref90"></a>
-<p class="titleinfigure">Specifying Secondary Tables</p>
-<img src="img/secondary_tables.png" alt="Secondary Tables area on the JPA Details view." title="Secondary Tables area on the JPA Details view." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Click <span class="bold">Add</span> to associate an additional table with the entity. The Edit Secondary Table dialog appears</p>
-</li>
-<li>
-<p>Select the <span class="bold">Name</span>, <span class="bold">Catalog</span>, and <span class="bold">Schema</span> of the additional table to associate with the entity.</p>
-</li>
-</ol>
-<p>Eclipse adds the following annotations the entity:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@SecondaryTable(name="NAME", catalog = "CATALOG", schema = "SCHEMA")
-
-</pre>
-<p>To override the default primary key:</p>
-<ol>
-<li>
-<p>Enable the <span class="bold">Overwrite default</span> option, then click <span class="bold">Add</span> to specify a new primary key join column. The Create New Primary Key Join Column appears.</p>
-</li>
-<li>
-<p>Select the <span class="bold">Name</span>, <span class="bold">Referenced column name</span>, <span class="bold">Table</span>, and <span class="bold">Column definition</span> of the primary key for the entity.</p>
-<p>Eclipse adds the following annotations the entity:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@SecondaryTable(name="NAME", catalog = "CATALOG", schema = "SCHEMA", pkJoinColumns = {@PrimaryKeyJoinColumn(name="id", referencedColumnName = "id"),@PrimaryKeyJoinColumn(name="NAME", referencedColumnName = "REFERENCED COLUMN NAME", columnDefinition = "COLUMN DEFINITION")})
-
-</pre></li>
-</ol>
-<br />
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_persistence.htm#BABCAHIC">Understanding Java persistence</a><br /></div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/task_create_jpa_entity.htm b/jpa/plugins/org.eclipse.jpt.doc.user/task_create_jpa_entity.htm
deleted file mode 100644
index 8684a7f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/task_create_jpa_entity.htm
+++ /dev/null
@@ -1,160 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Creating a JPA Entity</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:43Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Creating a JPA Entity" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABFBJBG" name="BABFBJBG"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1><a id="sthref40" name="sthref40"></a>Creating a JPA Entity</h1>
-<p>Use this procedure to create a JPA entity:</p>
-<ol>
-<li>
-<p>From the Navigator or Project Explorer, select the JPA project and then <span class="bold">File &gt; New &gt; Other</span>. The Select a Wizard dialog appears.</p>
-<div class="figure"><a id="sthref41" name="sthref41"></a>
-<p class="titleinfigure">Selecting the Create a JPA Entity Wizard</p>
-<img src="img/select_a_wizard_entity.png" alt="The Select a Wizard dialog with Entity selected." title="The Select a Wizard dialog with Entity selected." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Select <span class="bold">JPA &gt; Entity</span> and then click <span class="bold">Next</span>. The <a href="ref_EntityClassPage.htm#CIAFEIGF">Entity Class page</a> appears.</p>
-<div class="figure"><a id="sthref42" name="sthref42"></a>
-<p class="titleinfigure"><a id="sthref43" name="sthref43"></a>The Entity Class Page</p>
-<img src="img/create_jpa_entity_wizard.png" alt="The Entity Class page of the Create a JPA Entity wizard." title="The Entity Class page of the Create a JPA Entity wizard." /><br /></div>
-<!-- class="figure" -->
-<p>Complete this page as follows:</p>
-<ul>
-<li>
-<p>Select the JPA project in the <span class="bold">Project</span> field.</p>
-</li>
-<li>
-<p>In the <span class="bold">Source Folder</span> field, select, or enter, the location of the JPA project's <code>src</code> folder.</p>
-</li>
-<li>
-<p>Select, or enter, the name of the class package for this entity in the <span class="bold">Java Package</span> field.</p>
-</li>
-<li>
-<p>Enter the name of the Java class in the <span class="bold">Class name</span> field.</p>
-</li>
-<li>
-<p>If needed, enter, or select a superclass.</p>
-</li>
-<li>
-<p>If needed, complete the Inheritance section as follows (these properties are optional):</p>
-<ul>
-<li>
-<p>Accept the <span class="bold">Entity</span> option (the default) to create a Java class with the <code>@Entity</code> option.</p>
-</li>
-<li>
-<p>Alternatively, select <a href="tasks007.htm#BABDAGCI">Mapped superclass</a> (if you defined a super class).</p>
-</li>
-<li>
-<p>Select <span class="bold">Inheritance</span> and then select one of the JSR 220 inheritance mapping strategies (SINGLE_TABLE, TABLE_PER_CLASS, JOINED).</p>
-</li>
-<li>
-<p>Select <span class="bold">Add to entity mappings in XML</span> to create XML mappings in <code>orm.xml</code>, rather than annotations.</p>
-</li>
-</ul>
-</li>
-</ul>
-</li>
-<li>
-<p>Click <span class="bold">Next</span> to proceed to the <a href="ref_EntityPropertiesPage.htm#CIADECIA">Entity Properties page</a> where you define the persistent fields for the entity.</p>
-<div class="figure"><a id="sthref44" name="sthref44"></a>
-<p class="titleinfigure"><a id="sthref45" name="sthref45"></a>The Entity Properties Page</p>
-<img src="img/create_jpa_fields.png" alt="The Entity Properties page of the Create JPA Entity wizard." title="The Entity Properties page of the Create JPA Entity wizard." /><br /></div>
-<!-- class="figure" -->
-<p>Alternatively, click <span class="bold">Finish</span> to complete the entity.</p>
-</li>
-<li>
-<p>Complete the page as follows:</p>
-<ol>
-<li>
-<p>If needed, enter a new name for the entity. Doing so results in adding a <code>name</code> attribute to the <code>@Entity</code> notation (<code>@Entity(name="EntityName")</code>).</p>
-</li>
-<li>
-<p>Accept <span class="bold">Use default</span> (the default setting) to use the default value for the name of the mapped table. Entering a different name results in adding the <code>@Table</code> notation with its <code>name</code> attribute defined as the new table (<code>@Table(name="TableName")</code>).</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-The Entity Name-related options are not available if you selected <a href="tasks007.htm#BABDAGCI">Mapped superclass</a> on the <a href="ref_EntityClassPage.htm#CIAFEIGF">Entity Class page</a></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</li>
-<li>
-<p>Add persistence fields to the entity by clicking <span class="bold">Add</span>. The Entity Fields dialog appears.</p>
-<div class="figure"><a id="sthref46" name="sthref46"></a>
-<p class="titleinfigure">The Entity Fields Dialog</p>
-<img src="img/jpa_wizard_create_fields.png" alt="The Entity Fields dialog." title="The Entity Fields dialog." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Select a persistence type from the Type list. You can retrieve additional types using the <span class="bold">Browse</span> function.</p>
-</li>
-<li>
-<p>Enter the field name and then click <span class="bold">OK</span>. Repeat this procedure for each field.</p>
-</li>
-<li>
-<p>If needed, select <span class="bold">Key</span> to designate the field as a primary key.</p>
-</li>
-<li>
-<p>Select either the <span class="bold">Field-based</span> access type (the default) or <span class="bold">Property-based</span> access type.</p>
-</li>
-</ol>
-</li>
-<li>
-<p>Click <span class="bold">Finish</span>. Eclipse adds the entity to your project.</p>
-</li>
-</ol>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_create_jpa_entity_wizard.htm#CIAGGGDF">Create JPA Entity wizard</a><br />
-<a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a><br />
-<a href="ref_persistence_perspective.htm#BABIFBDB">JPA Development perspective</a>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related tasks" title="Related tasks" /><br />
-<br />
-<a href="task_manage_persistence.htm#CIHDAJID">Managing the persistence.xml file</a><br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_persistence.htm#BABCAHIC">Understanding Java persistence</a><br />
-<a href="concepts002.htm#CHDHAGIH">The persistence.xml file</a><br />
-<p>&nbsp;</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/task_create_new_project.htm b/jpa/plugins/org.eclipse.jpt.doc.user/task_create_new_project.htm
deleted file mode 100644
index 4a686e3..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/task_create_new_project.htm
+++ /dev/null
@@ -1,141 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Creating a new JPA project</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:43Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Creating a new JPA project" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHHEJCJ" name="CIHHEJCJ"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Creating a new JPA project</h1>
-<p><a id="sthref26" name="sthref26"></a><a id="sthref27" name="sthref27"></a>Use this procedure to create a new JPA project.</p>
-<ol>
-<li>
-<p>From the Navigator or Project Explorer, select <span class="bold">File &gt; New &gt; Project</span>. The Select a wizard dialog appears.</p>
-<div align="center">
-<div class="inftblnotealso"><br />
-<table class="NoteAlso oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Tip:</p>
-You can also select the JPA perspective and then select <span class="bold">File &gt; New &gt; JPA Project</span>.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnotealso" --></div>
-<div class="figure"><a id="sthref28" name="sthref28"></a>
-<p class="titleinfigure"><a id="sthref29" name="sthref29"></a>Selecting the Create a JPA Project wizard</p>
-<img src="img/select_a_wizard_jpa_project.png" alt="The Select a Wizard dialog with JPA project selected." title="The Select a Wizard dialog with JPA project selected." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Select <span class="bold">JPA Project</span> and then click <span class="bold">Next</span>. The <a href="ref_new_jpa_project.htm#CACBJAGC">New JPA Project page</a> appears.</p>
-<div class="figure"><a id="sthref30" name="sthref30"></a>
-<p class="titleinfigure"><a id="sthref31" name="sthref31"></a>The JPA Project Page</p>
-<img src="img/new_jpa_project_task.png" alt="The JPA Project page of the Create a JPA Project wizard." title="The JPA Project page of the Create a JPA Project wizard." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Complete the fields on the <a href="ref_new_jpa_project.htm#CACBJAGC">New JPA Project page</a> to specify the project name and location, target runtime, and pre-defined configuration.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-The Target Runtime is not required for Java SE development.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</li>
-<li>
-<p>Click <span class="bold">Next</span>. The Java source page appears.</p>
-<div class="figure"><a id="sthref32" name="sthref32"></a>
-<p class="titleinfigure">The Java Source Page</p>
-<img src="img/java_editor_address.png" alt="The JPA Facet page of the Create a JPA Project wizard." title="The JPA Facet page of the Create a JPA Project wizard." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Click <span class="bold">Add Folder</span> to add existing Java source files to the project.</p>
-</li>
-<li>
-<p>Click <span class="bold">Next</span>. <a href="ref_jpa_facet.htm#CACIFDIF">JPA Facet page</a> appears.</p>
-<div class="figure"><a id="sthref33" name="sthref33"></a>
-<p class="titleinfigure"><a id="sthref34" name="sthref34"></a>The JPA Facet Page</p>
-<img src="img/new_jpa_facet_task.png" alt="The JPA Facet page of the Create a JPA Project wizard." title="The JPA Facet page of the Create a JPA Project wizard." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Complete the fields on the <a href="ref_jpa_facet.htm#CACIFDIF">JPA Facet page</a> to specify your vender-specific platform, JPA implementation library, and database connection.</p>
-<p>Click <span class="bold">Manage libraries</span> to create or update your JPA user libraries. Click <span class="bold">Download libraries</span> to obtain additional JPA implementation libraries.</p>
-<p>If Dali derives the incorrect schema, select <span class="bold">Override the Default Schema for Connection</span>. Using this option, you can select a development time schema for defaults and validation.</p>
-<p>If you clear the <span class="bold">Create orm.xml</span> option (which is selected by default), you can later add a mapping file to the project using the <a href="reference002.htm#CIAIJCCE">Mapping File Wizard</a>.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-If the server runtime does not provide a JPA implementation, you must explicitly select a JPA implementation library.
-<p>To insure the portability of your application, you must explicitly list the managed persistence classes that are included in the persistence unit. If the server supports EJB 3.0, the persistent classes will be discovered automatically.</p>
-<p>Depending on your JPA implementation (for example, Generic or EclipseLink), different options may be available when creating JPA projects.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</li>
-<li>
-<p>Click <span class="bold">Finish</span>. You should now open the <a href="ref_persistence_perspective.htm#BABIFBDB">JPA Development perspective</a>.</p>
-</li>
-</ol>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a><br />
-<a href="ref_persistence_perspective.htm#BABIFBDB">JPA Development perspective</a><br />
-<a href="reference002.htm#CIAIJCCE">Mapping File Wizard</a>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related tasks" title="Related tasks" /><br />
-<br />
-<a href="task_manage_persistence.htm#CIHDAJID">Managing the persistence.xml file</a><br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a><br />
-<a href="tasks001.htm#BEIBADHH">Converting a Java Project to a JPA Project</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_persistence.htm#BABCAHIC">Understanding Java persistence</a><br />
-<a href="concepts002.htm#CHDHAGIH">The persistence.xml file</a>
-<p>&nbsp;</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/task_inheritance.htm b/jpa/plugins/org.eclipse.jpt.doc.user/task_inheritance.htm
deleted file mode 100644
index 5c95a13..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/task_inheritance.htm
+++ /dev/null
@@ -1,138 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Specifying entity inheritance</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:46Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Specifying entity inheritance" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHCCCJD" name="CIHCCCJD"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Specifying entity inheritance</h1>
-<p><a id="sthref91" name="sthref91"></a><a id="sthref92" name="sthref92"></a>An entity may inherit properties from other entities. You can specify a specific strategy to use for inheritance.</p>
-<p>Use this procedure to specify inheritance (<code>@Inheritance)</code> for an existing entity (<code>@Entity</code>):</p>
-<ol>
-<li>
-<p>Select the entity in the <span class="gui-object-title">Project Explorer</span>.</p>
-</li>
-<li>
-<p>In the <span class="gui-object-title">JPA Details</span> view, select the <span class="gui-object-action">Inheritance</span> information.</p>
-<div class="figure"><a id="sthref93" name="sthref93"></a>
-<p class="titleinfigure">Specifying Inheritance</p>
-<img src="img/inheritance_tab.png" alt="Selecting the Inheritance area on the JPA Details view." title="Selecting the Inheritance area on the JPA Details view." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>In the <span class="bold">Strategy</span> list, select one of the following the inheritance strategies:</p>
-<ul>
-<li>
-<p>A single table (default)</p>
-</li>
-<li>
-<p>Joined table</p>
-</li>
-<li>
-<p>One table per class</p>
-</li>
-</ul>
-</li>
-<li>
-<p>Use the following table to complete the remaining fields on the tab. See <a href="reference009.htm#CACFHGHE">"Inheritance information"</a> for additional details.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table describes the options on the Persistence Properties view, Inheritance tab." summary="This table describes the options on the Persistence Properties view, Inheritance tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="24%" />
-<col width="*" />
-<col width="23%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t13">Property</th>
-<th align="left" valign="bottom" id="r1c2-t13">Description</th>
-<th align="left" valign="bottom" id="r1c3-t13">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t13" headers="r1c1-t13"><a id="sthref94" name="sthref94"></a><a id="sthref95" name="sthref95"></a>Discriminator Column</td>
-<td align="left" headers="r2c1-t13 r1c2-t13">Name of the discriminator column when using a <span class="bold">Single</span> or <span class="bold">Joined</span> inheritance strategy.
-<p>This field corresponds to the <code>@DiscriminatorColumn</code> annotation.</p>
-</td>
-<td align="left" headers="r2c1-t13 r1c3-t13"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t13" headers="r1c1-t13">Discriminator Type</td>
-<td align="left" headers="r3c1-t13 r1c2-t13">Set the discriminator type to <code>Char</code> or <code>Integer</code> (instead of its default: <code>String</code>). The <span class="bold">Discriminator Value</span> must conform to this type.</td>
-<td align="left" headers="r3c1-t13 r1c3-t13">String</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t13" headers="r1c1-t13"><a id="sthref96" name="sthref96"></a><a id="sthref97" name="sthref97"></a>Discriminator Value</td>
-<td align="left" headers="r4c1-t13 r1c2-t13">Specify the discriminator value used to differentiate an entity in this inheritance hierarchy. The value must conform to the specified <span class="bold">Discriminator Type</span>.
-<p>This field corresponds to the <code>@DiscriminatorValue</code> annotation.</p>
-</td>
-<td align="left" headers="r4c1-t13 r1c3-t13"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t13" headers="r1c1-t13">Override Default</td>
-<td align="left" headers="r5c1-t13 r1c2-t13">Use this field to specify custom primary key join columns.
-<p>This field corresponds to the <code>@PrimaryKeyJoinClumn</code> annotation.</p>
-</td>
-<td align="left" headers="r5c1-t13 r1c3-t13"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Eclipse adds the following annotations the entity field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@Inheritance(strategy=InheritanceType.<span class="italic">&lt;INHERITANCE_STRATEGY&gt;</span>)
-@DiscriminatorColumn(name="<span class="italic">&lt;DISCRIMINATOR_COLUMN&gt;</span>",
-    discriminatorType=<span class="italic">&lt;DISCRIMINATOR_TYPE&gt;</span>)
-@DiscriminatorValue(value-"<span class="italic">&lt;DISCRIMINATOR_VALUE&gt;</span>")
-@PrimaryKeyJoinColumn(name="<span class="italic">&lt;JOIN_COLUMN_NAME&gt;</span>", 
-    referencedColumnName = "<span class="italic">&lt;REFERENCED_COLUMN_NAME&gt;</span>")
-
-</pre>
-<p><a id="sthref98" name="sthref98"></a><a id="sthref99" name="sthref99"></a><a id="sthref100" name="sthref100"></a>The following figures illustrates the different inheritance strategies.</p>
-<div class="figure"><a id="sthref101" name="sthref101"></a>
-<p class="titleinfigure">Single Table Inheritance</p>
-<img src="img/inheritance_single.png" alt="This figure illustrates entity inheritance in a single table." title="This figure illustrates entity inheritance in a single table." /><br /></div>
-<!-- class="figure" -->
-<div class="figure"><a id="sthref102" name="sthref102"></a>
-<p class="titleinfigure"><a id="sthref103" name="sthref103"></a><a id="sthref104" name="sthref104"></a>Joined Table Inheritance</p>
-<img src="img/inheritance_join.png" alt="This figure illustrates a joined subclass inheritance strategy." title="This figure illustrates a joined subclass inheritance strategy." /><br /></div>
-<!-- class="figure" -->
-<br />
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_persistence.htm#BABCAHIC">Understanding Java persistence</a><br /></div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/task_manage_orm.htm b/jpa/plugins/org.eclipse.jpt.doc.user/task_manage_orm.htm
deleted file mode 100644
index d8b5b2f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/task_manage_orm.htm
+++ /dev/null
@@ -1,64 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Managing the orm.xml file</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:44Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Managing the orm.xml file" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHDGDCD" name="CIHDGDCD"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1><a id="sthref56" name="sthref56"></a>Managing the orm.xml file</h1>
-<p>When creating a JPA project, (see <a href="task_create_new_project.htm#CIHHEJCJ">"Creating a new JPA project"</a>) you can also create the <code>orm.xml</code> file that defines the mapping metadata and defaults.</p>
-<p><a id="sthref57" name="sthref57"></a>Eclipse creates the <code>META-INF\orm.xml</code> file in your project's directory:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-&lt;?xml version="1.0" encoding="UTF-8"?&gt;
-&lt;persistence version="<span class="italic">&lt;PERSISTENCE_VERSION&gt;</span>"
-      xmlns="http://java.sun.com/xml/ns/persistence"
-      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-      xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
-      http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"&gt;
-  &lt;persistence-unit name="<span class="italic">&lt;PERSISTENCE_UNIT_NAME&gt;</span>"&gt;
-    &lt;provider="<span class="italic">&lt;PERSISTENCE_PROVIDER&gt;</span>" /&gt;
-  &lt;/persistence-unit&gt;
-&lt;/persistence&gt;
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a><br />
-<a href="ref_eclipselink_mapping_file.htm#CIAEDEJF">New EclipseLink Mapping File dialog</a>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="tasks004.htm#CIHBCDCE">Working with orm.xml file</a><br />
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concepts003.htm#CHDBIJAC">The orm.xml file</a><br />
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/task_manage_persistence.htm b/jpa/plugins/org.eclipse.jpt.doc.user/task_manage_persistence.htm
deleted file mode 100644
index 1461a8c..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/task_manage_persistence.htm
+++ /dev/null
@@ -1,222 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Managing the persistence.xml file</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:44Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Managing the persistence.xml file" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHDAJID" name="CIHDAJID"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1><a id="sthref47" name="sthref47"></a>Managing the persistence.xml file</h1>
-<p><a id="sthref48" name="sthref48"></a>When you create a project, Eclipse creates the <code>META-INF\persistence.xml</code> file in the project's directory.</p>
-<p>You can create a stub <code>persistence.xml</code> file in the META-INF directory when you create a JPA project (see <a href="task_create_new_project.htm#CIHHEJCJ">"Creating a new JPA project"</a>). You can manage this file either through the XML editor (see ) or through the <a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-Depending on your JPA implementation (for example, EclipseLink), the following additional pages may be available in the persistence.xml Editor:
-<ul>
-<li>
-<p><a href="reference019.htm#CIAJAFEG">Customization</a></p>
-<p>Use this page to define change-tracking and session customizer-related properties.</p>
-</li>
-<li>
-<p><a href="reference020.htm#CIABEDCH">Caching</a></p>
-<p>Use this page to define caching properties.</p>
-</li>
-<li>
-<p><a href="reference021.htm#CIABGHHI">Logging</a></p>
-<p>Use this page to define logging properties.</p>
-</li>
-<li>
-<p><a href="reference022.htm#CIAFJCHE">Options</a></p>
-<p>Use this page to define session and target database properties.</p>
-</li>
-<li>
-<p><a href="reference023.htm#CIACCFCB">Schema Generation</a></p>
-<p>Use this page to define DDL-related properties.</p>
-</li>
-</ul>
-<p>For projects using the EclipseLink JPA implementation, the Connections page also includes JDBC connection pool properties.</p>
-<p>If the project uses the Generic platform, then only the <a href="ref_persistence_general.htm#CIACIFGJ">General</a>, <a href="reference018.htm#CIAFFJIE">Connection</a>, <a href="reference024.htm#CIAHJDFF">Properties</a> and <a href="reference025.htm#CIAHCJAH">Source</a> pages are available.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-<p>To use the <code>persistence.xml</code> Editor:</p>
-<ol>
-<li>
-<p>Open the <code>peristence.xml</code> file. The <a href="ref_persistence_general.htm#CIACIFGJ">General</a> page of the editor appears.</p>
-</li>
-<li>
-<p>Use the <span class="bold">General</span> page to define the <code>persistence.xml</code> files <code>&lt;persistent-unit&gt;</code>-related attributes as well as the <code>&lt;provider&gt;</code>, and <code>&lt;class&gt;</code> elements (described in the following table).</p>
-<div align="center">
-<div class="inftblnotealso"><br />
-<table class="NoteAlso oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Tip:</p>
-The persistence.xml Editor's Source page enables you to view and edit the raw XML file.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnotealso" --></div>
-<div class="inftblinformal">
-<table class="Informal" summary="This table lists the properties of the persistence.xml editor." dir="ltr" border="1" width="100%" frame="hsides" rules="groups" cellpadding="3" cellspacing="0">
-<col width="29%" />
-<col width="29%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t8">Property</th>
-<th align="left" valign="bottom" id="r1c2-t8">Description</th>
-<th align="left" valign="bottom" id="r1c3-t8">Element Defined</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t8" headers="r1c1-t8">Name</td>
-<td align="left" headers="r2c1-t8 r1c2-t8">Enter the name of the persistence unit.</td>
-<td align="left" headers="r2c1-t8 r1c3-t8"><code>&lt;persistence-unit name = "&lt;Name&gt;"&gt;</code></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t8" headers="r1c1-t8"><a id="sthref49" name="sthref49"></a>Persistence Provider</td>
-<td align="left" headers="r3c1-t8 r1c2-t8">Enter the name of the persistence provider.</td>
-<td align="left" headers="r3c1-t8 r1c3-t8"><code>&lt;provider&gt;</code></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t8" headers="r1c1-t8">Description</td>
-<td align="left" headers="r4c1-t8 r1c2-t8">Enter a description for this persistence unit. This is an optional property.</td>
-<td align="left" headers="r4c1-t8 r1c3-t8"><code>&lt;description&gt;</code></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t8" headers="r1c1-t8"><a id="sthref50" name="sthref50"></a>Managed Classes</td>
-<td align="left" headers="r5c1-t8 r1c2-t8">Add or remove the classes managed through the persistence unit.</td>
-<td align="left" headers="r5c1-t8 r1c3-t8"><code>&lt;class&gt;</code></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t8" headers="r1c1-t8">&nbsp;&nbsp;Exclude&nbsp;Unlisted&nbsp;Classes</td>
-<td align="left" headers="r6c1-t8 r1c2-t8">Select to include all annotated entity classes in the root of the persistence unit.</td>
-<td align="left" headers="r6c1-t8 r1c3-t8"><code>&lt;exclude-unlisted-classes&gt;</code></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t8" headers="r1c1-t8">XML&nbsp;Mapping&nbsp;Files</td>
-<td align="left" headers="r7c1-t8 r1c2-t8">Add or remove the object/relational mapping XML files define the classes managed through the persistence unit.</td>
-<td align="left" headers="r7c1-t8 r1c3-t8"><code>&lt;mapping-file&gt;</code></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r8c1-t8" headers="r1c1-t8">JAR&nbsp;Files</td>
-<td align="left" headers="r8c1-t8 r1c2-t8">Add or remove additional JAR files and libraries</td>
-<td align="left" headers="r8c1-t8 r1c3-t8"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblinformal" --></li>
-<li>
-<p>Use the <a href="reference018.htm#CIAFFJIE">Connection</a> page to define the <code>&lt;jta-data-source&gt;</code> and <code>&lt;non-jta-data-source&gt;</code> elements as follows:</p>
-<p>To configure the JTA (Java Transaction API) source used by the persistence provider:</p>
-<ol>
-<li>
-<p>Select <span class="bold">JTA</span> from the Transaction Type list.</p>
-</li>
-<li>
-<p>Enter the global JNDI name of the data source.</p>
-</li>
-</ol>
-<p>To configure a non-JTA data source:</p>
-<ol>
-<li>
-<p>Select <span class="bold">Resource Local</span> from the Transaction Type list.</p>
-</li>
-<li>
-<p>Enter the global JNDI name of the data source.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-Select <span class="bold">Default()</span> to use the data source provided by the container.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</li>
-</ol>
-<p><a id="sthref51" name="sthref51"></a>For projects using the Generic platform, you can also define the EclipseLink connection pool driver, connection pool driver, URL, user name and password.</p>
-</li>
-<li>
-<p>Use the table in the Properties page to set the vendor-specific <code>&lt;properties&gt;</code> element.</p>
-<p>To add <code>&lt;property&gt;</code> elements:</p>
-<ol>
-<li>
-<p>Click <span class="bold">Add</span>.</p>
-</li>
-<li>
-<p>Enter the <code>&lt;name&gt;</code> and <code>&lt;value&gt;</code> attributes for the <code>&lt;property&gt;</code> element using the table's Name and Value fields.</p>
-</li>
-</ol>
-<p>To remove a <code>&lt;property&gt;</code> element, select a defined property in the table and then click <span class="bold">Remove</span>.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-If the project uses the EclipseLink platform, the connection page also includes parameters for JDBC connection pooling.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-</li>
-</ol>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_xmll_editor.htm#CIACCHID">persistence.xml Editor</a>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="tasks002.htm#CIHFEBAI">Synchronizing classes</a><br />
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concepts002.htm#CHDHAGIH">The persistence.xml file</a><br />
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/task_mapping.htm b/jpa/plugins/org.eclipse.jpt.doc.user/task_mapping.htm
deleted file mode 100644
index 782d60d..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/task_mapping.htm
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Mapping an entity</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:46Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Mapping an entity" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABDGBIJ" name="BABDGBIJ"></a></p>
-<div class="sect1">
-<h1>Mapping an entity</h1>
-<p>Dali supports the following mapping types for Java persistent entities:</p>
-<ul>
-<li>
-<p><a href="tasks009.htm#BABBABCE">Basic mapping</a></p>
-</li>
-<li>
-<p><a href="tasks010.htm#BABCBHDF">Embedded mapping</a></p>
-</li>
-<li>
-<p><a href="tasks011.htm#CIHDIAEE">Embedded ID mapping</a></p>
-</li>
-<li>
-<p><a href="tasks012.htm#BABGCBHG">ID mapping</a></p>
-</li>
-<li>
-<p><a href="tasks013.htm#BABEIEGD">Many-to-many mapping</a></p>
-</li>
-<li>
-<p><a href="tasks014.htm#BABHFAFJ">Many-to-one mapping</a></p>
-</li>
-<li>
-<p><a href="tasks015.htm#BABHGEBD">One-to-many mapping</a></p>
-</li>
-<li>
-<p><a href="tasks016.htm#BABFHBCJ">One-to-one mapping</a></p>
-</li>
-<li>
-<p><a href="tasks017.htm#BABHFHEI">Transient mapping</a></p>
-</li>
-<li>
-<p><a href="tasks018.htm#BABHIBII">Version mapping</a></p>
-</li>
-</ul>
-<p>Additional mapping types (such as Basic Collection mappings) may be available when using Dali with EclipseLink.</p>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a> <!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks.htm
deleted file mode 100644
index c3460b8..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks.htm
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Tasks</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:42Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content=" Tasks" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="sthref25" name="sthref25"></a></p>
-<h1>Tasks</h1>
-<p>This section includes detailed step-by-step procedures for accessing the Dali OR mapping tool functionality.</p>
-<ul>
-<li>
-<p><a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a></p>
-</li>
-<li>
-<p><a href="tasks001.htm#BEIBADHH">Converting a Java Project to a JPA Project</a></p>
-</li>
-<li>
-<p><a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a></p>
-</li>
-<li>
-<p><a href="task_manage_persistence.htm#CIHDAJID">Managing the persistence.xml file</a></p>
-</li>
-<li>
-<p><a href="task_manage_orm.htm#CIHDGDCD">Managing the orm.xml file</a></p>
-</li>
-<li>
-<p><a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a></p>
-</li>
-<li>
-<p><a href="task_additonal_tables.htm#CIHGBIEI">Specifying additional tables</a></p>
-</li>
-<li>
-<p><a href="task_inheritance.htm#CIHCCCJD">Specifying entity inheritance</a></p>
-</li>
-<li>
-<p><a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a></p>
-</li>
-<li>
-<p><a href="tasks019.htm#BABBAGFI">Generating entities from tables</a></p>
-</li>
-<li>
-<p><a href="tasks021.htm#BABFAIBA">Validating mappings and reporting problems</a></p>
-</li>
-<li>
-<p><a href="tasks024.htm#BABDBCBI">Modifying persistent project properties</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks001.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks001.htm
deleted file mode 100644
index 03be784..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks001.htm
+++ /dev/null
@@ -1,85 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Converting a Java Project to a JPA Project</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:43Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Converting a Java Project to a JPA Project" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BEIBADHH" name="BEIBADHH"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Converting a Java Project to a JPA Project</h1>
-<p><a id="sthref35" name="sthref35"></a><a id="sthref36" name="sthref36"></a><a id="sthref37" name="sthref37"></a>Use this procedure to convert an existing Java project to a JPA project.</p>
-<ol>
-<li>
-<p>From the Navigator or Project explorer, right-click the Java project and then select <span class="bold">Configure &gt; Convert to JPA Project.</span> The Project Facets page of the Modify Faceted Project wizard appears.</p>
-<div class="figure"><a id="sthref38" name="sthref38"></a>
-<p class="titleinfigure">Modify Faceted Project Page</p>
-<img src="img/modify_faceted_project.png" alt="" title="" /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Change the <span class="bold">Configuration</span> to <span class="bold">Default JPA Configuration</span>.</p>
-</li>
-<li>
-<p>Click <span class="bold">Next</span>. <a href="ref_jpa_facet.htm#CACIFDIF">JPA Facet page</a> appears.</p>
-<div class="figure"><a id="sthref39" name="sthref39"></a>
-<p class="titleinfigure">JPA Facet Page</p>
-<img src="img/new_jpa_facet_task.png" alt="" title="" /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Complete the fields on the <a href="ref_jpa_facet.htm#CACIFDIF">JPA Facet page</a> to specify your vender-specific platform, JPA implementation library, and database connection.</p>
-<p>Click <span class="bold">Manage libraries</span> to create or update your JPA user libraries. Click <span class="bold">Download libraries</span> to obtain additional JPA implementation libraries.</p>
-<p>If Dali derives the incorrect schema, select <span class="bold">Override the Default Schema for Connection</span>. Using this option, you can select a development time schema for defaults and validation.</p>
-<p>If you clear the <span class="bold">Create orm.xml</span> option (which is selected by default), you can later add a mapping file to the project using the <a href="reference002.htm#CIAIJCCE">Mapping File Wizard</a>.</p>
-</li>
-<li>
-<p>Click <span class="bold">Finish</span>.</p>
-</li>
-</ol>
-<p>The Dali OR Mapping Tool adds the JPA implementation libraries to your project and creates the necessary <code>orm.xml</code> and <code>perisistence.xml</code> files.</p>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_new_jpa_project_wizard.htm#CACBJGBG">Create New JPA Project wizard</a><br />
-<a href="ref_persistence_perspective.htm#BABIFBDB">JPA Development perspective</a><br />
-<a href="reference002.htm#CIAIJCCE">Mapping File Wizard</a>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related tasks" title="Related tasks" /><br />
-<br />
-<a href="task_manage_persistence.htm#CIHDAJID">Managing the persistence.xml file</a><br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a><br />
-<a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_persistence.htm#BABCAHIC">Understanding Java persistence</a><br />
-<a href="concepts002.htm#CHDHAGIH">The persistence.xml file</a>
-<p>&nbsp;</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks002.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks002.htm
deleted file mode 100644
index 93a424f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks002.htm
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Synchronizing classes</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:44Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Synchronizing classes" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHFEBAI" name="CIHFEBAI"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Synchronizing classes</h1>
-<p>As you work with the classes in your Java project, you will need to update the <code>persistence.xml</code> file to reflect the changes. <a id="sthref52" name="sthref52"></a><a id="sthref53" name="sthref53"></a><a id="sthref54" name="sthref54"></a></p>
-<p>Use this procedure to synchronize the <code>persistence.xml</code> file:</p>
-<ol>
-<li>
-<p>Right-click the <code>persistence.xml</code> file in the <span class="gui-object-title">Project Explorer</span> and select <span class="gui-object-action">JPA Tools &gt; Synchronize Class List</span>.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-Use this function if you selected <span class="bold">Annotated classes must be listed in the persistence.xml option</span> in the <a href="ref_jpa_facet.htm#CACIFDIF">JPA Facet page</a>. In general, you do not have to use this function within the container.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-<div class="figure"><a id="sthref55" name="sthref55"></a>
-<p class="titleinfigure">Synchronizing the persistence.xml File</p>
-<img src="img/synchornize_classes.png" alt="This figure shows the JPA Tools &gt; Synchronize Classes option." title="This figure shows the JPA Tools &gt; Synchronize Classes option." /><br /></div>
-<!-- class="figure" -->
-<p>Dali adds the necessary <code>&lt;class&gt;</code> elements to the <code>persistence.xml</code> file.</p>
-</li>
-<li>
-<p>Use the <span class="gui-object-title">Persistence XML Editor</span> to continue editing the <code>persistence.xml</code> file.</p>
-</li>
-</ol>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_manage_persistence.htm#CIHDAJID">Managing the persistence.xml file</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concepts002.htm#CHDHAGIH">The persistence.xml file</a><br />
-<br /></div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks003.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks003.htm
deleted file mode 100644
index aa2fb36..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks003.htm
+++ /dev/null
@@ -1,58 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Creating an orm.xml file</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:44Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Creating an orm.xml file" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<div class="sect2"><!-- infolevel="all" infotype="General" --><a id="sthref58" name="sthref58"></a>
-<h1>Creating an orm.xml file</h1>
-<p><a id="sthref59" name="sthref59"></a>If you opt not to create an <code>orm.xml</code> file when you create a JPA project, you can create one using the <a href="reference002.htm#CIAIJCCE">Mapping File Wizard</a>.</p>
-<p>Use this procedure to create an <code>orm.xml</code> file:</p>
-<ol>
-<li>
-<p>From the Navigator or Project Explorer, select <span class="bold">File &gt; New &gt; Other</span>. The Select a Wizard dialog appears.</p>
-<div class="figure"><a id="sthref60" name="sthref60"></a>
-<p class="titleinfigure">The Select a Wizard Dialog</p>
-<img src="img/select_a_wizard_mapping.png" alt="The Select a Wizard dialog with Mapping file selected." title="The Select a Wizard dialog with Mapping file selected." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Select <span class="bold">Mapping File</span> and then click <span class="bold">Next</span>. The Mapping File page appears.</p>
-<p>If you are using EclipseLink, you can select <span class="bold">EclipseLink &gt; EclipseLink Mapping File</span>.</p>
-<div class="figure"><a id="sthref61" name="sthref61"></a>
-<p class="titleinfigure">The Mapping File Page</p>
-<img src="img/mapping_file_new.png" alt="The Mapping File page." title="The Mapping File page." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Define the properties in the page and click <span class="bold">Finish</span>. The <code>orm.xml</code> file appears in the src directory of the selected JPA project. You can manage the orm.xml file using the JPA Details view or through the XML Editor. See also <a href="ref_details_orm.htm#CACGDGHC">JPA Details view (for orm.xml)</a>.</p>
-</li>
-</ol>
-</div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks004.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks004.htm
deleted file mode 100644
index 1dbf6bc..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks004.htm
+++ /dev/null
@@ -1,66 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Working with orm.xml file</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:44Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Working with orm.xml file" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHBCDCE" name="CIHBCDCE"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Working with orm.xml file</h1>
-<p><a id="sthref62" name="sthref62"></a><a id="sthref63" name="sthref63"></a>You can work with the <code>orm.xml</code> by using the JPA Details view.</p>
-<p>Use this procedure to work with the <code>orm.xml</code> file:</p>
-<ol>
-<li>
-<p>Right-click the <code>orm.xml</code> file in the <span class="gui-object-title">Project Explorer</span> and select <span class="gui-object-action">Open</span>.</p>
-</li>
-<li>
-<p>In the JPA Structure view, select <span class="bold">EntityMappings</span>.</p>
-</li>
-<li>
-<p>Use the JPA Details view to configure the entity mapping and persistence unit defaults.</p>
-<div class="figure"><a id="sthref64" name="sthref64"></a>
-<p class="titleinfigure">JPA Details view for EntityMappings (orm.xml)</p>
-<img src="img/details_entitymappings.png" alt="JPA Details view for orm.xml file." title="JPA Details view for orm.xml file." /><br /></div>
-<!-- class="figure" --></li>
-</ol>
-<img src="img/ngrelr.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="ref_details_orm.htm#CACGDGHC">JPA Details view (for orm.xml)</a><br />
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="#CIHBCDCE">Working with orm.xml file</a><br />
-<a href="../org.eclipse.wst.xmleditor.doc.user/topics/cworkXML.html">Working with XML Files</a><br />
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concepts003.htm#CHDBIJAC">The orm.xml file</a><br /></div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks005.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks005.htm
deleted file mode 100644
index a9446f0..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks005.htm
+++ /dev/null
@@ -1,96 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Entity</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:45Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Entity" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABGBIEE" name="BABGBIEE"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Entity</h1>
-<p><a id="sthref68" name="sthref68"></a><a id="sthref69" name="sthref69"></a><a id="sthref70" name="sthref70"></a><a id="sthref71" name="sthref71"></a>An <span class="bold">Entity</span> is a persistent domain object.</p>
-<p>An entity <span class="italic">can be</span>:</p>
-<ul>
-<li>
-<p>Abstract or concrete classes. Entities may also extend non-entity classes as well as entity classes, and non-entity classes may extend entity classes.</p>
-</li>
-</ul>
-<p>An entity <span class="italic">must have</span>:</p>
-<ul>
-<li>
-<p>A no-arg constructor (public or protected); the entity class may have other constructors as well.</p>
-</li>
-</ul>
-<p><a id="sthref72" name="sthref72"></a><a id="sthref73" name="sthref73"></a><a id="sthref74" name="sthref74"></a>Each persistent entity must be mapped to a database table and contain a primary key. Persistent entities are identified by the <code>@Entity</code> annotation.</p>
-<p>Use this procedure to add persistence to an existing entity:</p>
-<ol>
-<li>
-<p>Open the Java class in the <span class="gui-object-title">Project Explorer.</span></p>
-</li>
-<li>
-<p>Select the class in the JPA Structure view.</p>
-</li>
-<li>
-<p>In the JPA Details view, click the mapping type hyperlink to access the Mapping Type Selection dialog. In the following figure, clicking <span class="italic">entity</span> invokes the dialog from the JPA Details View.</p>
-<div class="figure"><a id="sthref75" name="sthref75"></a>
-<p class="titleinfigure">The Mapping Type Hyperlink</p>
-<img src="img/mapped_entity_type_link.png" alt="The JPA Details view for an entity showing the mapping type hyperlink." title="The JPA Details view for an entity showing the mapping type hyperlink." /><br /></div>
-<!-- class="figure" -->
-<div align="center">
-<div class="inftblnotealso"><br />
-<table class="NoteAlso oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Tip:</p>
-You can also change (or add) persistence for an entity by right-clicking the class in the JPA Structure View and then clicking <span class="bold">Map As &gt; Entity</span>.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnotealso" --></div>
-</li>
-<li>
-<p>Select <span class="bold">Entity</span> from the Mapping Type Selection dialog and then click <span class="bold">OK</span>.</p>
-<div class="figure"><a id="sthref76" name="sthref76"></a>
-<p class="titleinfigure">The Mapping Type Selection Dialog</p>
-<img src="img/mapping_type_selection_entity.png" alt="The Mapping Type selection dialog with Enity selected." title="The Mapping Type selection dialog with Enity selected." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Complete the remaining <a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a>.</p>
-</li>
-</ol>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related tasks" title="Related tasks" /><br />
-<br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a><br />
-<a href="task_additonal_tables.htm#CIHGBIEI">Specifying additional tables</a><br />
-<a href="task_inheritance.htm#CIHCCCJD">Specifying entity inheritance</a><br /></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks006.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks006.htm
deleted file mode 100644
index 38991a1..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks006.htm
+++ /dev/null
@@ -1,70 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Embeddable</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:45Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Embeddable" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABFEICE" name="BABFEICE"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Embeddable</h1>
-<p><a id="sthref77" name="sthref77"></a><a id="sthref78" name="sthref78"></a>An <span class="bold">Embedded</span> class is a class whose instances are stored as part of an owning entity; it shares the identity of the owning entity. Each field of the embedded class is mapped to the database table associated with the owning entity.</p>
-<p>To override the mapping information for a specific subclass, use the <code>@AttributeOverride</code> annotation for that specific class.</p>
-<p><a id="sthref79" name="sthref79"></a><a id="sthref80" name="sthref80"></a><a id="sthref81" name="sthref81"></a>An embeddable entity is identified by the <code>@Embeddable</code> annotation.</p>
-<p>Use this procedure to add embeddable persistence to an existing entity:</p>
-<ol>
-<li>
-<p>Open the Java class in the <span class="gui-object-title">Project Explorer</span>.</p>
-</li>
-<li>
-<p>Select the class in the JPA Structure view.</p>
-</li>
-<li>
-<p>Click the mapping type hyperlink to open the Mapping Type Selection dialog.</p>
-</li>
-<li>
-<p>Select <span class="bold">Embeddable</span> and then click <span class="bold">OK</span>.</p>
-<div class="figure"><a id="sthref82" name="sthref82"></a>
-<p class="titleinfigure">Mapping Type Selection Dialog (Embeddable)</p>
-<img src="img/mapping_type_selection_embed.png" alt="The Mapping Type Selection dialog with Embeddable selected." title="The Mapping Type Selection dialog with Embeddable selected." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Complete the remaining <a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a>.</p>
-</li>
-</ol>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related tasks" title="Related tasks" /><br />
-<dl>
-<dd><a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a></dd>
-<dd><a href="task_additonal_tables.htm#CIHGBIEI">Specifying additional tables</a></dd>
-<dd><a href="task_inheritance.htm#CIHCCCJD">Specifying entity inheritance</a></dd>
-</dl>
-</div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks007.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks007.htm
deleted file mode 100644
index 4e3a3c9..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks007.htm
+++ /dev/null
@@ -1,84 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Mapped superclass</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:45Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Mapped superclass" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABDAGCI" name="BABDAGCI"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Mapped superclass</h1>
-<p><a id="sthref83" name="sthref83"></a><a id="sthref84" name="sthref84"></a>An entity that extends a <span class="bold">Mapped Superclass</span> class inherits the persistent state and mapping information from a superclass. You should use a mapped superclass to define mapping information that is common to multiple entity classes.</p>
-<p>A mapped superclass <span class="italic">can be</span>:</p>
-<ul>
-<li>
-<p>Abstract or concrete classes</p>
-</li>
-</ul>
-<p>A mapped superclass <span class="italic">cannot be</span>:</p>
-<ul>
-<li>
-<p>Be queried or passed as an argument to Entity-Manager or Query operations</p>
-</li>
-<li>
-<p>Be the target of a persistent relationship</p>
-</li>
-</ul>
-<p>A mapped superclass does not have a defined database table. Instead, its mapping information is derived from its superclass. To override the mapping information for a specific subclass, use the <code>@AttributeOverride</code> annotation for that specific class.</p>
-<p><a id="sthref85" name="sthref85"></a><a id="sthref86" name="sthref86"></a><a id="sthref87" name="sthref87"></a><a id="sthref88" name="sthref88"></a>A mapped superclass is identified by the <code>@MappedSuperclass</code> annotation.</p>
-<p>Use this procedure to add Mapped Superclass persistence to an existing entity:</p>
-<ol>
-<li>
-<p>Open the Java class in the <span class="gui-object-title">Project Explorer</span>.</p>
-</li>
-<li>
-<p>Select the class in the JPA Structure view.</p>
-</li>
-<li>
-<p>In the JPA Details view, click the mapping type hyperlink to open the Mapping Type Selection dialog.</p>
-</li>
-<li>
-<p>Select <span class="bold">Mapped Superclass</span> and then <span class="bold">OK</span>.</p>
-<div class="figure"><a id="sthref89" name="sthref89"></a>
-<p class="titleinfigure">Mapping Type Selection Dialog (Mapped Superclass)</p>
-<img src="img/mapping_type_selection_superclass.png" alt="The Mapping Type Selection dialog with Mapped Superclass selected." title="The Mapping Type Selection dialog with Mapped Superclass selected." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Complete the remaining <a href="ref_persistence_prop_view.htm#BABFAEBB">JPA Details view (for entities)</a>.</p>
-</li>
-</ol>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related tasks" title="Related tasks" /><br />
-<br />
-<a href="task_add_persistence.htm#BABHICAI">Adding persistence to a class</a><br />
-<a href="task_additonal_tables.htm#CIHGBIEI">Specifying additional tables</a><br />
-<a href="task_inheritance.htm#CIHCCCJD">Specifying entity inheritance</a><br /></div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks008.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks008.htm
deleted file mode 100644
index 55a6ed1..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks008.htm
+++ /dev/null
@@ -1,65 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Creating Named Queries</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:46Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Creating Named Queries" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABIGBGG" name="BABIGBGG"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Creating Named Queries</h1>
-<p><a id="sthref105" name="sthref105"></a><a id="sthref106" name="sthref106"></a>Named queries improve application performance because they are prepared once and they (and all of their associated supporting objects) can be efficiently reused thereafter, making them well suited for complex and frequently executed operations. Named queries use the JPA query language for portable execution on any underlying database; named native queries use the SQL language native to the underlying database.</p>
-<p>Use this procedure to add <code>@NamedQuery</code> and <code>@NamedNativeQuery</code> annotations to the entity.</p>
-<p>To create a named query:</p>
-<ol>
-<li>
-<p>Select the entity in the Project Explorer.</p>
-</li>
-<li>
-<p>In the JPA Details view, expand Queries.</p>
-</li>
-<li>
-<p>Click <span class="bold">Add</span> for a named query, or <span class="bold">Add Native</span> for a native query.</p>
-</li>
-<li>
-<p>In the dialog that appears, enter the name of the query in the Name field and then click OK.</p>
-</li>
-<li>
-<p>Enter the query in the Query field.</p>
-</li>
-<li>
-<p><a id="sthref107" name="sthref107"></a><a id="sthref108" name="sthref108"></a><a id="sthref109" name="sthref109"></a><a id="sthref110" name="sthref110"></a>To add a Query hint, click <span class="bold">Add</span>.</p>
-<div class="figure"><a id="sthref111" name="sthref111"></a>
-<p class="titleinfigure">Entering a Named Query</p>
-<img src="img/task_entering_query.png" alt="The Queries section of the JPA Details view." title="The Queries section of the JPA Details view." /><br /></div>
-<!-- class="figure" --></li>
-</ol>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks009.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks009.htm
deleted file mode 100644
index 536fda3..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks009.htm
+++ /dev/null
@@ -1,183 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Basic mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:46Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Basic mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABBABCE" name="BABBABCE"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Basic mapping</h1>
-<p><a id="sthref112" name="sthref112"></a><a id="sthref113" name="sthref113"></a><a id="sthref114" name="sthref114"></a><a id="sthref115" name="sthref115"></a>Use a <span class="bold">Basic Mapping</span> to map an attribute directly to a database column. Basic mappings may be used only with the following attribute types:</p>
-<ul>
-<li>
-<p>Java primitive types and wrappers of the primitive types</p>
-</li>
-<li>
-<p><code>java.lang.String, java.math.BigInteger</code></p>
-</li>
-<li>
-<p><code>java.math.BigDecimal</code></p>
-</li>
-<li>
-<p><code>java.util.Date</code></p>
-</li>
-<li>
-<p><code>java.util.Calendar, java.sql.Date</code></p>
-</li>
-<li>
-<p><code>java.sql.Time</code></p>
-</li>
-<li>
-<p><code>java.sql.Timestamp</code></p>
-</li>
-<li>
-<p><code>byte[]</code></p>
-</li>
-<li>
-<p><code>Byte[]</code></p>
-</li>
-<li>
-<p><code>char[]</code></p>
-</li>
-<li>
-<p><code>Character[]</code></p>
-</li>
-<li>
-<p>enums</p>
-</li>
-<li>
-<p>any other type that implements <code>Serializable</code></p>
-</li>
-</ul>
-<p>To create a basic mapping:</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, right-click the field to map. Select <span class="bold">Map As &gt; Basic</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected field.</p>
-</li>
-<li>
-<p>Use this table to complete the remaining fields on the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="41%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t14">Property</th>
-<th align="left" valign="bottom" id="r1c2-t14">Description</th>
-<th align="left" valign="bottom" id="r1c3-t14">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t14" headers="r1c1-t14">Entity Map Hyperlink</td>
-<td align="left" headers="r2c1-t14 r1c2-t14">Defines this mapping as a <span class="bold">Basic Mapping</span>.
-<p>This corresponds to the <code>@Basic</code> annotation.</p>
-</td>
-<td align="left" headers="r2c1-t14 r1c3-t14">Basic</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t14" headers="r1c1-t14">Column</td>
-<td align="left" headers="r3c1-t14 r1c2-t14">The database column mapped to the entity attribute. See <a href="ref_mapping_general.htm#CACGCBHB">"Column"</a> for details.</td>
-<td align="left" headers="r3c1-t14 r1c3-t14">By default, the Column is assumed to be named identically to the attribute and always included in the <code>INSERT</code> and <code>UPDATE</code> statements.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t14" headers="r1c1-t14">Table</td>
-<td align="left" headers="r4c1-t14 r1c2-t14">Name of the database table.</td>
-<td align="left" headers="r4c1-t14 r1c3-t14"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t14" headers="r1c1-t14">Fetch</td>
-<td align="left" headers="r5c1-t14 r1c2-t14">Defines how data is loaded from the database. See <a href="ref_mapping_general.htm#CACGGGHB">"Fetch Type"</a> for details.
-<ul>
-<li>
-<p>Eager</p>
-</li>
-<li>
-<p>Lazy</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r5c1-t14 r1c3-t14">Eager</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t14" headers="r1c1-t14">Optional</td>
-<td align="left" headers="r6c1-t14 r1c2-t14">Specifies if this field is can be null.</td>
-<td align="left" headers="r6c1-t14 r1c3-t14">Yes</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t14" headers="r1c1-t14">Type</td>
-<td align="left" headers="r7c1-t14 r1c2-t14">Specifies the type of data:
-<ul>
-<li>
-<p>Default</p>
-</li>
-<li>
-<p>LOB &ndash; Specifies if this is a large objects (BLOB or CLOB). See <a href="ref_mapping_general.htm#CACBBIBI">"Lob"</a> for details.</p>
-</li>
-<li>
-<p>Temporal &ndash; Specify if this is a Date, Time, or Timestamp object. See <a href="ref_mapping_general.htm#CACEAJGD">"Temporal"</a> for details.</p>
-</li>
-<li>
-<p>Enumerated &ndash; Specify how to persist enumerated constraints as ordinal or string, in order to match an existing database schema.</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r7c1-t14 r1c3-t14"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@Column(name="<span class="italic">&lt;COLUMN_NAME&gt;</span>", table="<span class="italic">&lt;COLUMN_TABLE&gt;</span>", 
-    insertable=<span class="italic">&lt;INSERTABLE&gt;</span>, updatable=<span class="italic">&lt;UPDATABLE&gt;</span>)
-@Basic(fetch=FetchType.<span class="italic">&lt;FETCH_TYPE&gt;</span>, optional = <span class="italic">&lt;OPTIONAL&gt;</span>)
-@Temporal(TemporalType.<span class="italic">&lt;TEMPORAL&gt;</span>)
-
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks010.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks010.htm
deleted file mode 100644
index 4b29ebb..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks010.htm
+++ /dev/null
@@ -1,97 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Embedded mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:46Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Embedded mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABCBHDF" name="BABCBHDF"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Embedded mapping</h1>
-<p><a id="sthref116" name="sthref116"></a><a id="sthref117" name="sthref117"></a><a id="sthref118" name="sthref118"></a><a id="sthref119" name="sthref119"></a>Use an <span class="bold">Embedded Mapping</span> to specify a persistent field or property of an entity whose value is an instance of an embeddable class.</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, right-click the field to map.</p>
-</li>
-<li>
-<p>Select <span class="bold">Map as &gt; Embedded</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected field.</p>
-</li>
-<li>
-<p>Use this table to complete the remaining fields on the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="38%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t15">Property</th>
-<th align="left" valign="bottom" id="r1c2-t15">Description</th>
-<th align="left" valign="bottom" id="r1c3-t15">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t15" headers="r1c1-t15">Entity Mapping Hyperlink</td>
-<td align="left" headers="r2c1-t15 r1c2-t15">Defines this mapping as a <span class="bold">Embedded</span>.
-<p>This corresponds to the <code>@Embedded</code> annotation.</p>
-</td>
-<td align="left" headers="r2c1-t15 r1c3-t15">Embedded</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t15" headers="r1c1-t15">Attribute Overrides</td>
-<td align="left" headers="r3c1-t15 r1c2-t15">Specify to override the default mapping of an entity's attribute. Select <span class="bold">Override Default</span>.</td>
-<td align="left" headers="r3c1-t15 r1c3-t15"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@Embedded
-@AttributeOverride(column=@Column(table="<span class="italic">&lt;COLUMN_TABLE&gt;</span>", name = "<span class="italic">&lt;COLUMN_NAME&gt;</span>"))
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks011.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks011.htm
deleted file mode 100644
index 01aa24a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks011.htm
+++ /dev/null
@@ -1,91 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Embedded ID mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:46Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Embedded ID mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHDIAEE" name="CIHDIAEE"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Embedded ID mapping</h1>
-<p><a id="sthref120" name="sthref120"></a><a id="sthref121" name="sthref121"></a><a id="sthref122" name="sthref122"></a><a id="sthref123" name="sthref123"></a>Use an <span class="bold">Embedded ID Mapping</span> to specify the primary key of an embedded ID. These mappings may be used with a <a href="tasks006.htm#BABFEICE">Embeddable</a> entities.</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, select the field to map.</p>
-</li>
-<li>
-<p>Right-click the field and then select <span class="bold">Map As &gt; Embedded Id</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected field.</p>
-</li>
-<li>
-<p>Use this table to complete the remaining fields on the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="38%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t16">Property</th>
-<th align="left" valign="bottom" id="r1c2-t16">Description</th>
-<th align="left" valign="bottom" id="r1c3-t16">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t16" headers="r1c1-t16">Entity Mapping Hyperlink</td>
-<td align="left" headers="r2c1-t16 r1c2-t16">Defines this mapping as a <span class="bold">Embedded Id</span>.
-<p>This corresponds to the <code>@EmbeddedId</code> annotation.</p>
-</td>
-<td align="left" headers="r2c1-t16 r1c3-t16">Embedded Id</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@EmbeddedId
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks012.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks012.htm
deleted file mode 100644
index dc6d21b..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks012.htm
+++ /dev/null
@@ -1,176 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>ID mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:47Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="ID mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABGCBHG" name="BABGCBHG"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>ID mapping</h1>
-<p><a id="sthref124" name="sthref124"></a><a id="sthref125" name="sthref125"></a><a id="sthref126" name="sthref126"></a><a id="sthref127" name="sthref127"></a>Use an <span class="bold">ID Mapping</span> to specify the primary key of an entity. ID mappings may be used with a <a href="tasks005.htm#BABGBIEE">Entity</a> or <a href="tasks007.htm#BABDAGCI">Mapped superclass</a>. Each <a href="tasks005.htm#BABGBIEE">Entity</a> must have an ID mapping.</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, select the field to map.</p>
-</li>
-<li>
-<p>Right click the filed and then select <span class="bold">Map as &gt; ID</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected.</p>
-</li>
-<li>
-<p>Use this table to complete the <a href="ref_mapping_general.htm#CACBHFIJ">General information</a> fields in the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="22%" />
-<col width="*" />
-<col width="35%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t17">Property</th>
-<th align="left" valign="bottom" id="r1c2-t17">Description</th>
-<th align="left" valign="bottom" id="r1c3-t17">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t17" headers="r1c1-t17">Entity Mapping Hyperlink</td>
-<td align="left" headers="r2c1-t17 r1c2-t17">Defines this mapping as an <span class="bold">ID Mapping</span>.
-<p>This field corresponds to the <code>@Id</code> annotation.</p>
-</td>
-<td align="left" headers="r2c1-t17 r1c3-t17">ID</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t17" headers="r1c1-t17">Column</td>
-<td align="left" headers="r3c1-t17 r1c2-t17">The database column mapped to the entity attribute. See <a href="ref_mapping_general.htm#CACGCBHB">"Column"</a> for details.</td>
-<td align="left" headers="r3c1-t17 r1c3-t17">By default, the Column is assumed to be named identically to the attribute.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t17" headers="r1c1-t17">Table</td>
-<td align="left" headers="r4c1-t17 r1c2-t17">The database table mapped to the entity attribute.</td>
-<td align="left" headers="r4c1-t17 r1c3-t17">By default, the Table is assumed to be identical to the table associated with the entity.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t17" headers="r1c1-t17">Temporal</td>
-<td align="left" headers="r5c1-t17 r1c2-t17">Specifies the type of data. See <a href="ref_mapping_general.htm#CACEAJGD">"Temporal"</a> for details.
-<ul>
-<li>
-<p>Date</p>
-</li>
-<li>
-<p>Time</p>
-</li>
-<li>
-<p>Timestamp</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r5c1-t17 r1c3-t17"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-<li>
-<p>Use this table to complete the fields in <a href="ref_primary_key.htm#CACFCCAB">Primary Key Generation information</a> area in the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the PK Generation tab." summary="This table lists the fields in the PK Generation tab." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="22%" />
-<col width="*" />
-<col width="35%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t18">Property</th>
-<th align="left" valign="bottom" id="r1c2-t18">Description</th>
-<th align="left" valign="bottom" id="r1c3-t18">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t18" headers="r1c1-t18">Primary Key Generation</td>
-<td align="left" headers="r2c1-t18 r1c2-t18">These fields define how the primary key is generated.</td>
-<td align="left" headers="r2c1-t18 r1c3-t18"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t18" headers="r1c1-t18">&nbsp;&nbsp;Strategy</td>
-<td align="left" headers="r3c1-t18 r1c2-t18">See <a href="ref_primary_key.htm#CACBAJBC">"Primary Key Generation"</a> for details.
-<ul>
-<li>
-<p>Auto</p>
-</li>
-<li>
-<p>Sequence</p>
-</li>
-<li>
-<p>Identity</p>
-</li>
-<li>
-<p>Table</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r3c1-t18 r1c3-t18">Auto</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t18" headers="r1c1-t18">&nbsp;&nbsp;Generator&nbsp;Name</td>
-<td align="left" headers="r4c1-t18 r1c2-t18">Name of the primary key generator specified in the <span class="bold">Strategy</span></td>
-<td align="left" headers="r4c1-t18 r1c3-t18"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Additional fields will appear in the <a href="ref_primary_key.htm#CACFCCAB">Primary Key Generation information</a> area, depending on the selected Strategy. See <a href="ref_persistence_map_view.htm#BABIFBAF">"JPA Details view (for attributes)"</a> for additional information.</p>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@Id
-@Column(name="<span class="italic">&lt;COLUMN_NAME&gt;</span>", table="<span class="italic">&lt;TABLE_NAME&gt;</span>", insertable=<span class="italic">&lt;INSERTABLE&gt;</span>,
-    updatable=<span class="italic">&lt;UPDATABLE&gt;</span>)
-@Temporal(<span class="italic">&lt;TEMPORAL&gt;</span>)
-@GeneratedValue(strategy=GeneratorType.<span class="italic">&lt;STRATEGY&gt;</span>, generator="<span class="italic">&lt;GENERATOR_NAME&gt;</span>")@TableGenerator(name="<span class="italic">&lt;TABLE_GENERATOR_NAME&gt;</span>", table = "<span class="italic">&lt;TABLE_GENERATOR_TABLE&gt;</span>", 
-    pkColumnName = "<span class="italic">&lt;TABLE_GENERATOR_PK&gt;</span>", 
-    valueColumnName = "<span class="italic">&lt;TABLE_GENERATOR_VALUE_COLUMN&gt;</span>", 
-    pkColumnValue = "<span class="italic">&lt;TABLE_GENERATOR_PK_COLUMN_VALUE&gt;</span>")@SequenceGenerator(name="<span class="italic">&lt;SEQUENCE_GENERATOR_NAME&gt;</span>", 
-    sequenceName="<span class="italic">&lt;SEQUENCE_GENERATOR_SEQUENCE&gt;</span>")
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks013.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks013.htm
deleted file mode 100644
index bcd575f..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks013.htm
+++ /dev/null
@@ -1,179 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Many-to-many mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:47Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Many-to-many mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABEIEGD" name="BABEIEGD"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Many-to-many mapping</h1>
-<p><a id="sthref128" name="sthref128"></a><a id="sthref129" name="sthref129"></a><a id="sthref130" name="sthref130"></a><a id="sthref131" name="sthref131"></a>Use a <span class="bold">Many-to-Many Mapping</span> to define a many-valued association with many-to-many multiplicity. A many-to-many mapping has two sides: the <span class="italic">owning side</span> and <span class="italic">non-owning side</span>. You must specify the join table on the owning side. For bidirectional mappings, either side may be the owning side.</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, select the field to map.</p>
-</li>
-<li>
-<p>Right-click the field and then select <span class="bold">Map As &gt; Many-to-Many</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected field.</p>
-</li>
-<li>
-<p>Use this table to complete the <a href="ref_mapping_general.htm#CACBHFIJ">General information</a> fields of the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="41%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t19">Property</th>
-<th align="left" valign="bottom" id="r1c2-t19">Description</th>
-<th align="left" valign="bottom" id="r1c3-t19">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t19" headers="r1c1-t19">Mapping Entity Hyperlink</td>
-<td align="left" headers="r2c1-t19 r1c2-t19">Defines this mapping as a <span class="bold">Many to Many Mapping</span>.
-<p>This field corresponds to the <code>@ManyToMany</code> annotation.</p>
-</td>
-<td align="left" headers="r2c1-t19 r1c3-t19">Many to Many</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t19" headers="r1c1-t19">Target Entity</td>
-<td align="left" headers="r3c1-t19 r1c2-t19">The entity to which this attribute is mapped.</td>
-<td align="left" headers="r3c1-t19 r1c3-t19">null
-<p>You do not need to explicitly specify the target entity, since it can be inferred from the type of object being referenced.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t19" headers="r1c1-t19">Fetch</td>
-<td align="left" headers="r4c1-t19 r1c2-t19">Defines how data is loaded from the database. See <a href="ref_mapping_general.htm#CACGGGHB">"Fetch Type"</a> for details.
-<ul>
-<li>
-<p>Eager</p>
-</li>
-<li>
-<p>Lazy</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r4c1-t19 r1c3-t19">Lazy</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t19" headers="r1c1-t19">Mapped By</td>
-<td align="left" headers="r5c1-t19 r1c2-t19">The database field that owns the relationship.</td>
-<td align="left" headers="r5c1-t19 r1c3-t19"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t19" headers="r1c1-t19">Order By</td>
-<td align="left" headers="r6c1-t19 r1c2-t19">Specify the default order for objects returned from a query. See <a href="ref_mapping_general.htm#CACDADIH">"Order By"</a> for details.
-<ul>
-<li>
-<p>No ordering</p>
-</li>
-<li>
-<p>Primary key</p>
-</li>
-<li>
-<p>Custom</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r6c1-t19 r1c3-t19">No ordering</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-<li>
-<p>Use this table to complete the fields in the <a href="reference011.htm#CACBAEBC">Join Table Information</a> area in the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Join Table tab of the Persistence Properties view for this mapping." summary="This table lists the fields in the Join Table tab of the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="38%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t20">Property</th>
-<th align="left" valign="bottom" id="r1c2-t20">Description</th>
-<th align="left" valign="bottom" id="r1c3-t20">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t20" headers="r1c1-t20">Name</td>
-<td align="left" headers="r2c1-t20 r1c2-t20">Name of the join table that contains the foreign key column.</td>
-<td align="left" headers="r2c1-t20 r1c3-t20">You must specify the join table on the owning side.
-<p>By default, the name is assumed to be the primary tables associated with the entities concatenated with an underscore.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t20" headers="r1c1-t20">Join Columns</td>
-<td align="left" headers="r3c1-t20 r1c2-t20">Select <span class="bold">Override Default</span>, then Add, Edit, or Remove the join columns.</td>
-<td align="left" headers="r3c1-t20 r1c3-t20">By default, the name is assumed to be the primary tables associated with the entities concatenated with an underscore.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t20" headers="r1c1-t20">Inverse Join Columns</td>
-<td align="left" headers="r4c1-t20 r1c2-t20">Select <span class="bold">Override Default</span>, then Add, Edit, or Remove the join columns.</td>
-<td align="left" headers="r4c1-t20 r1c3-t20">By default, the mapping is assumed to have a single join.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-<li>
-<p>To add a new Join or Inverse Join Column, click <span class="gui-object-action">Add</span>.</p>
-<p>To edit an existing Join or Inverse Join Column, select the field to and click <span class="gui-object-action">Edit</span>.</p>
-</li>
-</ol>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@JoinTable(joinColumns=@JoinColumn(name="<span class="italic">&lt;JOIN_COLUMN&gt;</span>"), 
-    name = "<span class="italic">&lt;JOIN_TABLE_NAME&gt;</span>")
-@ManyToMany(cascade=CascadeType.<span class="italic">&lt;CASCADE_TYPE&gt;</span>, fetch=FetchType.<span class="italic">&lt;FETCH_TYPE&gt;</span>,
-    targetEntity=<span class="italic">&lt;TARGET_ENTITY&gt;</span>, mappedBy = "<span class="italic">&lt;MAPPED_BY&gt;</span>")
-@OrderBy("<span class="italic">&lt;ORDER_BY&gt;</span>")
-
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks014.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks014.htm
deleted file mode 100644
index a8760db..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks014.htm
+++ /dev/null
@@ -1,167 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Many-to-one mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:47Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Many-to-one mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABHFAFJ" name="BABHFAFJ"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Many-to-one mapping</h1>
-<p><a id="sthref132" name="sthref132"></a><a id="sthref133" name="sthref133"></a><a id="sthref134" name="sthref134"></a><a id="sthref135" name="sthref135"></a>Use a <span class="bold">Many-to-One</span> mapping to defines a single-valued association to another entity class that has many-to-one multiplicity.</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, select the field to map.</p>
-</li>
-<li>
-<p>Right click the field and then select <span class="bold">Map As &gt; Many-to-One</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected.</p>
-</li>
-<li>
-<p>Use this table to complete the <a href="ref_mapping_general.htm#CACBHFIJ">General information</a> fields JPA Details view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields ion the General tab for this mapping." summary="This table lists the fields ion the General tab for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="41%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t21">Property</th>
-<th align="left" valign="bottom" id="r1c2-t21">Description</th>
-<th align="left" valign="bottom" id="r1c3-t21">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t21" headers="r1c1-t21">Mapping Entity Hyperlink</td>
-<td align="left" headers="r2c1-t21 r1c2-t21">Defines mapping as <span class="bold">Many-to-One</span>. This corresponds to the <code>@ManyToOne</code> annotation.</td>
-<td align="left" headers="r2c1-t21 r1c3-t21">Many-to-One</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t21" headers="r1c1-t21">Target Entity</td>
-<td align="left" headers="r3c1-t21 r1c2-t21">The entity to which this attribute is mapped.</td>
-<td align="left" headers="r3c1-t21 r1c3-t21">null
-<p>You do not need to explicitly specify the target entity, since it can be inferred from the type of object being referenced.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t21" headers="r1c1-t21">Fetch</td>
-<td align="left" headers="r4c1-t21 r1c2-t21">Defines how data is loaded from the database. See <a href="ref_mapping_general.htm#CACGGGHB">"Fetch Type"</a> for details.
-<ul>
-<li>
-<p>Eager</p>
-</li>
-<li>
-<p>Lazy</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r4c1-t21 r1c3-t21">Eager</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t21" headers="r1c1-t21">Cascade</td>
-<td align="left" headers="r5c1-t21 r1c2-t21">See <a href="ref_mapping_general.htm#CACJAIHB">"Cascade Type"</a> for details.
-<ul>
-<li>
-<p>Default</p>
-</li>
-<li>
-<p>All</p>
-</li>
-<li>
-<p>Persist</p>
-</li>
-<li>
-<p>Merge</p>
-</li>
-<li>
-<p>Remove</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r5c1-t21 r1c3-t21">Default</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t21" headers="r1c1-t21">Optional</td>
-<td align="left" headers="r6c1-t21 r1c2-t21">Specifies if this field is can be null.</td>
-<td align="left" headers="r6c1-t21 r1c3-t21">Yes</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-<li>
-<p>Use this table to complete the fields on the <a href="reference012.htm#CACFCEJC">Join Columns Information</a> tab in the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="41%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t22">Property</th>
-<th align="left" valign="bottom" id="r1c2-t22">Description</th>
-<th align="left" valign="bottom" id="r1c3-t22">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t22" headers="r1c1-t22">Join Column</td>
-<td align="left" headers="r2c1-t22 r1c2-t22"><a id="sthref136" name="sthref136"></a><a id="sthref137" name="sthref137"></a>Specify a mapped column for joining an entity association. This field corresponds to the <code>@JoinColum</code> attribute.
-<p>Select <span class="bold">Override Default</span>, then Add, Edit, or Remove the join columns.</p>
-</td>
-<td align="left" headers="r2c1-t22 r1c3-t22">By default, the mapping is assumed to have a single join.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@JoinTable(joinColumns=@JoinColumn(name="<span class="italic">&lt;JOIN_COLUMN&gt;</span>"), 
-    name = "<span class="italic">&lt;JOIN_TABLE_NAME&gt;</span>")
-@ManyToOne(targetEntity=<span class="italic">&lt;TARGET_ENTITY&gt;</span>, fetch=<span class="italic">&lt;FETCH_TYPE&gt;</span>, 
-    cascade=<span class="italic">&lt;CASCADE_TYPE&gt;</span>)
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks015.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks015.htm
deleted file mode 100644
index 95bddfc..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks015.htm
+++ /dev/null
@@ -1,197 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>One-to-many mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:47Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="One-to-many mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABHGEBD" name="BABHGEBD"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>One-to-many mapping</h1>
-<p><a id="sthref138" name="sthref138"></a><a id="sthref139" name="sthref139"></a><a id="sthref140" name="sthref140"></a><a id="sthref141" name="sthref141"></a>Use a <span class="bold">One-to-Many Mapping</span> to define a relationship with one-to-many multiplicity.</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, select the field to map.</p>
-</li>
-<li>
-<p>Right-click the field and then select <span class="bold">Map As &gt; One-to-many</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected.</p>
-</li>
-<li>
-<p>Use this table to complete the <a href="ref_mapping_general.htm#CACBHFIJ">General information</a> fields JPA Details view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the General tab of the Persistence Properties view for this mapping." summary="This table lists the fields in the General tab of the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="38%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t23">Property</th>
-<th align="left" valign="bottom" id="r1c2-t23">Description</th>
-<th align="left" valign="bottom" id="r1c3-t23">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t23" headers="r1c1-t23">Mapping Entity Type Hyperlink</td>
-<td align="left" headers="r2c1-t23 r1c2-t23">Defines mapping as <span class="bold">One-to-Many</span>. This corresponds to the <code>@OneToMany</code> annotation.</td>
-<td align="left" headers="r2c1-t23 r1c3-t23">One-to-Many</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t23" headers="r1c1-t23">Target Entity</td>
-<td align="left" headers="r3c1-t23 r1c2-t23">The entity to which this attribute is mapped.</td>
-<td align="left" headers="r3c1-t23 r1c3-t23"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t23" headers="r1c1-t23">Cascade</td>
-<td align="left" headers="r4c1-t23 r1c2-t23">See <a href="ref_mapping_general.htm#CACJAIHB">"Cascade Type"</a> for details.
-<ul>
-<li>
-<p>Default</p>
-</li>
-<li>
-<p>All</p>
-</li>
-<li>
-<p>Persist</p>
-</li>
-<li>
-<p>Merge</p>
-</li>
-<li>
-<p>Remove</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r4c1-t23 r1c3-t23"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t23" headers="r1c1-t23">Fetch</td>
-<td align="left" headers="r5c1-t23 r1c2-t23">Defines how data is loaded from the database. See <a href="ref_mapping_general.htm#CACGGGHB">"Fetch Type"</a> for details.
-<ul>
-<li>
-<p>Eager</p>
-</li>
-<li>
-<p>Lazy</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r5c1-t23 r1c3-t23">Eager</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r6c1-t23" headers="r1c1-t23">Mapped By</td>
-<td align="left" headers="r6c1-t23 r1c2-t23">The database field that owns the relationship.</td>
-<td align="left" headers="r6c1-t23 r1c3-t23"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r7c1-t23" headers="r1c1-t23">Order By</td>
-<td align="left" headers="r7c1-t23 r1c2-t23">Specify the default order for objects returned from a query. See <a href="ref_mapping_general.htm#CACDADIH">"Order By"</a> for details.
-<ul>
-<li>
-<p>No ordering</p>
-</li>
-<li>
-<p>Primary key</p>
-</li>
-<li>
-<p>Custom</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r7c1-t23 r1c3-t23">No ordering</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-<li>
-<p>Use this table to complete the <a href="reference011.htm#CACBAEBC">Join Table Information</a> fields in the JPA Details view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Join Table tab of the Persistence Properties view for this mapping." summary="This table lists the fields in the Join Table tab of the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="38%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t24">Property</th>
-<th align="left" valign="bottom" id="r1c2-t24">Description</th>
-<th align="left" valign="bottom" id="r1c3-t24">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t24" headers="r1c1-t24">Name</td>
-<td align="left" headers="r2c1-t24 r1c2-t24">Name of the join table</td>
-<td align="left" headers="r2c1-t24 r1c3-t24">By default, the name is assumed to be the primary tables associated with the entities concatenated with an underscore.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t24" headers="r1c1-t24">Join Columns</td>
-<td align="left" headers="r3c1-t24 r1c2-t24">Specify two or more join columns (that is, a primary key).</td>
-<td align="left" headers="r3c1-t24 r1c3-t24"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t24" headers="r1c1-t24">Inverse Join Columns</td>
-<td align="left" headers="r4c1-t24 r1c2-t24">The join column on the owned (or inverse) side of the association: the owned entity's primary key column.</td>
-<td align="left" headers="r4c1-t24 r1c3-t24"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@OneToMany(targetEntity=<span class="italic">&lt;TARGET_ENTITY&gt;</span>)
-@Column(name="<span class="italic">&lt;COLUMN&gt;</span>")
-
-
-@OneToMany(targetEntity=<span class="italic">&lt;TARGET_ENTITY&gt;</span>.class, cascade=CascadeType.<span class="italic">&lt;CASCADE_TYPE&gt;</span>, 
-    fetch = FetchType.<span class="italic">&lt;FETCH_TYPE&gt;</span>, mappedBy = "<span class="italic">&lt;MAPPED_BY&gt;</span>")@OrderBy("<span class="italic">&lt;ORDER_BY&gt;</span>")
-@JoinTable(name="<span class="italic">&lt;JOIN_TABLE_NAME&gt;</span>", joinColumns=@JoinColumn(name=
-    "<span class="italic">&lt;JOIN_COLUMN_NAME&gt;</span>", referencedColumnName="<span class="italic">&lt;JOIN_COLUMN_REFERENCED_COLUMN&gt;</span>"), 
-    inverseJoinColumns=@JoinColumn(name="<span class="italic">&lt;INVERSE_JOIN_COLUMN_NAME&gt;</span>", 
-    referencedColumnName="<span class="italic">&lt;INVERSE_JOIN_COLUMN_REFERENCED_COLUMN&gt;</span>"))
-
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks016.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks016.htm
deleted file mode 100644
index d057a88..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks016.htm
+++ /dev/null
@@ -1,146 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>One-to-one mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:48Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="One-to-one mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABFHBCJ" name="BABFHBCJ"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>One-to-one mapping</h1>
-<p><a id="sthref142" name="sthref142"></a><a id="sthref143" name="sthref143"></a><a id="sthref144" name="sthref144"></a><a id="sthref145" name="sthref145"></a>Use a <span class="bold">One-to-One Mapping</span> to define a relationship with one-to-many multiplicity.</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, select the field to map.</p>
-</li>
-<li>
-<p>Right-click the field and then select <span class="bold">Map As &gt; One-to-One</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected.</p>
-</li>
-<li>
-<p>Use this table to complete the <a href="ref_mapping_general.htm#CACBHFIJ">General information</a> fields in the JPA Details view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="41%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t25">Property</th>
-<th align="left" valign="bottom" id="r1c2-t25">Description</th>
-<th align="left" valign="bottom" id="r1c3-t25">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t25" headers="r1c1-t25">Mapped Entity Hyperlink</td>
-<td align="left" headers="r2c1-t25 r1c2-t25">Defines mapping as <span class="bold">One-to-One</span>. This corresponds to the <code>@OneToOne</code> annotation.</td>
-<td align="left" headers="r2c1-t25 r1c3-t25">One-to-One</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t25" headers="r1c1-t25">Target Entity</td>
-<td align="left" headers="r3c1-t25 r1c2-t25">The entity to which this attribute is mapped.</td>
-<td align="left" headers="r3c1-t25 r1c3-t25">null
-<p>You do not need to explicitly specify the target entity, since it can be inferred from the type of object being referenced.</p>
-</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t25" headers="r1c1-t25">Fetch Type</td>
-<td align="left" headers="r4c1-t25 r1c2-t25">Defines how data is loaded from the database. See <a href="ref_mapping_general.htm#CACGGGHB">"Fetch Type"</a> for details.
-<ul>
-<li>
-<p>Eager</p>
-</li>
-<li>
-<p>Lazy</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r4c1-t25 r1c3-t25">Eager</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t25" headers="r1c1-t25">Mapped By</td>
-<td align="left" headers="r5c1-t25 r1c2-t25">The database field that owns the relationship.</td>
-<td align="left" headers="r5c1-t25 r1c3-t25"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-<li>
-<p>Use this table to complete the <a href="reference012.htm#CACFCEJC">Join Columns Information</a> fields in the <span class="gui-object-title">JPA Details</span> view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="41%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t26">Property</th>
-<th align="left" valign="bottom" id="r1c2-t26">Description</th>
-<th align="left" valign="bottom" id="r1c3-t26">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t26" headers="r1c1-t26">Join Column</td>
-<td align="left" headers="r2c1-t26 r1c2-t26"><a id="sthref146" name="sthref146"></a><a id="sthref147" name="sthref147"></a>Specify a mapped column for joining an entity association. This field corresponds to the <code>@JoinColum</code> attribute.
-<p>Select <span class="bold">Override Default</span>, then Add, Edit, or Remove the join columns.</p>
-</td>
-<td align="left" headers="r2c1-t26 r1c3-t26">By default, the mapping is assumed to have a single join.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@OneToOne(targetEntity=<span class="italic">&lt;TARGET_ENTITY&gt;</span>, cascade=CascadeType.<span class="italic">&lt;CASCADE_TYPE&gt;</span>, 
-    fetch = FetchType.<span class="italic">&lt;FETCH_TYPE&gt;</span>, mappedBy = "<span class="italic">&lt;MAPPED_BY&gt;</span>")
-@JoinColumn(name="<span class="italic">&lt;JOIN_COLUMN_NAME&gt;</span>", referencedColumnName=
-    "<span class="italic">&lt;JOIN_COLUMN_REFERENCED_COLUMN&gt;</span>", insertable = <span class="italic">&lt;INSERTABLE&gt;</span>, 
-    updatable = <span class="italic">&lt;UPDATABLE&gt;</span>)
-
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks017.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks017.htm
deleted file mode 100644
index 7d00676..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks017.htm
+++ /dev/null
@@ -1,66 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Transient mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:48Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Transient mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABHFHEI" name="BABHFHEI"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Transient mapping</h1>
-<p><a id="sthref148" name="sthref148"></a><a id="sthref149" name="sthref149"></a><a id="sthref150" name="sthref150"></a><a id="sthref151" name="sthref151"></a>Use the Transient Mapping to specify a field of the entity class that <span class="italic">is not</span> persistent.</p>
-<p>To create a transient mapping:</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, select the field to map.</p>
-</li>
-<li>
-<p>Right-click the field and then select <span class="bold">Map As Transient</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected.</p>
-</li>
-</ol>
-<p>Eclipse adds the following annotation to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@Transient
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks018.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks018.htm
deleted file mode 100644
index d33b7ab..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks018.htm
+++ /dev/null
@@ -1,137 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Version mapping</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:48Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Version mapping" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABHIBII" name="BABHIBII"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Version mapping</h1>
-<p><a id="sthref152" name="sthref152"></a><a id="sthref153" name="sthref153"></a><a id="sthref154" name="sthref154"></a><a id="sthref155" name="sthref155"></a>Use a <span class="bold">Version Mapping</span> to specify the field used for optimistic locking. If the entity is associated with multiple tables, you should use a version mapping only with the primary table. You should have only a single version mapping per persistent entity. Version mappings may be used only with the following attribute types:</p>
-<ul>
-<li>
-<p><code>int</code></p>
-</li>
-<li>
-<p><code>Integer</code></p>
-</li>
-<li>
-<p><code>short, Short</code></p>
-</li>
-<li>
-<p><code>long, Long</code></p>
-</li>
-<li>
-<p><code>Timestamp</code></p>
-</li>
-</ul>
-<p>To create a version mapping:</p>
-<ol>
-<li>
-<p>In the <a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a>, select the field to map.</p>
-</li>
-<li>
-<p>Right-click the field and then select <span class="bold">Map As &gt; Version</span>. The <a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a> displays the properties for the selected.</p>
-</li>
-<li>
-<p>Use this table to complete the remaining fields in the JPA Details view.</p>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the fields in the Persistence Properties view for this mapping." summary="This table lists the fields in the Persistence Properties view for this mapping." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="19%" />
-<col width="*" />
-<col width="38%" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t27">Property</th>
-<th align="left" valign="bottom" id="r1c2-t27">Description</th>
-<th align="left" valign="bottom" id="r1c3-t27">Default</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t27" headers="r1c1-t27">Mapped Entity Hyperlink</td>
-<td align="left" headers="r2c1-t27 r1c2-t27">Defines the mapping as Version. This corresponds to the <code>@Version</code> annotation.</td>
-<td align="left" headers="r2c1-t27 r1c3-t27">Version</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t27" headers="r1c1-t27">Column</td>
-<td align="left" headers="r3c1-t27 r1c2-t27">The database column mapped to the entity attribute. See <a href="ref_mapping_general.htm#CACGCBHB">"Column"</a> for details.</td>
-<td align="left" headers="r3c1-t27 r1c3-t27">By default, the Column is assumed to be named identically to the attribute and always included in the <code>INSERT</code> and <code>UPDATE</code> statements.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r4c1-t27" headers="r1c1-t27">Table</td>
-<td align="left" headers="r4c1-t27 r1c2-t27">Name of the database table. This must be the primary table associated with the attribute's entity.</td>
-<td align="left" headers="r4c1-t27 r1c3-t27"><br /></td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r5c1-t27" headers="r1c1-t27">Temporal</td>
-<td align="left" headers="r5c1-t27 r1c2-t27">Specifies the type of data. See <a href="ref_mapping_general.htm#CACEAJGD">"Temporal"</a> for details.
-<ul>
-<li>
-<p>Date</p>
-</li>
-<li>
-<p>Time</p>
-</li>
-<li>
-<p>Timestamp</p>
-</li>
-</ul>
-</td>
-<td align="left" headers="r5c1-t27 r1c3-t27"><br /></td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" --></li>
-</ol>
-<p>Eclipse adds the following annotations to the field:</p>
-<pre xml:space="preserve" class="oac_no_warn">
-@Version
-@Column(table="<span class="italic">&lt;COLUMN_TABLE&gt;</span>", name="&lt;<span class="italic">COLUMN_NAME</span>&gt;")
-
-</pre>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_mapping.htm#BABDGBIJ">Mapping an entity</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_persistence_outline.htm#BABEGGFE">JPA Structure view</a><br />
-<a href="ref_persistence_map_view.htm#BABIFBAF">JPA Details view (for attributes)</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_mapping.htm#BABBDJFI">Understanding OR mappings</a><br />
-<a href="concepts001.htm#BABBGFJG">Understanding EJB 3.0 Java Persistence API</a></div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks019.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks019.htm
deleted file mode 100644
index 8efbe14..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks019.htm
+++ /dev/null
@@ -1,95 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Generating entities from tables</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:48Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Generating entities from tables" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABBAGFI" name="BABBAGFI"></a></p>
-<div class="sect1">
-<h1>Generating entities from tables</h1>
-<p><a id="sthref156" name="sthref156"></a><a id="sthref157" name="sthref157"></a>Use this procedure to generate Java persistent entities from database tables. You must create a JPA project and establish a database connection <span class="italic">before</span> generating persistent entities. See <a href="task_create_new_project.htm#CIHHEJCJ">"Creating a new JPA project"</a> for more information.<a id="sthref158" name="sthref158"></a><a id="sthref159" name="sthref159"></a></p>
-<ol>
-<li>
-<p>Right-click the JPA project in the <span class="gui-object-title">Project Explorer</span> and select <span class="gui-object-action">JPA Tools &gt; Generate Entities from Tables</span>.</p>
-<div class="figure"><a id="sthref160" name="sthref160"></a>
-<p class="titleinfigure">Generating Entities</p>
-<img src="img/generate_entities.png" alt="Using the JPA Tools &gt; Generate Entities menu option." title="Using the JPA Tools &gt; Generate Entities menu option." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>On the <a href="ref_selectTables.htm#CIAHCGEE">Select Tables</a> page, select your database connection and schema.</p>
-<p>To create a new database connection, click <span class="bold">Add connection</span>.</p>
-<p>If you are not currently connected to the database, the Database Connection page appears. Select your database connection and schema, and click <span class="bold">Reconnect</span>.</p>
-<div class="figure"><a id="sthref161" name="sthref161"></a>
-<p class="titleinfigure">Select Tables</p>
-<img src="img/select_tables.png" alt="" title="" /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>After selecting a schema, select the tables from which to generate Java persistent entities and click <span class="bold">Next</span>.</p>
-</li>
-<li>
-<p>On the <a href="ref_tableAssociations.htm#CIACDICB">Table Associations</a> page, select the associations to generate. You can specify to generate specific references for each association.</p>
-<p>To create a new association, click <span class="bold">Add Association</span>. Use the <a href="ref_create_new_association_wizard.htm#CIAFGHIF">Create New Association</a> wizard to define the association.</p>
-<div class="figure"><a id="sthref162" name="sthref162"></a>
-<p class="titleinfigure">Table Associations</p>
-<img src="img/table_associations.png" alt="" title="" /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>After editing the table associations, click <span class="bold">Next</span>.</p>
-</li>
-<li>
-<p>On the <a href="ref_customizeDefaultEntityGeneration.htm#CIAEJDBE">Customize Default Entity Generation</a> page, customize the mapping and class information for each generated entity.</p>
-<div class="figure"><a id="sthref163" name="sthref163"></a>
-<p class="titleinfigure">Customize Default Entity Generation</p>
-<img src="img/customize_default_entity_generation.png" alt="" title="" /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>After customizing the mappings, click <span class="bold">Next</span>.</p>
-</li>
-<li>
-<p>On the <a href="ref_customizIndividualEntities.htm#CIACIGEE">Customize Individual Entities</a> page, review the mapping and class information for each entity that will be generated, then click <span class="bold">Finish</span>.</p>
-<div class="figure"><a id="sthref164" name="sthref164"></a>
-<p class="titleinfigure">Customize Individual Entities</p>
-<img src="img/customize_individual_entities.png" alt="" title="" /><br /></div>
-<!-- class="figure" --></li>
-</ol>
-<p>Eclipse creates a Java persistent entity for each database table. Each entity contains fields based on the table's columns. Eclipse will also generate entity relationships (such as one-to-one) based on the table constraints. <a href="#CIHJIJJC">Figure: Generating Entities from Tables</a> illustrates how Eclipse generates entities from tables.</p>
-<div class="figure"><a id="CIHJIJJC" name="CIHJIJJC"></a>
-<p class="titleinfigure">Generating Entities from Tables</p>
-<img src="img/table_entity.png" alt="This figure shows the EMPLOYEE and ADDRESS entities generated from database tables." title="This figure shows the EMPLOYEE and ADDRESS entities generated from database tables." /><br /></div>
-<!-- class="figure" -->
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<p><a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a></p>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_project_properties.htm#BABJHBCI">Project Properties page &ndash; Java Persistence Options</a></div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks020.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks020.htm
deleted file mode 100644
index ab49e2e..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks020.htm
+++ /dev/null
@@ -1,61 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Generating tables from entities</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Generating tables from entities" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHJIGBE" name="CIHJIGBE"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Generating tables from entities</h1>
-<p>When using a vendor-specific platform, you can create a DDL script from your persistent entities.</p>
-<div align="center">
-<div class="inftblnote"><br />
-<table class="Note oac_no_warn" summary="" cellpadding="3" cellspacing="0">
-<tbody>
-<tr>
-<td align="left">
-<p class="notep1">Note:</p>
-The DDL script with DROP existing tables on the database and CREATE new tables, based on the entities in your project.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblnote" --></div>
-<p>To generate a DDL script:</p>
-<p>Right-click the JPA project in the <span class="gui-object-title">Project Explorer</span> and select <span class="gui-object-action">JPA Tools &gt; Generate Tables from Entities</span>.</p>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<p><a href="task_create_jpa_entity.htm#BABFBJBG">Creating a JPA Entity</a></p>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_project_properties.htm#BABJHBCI">Project Properties page &ndash; Java Persistence Options</a></div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks021.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks021.htm
deleted file mode 100644
index 8d302ea..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks021.htm
+++ /dev/null
@@ -1,54 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Validating mappings and reporting problems</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Validating mappings and reporting problems" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABFAIBA" name="BABFAIBA"></a></p>
-<div class="sect1">
-<h1>Validating mappings and reporting problems</h1>
-<p><a id="sthref165" name="sthref165"></a><a id="sthref166" name="sthref166"></a><a id="sthref167" name="sthref167"></a><a id="sthref168" name="sthref168"></a>Errors and warnings on persistent entities and mappings are indicated with a red error or yellow warning next to the resource with the error, as well as the parent containers up to the project.</p>
-<div class="figure"><a id="sthref169" name="sthref169"></a>
-<p class="titleinfigure">Sample Errors and Warnings</p>
-<img src="img/error_sample.png" alt="This figure shows sample error and warning icons in the Explorer view." title="This figure shows sample error and warning icons in the Explorer view." /><br /></div>
-<!-- class="figure" -->
-<p>This section contains information on the following:</p>
-<ul>
-<li>
-<p><a href="tasks022.htm#CIHFEDEI">Error messages</a></p>
-</li>
-<li>
-<p><a href="tasks023.htm#CIHGEAIJ">Warning messages</a></p>
-</li>
-</ul>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<p><a href="../org.eclipse.platform.doc.user/concepts/cprbview.htm">Problems view</a></p>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" --></div>
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks022.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks022.htm
deleted file mode 100644
index 26315e7..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks022.htm
+++ /dev/null
@@ -1,92 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Error messages</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Error messages" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHFEDEI" name="CIHFEDEI"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Error messages<a id="sthref170" name="sthref170"></a></h1>
-<p>This section contains information on error messages (including how to resolve the issue) you may encounter while working with Dali.</p>
-<a id="sthref171" name="sthref171"></a>
-<p class="subhead2">Attribute "<span class="italic">&lt;ATTRIBUTE__NAME&gt;</span>" has invalid mapping type in this context</p>
-<p>The mapped attribute is invalid. Either change the mapping type or change the entity type.</p>
-<p>See <a href="task_mapping.htm#BABDGBIJ">"Mapping an entity"</a> for more information.</p>
-<a id="sthref172" name="sthref172"></a>
-<p class="subhead2">Attribute "<span class="italic">&lt;ATTRIBUTE_NAME&gt;</span>" cannot be resolved.</p>
-<p>Dali cannot map the attribute to a database table and column. Verify that you database connection information is correct.</p>
-<p>See <a href="task_create_new_project.htm#CIHHEJCJ">"Creating a new JPA project"</a> for more information.</p>
-<a id="sthref173" name="sthref173"></a>
-<p class="subhead2">Class "<span class="italic">&lt;CLASS_NAME&gt;</span>" is not annotated as a persistent class.</p>
-<p>The class has not been identified as a persistent class. Configure the class as an Entity, Mapped Superclass, or Embeddable persistent entity.</p>
-<p>See <a href="task_add_persistence.htm#BABHICAI">"Adding persistence to a class"</a>.</p>
-<a id="sthref174" name="sthref174"></a>
-<p class="subhead2">Column "<span class="italic">&lt;COLUMN_NAME&gt;</span>" cannot be resolved.</p>
-<p>You mapped an entity's field to an incorrect or invalid column in the database table. By default, Dali will attempt to map each field in the entity with an identically named row in the database table. If the field's name differs from the row's name, you must explicitly create the mapping.</p>
-<p>Map the field to a valid row in the database table as shown in <a href="task_mapping.htm#BABDGBIJ">"Mapping an entity"</a>.</p>
-<a id="sthref175" name="sthref175"></a>
-<p class="subhead2">Duplicate class "<span class="italic">&lt;CLASS_NAME&gt;</span>".</p>
-<p>You created to persistence classes with the same name. Each Java class must have a unique name. See <a href="task_add_persistence.htm#BABHICAI">"Adding persistence to a class"</a> for more information.</p>
-<a id="sthref176" name="sthref176"></a>
-<p class="subhead2">Entity does not have an Id or Embedded Id.</p>
-<p>You created a persistent entity without identifying its primary key. A persistent entity must have a primary key field designated with an <code>@Id</code> or <code>@EmbeddedId</code> annotation.</p>
-<p>Add an ID mapping to the entity as shown in <a href="tasks012.htm#BABGCBHG">"ID mapping"</a> or <a href="tasks011.htm#CIHDIAEE">"Embedded ID mapping"</a>.</p>
-<a id="sthref177" name="sthref177"></a>
-<p class="subhead2">Multiple persistence.xml files in project.</p>
-<p>You created a JPA project with more than one <code>persistence.xml</code> file. Each JPA project must contain a <span class="italic">single</span> <code>persistence.xml</code> file.</p>
-<p>See <a href="task_manage_persistence.htm#CIHDAJID">"Managing the persistence.xml file"</a> for more information.</p>
-<a id="sthref178" name="sthref178"></a>
-<p class="subhead2">No persistence unit defined.</p>
-<p>There is no persistence unit defined in the <code>persistence.xml</code> file. Use the &lt;persistence-unit name="<span class="italic">&lt;PERSISTENCE_UNIT_NAME&gt;</span>" tag to define the persistent unit.</p>
-<p>See <a href="task_manage_orm.htm#CIHDGDCD">"Managing the orm.xml file"</a> for more information.</p>
-<a id="sthref179" name="sthref179"></a>
-<p class="subhead2">No persistence.xml file in project.</p>
-<p>You created a JPA project without a <code>persistence.xml</code> file. Each JPA project must contain a <span class="italic">single</span> <code>persistence.xml</code> file.</p>
-<p>See <a href="task_manage_persistence.htm#CIHDAJID">"Managing the persistence.xml file"</a> for more information.</p>
-<a id="sthref180" name="sthref180"></a>
-<p class="subhead2">Referenced column "<span class="italic">&lt;COLUMN_NAME&gt;</span>" in join column "<span class="italic">&lt;COLUMN_NAME&gt;</span>" cannot be resolved.</p>
-<p>The column that you selected to join a relationship mapping does not exist on the database table. Either select a different column on the <a href="reference011.htm#CACBAEBC">Join Table Information</a> or create the necessary column on the database table.</p>
-<p>See <a href="ref_persistence_map_view.htm#BABIFBAF">"JPA Details view (for attributes)"</a> for more information.</p>
-<a id="sthref181" name="sthref181"></a>
-<p class="subhead2">Schema "&lt;<span class="italic">SCHEMA_NAME</span>&gt;" cannot be resolved for table/join table "&lt;<span class="italic">TABLE_NAME</span>&gt;".</p>
-<p>Define the default database schema information in the persistence unit.</p>
-<p>See <a href="task_manage_orm.htm#CIHDGDCD">"Managing the orm.xml file"</a> for more information.</p>
-<a id="sthref182" name="sthref182"></a>
-<p class="subhead2">Table "<span class="italic">&lt;TABLE_NAME&gt;</span>" cannot be resolved.</p>
-<p>You associated a persistent entity to an incorrect or invalid database table. By default, Dali will attempt to associate each persistent entity with an identically named database table. If the entity's name differs from the table's name, you must explicitly create the association.</p>
-<p>Associate the entity with a valid database table as shown in <a href="task_add_persistence.htm#BABHICAI">"Adding persistence to a class"</a>.</p>
-<a id="sthref183" name="sthref183"></a>
-<p class="subhead2">Unresolved generator "<span class="italic">&lt;GENERATOR_NAME&gt;</span>" is defined in persistence unit.</p>
-<p>You created a persistence entity that uses sequencing or a table generator, but did not define the generator in the persistence unit. Either define the generator by using an annotation or including it in the XML mapping file.</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<p><a href="../org.eclipse.platform.doc.user/concepts/cprbview.htm">Problems view</a></p>
-</div>
-<!-- class="sect2" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks023.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks023.htm
deleted file mode 100644
index 85bc97c..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks023.htm
+++ /dev/null
@@ -1,50 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Warning messages</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Warning messages" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CIHGEAIJ" name="CIHGEAIJ"></a></p>
-<div class="sect2"><!-- infolevel="all" infotype="General" -->
-<h1>Warning messages</h1>
-<p>This section contains information on warning messages (including how to resolve the issue) you may encounter while working with Dali.</p>
-<a id="sthref184" name="sthref184"></a>
-<p class="subhead2">Connection "<span class="italic">&lt;CONNECTION_NAME&gt;</span>" is not active. No validation will be done against the data source.</p>
-<p>The database connection you specified to use with the JPA project is not active. The JPA project requires an active connection.</p>
-<a id="sthref185" name="sthref185"></a>
-<p class="subhead2">No connection specified for the project. No data-specific validation will be performed.</p>
-<p>You created a JPA project without specifying a database connection. The JPA project requires an active connection.</p>
-<p>See <a href="task_create_new_project.htm#CIHHEJCJ">"Creating a new JPA project"</a> or <a href="tasks024.htm#BABDBCBI">"Modifying persistent project properties"</a> for information on specifying a database connection.</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<p><a href="../org.eclipse.platform.doc.user/concepts/cprbview.htm">Problems view</a></p>
-</div>
-<!-- class="sect2" -->
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tasks024.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tasks024.htm
deleted file mode 100644
index 13bfc0d..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tasks024.htm
+++ /dev/null
@@ -1,63 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Modifying persistent project properties</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:49Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Modifying persistent project properties" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="BABDBCBI" name="BABDBCBI"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Modifying persistent project properties</h1>
-<p>Each persistent project must be associated with a database connection. To create a new database connection, click <span class="gui-object-action">Database Connection</span> use the New Connection wizard.</p>
-<p>Use this procedure to modify the vender-specific platform and database connection associated with your JPA project.</p>
-<ol>
-<li>
-<p>Right-click the project in the <span class="gui-object-title">Explorer</span> view and select <span class="gui-object-action">Properties</span>. The Properties page appears.</p>
-<div class="figure"><a id="sthref186" name="sthref186"></a>
-<p class="titleinfigure">The Properties Page</p>
-<img src="img/project_properties_tasks.png" alt="The Persistence page." title="The Persistence page." /><br /></div>
-<!-- class="figure" --></li>
-<li>
-<p>Complete each field on the <a href="ref_project_properties.htm#BABJHBCI">Project Properties page &ndash; Java Persistence Options</a> click <span class="bold">OK</span>.</p>
-</li>
-</ol>
-<p>&nbsp;</p>
-<img src="img/ngrelt.png" alt="Related task" title="Related task" /><br />
-<br />
-<a href="task_create_new_project.htm#CIHHEJCJ">Creating a new JPA project</a>
-<p>&nbsp;</p>
-<img src="img/ngrelr.png" alt="Related reference" title="Related reference" /><br />
-<br />
-<a href="ref_project_properties.htm#BABJHBCI">Project Properties page &ndash; Java Persistence Options</a>
-<p>&nbsp;</p>
-<img src="img/ngrelc.png" alt="Related concept" title="Related concept" /><br />
-<br />
-<a href="concept_persistence.htm#BABCAHIC">Understanding Java persistence</a></div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/tips_and_tricks.htm b/jpa/plugins/org.eclipse.jpt.doc.user/tips_and_tricks.htm
deleted file mode 100644
index 49f3a06..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/tips_and_tricks.htm
+++ /dev/null
@@ -1,68 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Tips and tricks</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content=" Tips and tricks" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CHDHGHBF" name="CHDHGHBF"></a></p>
-<h1>Tips and tricks</h1>
-<p>The following tips and tricks give some helpful ideas for increasing your productivity.</p>
-<ul>
-<li>
-<p><a href="#BABFIIHA"><span class="bold">Database Connections</span></a></p>
-</li>
-<li>
-<p><a href="#BABCHAHF"><span class="bold">Schema-based persistence.xml</span></a></p>
-</li>
-</ul>
-<div class="inftblruleinformal">
-<table class="RuleInformal" title="This table lists the tips and tricks in this category." summary="This table lists the tips and tricks in this category." dir="ltr" border="1" width="100%" frame="border" rules="all" cellpadding="3" cellspacing="0">
-<col width="27%" />
-<col width="*" />
-<thead>
-<tr align="left" valign="top">
-<th align="left" valign="bottom" id="r1c1-t2">Tip</th>
-<th align="left" valign="bottom" id="r1c2-t2">Description</th>
-</tr>
-</thead>
-<tbody>
-<tr align="left" valign="top">
-<td align="left" id="r2c1-t2" headers="r1c1-t2"><a id="BABFIIHA" name="BABFIIHA"></a><span class="bold">Database Connections</span></td>
-<td align="left" headers="r2c1-t2 r1c2-t2">When starting a new workbench session, be sure to <a href="../org.eclipse.datatools.connectivity.doc.user/doc/html/asc1229700343352.html">reconnect to your database</a> (if you are working online). This allows Dali to provide database-related mapping assistance and validation.</td>
-</tr>
-<tr align="left" valign="top">
-<td align="left" id="r3c1-t2" headers="r1c1-t2"><a id="BABCHAHF" name="BABCHAHF"></a><span class="bold">Schema-based persistence.xml</span></td>
-<td align="left" headers="r3c1-t2 r1c2-t2">If you are behind a firewall, you may need to configure your Eclipse workspace proxy in the <a href="../org.eclipse.platform.doc.user/reference/ref-72.htm">Preferences dialog</a> (<span class="gui-object-action">Preferences &gt; Internet &gt; Proxy Settings</span>) to properly validate a schema-based <code>persistence.xml</code> file.</td>
-</tr>
-</tbody>
-</table>
-<br /></div>
-<!-- class="inftblruleinformal" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/toc.xml b/jpa/plugins/org.eclipse.jpt.doc.user/toc.xml
deleted file mode 100644
index 8251cc9..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/toc.xml
+++ /dev/null
@@ -1,145 +0,0 @@
-<?xml version='1.0' encoding='iso-8859-1'?>
-<!-- User Guide -->
-  <toc label="Dali Java Persistence Tools User Guide">
-    <topic href="getting_started.htm" label="Getting started">
-      <topic href="getting_started001.htm#BABEFHCD" label="Requirements and installation" />
-      <topic href="getting_started002.htm#BABIGCJA" label="Dali quick start">
-        <topic href="getting_started003.htm#BABDFHDA" label="Creating a new JPA project" />
-        <topic href="getting_started004.htm#BABFGDDG" label="Creating a Java persistent entity with persistent fields" />
-      </topic>
-    </topic>
-    <topic href="concepts.htm" label=" Concepts">
-      <topic href="concept_persistence.htm#BABCAHIC" label="Understanding Java persistence" />
-      <topic href="concept_mapping.htm#BABBDJFI" label="Understanding OR mappings" />
-      <topic href="concepts001.htm#BABBGFJG" label="Understanding EJB 3.0 Java Persistence API">
-        <topic href="concepts002.htm#CHDHAGIH" label="The persistence.xml file" />
-        <topic href="concepts003.htm#CHDBIJAC" label="The orm.xml file" />
-      </topic>
-    </topic>
-    <topic href="tasks.htm" label=" Tasks">
-      <topic href="task_create_new_project.htm#CIHHEJCJ" label="Creating a new JPA project" />
-      <topic href="tasks001.htm#BEIBADHH" label="Converting a Java Project to a JPA Project" />
-      <topic href="task_create_jpa_entity.htm#BABFBJBG" label="Creating a JPA Entity" />
-      <topic href="task_manage_persistence.htm#CIHDAJID" label="Managing the persistence.xml file">
-        <topic href="tasks002.htm#CIHFEBAI" label="Synchronizing classes" />
-      </topic>
-      <topic href="task_manage_orm.htm#CIHDGDCD" label="Managing the orm.xml file">
-        <topic href="tasks003.htm#sthref59" label="Creating an orm.xml file" />
-        <topic href="tasks004.htm#CIHBCDCE" label="Working with orm.xml file" />
-      </topic>
-      <topic href="task_add_persistence.htm#BABHICAI" label="Adding persistence to a class">
-        <topic href="tasks005.htm#BABGBIEE" label="Entity" />
-        <topic href="tasks006.htm#BABFEICE" label="Embeddable" />
-        <topic href="tasks007.htm#BABDAGCI" label="Mapped superclass" />
-      </topic>
-      <topic href="task_additonal_tables.htm#CIHGBIEI" label="Specifying additional tables" />
-      <topic href="task_inheritance.htm#CIHCCCJD" label="Specifying entity inheritance" />
-      <topic href="tasks008.htm#BABIGBGG" label="Creating Named Queries" />
-      <topic href="task_mapping.htm#BABDGBIJ" label="Mapping an entity">
-        <topic href="tasks009.htm#BABBABCE" label="Basic mapping" />
-        <topic href="tasks010.htm#BABCBHDF" label="Embedded mapping" />
-        <topic href="tasks011.htm#CIHDIAEE" label="Embedded ID mapping" />
-        <topic href="tasks012.htm#BABGCBHG" label="ID mapping" />
-        <topic href="tasks013.htm#BABEIEGD" label="Many-to-many mapping" />
-        <topic href="tasks014.htm#BABHFAFJ" label="Many-to-one mapping" />
-        <topic href="tasks015.htm#BABHGEBD" label="One-to-many mapping" />
-        <topic href="tasks016.htm#BABFHBCJ" label="One-to-one mapping" />
-        <topic href="tasks017.htm#BABHFHEI" label="Transient mapping" />
-        <topic href="tasks018.htm#BABHIBII" label="Version mapping" />
-      </topic>
-      <topic href="tasks019.htm#BABBAGFI" label="Generating entities from tables" />
-      <topic href="tasks020.htm#CIHJIGBE" label="Generating tables from entities" />
-      <topic href="tasks021.htm#BABFAIBA" label="Validating mappings and reporting problems">
-        <topic href="tasks022.htm#CIHFEDEI" label="Error messages" />
-        <topic href="tasks023.htm#CIHGEAIJ" label="Warning messages" />
-      </topic>
-      <topic href="tasks024.htm#BABDBCBI" label="Modifying persistent project properties" />
-    </topic>
-    <topic label=" Reference">
-      <topic label="Wizards">
-        <topic href="ref_new_jpa_project_wizard.htm#CACBJGBG" label="Create New JPA Project wizard">
-          <topic href="ref_new_jpa_project.htm#CACBJAGC" label="New JPA Project page" />
-          <topic href="ref_java_page.htm#CIAGEBAA" label="Java Page" />
-          <topic href="ref_jpa_facet.htm#CACIFDIF" label="JPA Facet page" />
-        </topic>
-        <topic href="ref_create_jpa_entity_wizard.htm#CIAGGGDF" label="Create JPA Entity wizard">
-          <topic href="ref_EntityClassPage.htm#CIAFEIGF" label="Entity Class page" />
-          <topic href="ref_EntityPropertiesPage.htm#CIADECIA" label="Entity Properties page" />
-        </topic>
-        <topic href="reference002.htm#CIAIJCCE" label="Mapping File Wizard">
-          <topic href="reference003.htm#CIAJEIDJ" label="Mapping File" />
-        </topic>
-        <topic href="reference004.htm#CIAGHCGA" label="Generate Tables from Entities Wizard" />
-        <topic href="ref_create_custom_entities_wizard.htm#CIAGBFJE" label="Generate Entities from Tables Wizard">
-          <topic href="ref_selectTables.htm#CIAHCGEE" label="Select Tables" />
-          <topic href="ref_tableAssociations.htm#CIACDICB" label="Table Associations" />
-          <topic href="ref_customizeDefaultEntityGeneration.htm#CIAEJDBE" label="Customize Default Entity Generation" />
-          <topic href="ref_customizIndividualEntities.htm#CIACIGEE" label="Customize Individual Entities" />
-        </topic>
-        <topic href="ref_create_new_association_wizard.htm#CIAFGHIF" label="Create New Association">
-          <topic href="ref_association_table.htm#CIAGJHDC" label="Association Tables" />
-          <topic href="ref_join_columns.htm#CIAEGEEG" label="Join Columns" />
-          <topic href="ref_association_cardinality.htm#CIAFIIFH" label="Association Cardinality" />
-        </topic>
-      </topic>
-      <topic label="Property pages">
-        <topic href="ref_persistence_prop_view.htm#BABFAEBB" label="JPA Details view (for entities)">
-          <topic href="reference006.htm#CACCAGGC" label="General information" />
-          <topic href="reference007.htm#CACIJBGH" label="Attribute overrides" />
-          <topic href="reference008.htm#CACBHIDA" label="Secondary table information" />
-          <topic href="reference009.htm#CACFHGHE" label="Inheritance information" />
-          <topic href="reference010.htm#sthref226" label="Queries" />
-        </topic>
-        <topic href="ref_persistence_map_view.htm#BABIFBAF" label="JPA Details view (for attributes)">
-          <topic href="ref_mapping_general.htm#CACBHFIJ" label="General information" />
-          <topic href="reference011.htm#CACBAEBC" label="Join Table Information" />
-          <topic href="reference012.htm#CACFCEJC" label="Join Columns Information" />
-          <topic href="ref_primary_key.htm#CACFCCAB" label="Primary Key Generation information" />
-        </topic>
-        <topic href="ref_details_orm.htm#CACGDGHC" label="JPA Details view (for orm.xml)">
-          <topic href="reference013.htm#CACCACGH" label="General information" />
-          <topic href="reference014.htm#CACEAGBG" label="Persistence Unit information" />
-          <topic href="reference015.htm#CIAFGAIJ" label="Generators" />
-          <topic href="reference016.htm#CIAIBAAJ" label="Queries" />
-          <topic href="reference017.htm#CIADGCID" label="Converters" />
-        </topic>
-        <topic href="ref_persistence_outline.htm#BABEGGFE" label="JPA Structure view" />
-        <topic href="ref_persistence_xmll_editor.htm#CIACCHID" label="persistence.xml Editor">
-          <topic href="ref_persistence_general.htm#CIACIFGJ" label="General" />
-          <topic href="reference018.htm#CIAFFJIE" label="Connection" />
-          <topic href="reference019.htm#CIAJAFEG" label="Customization" />
-          <topic href="reference020.htm#CIABEDCH" label="Caching" />
-          <topic href="reference021.htm#CIABGHHI" label="Logging" />
-          <topic href="reference022.htm#CIAFJCHE" label="Options" />
-          <topic href="reference023.htm#CIACCFCB" label="Schema Generation" />
-          <topic href="reference024.htm#CIAHJDFF" label="Properties" />
-          <topic href="reference025.htm#CIAHCJAH" label="Source" />
-        </topic>
-      </topic>
-      <topic label="Preferences">
-        <topic href="ref_project_properties.htm#BABJHBCI" label="Project Properties page - Java Persistence Options" />
-      </topic>
-      <topic label="Dialogs">
-        <topic href="reference028.htm#CACCGEHC" label="Edit Join Columns Dialog" />
-        <topic href="ref_select_cascade_dialog.htm#CIAFDGIJ" label="Select Cascade dialog" />
-        <topic href="ref_eclipselink_mapping_file.htm#CIAEDEJF" label="New EclipseLink Mapping File dialog" />
-        <topic href="ref_add_converter.htm#CIAGCGIJ" label="Add Converter dialog" />
-      </topic>
-      <topic href="ref_persistence_perspective.htm#BABIFBDB" label="JPA Development perspective" />
-      <topic label="Icons and buttons">
-        <topic href="reference030.htm#CACGEACG" label="Icons" />
-        <topic href="reference031.htm#CACDJCEI" label="Buttons" />
-      </topic>
-      <topic href="reference032.htm#CACBBDIB" label="Dali Developer Documentation" />
-    </topic>
-    <topic href="tips_and_tricks.htm" label="Tips and tricks">
-      <topic href="whats_new001.htm#CJACEDDE" label="JPA Library Management" />
-      <topic href="whats_new002.htm#CJADIFHJ" label="New Generate Entities from Tables Wizard" />
-      <topic href="whats_new003.htm#CJABIJEC" label="Conversion of Java Projects to JPA Projects" />
-      <topic href="whats_new004.htm#CJACJBDA" label="EclipseLink 1.1 Support" />
-      <topic href="whats_new005.htm#sthref286" label="Table-per-Concrete-Class Inheritance" />
-    </topic>
-    <topic href="legal.htm" label=" Legal">
-      <topic href="about.htm#sthref288" label="About this content" />
-    </topic>
-</toc>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new.htm b/jpa/plugins/org.eclipse.jpt.doc.user/whats_new.htm
deleted file mode 100644
index 2dd89cb..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new.htm
+++ /dev/null
@@ -1,50 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>What's new</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content=" What's new" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="sthref286" name="sthref286"></a> What's new</p>
-<p>This section contains descriptions of the following new features and significant changes made to the Dali OR Mapping Tool for Release 2.3:</p>
-<ul>
-<li>
-<p><a href="whats_new002.htm#CJACEDDE">Multiple Improvements to the Dali Perspective</a></p>
-</li>
-<li>
-<p><a href="whats_new003.htm#CJADIFHJ">Support for JPA 2.0 and EclipseLink</a></p>
-</li>
-<li>
-<p><a href="whats_new004.htm#CJABIJEC">Conversion of Java Projects to JPA Projects</a></p>
-</li>
-<li>
-<p><a href="whats_new005.htm#CJACJBDA">EclipseLink 1.1 Support</a></p>
-</li>
-</ul>
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new001.htm b/jpa/plugins/org.eclipse.jpt.doc.user/whats_new001.htm
deleted file mode 100644
index 2efa8a6..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new001.htm
+++ /dev/null
@@ -1,39 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Improved Internationalization and Localization</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Improved Internationalization and Localization" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<div class="sect1"><!-- infolevel="all" infotype="General" --><a id="sthref287" name="sthref287"></a>
-<h1>Improved Internationalization and Localization</h1>
-<p>This release of the Dali OR Mapping Tool provides improved internationalization (i18n) and localization support. Dali projects can support different locales and processing of international data (such as dates and strings).</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new002.htm b/jpa/plugins/org.eclipse.jpt.doc.user/whats_new002.htm
deleted file mode 100644
index 2ea82ee..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new002.htm
+++ /dev/null
@@ -1,48 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Multiple Improvements to the Dali Perspective</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Multiple Improvements to the Dali Perspective" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CJACEDDE" name="CJACEDDE"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Multiple Improvements to the Dali Perspective</h1>
-<p>There have been multiple improvements to the Dali perspectives to improve its ease-of-use:</p>
-<ul>
-<li>
-<p>The <a href="ref_create_jpa_entity_wizard.htm#CIAGGGDF">Create JPA Entity wizard</a> now accepts short names as attribute types.</p>
-</li>
-<li>
-<p>Dali will perform validation after refreshing database information.</p>
-</li>
-</ul>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new003.htm b/jpa/plugins/org.eclipse.jpt.doc.user/whats_new003.htm
deleted file mode 100644
index 13f731a..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new003.htm
+++ /dev/null
@@ -1,40 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Support for JPA 2.0 and EclipseLink</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Support for JPA 2.0 and EclipseLink" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CJADIFHJ" name="CJADIFHJ"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Support for JPA 2.0 and EclipseLink</h1>
-<p>This release of the Dali OR Mapping Tool supports generic JPA 2.0 as well as specific items for EclispeLink 1.2.</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new004.htm b/jpa/plugins/org.eclipse.jpt.doc.user/whats_new004.htm
deleted file mode 100644
index dcdff9c..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new004.htm
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Conversion of Java Projects to JPA Projects</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Conversion of Java Projects to JPA Projects" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CJABIJEC" name="CJABIJEC"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>Conversion of Java Projects to JPA Projects</h1>
-<p>The Dali OR Mapping Tool now uses the Eclipse <span class="bold">Configure</span> menu to convert existing Java projects to JPA projects.</p>
-<p>See <a href="tasks001.htm#BEIBADHH">"Converting a Java Project to a JPA Project"</a> for more information.</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new005.htm b/jpa/plugins/org.eclipse.jpt.doc.user/whats_new005.htm
deleted file mode 100644
index baa5e14..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new005.htm
+++ /dev/null
@@ -1,49 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>EclipseLink 1.1 Support</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="EclipseLink 1.1 Support" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<p><a id="CJACJBDA" name="CJACJBDA"></a></p>
-<div class="sect1"><!-- infolevel="all" infotype="General" -->
-<h1>EclipseLink 1.1 Support</h1>
-<p>Release 2.3 provides support of the following EclipseLink 1.1 features.</p>
-<ul>
-<li>
-<p>EclipseLink XML mapping file and its configuration options</p>
-</li>
-<li>
-<p>One-to-Many mapping <span class="italic">without</span> a join table.</p>
-</li>
-</ul>
-<p>EclipseLink (the Eclipse Persistence Services Project) is a complete persistence frame work. Refer to <code><a href="http://www.eclipse.org/eclipselink/">http://www.eclipse.org/eclipselink/</a></code> for more information.</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new006.htm b/jpa/plugins/org.eclipse.jpt.doc.user/whats_new006.htm
deleted file mode 100644
index 213652d..0000000
--- a/jpa/plugins/org.eclipse.jpt.doc.user/whats_new006.htm
+++ /dev/null
@@ -1,39 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
- 
-<meta http-equiv="Content-Style-Type" content="text/css" />
-<meta http-equiv="Content-Script-Type" content="text/javascript" />
-<title>Table-per-Concrete-Class Inheritance</title>
-<meta name="generator" content="Oracle DARB XHTML Converter (Mode = ohj/ohw) - Version 5.1.1 Build 004" />
-<meta name="date" content="2010-01-22T9:29:56Z" />
-<meta name="robots" content="noarchive" />
-<meta name="doctitle" content="Table-per-Concrete-Class Inheritance" />
-<meta name="relnum" content="Release 2.3" />
-<meta name="copyright" content="Copyright (c) 2000, 2008 oracle . 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: Oracle - initial API and implementation" />
-<link rel="copyright" href="dcommon/html/cpyr.htm" title="Copyright" type="text/html" />
-<link rel="stylesheet" href="dcommon/css/blafdoc.css" title="Oracle BLAFDoc" type="text/css" />
-<!-- contents -->
-</head>
-<body>
-<div class="sect1"><!-- infolevel="all" infotype="General" --><a id="sthref288" name="sthref288"></a>
-<h1>Table-per-Concrete-Class Inheritance</h1>
-<p>The Dali OR Mapping Tool now supports the JPA 1.0-optional table-per-concrete-class inheritance option. This functionality may be required in JPA 2.0.</p>
-</div>
-<!-- class="sect1" -->
-<!-- Start Footer -->
-<div class="footer">
-<table class="simple oac_no_warn" summary="" cellspacing="0" cellpadding="0" width="100%">
-<col width="86%" />
-<col width="*" />
-<tr>
-<td align="left"><span class="copyrightlogo">Copyright&nbsp;&copy;&nbsp;2006, 2010,&nbsp;Oracle&nbsp;and/or&nbsp;its&nbsp;affiliates.&nbsp;All&nbsp;rights&nbsp;reserved.</span><br />
-<a href="dcommon/html/cpyr.htm"><span class="copyrightlogo">Legal Notices</span></a></td>
-</tr>
-</table>
-</div>
-<!-- class="footer" -->
-</body>
-</html>
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.cvsignore b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.cvsignore
deleted file mode 100644
index c14487c..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-build.xml
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.project b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.project
deleted file mode 100644
index e29a7c6..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.project
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.eclipselink.branding</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.settings/org.eclipse.core.resources.prefs b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 4aec29d..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 15:10:09 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/META-INF/MANIFEST.MF b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/META-INF/MANIFEST.MF
deleted file mode 100644
index 873af36..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,7 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jpt.eclipselink.branding;singleton:=true
-Bundle-Version: 2.3.0.qualifier
-Bundle-Localization: plugin
-Bundle-Vendor: %providerName
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.html b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.html
deleted file mode 100644
index ca606b1..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<HTML>
-
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-
-<BODY lang="EN-US">
-
-<H3>About This Content</H3>
-
-<P>June 06, 2007</P>
-
-<H3>License</H3>
-
-<P>The Eclipse Foundation makes available all content in this plug-in 
-("Content"). Unless otherwise indicated below, the Content is provided to you 
-under the terms and conditions of the Eclipse Public License Version 1.0 
-("EPL"). A copy of the EPL is available at
-<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-
-<P>If you did not receive this Content directly from the Eclipse Foundation, the 
-Content is being redistributed by another party ("Redistributor") and different 
-terms and conditions may apply to your use of any object code in the Content. 
-Check the Redistributor's license that was provided with the Content. If no such 
-license exists, contact the Redistributor. Unless otherwise indicated below, the 
-terms and conditions of the EPL still apply to any source code in the Content 
-and such source code may be obtained at
-<A href="http://www.eclipse.org/">http://www.eclipse.org/</A>.</P>
-
-</BODY>
-</HTML>
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.ini b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.ini
deleted file mode 100644
index 7d88b9d..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.ini
+++ /dev/null
@@ -1,44 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=icons/WTP_icon_x32_v2.png
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-# Property "tipsAndTricksHref" contains the Help topic href to a tips and tricks page 
-# optional
-tipsAndTricksHref=/org.eclipse.jpt.doc.user/tips_and_tricks.htm
-
-
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.mappings b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.mappings
deleted file mode 100644
index bddaab4..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.properties b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.properties
deleted file mode 100644
index af0e36f..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/about.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-
-blurb=Dali Java Persistence Tools - EclipseLink Support\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Oracle contributors and others 2006, 2009.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/build.properties b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/build.properties
deleted file mode 100644
index 8ce4550..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/build.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-bin.includes = META-INF/,\
-               about.ini,\
-               about.html,\
-               about.mappings,\
-               about.properties,\
-               icons/,\
-               plugin.properties
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/icons/WTP_icon_x32_v2.png b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/icons/WTP_icon_x32_v2.png
deleted file mode 100644
index 6f09c2a..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/icons/WTP_icon_x32_v2.png
+++ /dev/null
Binary files differ
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/plugin.properties b/jpa/plugins/org.eclipse.jpt.eclipselink.branding/plugin.properties
deleted file mode 100644
index 33c60d3..0000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.branding/plugin.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-
-pluginName = Dali Java Persistence Tools - EclipseLink Support
-providerName = Eclipse Web Tools Platform
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.classpath b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.classpath
deleted file mode 100644
index 64c5e31..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.cvsignore b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.cvsignore
deleted file mode 100644
index c5e82d7..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-bin
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.project b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.project
deleted file mode 100644
index 025cb3b..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.jaxb.core.schemagen</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.settings/org.eclipse.jdt.core.prefs b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 5b24c9f..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,8 +0,0 @@
-#Mon Mar 22 12:16:03 EDT 2010
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/META-INF/MANIFEST.MF b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/META-INF/MANIFEST.MF
deleted file mode 100644
index 5ca5fb5..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,10 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-Vendor: %providerName
-Bundle-SymbolicName: org.eclipse.jpt.jaxb.core.schemagen;singleton:=true
-Bundle-Version: 1.0.0.qualifier
-Bundle-Localization: plugin
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Import-Package: javax.xml.bind
-Export-Package: org.eclipse.jpt.jaxb.core.schemagen
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/about.html b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/about.html
deleted file mode 100644
index 071f586..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/about.html
+++ /dev/null
@@ -1,47 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<HTML>
-
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-
-<BODY lang="EN-US">
-
-<H2>About This Content</H2>
-
-<P>May 02, 2008</P>
-
-<H3>License</H3>
-
-<P>The Eclipse Foundation makes available all content in this plug-in 
-("Content"). Unless otherwise indicated below, the Content is provided to you 
-under the terms and conditions of the Eclipse Public License Version 1.0 
-("EPL"). A copy of the EPL is available at
-<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-
-<P>If you did not receive this Content directly from the Eclipse Foundation, the 
-Content is being redistributed by another party ("Redistributor") and different 
-terms and conditions may apply to your use of any object code in the Content. 
-Check the Redistributor's license that was provided with the Content. If no such 
-license exists, contact the Redistributor. Unless otherwise indicated below, the 
-terms and conditions of the EPL still apply to any source code in the Content 
-and such source code may be obtained at
-<A href="http://www.eclipse.org/">http://www.eclipse.org/</A>.</P>
-
-<h3>Third Party Content</h3>
-<p>The Content includes items that have been sourced from third parties as set 
-  out below. If you did not receive this Content directly from the Eclipse Foundation, 
-  the following is provided for informational purposes only, and you should look 
-  to the Redistributor&#8217;s license for terms and conditions of use.</p>
-
-<h4><a name="JPA" id="JPA"></a>Java Persistence API (JPA) v1.0</h4>
-
-<blockquote>
-  <p>The Java Persistence API (JPA) which is distributed under <a href="https://glassfish.dev.java.net/public/CDDLv1.0.html">CDDL 
-    v1.0</a> is required by the Dali Java Persistence Tools Project in order 
-    to support this standard.</p>
-</blockquote>
-</BODY>
-</HTML>
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/build.properties b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/build.properties
deleted file mode 100644
index 8ac4a49..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/build.properties
+++ /dev/null
@@ -1,19 +0,0 @@
-###############################################################################
-# Copyright (c) 2010 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-javacSource=1.5
-javacTarget=1.5
-source.. = src/
-output.. = bin/
-bin.includes = .,\
-               META-INF/,\
-               about.html,\
-               plugin.properties
-jars.compile.order = .
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/plugin.properties b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/plugin.properties
deleted file mode 100644
index 2e7dfca..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/plugin.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2008 Oracle.
-# 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:
-#     Oracle. - initial API and implementation
-###############################################################################
-# ====================================================================
-# To code developer:
-#   Do NOT change the properties between this line and the
-#   "%%% END OF TRANSLATED PROPERTIES %%%" line.
-#   Make a new property name, append to the end of the file and change
-#   the code to use the new property.
-# ====================================================================
-
-# ====================================================================
-# %%% END OF TRANSLATED PROPERTIES %%%
-# ====================================================================
-
-pluginName = Dali Java Persistence Tools - JAXB Support - Schema Generation
-providerName = Eclipse Web Tools Platform
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/src/org/eclipse/jpt/jaxb/core/schemagen/Main.java b/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/src/org/eclipse/jpt/jaxb/core/schemagen/Main.java
deleted file mode 100644
index 0c76b6a..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.core.schemagen/src/org/eclipse/jpt/jaxb/core/schemagen/Main.java
+++ /dev/null
@@ -1,156 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.core.schemagen;
-
-import java.io.File;
-import java.io.IOException;
-
-import javax.xml.bind.JAXBContext;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.SchemaOutputResolver;
-import javax.xml.transform.stream.StreamResult;
-
-import javax.xml.transform.Result;
-
-/**
- *  Generate a JAXB Schema
- *  
- * Current command-line arguments:
- *     [-s schema.xsd] - specifies the target schema
- *     [-p packageName] - specifies the source package 
- * 
- *  Required JRE 1.6 and eclipselink.jar to run
- */
-public class Main
-{
-	private String sourcePackageName;
-	private String targetSchemaName;
-	private boolean isDebugMode;
-
-	static public String NO_FACTORY_CLASS = "doesnt contain ObjectFactory.class";   //$NON-NLS-1$
-
-	// ********** static methods **********
-	
-	public static void main(String[] args) {
-		new Main().execute(args);
-	}
-	
-	// ********** constructors **********
-
-	private Main() {
-		super();
-	}
-
-	// ********** behavior **********
-	
-	protected void execute(String[] args) {
-		
-		this.initializeWith(args);
-		
-		this.generate();
-	}
-		
-    private void generate() {
-        // Create the JAXBContext
-        JAXBContext jaxbContext = null;
-		try {
-			jaxbContext = JAXBContext.newInstance(this.sourcePackageName);
-		}
-		catch (JAXBException e) {
-			String message = e.getMessage();
-			if(message.indexOf(NO_FACTORY_CLASS) > -1) {
-				System.out.println(message);
-			}
-			else {
-				e.printStackTrace();
-			}
-			System.out.println("\nSchema " + this.targetSchemaName + " not created");
-			return;
-		}
-        // Generate an XML Schema
-		SchemaOutputResolver schemaOutputResolver = 
-			new JptSchemaOutputResolver(this.targetSchemaName);
-		
-		try {
-			jaxbContext.generateSchema(schemaOutputResolver);
-		}
-		catch (IOException e) {
-			e.printStackTrace();
-			return;
-		}
-		System.out.println("\nSchema " + this.targetSchemaName + " generated");
-    }
-    
-	private void initializeWith(String[] args) {
-    	this.sourcePackageName = this.getSourcePackageName(args);
-    	this.targetSchemaName = this.getTargetSchemaName(args);
-
-		this.isDebugMode = this.getDebugMode(args);
-	}
-
-	// ********** argument queries **********
-    
-	private String getSourcePackageName(String[] args) {
-
-		return this.getArgumentValue("-p", args);
-	}
-	
-	private String getTargetSchemaName(String[] args) {
-
-		return this.getArgumentValue("-s", args);
-	}
-
-	private boolean getDebugMode(String[] args) {
-
-		return this.argumentExists("-debug", args);
-	}
-	
-	private String getArgumentValue(String argument, String[] args) {
-		for (int i = 0; i < args.length; i++) {
-			String arg = args[i];
-			if (arg.toLowerCase().equals(argument)) {
-				int j = i + 1;
-				if (j < args.length) {
-					return args[j];
-				}
-			}
-		}
-		return null;
-	}
-	
-	private boolean argumentExists(String argument, String[] args) {
-		for (int i = 0; i < args.length; i++) {
-			String arg = args[i];
-			if (arg.toLowerCase().equals(argument)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-}
-
-class JptSchemaOutputResolver extends SchemaOutputResolver {
-	
-	private final String targetSchemaName;
-	
-	protected JptSchemaOutputResolver(String targetSchemaName) {
-		this.targetSchemaName = targetSchemaName;
-	}
-	
-	 @Override
-    public Result createOutput(String namespaceURI, String suggestedFileName) throws IOException {
-
-        File file = new File(this.targetSchemaName );
-        StreamResult result = new StreamResult(file);
-        result.setSystemId(file.toURI().toURL().toString());
-        return result;
-    }
-}
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/.classpath b/jpa/plugins/org.eclipse.jpt.jaxb.ui/.classpath
deleted file mode 100644
index a1d4f10..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/.classpath
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="property_files"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/.cvsignore b/jpa/plugins/org.eclipse.jpt.jaxb.ui/.cvsignore
deleted file mode 100644
index a196dd7..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/.cvsignore
+++ /dev/null
@@ -1,6 +0,0 @@
-bin
-@dot
-temp.folder
-build.xml
-javaCompiler...args
-javaCompiler...args.*
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/.project b/jpa/plugins/org.eclipse.jpt.jaxb.ui/.project
deleted file mode 100644
index 6737128..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.jaxb.ui</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/.settings/org.eclipse.jdt.core.prefs b/jpa/plugins/org.eclipse.jpt.jaxb.ui/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 7e50a8f..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,8 +0,0 @@
-#Mon Feb 08 18:48:37 EST 2010
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/META-INF/MANIFEST.MF b/jpa/plugins/org.eclipse.jpt.jaxb.ui/META-INF/MANIFEST.MF
deleted file mode 100644
index c251129..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,27 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-Vendor: %providerName
-Bundle-SymbolicName: org.eclipse.jpt.jaxb.ui;singleton:=true
-Bundle-Version: 1.0.0.qualifier
-Bundle-Activator: org.eclipse.jpt.jaxb.ui.JptJaxbUiPlugin
-Bundle-ActivationPolicy: lazy
-Bundle-ClassPath: .
-Bundle-Localization: plugin
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Require-Bundle: org.eclipse.core.resources;bundle-version="[3.4.0,4.0.0)",
- org.eclipse.core.runtime;bundle-version="[3.4.0,4.0.0)",
- org.eclipse.debug.core;bundle-version="[3.4.0,4.0.0)",
- org.eclipse.jdt.core;bundle-version="[3.4.0,4.0.0)",
- org.eclipse.jdt.launching;bundle-version="[3.4.0,4.0.0)",
- org.eclipse.jdt.ui;bundle-version="[3.6.0,4.0.0)",
- org.eclipse.jpt.core;bundle-version="[2.0.0,3.0.0)",
- org.eclipse.jpt.ui;bundle-version="[2.0.0,3.0.0)",
- org.eclipse.jpt.utility;bundle-version="[1.2.0,2.0.0)",
- org.eclipse.ui;bundle-version="[3.4.0,4.0.0)"
-Export-Package: org.eclipse.jpt.jaxb.core.internal,
- org.eclipse.jpt.jaxb.ui;x-internal:=true,
- org.eclipse.jpt.jaxb.ui.internal;x-internal:=true,
- org.eclipse.jpt.jaxb.ui.internal.actions;x-internal:=true,
- org.eclipse.jpt.jaxb.ui.internal.wizards;x-internal:=true
-Import-Package: com.ibm.icu.text;version="4.0.1"
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/about.html b/jpa/plugins/org.eclipse.jpt.jaxb.ui/about.html
deleted file mode 100644
index be534ba..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/about.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<HTML>
-
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-
-<BODY lang="EN-US">
-
-<H3>About This Content</H3>
-
-<P>May 02, 2008</P>
-
-<H3>License</H3>
-
-<P>The Eclipse Foundation makes available all content in this plug-in 
-("Content"). Unless otherwise indicated below, the Content is provided to you 
-under the terms and conditions of the Eclipse Public License Version 1.0 
-("EPL"). A copy of the EPL is available at
-<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-
-<P>If you did not receive this Content directly from the Eclipse Foundation, the 
-Content is being redistributed by another party ("Redistributor") and different 
-terms and conditions may apply to your use of any object code in the Content. 
-Check the Redistributor's license that was provided with the Content. If no such 
-license exists, contact the Redistributor. Unless otherwise indicated below, the 
-terms and conditions of the EPL still apply to any source code in the Content 
-and such source code may be obtained at
-<A href="http://www.eclipse.org/">http://www.eclipse.org/</A>.</P>
-
-</BODY>
-</HTML>
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/build.properties b/jpa/plugins/org.eclipse.jpt.jaxb.ui/build.properties
deleted file mode 100644
index 26a9ace..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/build.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-################################################################################
-# Copyright (c) 2010 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-javacSource = 1.5
-javacTarget = 1.5
-source.. = src/,\
-               property_files/
-output.. = bin/
-bin.includes = .,\
-               META-INF/,\
-               about.html,\
-               plugin.xml,\
-               plugin.properties
-jars.compile.order = .
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/component.xml b/jpa/plugins/org.eclipse.jpt.jaxb.ui/component.xml
deleted file mode 100644
index 04957fe..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/component.xml
+++ /dev/null
@@ -1 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?><component  xmlns="http://eclipse.org/wtp/releng/tools/component-model" name="org.eclipse.jpt.jaxb.ui"><description url=""></description><component-depends unrestricted="true"></component-depends><plugin id="org.eclipse.jpt.jaxb.ui" fragment="false"/></component>
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/plugin.properties b/jpa/plugins/org.eclipse.jpt.jaxb.ui/plugin.properties
deleted file mode 100644
index 929c959..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/plugin.properties
+++ /dev/null
@@ -1,25 +0,0 @@
-###############################################################################
-# Copyright (c) 2010 Oracle. 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:
-#     Oracle - initial API and implementation
-###############################################################################
-
-# ====================================================================
-# To code developer:
-#   Do NOT change the properties between this line and the
-#   "%%% END OF TRANSLATED PROPERTIES %%%" line.
-#   Make a new property name, append to the end of the file and change
-#   the code to use the new property.
-# ====================================================================
-
-# ====================================================================
-# %%% END OF TRANSLATED PROPERTIES %%%
-# ====================================================================
-pluginName= Dali Java Persistence Tools - JAXB Support - UI
-providerName=Eclipse Web Tools Platform
-
-generateJaxbClasses = JAXB Classes...
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/plugin.xml b/jpa/plugins/org.eclipse.jpt.jaxb.ui/plugin.xml
deleted file mode 100644
index 745b7b3..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/plugin.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.2"?>
-<plugin>
-
-	<extension
-		point="org.eclipse.ui.popupMenus">
-
-	<!-- contributions to the "Generate" submenu -->
-	<objectContribution
-		id="org.eclipse.jpt.ui.xsdFileActions"
-		objectClass="org.eclipse.core.resources.IFile"
-		nameFilter="*.xsd">
-		<filter
-			name="projectNature"
-			value="org.eclipse.jdt.core.javanature">
-		</filter>
-		<action
-			id="org.eclipse.jpt.jaxb.ui.generateJaxbClasses" 
-			label="%generateJaxbClasses"
-			menubarPath="generateMenuId/GenerateXML"
-			class="org.eclipse.jpt.jaxb.ui.internal.actions.GenerateClassesAction"> 
-		</action> 
-	</objectContribution> 
-	</extension>
-
-</plugin>
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/property_files/jpt_jaxb_ui.properties b/jpa/plugins/org.eclipse.jpt.jaxb.ui/property_files/jpt_jaxb_ui.properties
deleted file mode 100644
index cfd4fae..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/property_files/jpt_jaxb_ui.properties
+++ /dev/null
@@ -1,35 +0,0 @@
-################################################################################
-# Copyright (c) 2010 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-ClassesGeneratorWizard_title = JAXB
-
-ClassesGeneratorWizard_errorDialogTitle = Generate Classes Failed
-ClassesGeneratorWizard_couldNotCreate = Could not create {0}
-
-ClassesGeneratorWizardPage_title = Generate classes from: {0}
-ClassesGeneratorWizardPage_desc = Configure JAXB class generation.
-
-ClassesGeneratorWizardPage_usesMoxyImplementation = Use EclipseLink MOXy as the JAXB implementation
-
-ClassesGeneratorWizardPage_settingsGroupTitle = JAXB Settings
-ClassesGeneratorWizardPage_catalog = Catalog:
-ClassesGeneratorWizardPage_bindingsFiles = Bindings files:
-ClassesGeneratorWizardPage_addButton = Add
-ClassesGeneratorWizardPage_removeButton = Remove
-ClassesGeneratorWizardPage_chooseABindingsFile = Choose an external bindings file
-
-ClassesGeneratorWizardPage_jaxbLibrariesNotAvailable = \
-		The classpath for this project does not appear to contain the necessary libraries to proceed with class generation.\
-		\nPlease insure that a JAXB implementation is available on the classpath.
-
-ClassesGeneratorWizardPage_moxyLibrariesNotAvailable = \
-		The classpath for this project does not appear to contain the necessary libraries to proceed with class generation.\
-		\nPlease insure that EclipseLink MOXy is available on the classpath.
-
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/core/internal/ClassesGenerator.java b/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/core/internal/ClassesGenerator.java
deleted file mode 100644
index 38f9ede..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/core/internal/ClassesGenerator.java
+++ /dev/null
@@ -1,341 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.core.internal;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.NullProgressMonitor;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.debug.core.DebugPlugin;
-import org.eclipse.debug.core.ILaunch;
-import org.eclipse.debug.core.ILaunchConfiguration;
-import org.eclipse.debug.core.ILaunchConfigurationType;
-import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
-import org.eclipse.debug.core.ILaunchManager;
-import org.eclipse.debug.core.ILaunchesListener2;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
-import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
-import org.eclipse.jdt.launching.IVMInstall;
-import org.eclipse.jdt.launching.JavaRuntime;
-import org.eclipse.jpt.core.JpaProject;
-import org.eclipse.jpt.utility.internal.StringTools;
-
-/**
- *  ClassesGenerator
- */
-public class ClassesGenerator
-{
-	static public String LAUNCH_CONFIG_NAME = "JAXB Run Config";   //$NON-NLS-1$
-	static public String JAXB_GENERIC_GEN_CLASS = "com.sun.tools.xjc.XJCFacade";   //$NON-NLS-1$
-	static public String JAXB_ECLIPSELINK_GEN_CLASS = "org.eclipse.persistence.jaxb.xjc.MOXyXJC";   //$NON-NLS-1$
-	
-	private IVMInstall jre;
-	private ILaunchConfigurationWorkingCopy launchConfig;
-	private ILaunch launch;
-	
-	private final JpaProject jpaProject;
-	private final String xmlSchemaName;
-	private final String outputDir;
-	private final String targetPackage;
-	private final String catalog;
-	private final String[] bindingsFileNames;
-	private final String mainType;
-	private final boolean isDebug = false;
-
-	// ********** static methods **********
-	
-	public static void generate(
-			JpaProject project, 
-			String xmlSchemaName, 
-			String outputDir, 
-			String targetPackage, 
-			String catalog, 
-			boolean useMoxyGenerator,
-			String[] bindingsFileNames,
-			IProgressMonitor monitor) {
-		if (project == null) {
-			throw new NullPointerException();
-		}
-		new ClassesGenerator(project, 
-			xmlSchemaName, 
-			outputDir, 
-			targetPackage, 
-			catalog, 
-			useMoxyGenerator, 
-			bindingsFileNames, 
-			monitor).generate();
-	}
-
-	// ********** constructors **********
-	
-	protected ClassesGenerator(
-			JpaProject jpaProject, 
-			String xmlSchemaName, 
-			String outputDir, 
-			String targetPackage, 
-			String catalog, 
-			boolean useMoxyGenerator, 
-			String[] bindingsFileNames,
-			@SuppressWarnings("unused") IProgressMonitor monitor) {
-		super();
-		this.jpaProject = jpaProject;
-		this.xmlSchemaName = xmlSchemaName;
-		this.outputDir = outputDir;
-		this.targetPackage = targetPackage;
-		this.catalog = catalog;
-		this.bindingsFileNames = bindingsFileNames;
-		this.mainType = (useMoxyGenerator) ? JAXB_ECLIPSELINK_GEN_CLASS : JAXB_GENERIC_GEN_CLASS;
-
-		this.initialize();
-	}
-
-	// ********** behavior **********
-	
-	protected void initialize() {
-		try {
-			this.jre = this.getProjectJRE();
-			if (this.jre == null) {
-				String message = "Could not identify the VM.";   //$NON-NLS-1$
-				throw new RuntimeException(message);
-			}
-			this.launchConfig = this.buildLaunchConfiguration();
-		} 
-		catch (CoreException e) {
-			throw new RuntimeException(e);
-		}
-	}
-
-	protected void generate() {
-		String projectLocation = this.jpaProject.getProject().getLocation().toString();
-		
-		this.initializeLaunchConfiguration(projectLocation);
-
-		this.addLaunchListener();
-		this.launch = this.saveAndLaunchConfig();
-	}
-	
-	private void initializeLaunchConfiguration(String projectLocation) {
-
-		this.specifyJRE(this.jre.getName(), this.jre.getVMInstallType().getId());
-
-		this.specifyProject(this.getJpaProject().getProject().getName()); 
-		this.specifyMainType(this.mainType);
-
-		this.specifyProgramArguments(
-			this.xmlSchemaName, 
-			this.outputDir, 
-			this.targetPackage, 
-			this.catalog, 
-			this.bindingsFileNames);  // -d -p
-		this.specifyWorkingDir(projectLocation); 
-
-		this.specifyClasspathProperties(this.getJpaProject());
-	}
-
-	protected void postGenerate() {
-		try {
-			if ( ! this.isDebug) {
-				this.removeLaunchConfiguration(LAUNCH_CONFIG_NAME);
-			}
-		}
-		catch (CoreException e) {
-			throw new RuntimeException(e);
-		}
-	}
-
-	// ********** Launch Configuration Setup **********
-
-	private void specifyClasspathProperties(JpaProject project)  {
-		List<String> classpath = new ArrayList<String>();
-		try {
-			// Default Project classpath
-			classpath.add(this.getDefaultProjectClasspathEntry(project.getJavaProject()).getMemento());
-			// System Library  
-			classpath.add(this.getSystemLibraryClasspathEntry().getMemento());
-		}
-		catch (CoreException e) {
-			throw new RuntimeException("An error occurs generating a memento", e);
-		}
-		this.launchConfig.setAttribute(IJavaLaunchConfigurationConstants.ATTR_CLASSPATH, classpath);
-		this.launchConfig.setAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, false);
-	}
-	
-	private void specifyJRE(String jreName, String vmId) {
-
-		this.launchConfig.setAttribute(IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH, jreName);
-		this.launchConfig.setAttribute(IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH, vmId);
-	}
-	
-	private void specifyProject(String projectName) {
-
-		this.launchConfig.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, projectName);
-	}
-	
-	private void specifyMainType(String mainType) {
-
-		this.launchConfig.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, mainType);
-	}
-	
-	private void specifyProgramArguments(
-		String xmlSchemaName, 
-		String outputDir,
-		String targetPackage, 
-		String catalog,
-		String[] bindingsFileNames) {
-
-		StringBuffer programArguments = new StringBuffer();
-		// options
-		programArguments.append("-d ");	  //$NON-NLS-1$
-		programArguments.append(outputDir);
-		if( ! StringTools.stringIsEmpty(targetPackage)) {
-			programArguments.append(" -p ");	  //$NON-NLS-1$
-			programArguments.append(targetPackage);
-		}
-		if( ! StringTools.stringIsEmpty(catalog)) {
-			programArguments.append(" -catalog ");	  //$NON-NLS-1$
-			programArguments.append(catalog);
-		}
-		// schema
-		programArguments.append(" ");	  //$NON-NLS-1$
-		programArguments.append(xmlSchemaName);
-		
-		// bindings
-		if( bindingsFileNames.length > 0) {
-			for(String bindingsFileName: bindingsFileNames) {
-				programArguments.append(" -b ");	  //$NON-NLS-1$
-				programArguments.append(bindingsFileName);
-			}
-		}
-		this.launchConfig.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, programArguments.toString());
-	}
-	
-	private void specifyWorkingDir(String projectLocation) {
-		
-		File workingDir = new Path(projectLocation).toFile();
-		this.launchConfig.setAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, workingDir.getAbsolutePath());
-	}
-	
-	// ********** LaunchConfig **********
-
-	private ILaunchConfigurationWorkingCopy buildLaunchConfiguration() throws CoreException {
-		ILaunchConfigurationWorkingCopy launchConfig = null;
-		this.removeLaunchConfiguration(LAUNCH_CONFIG_NAME);
-
-		ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
-		ILaunchConfigurationType type = manager.getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
-
-		launchConfig = type.newInstance(null, LAUNCH_CONFIG_NAME);
-		return launchConfig;
-	}
-
-	private void removeLaunchConfiguration(String launchConfigurationName) throws CoreException {
-
-		ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
-		ILaunchConfigurationType type = manager.getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
-	
-		ILaunchConfiguration[] configurations = manager.getLaunchConfigurations(type);
-				for (int i = 0; i < configurations.length; i++) {
-			ILaunchConfiguration configuration = configurations[i];
-			if (configuration.getName().equals(launchConfigurationName)) {
-				configuration.delete();
-				break;
-			}
-		}
-	}
-	
-	private ILaunch saveAndLaunchConfig() {
-		ILaunchConfiguration configuration = null;
-		ILaunch result = null;
-		try {
-			configuration = this.launchConfig.doSave();
-		}
-		catch (CoreException saveException) {
-			throw new RuntimeException("Could not save LaunchConfig", saveException);
-		}
-		 try {
-			result = configuration.launch(ILaunchManager.RUN_MODE, new NullProgressMonitor());
-		}
-		catch (CoreException lauchException) {
-			throw new RuntimeException("An error occured during launch", lauchException);
-		}
-		return result;
-	}
-	
-	private void addLaunchListener() {
-
-		this.getLaunchManager().addLaunchListener(this.buildLaunchListener());
-	}
-
-	private ILaunchesListener2 buildLaunchListener() {
-		return new ILaunchesListener2() {
-			
-			public void launchesTerminated(ILaunch[] launches) {
-				for (int i = 0; i < launches.length; i++) {
-					ILaunch launch = launches[i];
-					if (launch.equals(ClassesGenerator.this.getLaunch())) {
-
-						ClassesGenerator.this.postGenerate();
-						return;
-					}
-				}
-			}
-
-			public void launchesAdded(ILaunch[] launches) {
-				// not interested to this event
-			}
-
-			public void launchesChanged(ILaunch[] launches) {
-				// not interested to this event
-			}
-
-			public void launchesRemoved(ILaunch[] launches) {
-				// not interested to this event
-			}
-		};
-	}
-	
-	// ********** Queries **********
-
-	private IRuntimeClasspathEntry getSystemLibraryClasspathEntry() throws CoreException {
-
-		IPath systemLibsPath = new Path(JavaRuntime.JRE_CONTAINER);
-		return JavaRuntime.newRuntimeContainerClasspathEntry(systemLibsPath, IRuntimeClasspathEntry.STANDARD_CLASSES);
-	}
-	
-	private IRuntimeClasspathEntry getDefaultProjectClasspathEntry(IJavaProject project) {
-
-		IRuntimeClasspathEntry projectEntry = JavaRuntime.newDefaultProjectClasspathEntry(project);
-		projectEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES);
-		
-		return projectEntry;
-	}
-	
-	protected JpaProject getJpaProject() {
-		return this.jpaProject;
-	}
-	
-	private IVMInstall getProjectJRE() throws CoreException {
-		return JavaRuntime.getVMInstall(this.getJpaProject().getJavaProject());
-	}
-	
-	protected ILaunch getLaunch() {
-		return this.launch;
-	}
-	
-	protected ILaunchManager getLaunchManager() {
-		return DebugPlugin.getDefault().getLaunchManager();
-	}
-}
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/JptJaxbUiPlugin.java b/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/JptJaxbUiPlugin.java
deleted file mode 100644
index 09ff02e..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/JptJaxbUiPlugin.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.ui;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.resource.ImageRegistry;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-
-/**
- * The activator class controls the plug-in life cycle
- * 
- * 
- * Provisional API: This interface is part of an interim API that is still
- * under development and expected to change significantly before reaching
- * stability. It is available at this early stage to solicit feedback from
- * pioneering adopters on the understanding that any code that uses this API
- * will almost certainly be broken (repeatedly) as the API evolves.
- */
-@SuppressWarnings("nls")
-public class JptJaxbUiPlugin extends AbstractUIPlugin
-{
-
-	// The plug-in ID
-	public static final String PLUGIN_ID = "org.eclipse.jpt.jaxb.ui";
-
-	
-	// ********** singleton **********
-	private static JptJaxbUiPlugin INSTANCE;
-
-	/**
-	 * Returns the singleton Plugin
-	 */
-	public static JptJaxbUiPlugin instance() {
-		return INSTANCE;
-	}
-
-	public static void log(IStatus status) {
-        INSTANCE.getLog().log(status);
-    }
-
-	public static void log(String msg) {
-        log(new Status(IStatus.ERROR, PLUGIN_ID, IStatus.OK, msg, null));
-    }
-
-	public static void log(Throwable throwable) {
-		log(new Status(IStatus.ERROR, PLUGIN_ID, IStatus.OK, throwable.getLocalizedMessage(), throwable));
-	}
-
-	// ********** Image API **********
-	/**
-	 * This gets a .gif from the icons folder.
-	 */
-	public static ImageDescriptor getImageDescriptor(String key) {
-		if (! key.startsWith("icons/")) {
-			key = "icons/" + key;
-		}
-		if (! key.endsWith(".gif")) {
-			key = key + ".gif";
-		}
-		return imageDescriptorFromPlugin(PLUGIN_ID, key);
-	}
-
-	/**
-	 * This returns an image for a .gif from the icons folder
-	 */
-	//TODO we are using the ImageRegistry here and storing all our icons for the life of the plugin, 
-	//which means until the workspace is closed.  This is better than before where we constantly 
-	//created new images. Bug 306437 is about cleaning this up and using Local Resource Managers 
-	//on our views so that closing the JPA perspective would mean our icons are disposed.
-	public static Image getImage(String key) {
-		ImageRegistry imageRegistry = instance().getImageRegistry();
-		Image image = imageRegistry.get(key);
-		if (image == null) {
-			imageRegistry.put(key, getImageDescriptor(key));
-			image = imageRegistry.get(key);
-		}
-		return image;
-	}
-
-
-	
-	// ********** constructors **********
-	public JptJaxbUiPlugin() {
-		super();
-		if (INSTANCE != null) {
-			throw new IllegalStateException();
-		}
-		INSTANCE = this;
-	}
-}
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/ClassesGeneratorUi.java b/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/ClassesGeneratorUi.java
deleted file mode 100644
index b8ca74c..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/ClassesGeneratorUi.java
+++ /dev/null
@@ -1,222 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.ui.internal;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IWorkspaceRunnable;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.NullProgressMonitor;
-import org.eclipse.core.runtime.OperationCanceledException;
-import org.eclipse.jface.dialogs.MessageDialog;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jface.wizard.WizardDialog;
-import org.eclipse.jpt.core.JpaProject;
-import org.eclipse.jpt.core.JptCorePlugin;
-import org.eclipse.jpt.jaxb.core.internal.ClassesGenerator;
-import org.eclipse.jpt.jaxb.ui.internal.wizards.ClassesGeneratorWizard;
-import org.eclipse.jpt.utility.internal.StringTools;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- *  ClassesGeneratorUi
- */
-public class ClassesGeneratorUi {
-	private final JpaProject project;
-	private final String xmlSchemaName;
-
-	// ********** static methods **********
-	
-	public static void generate(IFile xsdFile) {
-		JpaProject jpaProject = JptCorePlugin.getJpaProject(xsdFile.getProject());
-		if (jpaProject == null) {
-			return;
-		}
-		IPath xmlSchema = xsdFile.getProjectRelativePath();
-		
-		new ClassesGeneratorUi(jpaProject, xmlSchema.toOSString()).generate();
-	}
-
-	// ********** constructors **********
-	private ClassesGeneratorUi(JpaProject project, String xmlSchemaName) {
-		super();
-		if (project == null || StringTools.stringIsEmpty(xmlSchemaName)) {
-			throw new NullPointerException();
-		}
-		this.project = project;
-		this.xmlSchemaName = xmlSchemaName;
-	}
-
-	// ********** generate **********
-	/**
-	 * prompt the user with a wizard
-	 */
-	protected void generate() {
-
-		ClassesGeneratorWizard wizard = new ClassesGeneratorWizard(this.project, this.xmlSchemaName);
-		WizardDialog dialog = new WizardDialog(this.getCurrentShell(), wizard);
-		dialog.create();
-		int returnCode = dialog.open();
-		if (returnCode != Window.OK) {
-			return;
-		}
-		String outputDir = wizard.getDestinationFolder();
-		String targetPackage = wizard.getTargetPackage();
-		String catalog = wizard.getCatalog();
-		boolean useMoxy = wizard.getUseMoxy();
-		String[] bindingsFileNames = wizard.getBindingsFileNames();
-
-		this.run(outputDir, targetPackage, catalog, useMoxy, bindingsFileNames);
-	}
-
-	// ********** internal methods **********
-
-	private void run(
-		String outputDir,
-		String targetPackage, 
-		String catalog, 
-		boolean useMoxyGenerator,
-		String[] bindingsFileNames) {
-		
-		IWorkspaceRunnable runnable = this.buildGenerateEntitiesRunnable(
-			this.project, 
-			this.xmlSchemaName, 
-			outputDir, 
-			targetPackage, 
-			catalog, 
-			useMoxyGenerator,
-			bindingsFileNames);
-		try {
-			ResourcesPlugin.getWorkspace().run(runnable, new NullProgressMonitor());
-		} 
-		catch (CoreException ex) {
-			throw new RuntimeException(ex);
-		}
-	}
-	
-	private IWorkspaceRunnable buildGenerateEntitiesRunnable(
-		JpaProject project, 
-		String xmlSchemaName, 
-		String outputDir,
-		String targetPackage, 
-		String catalog, 
-		boolean useMoxyGenerator,
-		String[] bindingsFileNames) {
-
-		return new GenerateEntitiesRunnable(project, xmlSchemaName, outputDir, targetPackage, catalog, useMoxyGenerator, bindingsFileNames);
-	}
-	
-	private Shell getCurrentShell() {
-	    return Display.getCurrent().getActiveShell();
-	}
-
-	// ********** Runnable Class **********
-
-	private static class GenerateEntitiesRunnable implements IWorkspaceRunnable {
-		private final JpaProject project;
-		private final String xmlSchemaName;
-		private final String outputDir;
-		private final String targetPackage;
-		private final String catalog;
-		private final boolean useMoxyGenerator;
-		private final String[] bindingsFileNames;
-
-		// ********** constructors **********
-		
-		public GenerateEntitiesRunnable(
-			JpaProject project, 
-			String xmlSchemaName, 
-			String outputDir,
-			String targetPackage, 
-			String catalog, 
-			boolean useMoxyGenerator,
-			String[] bindingsFileNames) {
-			
-			super();
-			this.project = project;
-			this.xmlSchemaName = xmlSchemaName;
-			this.outputDir = outputDir;
-			this.targetPackage = targetPackage;
-			this.catalog = catalog;
-			this.useMoxyGenerator = useMoxyGenerator;
-			this.bindingsFileNames = bindingsFileNames;
-		}
-
-		public void run(IProgressMonitor monitor) {
-			try {
-				this.entitiesGeneratorGenerate(this.project, 
-					this.xmlSchemaName, 
-					this.outputDir, 
-					this.targetPackage, 
-					this.catalog, 
-					this.useMoxyGenerator,
-					this.bindingsFileNames,
-					monitor);
-			} 
-			catch (OperationCanceledException e) {
-				return;
-				// fall through and tell monitor we are done
-			}
-			catch (RuntimeException re) {
-				String msg = re.getMessage();
-				String message = (msg == null) ? re.toString() : msg;
-				
-				this.logError(message);
-				throw new RuntimeException(re);
-			}
-		}
-	
-		private void entitiesGeneratorGenerate(JpaProject project, 
-			String xmlSchemaName, 
-			String outputDir, 
-			String targetPackage, 
-			String catalog, 
-			boolean useMoxyGenerator,
-			String[] bindingsFileNames, 
-			IProgressMonitor monitor) {
-	
-			ClassesGenerator.generate(project, 
-				xmlSchemaName, 
-				outputDir, 
-				targetPackage, 
-				catalog, 
-				useMoxyGenerator, 
-				bindingsFileNames, 
-				monitor);
-			return;
-		}
-	
-		private void logError(String message) {
-				this.displayError(message);
-		}
-		
-		private void displayError(String message) {
-			MessageDialog.openError(
-					this.getShell(),
-					JptJaxbUiMessages.ClassesGeneratorWizard_errorDialogTitle,
-					message
-				);
-		}
-
-		private Shell getShell() {
-			Display display = Display.getCurrent();
-			Shell shell = (display == null) ? null : display.getActiveShell();
-			if (shell == null && display != null) {
-				Shell[] shells = display.getShells();
-				if (shells.length > 0)
-					shell = shells[0];
-			}
-			return shell;
-		}
-	}
-}
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/JptJaxbUiMessages.java b/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/JptJaxbUiMessages.java
deleted file mode 100644
index 3ede138..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/JptJaxbUiMessages.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.ui.internal;
-
-import org.eclipse.osgi.util.NLS;
-
-/**
- * Localized messages used by Dali JAXB UI.
- *
- * @version 2.3
- */
-public class JptJaxbUiMessages {
-
-	public static String ClassesGeneratorWizard_title;
-	public static String ClassesGeneratorWizard_errorDialogTitle;
-	public static String ClassesGeneratorWizard_couldNotCreate;
-
-	public static String ClassesGeneratorWizardPage_title;
-	public static String ClassesGeneratorWizardPage_desc;
-	
-	public static String ClassesGeneratorWizardPage_usesMoxyImplementation;
-	
-	public static String ClassesGeneratorWizardPage_settingsGroupTitle;
-	public static String ClassesGeneratorWizardPage_catalog;
-	public static String ClassesGeneratorWizardPage_bindingsFiles;
-	public static String ClassesGeneratorWizardPage_addButton;
-	public static String ClassesGeneratorWizardPage_removeButton;
-	public static String ClassesGeneratorWizardPage_chooseABindingsFile;
-	
-	public static String ClassesGeneratorWizardPage_jaxbLibrariesNotAvailable;
-	
-	public static String ClassesGeneratorWizardPage_moxyLibrariesNotAvailable;
-
-	private static final String BUNDLE_NAME = "jpt_jaxb_ui"; //$NON-NLS-1$
-	private static final Class<?> BUNDLE_CLASS = JptJaxbUiMessages.class;
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, BUNDLE_CLASS);
-	}
-
-	private JptJaxbUiMessages() {
-		throw new UnsupportedOperationException();
-	}
-
-}
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/actions/GenerateClassesAction.java b/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/actions/GenerateClassesAction.java
deleted file mode 100644
index 526fd69..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/actions/GenerateClassesAction.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.ui.internal.actions;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.jpt.jaxb.ui.internal.ClassesGeneratorUi;
-
-/**
- *  GenerateClassesAction
- */
-public class GenerateClassesAction extends ObjectAction
-{
-
-	@Override
-	protected void execute(IFile xsdFile) {
-
-		ClassesGeneratorUi.generate(xsdFile);
-	}
-
-}
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/actions/ObjectAction.java b/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/actions/ObjectAction.java
deleted file mode 100644
index 6146578..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/actions/ObjectAction.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.ui.internal.actions;
-
-import java.util.Iterator;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.ITreeSelection;
-import org.eclipse.ui.IObjectActionDelegate;
-import org.eclipse.ui.IWorkbenchPart;
-import org.eclipse.ui.actions.ActionDelegate;
-
-/**
- *  GenerateEntitiesAction
- */
-public abstract class ObjectAction extends ActionDelegate implements IObjectActionDelegate 
-{
-	private ISelection currentSelection;
-
-	public ObjectAction() {
-		super();
-	}
-
-	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
-		// do nothing
-	}
-
-	@Override
-	public void selectionChanged(IAction action, ISelection selection) {
-        this.currentSelection = selection;
-	}
-
-	@Override
-	public void run(IAction action) {
-		if (this.currentSelection instanceof ITreeSelection) {
-			for (Iterator stream = ((ITreeSelection) this.currentSelection).iterator(); stream.hasNext(); ) {
-				this.execute(stream.next());
-			}
-		}
-	}
-
-	protected void execute(Object selection) {
-		
-		if(selection instanceof IFile) {
-			this.execute((IFile)selection);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	protected void execute(IFile file) {
-		throw new UnsupportedOperationException();
-	}
-
-}
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/wizards/ClassesGeneratorWizard.java b/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/wizards/ClassesGeneratorWizard.java
deleted file mode 100644
index d13063e..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/wizards/ClassesGeneratorWizard.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.ui.internal.wizards;
-
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jface.dialogs.MessageDialog;
-import org.eclipse.jface.wizard.Wizard;
-import org.eclipse.jpt.core.JpaProject;
-import org.eclipse.jpt.jaxb.ui.internal.JptJaxbUiMessages;
-import org.eclipse.osgi.util.NLS;
-
-/**
- *  ClassesGeneratorWizard
- */
-public class ClassesGeneratorWizard extends Wizard {	
-
-	private final JpaProject jpaProject;
-	private final String xmlSchemaName;
-
-	private String destinationFolder;
-	private String targetPackage;
-	private String catalog;
-	private boolean useMoxy;
-	private String[] bindingsFileNames;
-
-	private ClassesGeneratorWizardPage generatorSettingsPage;
-
-	// ********** constructor **********
-	
-	public ClassesGeneratorWizard(JpaProject jpaProject, String xmlSchemaName) {
-		super();
-		this.jpaProject = jpaProject;
-		this.xmlSchemaName = xmlSchemaName;
-		this.setWindowTitle(JptJaxbUiMessages.ClassesGeneratorWizard_title); 
-	}
-	
-	// ********** overrides **********
-	
-	@Override
-	public void addPages() {
-		super.addPages();
-		
-		this.generatorSettingsPage = this.buildClassesGeneratorPage();
-		
-		this.addPage(this.generatorSettingsPage);
-	}
-	
-	@Override
-	public boolean performFinish() {
-		this.destinationFolder = this.generatorSettingsPage.getTargetFolder();
-		this.targetPackage = this.generatorSettingsPage.getTargetPackage();
-		this.catalog = this.generatorSettingsPage.getCatalog();
-		this.useMoxy = this.generatorSettingsPage.usesMoxy();
-		this.bindingsFileNames = this.generatorSettingsPage.getBindingsFileNames();
-		
-		IFolder folder = this.jpaProject.getProject().getFolder(this.destinationFolder);
-		this.createFolderIfNotExist(folder);
-		return true;
-	}
-
-    @Override
-	public boolean canFinish() {
-    	return this.generatorSettingsPage.isPageComplete();
-    }
-
-	// ********** public methods **********
-    
-    public String getDestinationFolder() {
-		return this.destinationFolder;
-	}
-	
-    public String getTargetPackage() {
-		return this.targetPackage;
-	}
-	
-    public String getCatalog() {
-		return this.catalog;
-	}
-	
-    public boolean getUseMoxy() {
-		return this.useMoxy;
-	}
-
-    public String[] getBindingsFileNames() {
-		return this.bindingsFileNames;
-	}
-
-	// ********** internal methods **********
-
-	private ClassesGeneratorWizardPage buildClassesGeneratorPage() {
-		return new ClassesGeneratorWizardPage(this.jpaProject, this.xmlSchemaName);
-	}
-	
-	private void createFolderIfNotExist(IFolder folder) {
-		if( folder.exists()) {
-			return;
-		}
-		try {
-			folder.create(true, true, null);
-		}
-		catch (CoreException e) {
-			this.logError(NLS.bind(
-				JptJaxbUiMessages.ClassesGeneratorWizard_couldNotCreate, 
-				folder.getProjectRelativePath().toOSString()));
-		}
-	}
-	
-	protected void logError(String message) {
-			this.displayError(message);
-	}
-	
-	private void displayError(String message) {
-		MessageDialog.openError(
-				this.getShell(),
-				JptJaxbUiMessages.ClassesGeneratorWizard_errorDialogTitle,
-				message
-			);
-	}
-}
diff --git a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/wizards/ClassesGeneratorWizardPage.java b/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/wizards/ClassesGeneratorWizardPage.java
deleted file mode 100644
index 80e3ff3..0000000
--- a/jpa/plugins/org.eclipse.jpt.jaxb.ui/src/org/eclipse/jpt/jaxb/ui/internal/wizards/ClassesGeneratorWizardPage.java
+++ /dev/null
@@ -1,508 +0,0 @@
-/*******************************************************************************
-* Copyright (c) 2010 Oracle. 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:
-*     Oracle - initial API and implementation
-*******************************************************************************/
-package org.eclipse.jpt.jaxb.ui.internal.wizards;
-
-import java.util.ArrayList;
-import java.util.Collection;
-
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.ui.wizards.NewTypeWizardPage;
-import org.eclipse.jface.dialogs.Dialog;
-import org.eclipse.jface.viewers.ColumnWeightData;
-import org.eclipse.jface.viewers.IBaseLabelProvider;
-import org.eclipse.jface.viewers.IContentProvider;
-import org.eclipse.jface.viewers.IStructuredContentProvider;
-import org.eclipse.jface.viewers.ITableLabelProvider;
-import org.eclipse.jface.viewers.LabelProvider;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.jface.viewers.TableViewer;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jpt.core.JpaProject;
-import org.eclipse.jpt.jaxb.core.internal.ClassesGenerator;
-import org.eclipse.jpt.jaxb.ui.internal.JptJaxbUiMessages;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.jpt.ui.internal.util.TableLayoutComposite;
-import org.eclipse.jpt.utility.internal.ArrayTools;
-import org.eclipse.jpt.utility.internal.StringTools;
-import org.eclipse.osgi.util.NLS;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.FileDialog;
-import org.eclipse.swt.widgets.Group;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Table;
-import org.eclipse.swt.widgets.TableColumn;
-import org.eclipse.swt.widgets.Text;
-import org.osgi.framework.Bundle;
-
-/**
- *  ClassesGeneratorWizardPage
- */
-public class ClassesGeneratorWizardPage extends NewTypeWizardPage {
-	static public String JPT_JAXB_ECLIPSELINK_UI_PLUGIN_ID = "org.eclipse.jpt.eclipselink.jaxb.ui";   //$NON-NLS-1$
-
-	private final JpaProject jpaProject;
-
-	private SettingsGroup settingsGroup;
-	
-	private String targetFolder;
-	private String targetPackage;
-	
-	private Button usesMoxyCheckBox;
-	private boolean usesMoxy;
-
-	// ********** constructor **********
-	
-	public ClassesGeneratorWizardPage(JpaProject jpaProject, String xmlSchemaName) {
-		super(true, "Classes Generator"); //$NON-NLS-1$
-		if (jpaProject == null) {
-			throw new NullPointerException();
-		}
-		this.jpaProject = jpaProject;
-		// default usesMoxy to true only when JPT EclipseLink bundle exists and MOXy is on the classpath
-		this.usesMoxy = (jptEclipseLinkJaxbBundleExists() && moxyIsOnClasspath()); 
-		
-		this.setTitle(NLS.bind(JptJaxbUiMessages.ClassesGeneratorWizardPage_title, xmlSchemaName));
-		this.setDescription(JptJaxbUiMessages.ClassesGeneratorWizardPage_desc);
-	}
-
-	// ********** UI components **********
-
-	public void createControl(Composite parent) {
-		this.setPageComplete(false);
-		this.setControl(this.buildTopLevelControl(parent));
-		
-		initContainerPage(this.jpaProject.getJavaProject());
-	}
-
-	private Control buildTopLevelControl(Composite parent) {
-		Composite composite = new Composite(parent, SWT.NULL);
-		composite.setLayout(new GridLayout());
-		
-		this.settingsGroup = new SettingsGroup(composite);
-
-		// add checkbox only if jpt.eclipselink.jaxb plugin is available
-		// and EclipseLink MOXy is not on the classpath
-		if(jptEclipseLinkJaxbBundleExists() && ! moxyIsOnClasspath()) {
-			this.usesMoxyCheckBox = this.buildUsesMoxyCheckBox(composite);
-		}
-		
-		Dialog.applyDialogFont(parent);
-		return composite;
-	}
-	
-	private Button buildUsesMoxyCheckBox(Composite parent) {
-
-		 Button checkBox = new Button(parent, SWT.CHECK);
-		checkBox.setText(JptJaxbUiMessages.ClassesGeneratorWizardPage_usesMoxyImplementation);
-		checkBox.setSelection(this.usesMoxy());
-		checkBox.addSelectionListener(this.buildUsesMoxySelectionListener());
-		
-		return checkBox;
-	}
-	
-	private SelectionListener buildUsesMoxySelectionListener() {
-		return new SelectionListener() {
-			public void widgetDefaultSelected(SelectionEvent event) {
-				this.widgetSelected(event);
-			}
-			
-			public void widgetSelected(SelectionEvent event) {
-				setUsesMoxy(usesMoxyCheckBox.getSelection());
-				validateProjectClasspath();
-			}
-		};
-	}
-
-	// ********** intra-wizard methods **********
-	
-	protected String getTargetFolder() {
-		return this.targetFolder;
-	}
-
-	protected String getTargetPackage() {
-		return this.targetPackage;
-	}
-
-	protected String getCatalog() {
-		return this.settingsGroup.getCatalog();
-	}
-
-	protected String[] getBindingsFileNames() {
-		return this.settingsGroup.getBindingsFileNames();
-	}
-	
-	protected Boolean usesMoxy() {
-		return this.usesMoxy;
-	}
-	
-	protected void setUsesMoxy(boolean usesMoxy){
-		this.usesMoxy = usesMoxy;
-	}
-
-	// ********** internal methods **********
-	
-	private boolean jptEclipseLinkJaxbBundleExists() {
-		return (this.getJptEclipseLinkJaxbBundle() != null);
-	}
-	
-	private Bundle getJptEclipseLinkJaxbBundle() {
-		return Platform.getBundle(JPT_JAXB_ECLIPSELINK_UI_PLUGIN_ID);	// Cannot reference directly EL plugin.
-	}
-	
-	private void validateProjectClasspath() {
-		//this line will suppress the "default package" warning (which doesn't really apply here
-		//as the JAXB gen uses an org.example.schemaName package by default) and will clear the classpath warnings when necessary
-		setMessage(null);
-		
-		if ( ! this.genericJaxbIsOnClasspath()) {
-			this.displayWarning(JptJaxbUiMessages.ClassesGeneratorWizardPage_jaxbLibrariesNotAvailable);
-		}
-		else if (this.usesMoxy() && ! this.moxyIsOnClasspath()) {
-			//this message is being truncated by the wizard width in some cases
-			this.displayWarning(JptJaxbUiMessages.ClassesGeneratorWizardPage_moxyLibrariesNotAvailable);
-		}
-
-		//this code will intelligently remove our classpath warnings when they are present but no longer apply (as an alternative 
-		//to setting the message to null continuously as is currently done)
-//		else if( this.getMessage() != null){
-//			if (this.getMessage().equals(JptJaxbUiMessages.ClassesGeneratorWizardPage_jaxbLibrariesNotAvailable) ||
-//					this.getMessage().equals(JptJaxbUiMessages.ClassesGeneratorWizardPage_moxyLibrariesNotAvailable)) { 
-//				setMessage(null);
-//			}
-//		}
-	}
-	
-	private void displayWarning(String message) {
-		this.setMessage(message, WARNING);
-	}
-
-	/**
-	 * Test if the Jaxb compiler is on the classpath.
-	 */
-	private boolean genericJaxbIsOnClasspath() {
-		try {
-			String className = ClassesGenerator.JAXB_GENERIC_GEN_CLASS;
-			IType genClass = this.jpaProject.getJavaProject().findType(className);
-			return (genClass != null);
-		} 
-		catch (JavaModelException e) {
-			throw new RuntimeException(e);
-		}
-	}
-	/**
-	 * Test if the EclipseLink Jaxb compiler is on the classpath.
-	 */
-	private boolean moxyIsOnClasspath() {
-		try {
-			String className = ClassesGenerator.JAXB_ECLIPSELINK_GEN_CLASS;
-			IType genClass = this.jpaProject.getJavaProject().findType(className);
-			return (genClass != null);
-		} 
-		catch (JavaModelException e) {
-			throw new RuntimeException(e);
-		}
-	}
-	
-	// ********** overrides **********
-	
-
-	
-	@Override
-	protected IStatus packageChanged() {
-		IStatus status = super.packageChanged(); 
-		IPackageFragment packageFragment = getPackageFragment();
-		if (!status.matches(IStatus.ERROR)) {
-			this.targetPackage = packageFragment.getElementName();
-		}
-		return status;
-	}			
-	
-	@Override
-	protected IStatus containerChanged() {
-		IStatus status = super.containerChanged();
-		String srcFolder = getPackageFragmentRootText();
-		if( !status.matches(IStatus.ERROR) ){
-				this.targetFolder = srcFolder.substring(srcFolder.indexOf("/") + 1);
-		}
-		return status;
-	}
-	
-	@Override
-	protected void handleFieldChanged(String fieldName) {
-		super.handleFieldChanged(fieldName);
-		if (this.fContainerStatus.matches(IStatus.ERROR)) {
-			updateStatus(fContainerStatus);
-		}else if( ! this.fPackageStatus.matches(IStatus.OK) ) {
-			updateStatus(fPackageStatus);
-		} else {
-			updateStatus(Status.OK_STATUS);
-		}
-		validateProjectClasspath();
-	}
-	
-	/**
-	 * Override setVisible to insure that our more important warning
-	 * message about classpath problems is displayed to the user first.
-	 */
-	@Override
-	public void setVisible(boolean visible) {
-		super.setVisible(visible);
-		validateProjectClasspath();
-	}
-	
-    @Override
-    public final void performHelp() {
-        //TODO We need a help ID for JAXB Generation
-    }
-	
-	// ********** SettingsGroup class **********
-
-	private class SettingsGroup {
-
-		private final Text catalogText;
-
-		private final ArrayList<String> bindingsFileNames;
-		
-		// ********** constructor **********
-
-		private SettingsGroup(Composite composite) {
-			super();
-			Group group = new Group(composite, SWT.NONE);
-			group.setLayout(new GridLayout(4, false));  // false = do not make columns equal width
-			group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-			group.setText(JptJaxbUiMessages.ClassesGeneratorWizardPage_settingsGroupTitle);
-			// TODO PlatformUI.getWorkbench().getHelpSystem().setHelp(this.group, JpaHelpContextIds.XXX);
-
-			// Source folder
-			createContainerControls(group, 4);
-			
-			// Package
-			createPackageControls(group, 4);
-			
-			// Catalog
-			this.buildLabel(group, 1, JptJaxbUiMessages.ClassesGeneratorWizardPage_catalog);
-			this.catalogText = this.buildText(group);
-			
-			// Bindings files
-			this.bindingsFileNames = new ArrayList<String>();
-			this.buildLabel(group, 1, JptJaxbUiMessages.ClassesGeneratorWizardPage_bindingsFiles);
-			this.buildBindingsFileTable(group);
-		}
-
-		// ********** intra-wizard methods **********
-
-		protected String getCatalog() {
-			return this.catalogText.getText();
-		}
-
-		protected String[] getBindingsFileNames() {
-			return ArrayTools.array(this.bindingsFileNames.iterator(), new String[0]);
-		}
-		
-		// ********** UI components **********
-
-		private Label buildLabel(Composite parent, int span, String text) {
-			Label label = new Label(parent, SWT.NONE);
-			label.setText(text);
-			GridData gd = new GridData();
-			gd.horizontalSpan = span;
-			label.setLayoutData(gd);
-			return label;
-		}
-
-		private Text buildText(Composite parent) {
-			
-			Text text = new Text(parent, SWT.BORDER);
-			text.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-			//Filler columns
-			new Label(parent, SWT.NONE);
-			new Label(parent, SWT.NONE);
-			return text;
-		}
-
-		private TableViewer buildBindingsFileTable(Composite parent) {
-			
-			TableViewer tableViewer = this.buildTableViewer(parent, this.bindingsFileNames);
-			
-			this.buildAddRemoveButtons(parent, tableViewer, this.bindingsFileNames);
-			return tableViewer;
-		}
-		
-		private TableViewer buildTableViewer(Composite parent, ArrayList<String> tableDataModel) {	
-		
-			TableLayoutComposite tableLayout = new TableLayoutComposite(parent, SWT.NONE);
-			this.addColumnsData(tableLayout);
-		
-			final Table table = new Table(tableLayout, SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER);
-			table.setLinesVisible(false);
-			
-			TableColumn column = new TableColumn(table, SWT.NONE, 0);
-			column.setResizable(true);
-		
-			GridData gridData= new GridData(GridData.FILL_BOTH);
-			gridData.heightHint= SWTUtil.getTableHeightHint(table, 3);
-			gridData.widthHint = 300;
-			tableLayout.setLayoutData(gridData);
-		
-			TableViewer tableViewer = new TableViewer(table);
-			tableViewer.setUseHashlookup(true);
-			tableViewer.setLabelProvider(this.buildLabelProvider());
-			tableViewer.setContentProvider(this.buildContentProvider());
-			
-			tableViewer.setInput(tableDataModel);
-			return tableViewer;
-		}
-		
-		private void buildAddRemoveButtons(Composite parent, final TableViewer tableViewer, final ArrayList<String> tableDataModel) {
-		
-			Composite buttonComposite = new Composite(parent, SWT.NULL);
-			GridLayout buttonLayout = new GridLayout(1, false);
-			buttonComposite.setLayout(buttonLayout);
-			GridData gridData =  new GridData();
-			gridData.horizontalAlignment = GridData.FILL;
-			gridData.verticalAlignment = GridData.BEGINNING;
-			buttonComposite.setLayoutData(gridData);
-			// Add buttons
-			Button addButton = new Button(buttonComposite, SWT.PUSH);
-			addButton.setText(JptJaxbUiMessages.ClassesGeneratorWizardPage_addButton);
-			gridData =  new GridData();
-			gridData.horizontalAlignment = GridData.FILL;
-			addButton.setLayoutData(gridData);
-			addButton.addSelectionListener(new SelectionListener() {
-				public void widgetDefaultSelected(SelectionEvent e) {}
-			
-				public void widgetSelected(SelectionEvent e) {
-
-					String fileName = promptFile();
-					if( ! StringTools.stringIsEmpty(fileName)) {
-						
-						tableDataModel.add(makeRelativeToProjectPath(fileName));
-						tableViewer.refresh();
-					}
-				}
-			});
-			// Remove buttons
-			Button removeButton = new Button(buttonComposite, SWT.PUSH);
-			removeButton.setText(JptJaxbUiMessages.ClassesGeneratorWizardPage_removeButton);
-			gridData =  new GridData();
-			gridData.horizontalAlignment = GridData.FILL;
-			removeButton.setLayoutData(gridData);
-			removeButton.addSelectionListener(new SelectionListener() {
-				public void widgetDefaultSelected(SelectionEvent e) {}
-			
-				public void widgetSelected(SelectionEvent e) {
-					StructuredSelection selection = (StructuredSelection)tableViewer.getSelection();
-					if(selection.isEmpty()) {
-						return;
-					}
-					String bindingsFileName = (String)selection.getFirstElement();
-					removeBindingsFileName(bindingsFileName);
-		
-					tableViewer.refresh();
-				}
-			});
-			addButton.setFocus();
-		}
-
-		// ********** internal methods **********
-
-		private String makeRelativeToProjectPath(String filePath) {
-			Path path = new Path(filePath);
-			IPath relativePath = path.makeRelativeTo(jpaProject.getProject().getLocation());
-			return relativePath.toOSString();
-		}
-		
-		private void removeBindingsFileName(String bindingsName) {
-			String name = this.getBindingsFileName(bindingsName);
-			this.bindingsFileNames.remove(name);
-		}
-		
-		private String getBindingsFileName(String bindingsName) {
-			for(String name: this.bindingsFileNames) {
-				if(name.equals(bindingsName)) {
-					return name;
-				}
-			}
-			return null;
-		}
-
-		private IBaseLabelProvider buildLabelProvider() {
-			return new TableLabelProvider();
-		}
-		
-		private IContentProvider buildContentProvider() {
-			return new TableContentProvider();
-		}
-
-		/**
-		 * The Add button was clicked, its action invokes this action which should
-		 * prompt the user to select a file and return it.
-		 */
-		private String promptFile() {
-			String projectPath= jpaProject.getProject().getLocation().toString();
-
-			FileDialog dialog = new FileDialog(getShell());
-			dialog.setText(JptJaxbUiMessages.ClassesGeneratorWizardPage_chooseABindingsFile);
-			dialog.setFilterPath(projectPath);
-			dialog.setFilterExtensions(new String[] {"*.xjb"});   //$NON-NLS-1$
-			String filePath = dialog.open();
-			
-			return (filePath != null) ? filePath : null;
-		}
-		
-		private void addColumnsData(TableLayoutComposite layout) {
-			layout.addColumnData(new ColumnWeightData(50, true));
-		}
-		
-	}
-
-	// ********** inner class **********
-	private class TableLabelProvider extends LabelProvider implements ITableLabelProvider {
-
-		public Image getColumnImage(Object element, int columnIndex) {
-			return null;
-		}
-		
-		public String getColumnText(Object element, int columnIndex) {
-			return (String)element;
-		}
-	}
-	
-	private class TableContentProvider implements IStructuredContentProvider {
-
-		TableContentProvider() {
-			super();
-		}
-
-		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
-		
-		public void dispose() {}
-		
-		public Object[] getElements(Object inputElement) {
-			return ((Collection<?>) inputElement).toArray();
-		}
-	}
-	
-}
\ No newline at end of file
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/.classpath b/jpa/tests/org.eclipse.jpt.db.tests/.classpath
deleted file mode 100644
index ef8d91c..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/.classpath
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">
-		<accessrules>
-			<accessrule kind="accessible" pattern="org/eclipse/jpt/utility/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/.cvsignore b/jpa/tests/org.eclipse.jpt.db.tests/.cvsignore
deleted file mode 100644
index ba077a4..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-bin
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/.project b/jpa/tests/org.eclipse.jpt.db.tests/.project
deleted file mode 100644
index f5b0127..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.db.tests</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/.settings/org.eclipse.core.resources.prefs b/jpa/tests/org.eclipse.jpt.db.tests/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index b23d0c7..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Tue Jan 15 11:11:11 EST 2008
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/.settings/org.eclipse.jdt.core.prefs b/jpa/tests/org.eclipse.jpt.db.tests/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 929d545..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,7 +0,0 @@
-#Sun May 27 14:59:18 EDT 2007
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/META-INF/MANIFEST.MF b/jpa/tests/org.eclipse.jpt.db.tests/META-INF/MANIFEST.MF
deleted file mode 100644
index 8d2559e..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,19 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-Vendor: %providerName
-Bundle-SymbolicName: org.eclipse.jpt.db.tests
-Bundle-Version: 1.0.100.qualifier
-Bundle-Activator: org.eclipse.jpt.db.tests.internal.JptDbTestsPlugin
-Bundle-ActivationPolicy: lazy
-Bundle-Localization: plugin
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.4.0,4.0.0)",
- org.eclipse.datatools.connectivity;bundle-version="[1.1.0,1.3.0)",
- org.eclipse.datatools.connectivity.sqm.core;bundle-version="1.0.1",
- org.eclipse.datatools.modelbase.sql;bundle-version="1.0.0",
- org.eclipse.jpt.utility;bundle-version="[1.2.0,2.0.0)",
- org.eclipse.jpt.db;bundle-version="[1.2.0,2.0.0)",
- org.junit;bundle-version="3.8.0"
-Export-Package: org.eclipse.jpt.db.tests.internal;x-internal:=true,
- org.eclipse.jpt.db.tests.internal.platforms;x-internal:=true
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/about.html b/jpa/tests/org.eclipse.jpt.db.tests/about.html
deleted file mode 100644
index be534ba..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/about.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<HTML>
-
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-
-<BODY lang="EN-US">
-
-<H3>About This Content</H3>
-
-<P>May 02, 2008</P>
-
-<H3>License</H3>
-
-<P>The Eclipse Foundation makes available all content in this plug-in 
-("Content"). Unless otherwise indicated below, the Content is provided to you 
-under the terms and conditions of the Eclipse Public License Version 1.0 
-("EPL"). A copy of the EPL is available at
-<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-
-<P>If you did not receive this Content directly from the Eclipse Foundation, the 
-Content is being redistributed by another party ("Redistributor") and different 
-terms and conditions may apply to your use of any object code in the Content. 
-Check the Redistributor's license that was provided with the Content. If no such 
-license exists, contact the Redistributor. Unless otherwise indicated below, the 
-terms and conditions of the EPL still apply to any source code in the Content 
-and such source code may be obtained at
-<A href="http://www.eclipse.org/">http://www.eclipse.org/</A>.</P>
-
-</BODY>
-</HTML>
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/build.properties b/jpa/tests/org.eclipse.jpt.db.tests/build.properties
deleted file mode 100644
index d27ab8f..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/build.properties
+++ /dev/null
@@ -1,14 +0,0 @@
-################################################################################
-# Copyright (c) 2007 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-source.. = src/
-output.. = bin/
-bin.includes = .,\
-               META-INF/,\
-               plugin.properties
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/config/derby.properties b/jpa/tests/org.eclipse.jpt.db.tests/config/derby.properties
deleted file mode 100644
index 242d156..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/config/derby.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-# Configure the workspace- and database server-specific settings here.
-
-# user and password are optional for Derby
-userID = 
-password = 
-
-# the JDBC driver JAR(s) must be specified;
-# if there are multiple JARs, separate the names with commas
-# jars = C:/derby/lib/derby.jar
-jars = 
-
-# the JDBC URL is required for Derby
-# url = jdbc:derby:C:/derby/data/testdb;create=true
-url = 
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/config/mysql.properties b/jpa/tests/org.eclipse.jpt.db.tests/config/mysql.properties
deleted file mode 100644
index d6407de..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/config/mysql.properties
+++ /dev/null
@@ -1,23 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-# Configure the workspace- and database server-specific settings here.
-
-# user and password are optional, depending on the platform
-userID = 
-password = 
-
-# the JDBC driver JAR(s) must be specified;
-# if there are multiple JARs, separate the names with commas
-# jars = C:/mysql/mysql-connector-java-5.0.6-bin.jar
-jars = 
-
-# the JDBC URL is optional for MySQL
-# url = jdbc:mysql://localhost:3306
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/config/oracle10g.properties b/jpa/tests/org.eclipse.jpt.db.tests/config/oracle10g.properties
deleted file mode 100644
index 4b911b4..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/config/oracle10g.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-# Configure the workspace- and database server-specific settings here.
-
-# user and password are optional, depending on the platform
-userID = scott
-password = tiger
-
-# the JDBC driver JAR(s) must be specified;
-# if there are multiple JARs, separate the names with commas
-# jars = C:/oracle/jdbc/lib/ojdbc5.jar
-jars = 
-
-# the JDBC URL is required
-# url = jdbc:oracle:thin:@localhost:1521:testdb
-url = 
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/config/oracle10gXE.properties b/jpa/tests/org.eclipse.jpt.db.tests/config/oracle10gXE.properties
deleted file mode 100644
index e67c01a..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/config/oracle10gXE.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-# Configure the workspace- and database server-specific settings here.
-
-# user and password are optional, depending on the platform
-userID = scott
-password = tiger
-
-# the JDBC driver JAR(s) must be specified;
-# if there are multiple JARs, separate the names with commas
-# jars = C:/oracle/jdbc/lib/ojdbc5.jar
-jars = 
-
-# the JDBC URL is required
-# url = jdbc:oracle:thin:@localhost:1521:XE
-url = 
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/config/oracle9i.properties b/jpa/tests/org.eclipse.jpt.db.tests/config/oracle9i.properties
deleted file mode 100644
index 4b911b4..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/config/oracle9i.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-# Configure the workspace- and database server-specific settings here.
-
-# user and password are optional, depending on the platform
-userID = scott
-password = tiger
-
-# the JDBC driver JAR(s) must be specified;
-# if there are multiple JARs, separate the names with commas
-# jars = C:/oracle/jdbc/lib/ojdbc5.jar
-jars = 
-
-# the JDBC URL is required
-# url = jdbc:oracle:thin:@localhost:1521:testdb
-url = 
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/config/postgresql.properties b/jpa/tests/org.eclipse.jpt.db.tests/config/postgresql.properties
deleted file mode 100644
index 32fafe4..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/config/postgresql.properties
+++ /dev/null
@@ -1,23 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-# Configure the workspace- and database server-specific settings here.
-
-# user and password are optional, depending on the platform
-userID = 
-password = 
-
-# the JDBC driver JAR(s) must be specified;
-# if there are multiple JARs, separate the names with commas
-# jars = C:/postgresql/jdbc/postgresql-8.2-505.jdbc3.jar
-jars = 
-
-# the JDBC URL is optional for PostgreSQL
-# url = jdbc:postgresql
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/config/sqlserver.properties b/jpa/tests/org.eclipse.jpt.db.tests/config/sqlserver.properties
deleted file mode 100644
index f72b645..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/config/sqlserver.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-# Configure the workspace- and database server-specific settings here.
-
-# user and password are optional, depending on the platform
-userID = 
-password = 
-
-# the JDBC driver JAR(s) must be specified;
-# if there are multiple JARs, separate the names with commas
-# jars = C:/sqlserver/lib/sqljdbc.jar
-jars = 
-
-# the JDBC URL is required
-# url = jdbc:sqlserver://localhost:1433
-url = 
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/config/sybase.properties b/jpa/tests/org.eclipse.jpt.db.tests/config/sybase.properties
deleted file mode 100644
index 493d5d4..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/config/sybase.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-
-# Configure the workspace- and database server-specific settings here.
-
-# user and password are optional, depending on the platform
-userID = 
-password = 
-
-# the JDBC driver JAR(s) must be specified;
-# if there are multiple JARs, separate the names with commas
-# jars = C:/sybase/lib/jconn3.jar
-jars = 
-
-# the JDBC URL is required
-# url = jdbc:sybase:Tds:localhost:5000
-url = 
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/plugin.properties b/jpa/tests/org.eclipse.jpt.db.tests/plugin.properties
deleted file mode 100644
index 2c98779..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/plugin.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-################################################################################
-# Copyright (c) 2007 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-# ====================================================================
-# To code developer:
-#   Do NOT change the properties between this line and the
-#   "%%% END OF TRANSLATED PROPERTIES %%%" line.
-#   Make a new property name, append to the end of the file and change
-#   the code to use the new property.
-# ====================================================================
-
-# ====================================================================
-# %%% END OF TRANSLATED PROPERTIES %%%
-# ====================================================================
-
-pluginName = JPA DB Tests
-providerName = Eclipse.org
-
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JDBCTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JDBCTests.java
deleted file mode 100644
index ce05d76..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JDBCTests.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal;
-
-import java.sql.Connection;
-import java.sql.DriverManager;
-
-import junit.framework.TestCase;
-
-/**
- * These aren't tests. They are just an easy way to dump JDBC metadata to the
- * console.
- */
-@SuppressWarnings("nls")
-public class JDBCTests extends TestCase {
-
-	public JDBCTests(String name) {
-		super(name);
-	}
-
-	public void testDerby() throws Exception {
-		this.dumpMetaData(DERBY);
-	}
-
-	public void testMySQL() throws Exception {
-		this.dumpMetaData(MYSQL);
-	}
-
-	public void testOracle() throws Exception {
-		this.dumpMetaData(ORACLE);
-	}
-
-	public void testPostgreSQL() throws Exception {
-		this.dumpMetaData(POSTGRESQL);
-	}
-
-	public void testSybase() throws Exception {
-		this.dumpMetaData(SYBASE);
-	}
-
-	protected void dumpMetaData(ConnectionConfig config) throws Exception {
-		System.out.println("***** PLATFORM: " + config.platformName + " *****");
-		System.out.println();
-		Class.forName(config.driverClassName);
-		Connection connection = DriverManager.getConnection(this.buildURL(config), config.user, config.password);
-		System.out.println("CATALOGS:");
-		JDBCTools.dump(connection.getMetaData().getCatalogs());
-		System.out.println();
-		System.out.println("SCHEMATA:");
-		JDBCTools.dump(connection.getMetaData().getSchemas());
-		connection.close();
-		System.out.println();
-	}
-
-	protected String buildURL(ConnectionConfig config) {
-		return "jdbc:" + config.databaseURL;
-	}
-
-	protected static final ConnectionConfig DERBY =
-		new ConnectionConfig(
-			"Derby",
-			"org.apache.derby.jdbc.EmbeddedDriver",
-			"derby:C:/derby/data/test",
-			null,
-			null
-		);
-
-	protected static final ConnectionConfig MYSQL =
-		new ConnectionConfig(
-			"MySQL",
-			"com.mysql.jdbc.Driver",
-			"mysql://localhost:3306",
-			"root",
-			"oracle"
-		);
-
-	protected static final ConnectionConfig ORACLE =
-		new ConnectionConfig(
-			"Oracle",
-			"oracle.jdbc.OracleDriver",
-			"oracle:thin:@localhost:1521:orcl",
-			"scott",
-			"tiger"
-		);
-
-	protected static final ConnectionConfig POSTGRESQL =
-		new ConnectionConfig(
-			"PostgreSQL",
-			"org.postgresql.Driver",
-			"postgresql:postgres",
-			"postgres",
-			"oracle"
-		);
-
-	// the Sybase server must be configured explicitly to "localhost"
-	// in the config file [SYBASE]/ini/sql.ini
-	protected static final ConnectionConfig SYBASE =
-		new ConnectionConfig(
-			"Sybase",
-			"com.sybase.jdbc3.jdbc.SybDriver",
-			"sybase:Tds:localhost:5000",
-			"sa",
-			"oracle"
-		);
-
-	protected static class ConnectionConfig {
-		protected final String platformName;
-		protected final String driverClassName;
-		protected final String databaseURL;
-		protected final String user;
-		protected final String password;
-		protected ConnectionConfig(
-				String platformName,
-				String driverClassName,
-				String databaseURL,
-				String user,
-				String password
-		) {
-			super();
-			this.platformName = platformName;
-			this.driverClassName = driverClassName;
-			this.databaseURL = databaseURL;
-			this.user = user;
-			this.password = password;
-		}
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JDBCTools.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JDBCTools.java
deleted file mode 100644
index 57c98fe..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JDBCTools.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal;
-
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.sql.Connection;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-
-import org.eclipse.jpt.utility.internal.iterators.ResultSetIterator;
-
-@SuppressWarnings("nls")
-public class JDBCTools {
-
-	public static void dump(Connection connection, String sql) throws SQLException {
-		dump(execute(connection, sql));
-	}
-
-	public static void dump(ResultSet resultSet) throws SQLException {
-		PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
-		// synchronize the console so everything is contiguous
-		synchronized (System.out) {
-			dumpOn(resultSet, pw);
-		}
-		pw.flush();
-	}
-
-	public static void dumpOn(ResultSet resultSet, PrintWriter pw) throws SQLException {
-		ArrayList<HashMap<String, Object>> maps = convertToMaps(resultSet);
-		for (Iterator<HashMap<String, Object>> mapStream = maps.iterator(); mapStream.hasNext(); ) {
-			for (Iterator<Map.Entry<String, Object>> entryStream = mapStream.next().entrySet().iterator(); entryStream.hasNext(); ) {
-				Map.Entry<String, Object> entry = entryStream.next();
-				pw.print(entry.getKey());
-				pw.print(" = ");
-				pw.print(entry.getValue());
-				pw.println();
-			}
-			if (mapStream.hasNext()) {
-				pw.println();
-			}
-		}
-		pw.println("total rows: " + maps.size());
-	}
-
-	public static ArrayList<HashMap<String, Object>> convertToMaps(Connection connection, String sql) throws SQLException {
-		return convertToMaps(execute(connection, sql));
-	}
-
-	public static ResultSet execute(Connection connection, String sql) throws SQLException {
-		Statement statement = connection.createStatement();
-		statement.execute(sql);
-		ResultSet resultSet = statement.getResultSet();
-		statement.close();
-		return resultSet;
-	}
-
-	public static ArrayList<HashMap<String, Object>> convertToMaps(ResultSet resultSet) throws SQLException {
-		ArrayList<HashMap<String, Object>> rows = new ArrayList<HashMap<String, Object>>();
-		for (Iterator<HashMap<String, Object>> stream = buildMapIterator(resultSet); stream.hasNext(); ) {
-			rows.add(stream.next());
-		}
-		return rows;
-	}
-
-	public static Iterator<HashMap<String, Object>> buildMapIterator(ResultSet resultSet) throws SQLException {
-		return new ResultSetIterator<HashMap<String, Object>>(resultSet, new MapResultSetIteratorAdapter(buildColumnNames(resultSet)));
-	}
-
-	public static String[] buildColumnNames(ResultSet resultSet) throws SQLException {
-		String[] names = new String[resultSet.getMetaData().getColumnCount()];
-		for (int i = 0; i < names.length; i++) {
-			names[i] = resultSet.getMetaData().getColumnName(i + 1);  // NB: ResultSet index/subscript is 1-based
-		}
-		return names;
-	}
-
-	public static class MapResultSetIteratorAdapter implements ResultSetIterator.Adapter<HashMap<String, Object>> {
-		private final String[] columnNames;
-		public MapResultSetIteratorAdapter(String[] columnNames) {
-			super();
-			this.columnNames = columnNames;
-		}
-		public HashMap<String, Object> buildNext(ResultSet rs) throws SQLException {
-			HashMap<String, Object> map = new HashMap<String, Object>(this.columnNames.length);
-			for (int i = 0; i < this.columnNames.length; i++) {
-				map.put(this.columnNames[i], rs.getObject(i + 1));  // NB: ResultSet index/subscript is 1-based
-			}
-			return map;
-		}
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JptDbTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JptDbTests.java
deleted file mode 100644
index ea34d08..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JptDbTests.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import org.eclipse.jpt.db.tests.internal.platforms.AllPlatformTests;
-
-/**
- *  JPT DB Tests
- */
-public class JptDbTests {
-
-    public static Test suite() {
-		TestSuite suite = new TestSuite(JptDbTests.class.getPackage().getName());
-    
-        suite.addTest( AllPlatformTests.suite());
-    
-        return suite;
-    }
-    
-    private JptDbTests() {
-        super();
-        throw new UnsupportedOperationException();
-    }
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JptDbTestsPlugin.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JptDbTestsPlugin.java
deleted file mode 100644
index 6d517b5..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/JptDbTestsPlugin.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal;
-
-import org.eclipse.core.runtime.Plugin;
-import org.osgi.framework.BundleContext;
-
-/**
- *  JptDbTestsPlugin
- */
-public class JptDbTestsPlugin extends Plugin {
-
-	// The shared instance
-	private static JptDbTestsPlugin INSTANCE;
-
-	public static final String BUNDLE_ID = "org.eclipse.jpt.db.tests"; //$NON-NLS-1$
-
-	/**
-	 * Returns the shared instance
-	 */
-	public static JptDbTestsPlugin instance() {
-		return INSTANCE;
-	}
-	
-	/**
-	 * The constructor
-	 */
-	public JptDbTestsPlugin() {
-		super();
-		INSTANCE = this;
-	}
-
-	/**
-	 * This method is called upon plug-in activation
-	 */
-	@Override
-	public void start(BundleContext context) throws Exception {
-		super.start(context);
-	}
-
-	/**
-	 * This method is called when the plug-in is stopped
-	 */
-	@Override
-	public void stop(BundleContext context) throws Exception {
-		INSTANCE = null;
-		super.stop(context);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/AllPlatformTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/AllPlatformTests.java
deleted file mode 100644
index 22ece7e..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/AllPlatformTests.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-public class AllPlatformTests {
-
-    public static Test suite() {
-		TestSuite suite = new TestSuite(AllPlatformTests.class.getPackage().getName());
-
-		suite.addTestSuite(DerbyTests.class);
-		suite.addTestSuite(MySQLTests.class);
-		suite.addTestSuite(Oracle10gTests.class);
-//		suite.addTestSuite(Oracle10gXETests.class);
-//		suite.addTestSuite(Oracle9iTests.class);
-		suite.addTestSuite(PostgreSQLTests.class);
-//		suite.addTestSuite(SQLServerTests.class);
-		suite.addTestSuite(SybaseTests.class);
-
-        return suite;
-    }
-
-    private AllPlatformTests() {
-        super();
-        throw new UnsupportedOperationException();
-    }
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/DTPPlatformTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/DTPPlatformTests.java
deleted file mode 100644
index 93a5779..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/DTPPlatformTests.java
+++ /dev/null
@@ -1,1027 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.net.URL;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Properties;
-
-import junit.framework.TestCase;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.datatools.connectivity.ConnectionProfileException;
-import org.eclipse.datatools.connectivity.IConnectionProfile;
-import org.eclipse.datatools.connectivity.IManagedConnection;
-import org.eclipse.datatools.connectivity.ProfileManager;
-import org.eclipse.datatools.connectivity.drivers.IDriverMgmtConstants;
-import org.eclipse.datatools.connectivity.drivers.IPropertySet;
-import org.eclipse.datatools.connectivity.drivers.PropertySetImpl;
-import org.eclipse.datatools.connectivity.drivers.XMLFileManager;
-import org.eclipse.datatools.connectivity.drivers.jdbc.IJDBCDriverDefinitionConstants;
-import org.eclipse.datatools.connectivity.internal.ConnectivityPlugin;
-import org.eclipse.datatools.connectivity.sqm.core.connection.ConnectionInfo;
-import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObject;
-import org.eclipse.jpt.db.Catalog;
-import org.eclipse.jpt.db.Column;
-import org.eclipse.jpt.db.ConnectionListener;
-import org.eclipse.jpt.db.ConnectionProfile;
-import org.eclipse.jpt.db.ConnectionProfileFactory;
-import org.eclipse.jpt.db.ConnectionProfileListener;
-import org.eclipse.jpt.db.Database;
-import org.eclipse.jpt.db.DatabaseIdentifierAdapter;
-import org.eclipse.jpt.db.ForeignKey;
-import org.eclipse.jpt.db.JptDbPlugin;
-import org.eclipse.jpt.db.Schema;
-import org.eclipse.jpt.db.SchemaContainer;
-import org.eclipse.jpt.db.Sequence;
-import org.eclipse.jpt.db.Table;
-import org.eclipse.jpt.db.ForeignKey.ColumnPair;
-import org.eclipse.jpt.db.tests.internal.JptDbTestsPlugin;
-import org.eclipse.jpt.utility.internal.ReflectionTools;
-import org.eclipse.jpt.utility.internal.IndentingPrintWriter;
-import org.eclipse.jpt.utility.internal.StringTools;
-import org.eclipse.jpt.utility.internal.iterators.ResultSetIterator;
-
-/**
- * Base class for testing DTP wrappers on various databases.
- */
-@SuppressWarnings("nls")
-public abstract class DTPPlatformTests extends TestCase {
-
-	/**
-	 * The platform properties are loaded from a Java properties file in the
-	 * 'org.eclipse.jpt.db.tests/config' directory. Each database platform has
-	 * its own properties file (e.g. 'derby.properties').
-	 */
-	private Properties platformProperties;
-
-	/**
-	 * This is the Dali connection profile wrapper.
-	 */
-	protected ConnectionProfile connectionProfile;
-
-
-	// ********** constants **********
-
-	private static final String PLATFORM_CONFIG_DIRECTORY = "config";
-
-	private static final String DB_USER_ID_PROPERTY = "userID";
-		private static final String DB_USER_ID_DEFAULT = "user";
-
-	private static final String DB_PASSWORD_PROPERTY = "password";
-		private static final String DB_PASSWORD_DEFAULT = "";
-
-	private static final String DB_DRIVER_JARS_PROPERTY = "jars";
-		// required - no default
-
-	private static final String DB_URL_PROPERTY = "url";
-		// required - no default
-
-
-
-	// ********** constructor **********
-
-	protected DTPPlatformTests(String name) {
-		super(name);
-	}
-
-
-	// ********** set-up/tear-down **********
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-
-		this.platformProperties = this.loadPlatformProperties();
-		this.buildDTPDriverDefinitionFile();
-		this.buildDTPConnectionProfile();
-		this.connectionProfile = this.getConnectionProfileFactory().buildConnectionProfile(this.getProfileName(), DatabaseIdentifierAdapter.Default.instance());
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		this.connectionProfile = null;
-		this.platformProperties = null;
-
-		super.tearDown();
-	}
-
-	// ***** platform properties file
-	private Properties loadPlatformProperties() throws IOException {
-		Properties p = new Properties();
-		p.load(this.buildPlatformPropertiesFileURL().openStream());
-		return p;
-	}
-
-	private URL buildPlatformPropertiesFileURL() {
-		return Platform.getBundle(this.getTestPluginBundleID()).getEntry(this.getPlatformPropertiesFilePath());
-	}
-
-	private String getTestPluginBundleID() {
-		return JptDbTestsPlugin.BUNDLE_ID;
-	}
-
-	private String getPlatformPropertiesFilePath() {
-		return this.getPlatformPropertiesDirectoryName() + '/' + this.getPlatformPropertiesFileName();
-	}
-
-	private String getPlatformPropertiesDirectoryName() {
-		return PLATFORM_CONFIG_DIRECTORY;
-	}
-
-	/**
-	 * Each database platform has a separate properties file in the 'config'
-	 * directory that must be customized by whomever is executing the tests.
-	 */
-	protected abstract String getPlatformPropertiesFileName();
-
-	// ***** driver definition file
-	private void buildDTPDriverDefinitionFile() throws CoreException {
-		XMLFileManager.setStorageLocation(this.getDTPDriverDefinitionLocation());
-		XMLFileManager.setFileName(this.getDTPDriverFileName());
-
-		IPropertySet[] sets = XMLFileManager.loadPropertySets();
-		for (IPropertySet set : sets) {
-			if (set.getID().equals(this.getDriverDefinitionID())) {
-				return;  // property sets live across tests
-			}
-		}
-
-		XMLFileManager.saveNamedPropertySet(this.buildDTPDriverDefinitionPropertySets());
-
-		// verify the file was created:
-		File driverDefinitioneFile = this.getDTPDriverDefinitionLocation().append(this.getDTPDriverFileName()).toFile();
-		assertTrue(driverDefinitioneFile.exists());
-	}
-
-	private IPath getDTPDriverDefinitionLocation() {
-		return ConnectivityPlugin.getDefault().getStateLocation();
-	}
-
-	private String getDTPDriverFileName() {
-		return IDriverMgmtConstants.DRIVER_FILE;
-	}
-
-	private IPropertySet[] buildDTPDriverDefinitionPropertySets() {
-		IPropertySet[] propertySets = new IPropertySet[1];
-		PropertySetImpl propertySet = new PropertySetImpl(this.getDriverName(), this.getDriverDefinitionID());
-		propertySet.setProperties(this.getDriverDefinitionID(), this.buildDTPDriverDefinitionProperties());
-		propertySets[0] = propertySet;
-		return propertySets;
-	}
-
-	protected abstract String getDriverName();
-
-	protected abstract String getDriverDefinitionID();
-
-	private Properties buildDTPDriverDefinitionProperties() {
-		Properties p = new Properties();
-		p.setProperty(ConnectionProfile.DRIVER_DEFINITION_TYPE_PROP_ID, this.getDriverDefinitionType());
-		p.setProperty(ConnectionProfile.DRIVER_JAR_LIST_PROP_ID, this.getJDBCDriverJarList());
-		p.setProperty(IJDBCDriverDefinitionConstants.DATABASE_VENDOR_PROP_ID, this.getDatabaseVendor());
-		p.setProperty(IJDBCDriverDefinitionConstants.DATABASE_VERSION_PROP_ID, this.getDatabaseVersion());
-		p.setProperty(IJDBCDriverDefinitionConstants.DRIVER_CLASS_PROP_ID, this.getDriverClass());
-		p.setProperty(IJDBCDriverDefinitionConstants.URL_PROP_ID, this.getJDBCURL());
-		p.setProperty(IJDBCDriverDefinitionConstants.USERNAME_PROP_ID, this.getUserID());
-		p.setProperty(IJDBCDriverDefinitionConstants.PASSWORD_PROP_ID, this.getPassword());
-		return p;
-	}
-
-	protected abstract String getDriverDefinitionType();
-
-	/**
-	 * The JAR list is workspace-specific and is set in the properties file.
-	 */
-	private String getJDBCDriverJarList() {
-		return this.getRequiredPlatformProperty(DB_DRIVER_JARS_PROPERTY);
-	}
-
-	protected abstract String getDatabaseVendor();
-
-	protected abstract String getDatabaseVersion();
-
-	protected abstract String getDriverClass();
-
-	/**
-	 * The database URL is workspace-specific and is set in the properties file
-	 * for some databases.
-	 */
-	private String getJDBCURL() {
-		return this.platformProperties.getProperty(DB_URL_PROPERTY, this.getDefaultJDBCURL());
-	}
-
-	protected String getDefaultJDBCURL() {
-		return "";
-	}
-
-	/**
-	 * The user ID is optional and can be set in the properties file.
-	 */
-	protected String getUserID() {
-		return this.platformProperties.getProperty(DB_USER_ID_PROPERTY, DB_USER_ID_DEFAULT);
-	}
-
-	/**
-	 * The password is optional and can be set in the properties file.
-	 */
-	private String getPassword() {
-		return this.platformProperties.getProperty(DB_PASSWORD_PROPERTY, DB_PASSWORD_DEFAULT);
-	}
-
-	// ***** DTP connection profile
-	private void buildDTPConnectionProfile() throws ConnectionProfileException {
-		if (this.getDTPProfileManager().getProfileByName(this.getProfileName()) != null) {
-			return;  // profiles live across tests
-		}
-		this.createProfile(this.getProfileName());
-		assertNotNull(this.getDTPProfileManager().getProfileByName(this.getProfileName()));
-	}
-
-	protected void createProfile(String profileName) throws ConnectionProfileException {
-		this.getDTPProfileManager().createProfile(
-				profileName,
-				this.getProfileDescription(),
-				this.getProviderID(),
-				this.buildDTPConnectionProfileProperties()
-		);
-	}
-
-	protected abstract String getProfileName();
-
-	protected abstract String getProfileDescription();
-
-	protected String getProviderID() {
-		return ConnectionProfile.CONNECTION_PROFILE_TYPE;
-	}
-	 
-	protected Properties buildDTPConnectionProfileProperties() {
-		Properties p = new Properties();
-		p.setProperty(IJDBCDriverDefinitionConstants.USERNAME_PROP_ID, this.getUserID());
-		p.setProperty(IJDBCDriverDefinitionConstants.PASSWORD_PROP_ID, this.getPassword());
-		p.setProperty(ConnectionProfile.DRIVER_DEFINITION_PROP_ID, this.getDriverDefinitionID());
-
-		p.setProperty(IJDBCDriverDefinitionConstants.DRIVER_CLASS_PROP_ID, this.getDriverClass());
-		p.setProperty(IJDBCDriverDefinitionConstants.URL_PROP_ID, this.getJDBCURL());
-		p.setProperty(IJDBCDriverDefinitionConstants.DATABASE_VENDOR_PROP_ID, this.getDatabaseVendor());
-		p.setProperty(IJDBCDriverDefinitionConstants.DATABASE_VERSION_PROP_ID, this.getDatabaseVersion());
-
-		p.setProperty(ConnectionProfile.DATABASE_SAVE_PWD_PROP_ID, this.passwordIsSaved());
-		return p;
-	}
-
-	private String passwordIsSaved() {
-		return "true";
-	}
-
-
-	// ********** tests **********
-
-	public void testConnectionProfileListener() throws ConnectionProfileException {
-		TestConnectionProfileListener listener = new TestConnectionProfileListener();
-		this.getConnectionProfileFactory().addConnectionProfileListener(listener);
-
-		String cpName1 = this.getProfileName() + "1";
-		this.createProfile(cpName1);
-		IConnectionProfile dtpCP = this.getDTPProfileManager().getProfileByName(cpName1);
-		assertNotNull(dtpCP);
-
-		assertEquals(cpName1, listener.addedName);
-		listener.clear();
-
-		String cpName2 = this.getProfileName() + "2";
-		this.getDTPProfileManager().modifyProfile(dtpCP, cpName2, null);
-		assertEquals(cpName1, listener.renamedOldName);
-		assertEquals(cpName2, listener.renamedNewName);
-		listener.clear();
-
-		ConnectionProfile cp = this.getConnectionProfileFactory().buildConnectionProfile(cpName2);
-		assertNotNull(cp);
-
-		this.getDTPProfileManager().deleteProfile(dtpCP);
-		assertEquals(cpName2, listener.removedName);
-		listener.clear();
-
-		cp = this.getConnectionProfileFactory().buildConnectionProfile(cpName2);
-		assertNull(cp);
-
-		this.getConnectionProfileFactory().removeConnectionProfileListener(listener);
-	}
-
-	public void testName() {
-		assertEquals(this.getProfileName(), this.connectionProfile.getName());
-	}
-
-	public void testConnection() throws Exception {
-		assertTrue(this.connectionProfile.isInactive());
-		assertTrue(this.connectionProfile.isDisconnected());
-		this.connectionProfile.connect();
-		assertTrue(this.connectionProfile.isActive());
-		assertTrue(this.connectionProfile.isConnected());
-
-		this.verifyDatabaseVersionNumber();
-		this.verifyDatabaseVendor();
-		this.verifyDatabaseContent();
-
-		this.connectionProfile.disconnect();
-		assertTrue(this.connectionProfile.isInactive());
-		assertTrue(this.connectionProfile.isDisconnected());
-	}
-
-	private void verifyDatabaseVersionNumber() {
-		Database database = this.connectionProfile.getDatabase();
-		assertNotNull(database);
-
-		String actual = database.getVersion();
-		String expected = this.getDatabaseVersion();
-		String errorMessage = "expected: " + expected + " - actual: " + actual;
-		// partial match is good enough
-		assertTrue(errorMessage, actual.indexOf(expected) != -1);
-	}
-
-	private void verifyDatabaseVendor() {
-		Database database = this.connectionProfile.getDatabase();
-		String actual = database.getVendorName();
-		String expected = this.getDatabaseVendor();
-		assertEquals(expected, actual);
-	}
-
-	private void verifyDatabaseContent() {
-		Database database = this.connectionProfile.getDatabase();
-		assertTrue(database.getSchemataSize() >= 0);
-
-		Schema schema = database.getDefaultSchema();
-		if (schema != null) {
-			if (schema.getTablesSize() > 0) {
-				Table table = schema.getTables().iterator().next();
-				assertTrue(table.getColumnsSize() >= 0);
-				assertTrue(table.getPrimaryKeyColumnsSize() >= 0);
-				assertTrue(table.getForeignKeysSize() >= 0);
-			}
-		}
-	}
-
-	protected abstract boolean executeOfflineTests();
-
-	public final void testOffline() {
-		if ( ! this.executeOfflineTests()) {
-			return;
-		}
-		if ( ! this.connectionProfile.supportsWorkOfflineMode()) {
-			return;
-		}
-
-		this.prepareForOfflineWork();
-
-		IStatus status = this.connectionProfile.workOffline();
-		assertTrue(status.isOK());
-		assertTrue(this.connectionProfile.isActive());
-		assertTrue(this.connectionProfile.isWorkingOffline());
-
-		this.connectionProfile.disconnect();
-		assertTrue(this.connectionProfile.isInactive());
-		assertTrue(this.connectionProfile.isDisconnected());
-	}
-
-	protected void prepareForOfflineWork() {
-		if ( ! this.connectionProfile.canWorkOffline()) {
-			this.connectionProfile.connect();
-			IStatus status = this.connectionProfile.saveWorkOfflineData();
-			assertTrue(status.isOK());
-			this.connectionProfile.disconnect();
-			assertTrue(this.connectionProfile.canWorkOffline());
-		}
-	}
-
-	public void testConnectionListenerConnect() {
-		assertTrue(this.connectionProfileHasNoListeners());
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-		assertTrue(this.connectionProfileHasAnyListeners());
-
-		this.connectionProfile.connect();
-		assertSame(this.connectionProfile, listener.openedProfile);
-		listener.clear();
-
-		this.connectionProfile.disconnect();
-		assertSame(this.connectionProfile, listener.okToCloseProfile);
-		assertSame(this.connectionProfile, listener.aboutToCloseProfile);
-		assertSame(this.connectionProfile, listener.closedProfile);
-
-		this.connectionProfile.removeConnectionListener(listener);
-		assertTrue(this.connectionProfileHasNoListeners());
-	}
-
-	public final void testConnectionListenerOffline() {
-		if ( ! this.executeOfflineTests()) {
-			return;
-		}
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.prepareForOfflineWork();
-		listener.clear();
-
-		this.connectionProfile.workOffline();
-		assertSame(this.connectionProfile, listener.openedProfile);
-		listener.clear();
-
-		this.connectionProfile.disconnect();
-		assertSame(this.connectionProfile, listener.okToCloseProfile);
-		assertSame(this.connectionProfile, listener.aboutToCloseProfile);
-		assertSame(this.connectionProfile, listener.closedProfile);
-		listener.clear();
-
-		this.connectionProfile.removeConnectionListener(listener);
-	}
-
-	public void testConnectionListenerDatabase() {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		assertSame(this.connectionProfile.getDatabase(), listener.changedDatabase);
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testConnectionListenerCatalog() {
-		this.connectionProfile.connect();
-		if ( ! this.connectionProfile.getDatabase().supportsCatalogs()) {
-			this.connectionProfile.disconnect();
-			return;
-		}
-			
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		// take the first catalog
-		org.eclipse.datatools.modelbase.sql.schema.Catalog dtpCatalog = this.getFirstDTPCatalog();
-		Catalog catalog = this.getCatalogNamed(dtpCatalog.getName());
-		((ICatalogObject) dtpCatalog).refresh();
-		assertSame(catalog, listener.changedCatalog);
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testConnectionListenerSchema() {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		List<org.eclipse.datatools.modelbase.sql.schema.Catalog> dtpCatalogs = this.getDTPCatalogs();
-		org.eclipse.datatools.modelbase.sql.schema.Catalog dtpCatalog = null;
-		org.eclipse.datatools.modelbase.sql.schema.Schema dtpSchema = null;
-		Schema schema = null;
-		if (this.connectionProfile.getDatabase().supportsCatalogs()) {
-			dtpCatalog = dtpCatalogs.get(0);
-			dtpSchema = (org.eclipse.datatools.modelbase.sql.schema.Schema) dtpCatalog.getSchemas().get(0);
-			schema = this.getCatalogNamed(dtpCatalog.getName()).getSchemaNamed(dtpSchema.getName());
-		} else {
-			if (dtpCatalogs.isEmpty()) {
-				dtpSchema = (org.eclipse.datatools.modelbase.sql.schema.Schema) this.getDTPDatabase().getSchemas().get(0);
-				schema = this.connectionProfile.getDatabase().getSchemaNamed(dtpSchema.getName());
-			} else {
-				dtpCatalog = dtpCatalogs.get(0);  // should be the "virtual" catalog
-				assertEquals("", dtpCatalog.getName());
-				dtpSchema = (org.eclipse.datatools.modelbase.sql.schema.Schema) dtpCatalog.getSchemas().get(0);
-				// the schemata are held directly by the database in this situation
-				schema = this.getDatabase().getSchemaNamed(dtpSchema.getName());
-			}
-		}
-		assertTrue(schema.getTablesSize() >= 0);  // force tables to be loaded
-		((ICatalogObject) dtpSchema).refresh();
-		assertSame(schema, listener.changedSchema);
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testSupportsCatalogs() {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		boolean supportsCatalogs = this.supportsCatalogs();
-		assertEquals(supportsCatalogs, this.connectionProfile.getDatabase().supportsCatalogs());
-		if (supportsCatalogs) {
-			assertTrue(this.connectionProfile.getDatabase().getCatalogsSize() > 0);
-			assertEquals(0, this.connectionProfile.getDatabase().getSchemataSize());
-		} else {
-			assertEquals(0, this.connectionProfile.getDatabase().getCatalogsSize());
-			assertTrue(this.connectionProfile.getDatabase().getSchemataSize() > 0);
-		}
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	protected abstract boolean supportsCatalogs();
-
-//	public void testDEBUG() throws Exception {
-//		this.connectionProfile.connect();
-//		this.dumpJDBCCatalogs();
-//		this.dumpJDBCSchemata();
-//		this.dumpDatabaseContainers();
-//		this.connectionProfile.disconnect();
-//	}
-
-
-	// ********** convenience methods **********
-
-	protected ConnectionProfileFactory getConnectionProfileFactory() {
-		return JptDbPlugin.instance().getConnectionProfileFactory();
-	}
-
-	protected ConnectionProfile getConnectionProfile() {
-		return this.connectionProfile;
-	}
-
-	protected Database getDatabase() {
-		return this.connectionProfile.getDatabase();
-	}
-
-	protected Catalog getDefaultCatalog() {
-		return this.getDatabase().getDefaultCatalog();
-	}
-
-	/**
-	 * only valid on databases that do not support catalogs
-	 */
-	protected Schema getDefaultSchema() {
-		return this.getDatabase().getDefaultSchema();
-	}
-
-	protected Catalog getCatalogNamed(String catalogName) {
-		return this.connectionProfile.getDatabase().getCatalogNamed(catalogName);
-	}
-
-	protected String getRequiredPlatformProperty(String propertyKey) {
-		String propertyValue = this.platformProperties.getProperty(propertyKey);
-		if (StringTools.stringIsEmpty(propertyValue)) {
-			throw new IllegalArgumentException("The database platform properties file '" + this.getPlatformPropertiesFilePath()
-					+ "' is missing a value for the property '" + propertyKey + "'.");
-		}
-		return propertyValue;
-	}
-
-	protected boolean connectionProfileHasAnyListeners() {
-		return connectionProfileHasAnyListeners(this.connectionProfile);
-	}
-
-	protected static boolean connectionProfileHasAnyListeners(ConnectionProfile cp) {
-		return ((Boolean) ReflectionTools.executeMethod(cp, "hasAnyListeners")).booleanValue();
-	}
-
-	protected boolean connectionProfileHasNoListeners() {
-		return connectionProfileHasNoListeners(this.connectionProfile);
-	}
-
-	protected static boolean connectionProfileHasNoListeners(ConnectionProfile cp) {
-		return ((Boolean) ReflectionTools.executeMethod(cp, "hasNoListeners")).booleanValue();
-	}
-
-
-	// ********** DTP model **********
-
-	protected ProfileManager getDTPProfileManager() {
-		return ProfileManager.getInstance();
-	}
-
-	protected IConnectionProfile getDTPConnectionProfile() {
-		return getDTPConnectionProfile(this.connectionProfile);
-	}
-
-	protected static IConnectionProfile getDTPConnectionProfile(ConnectionProfile cp) {
-		return (IConnectionProfile) ReflectionTools.getFieldValue(cp, "dtpConnectionProfile");
-	}
-
-	protected IManagedConnection getDTPManagedConnection() {
-		return (IManagedConnection) ReflectionTools.getFieldValue(this.connectionProfile, "dtpManagedConnection");
-	}
-
-	protected org.eclipse.datatools.modelbase.sql.schema.Database getDTPDatabase() {
-		return getDTPDatabase(this.connectionProfile.getDatabase());
-	}
-
-	protected static org.eclipse.datatools.modelbase.sql.schema.Database getDTPDatabase(Database database) {
-		return (org.eclipse.datatools.modelbase.sql.schema.Database) ReflectionTools.getFieldValue(database, "dtpDatabase");
-	}
-
-	@SuppressWarnings("unchecked")
-	protected List<org.eclipse.datatools.modelbase.sql.schema.Catalog> getDTPCatalogs() {
-		return this.getDTPDatabase().getCatalogs();
-	}
-
-	protected org.eclipse.datatools.modelbase.sql.schema.Catalog getFirstDTPCatalog() {
-		return this.getDTPCatalogs().get(0);
-	}
-
-	protected org.eclipse.datatools.modelbase.sql.schema.Catalog getDTPCatalogNamed(String name) {
-		return getDTPCatalog(this.getDatabase().getCatalogNamed(name));
-	}
-
-	protected static org.eclipse.datatools.modelbase.sql.schema.Catalog getDTPCatalog(Catalog catalog) {
-		return (org.eclipse.datatools.modelbase.sql.schema.Catalog) ReflectionTools.getFieldValue(catalog, "dtpCatalog");
-	}
-
-	protected org.eclipse.datatools.modelbase.sql.schema.Schema getDTPSchemaNamed(String name) {
-		return getDTPSchema(this.getDatabase().getSchemaNamed(name));
-	}
-
-	protected static org.eclipse.datatools.modelbase.sql.schema.Schema getDTPSchema(Schema schema) {
-		return (org.eclipse.datatools.modelbase.sql.schema.Schema) ReflectionTools.getFieldValue(schema, "dtpSchema");
-	}
-
-
-	// ********** execute SQL **********
-
-	/**
-	 * ignore any errors (useful for dropping database objects that might
-	 * not be there)
-	 */
-	protected void executeUpdateIgnoreErrors(String sql) {
-		try {
-			this.executeUpdate(sql);
-		} catch (Exception ex) {
-//			System.err.println("SQL: " + sql);
-//			ex.printStackTrace();
-		}
-	}
-
-	protected void executeUpdate(String sql) throws SQLException {
-		Statement jdbcStatement = this.createJDBCStatement();
-		try {
-			jdbcStatement.executeUpdate(sql);
-		} finally {
-			jdbcStatement.close();
-		}
-	}
-
-	protected void dump(String sql) throws SQLException {
-		this.dump(sql, 20);
-	}
-
-	protected void dump(String sql, int columnWidth) throws SQLException {
-		IndentingPrintWriter pw = new IndentingPrintWriter(new OutputStreamWriter(System.out));
-		// synchronize the console so everything is contiguous
-		synchronized (System.out) {
-			this.dumpOn(sql, pw, columnWidth);
-		}
-		pw.flush();
-	}
-
-	protected void dumpOn(String sql, IndentingPrintWriter pw, int columnWidth) throws SQLException {
-		pw.println(sql);
-		for (ArrayList<Object> row : this.execute(sql)) {
-			for (Object columnValue : row) {
-				StringTools.padOrTruncateOn(String.valueOf(columnValue), columnWidth, pw);
-				pw.print(' ');
-			}
-			pw.println();
-		}
-	}
-
-	protected ArrayList<ArrayList<Object>> execute(String sql) throws SQLException {
-		Statement jdbcStatement = this.createJDBCStatement();
-		jdbcStatement.execute(sql);
-		ArrayList<ArrayList<Object>> rows = this.buildRows(jdbcStatement.getResultSet());
-		jdbcStatement.close();
-		return rows;
-	}
-
-	protected ArrayList<ArrayList<Object>> buildRows(ResultSet resultSet) throws SQLException {
-		ArrayList<ArrayList<Object>> rows = new ArrayList<ArrayList<Object>>();
-		for (Iterator<ArrayList<Object>> stream = this.buildArrayIterator(resultSet); stream.hasNext(); ) {
-			rows.add(stream.next());
-		}
-		return rows;
-	}
-
-	protected Iterator<ArrayList<Object>> buildArrayIterator(ResultSet resultSet) throws SQLException {
-		return new ResultSetIterator<ArrayList<Object>>(resultSet, new ListResultSetIteratorAdapter(resultSet.getMetaData().getColumnCount()));
-	}
-
-	public static class ListResultSetIteratorAdapter implements ResultSetIterator.Adapter<ArrayList<Object>> {
-		private final int columnCount;
-		public ListResultSetIteratorAdapter(int columnCount) {
-			super();
-			this.columnCount = columnCount;
-		}
-		public ArrayList<Object> buildNext(ResultSet rs) throws SQLException {
-			ArrayList<Object> list = new ArrayList<Object>(this.columnCount);
-			for (int i = 1; i <= this.columnCount; i++) {  // NB: ResultSet index/subscript is 1-based
-				list.add(rs.getObject(i));
-			}
-			return list;
-		}
-	}
-
-	protected Statement createJDBCStatement() throws SQLException {
-		return this.getJDBCConnection().createStatement();
-	}
-
-	protected Connection getJDBCConnection() {
-		return ((ConnectionInfo) this.getDTPManagedConnection().getConnection().getRawConnection()).getSharedConnection();
-	}
-
-	protected DatabaseMetaData getDatabaseMetaData() throws SQLException {
-		return this.getJDBCConnection().getMetaData();
-	}
-
-
-	// ********** dump DTP metadata **********
-
-	/**
-	 * dump all the database metadata to the console
-	 */
-	protected void dumpDatabase() {
-		this.dumpDatabase(true);
-	}
-
-	/**
-	 * dump the database catalogs and schemata to the console
-	 */
-	protected void dumpDatabaseContainers() {
-		this.dumpDatabase(false);
-	}
-
-	protected void dumpDatabase(boolean deep) {
-		IndentingPrintWriter pw = new IndentingPrintWriter(new OutputStreamWriter(System.out));
-		// synchronize the console so everything is contiguous
-		synchronized (System.out) {
-			this.dumpDatabaseOn(pw, deep);
-		}
-		pw.flush();
-	}
-
-	protected void dumpDatabaseOn(IndentingPrintWriter pw, boolean deep) {
-		Database database = this.connectionProfile.getDatabase();
-		pw.print("database: ");
-		pw.println(database.getName());
-		if (database.supportsCatalogs()) {
-			for (Catalog catalog : database.getCatalogs()) {
-				this.dumpCatalogOn(catalog, pw, deep);
-			}
-		} else {
-			this.dumpSchemaContainerOn(database, pw, deep);
-		}
-	}
-
-	protected void dumpCatalogOn(Catalog catalog, IndentingPrintWriter pw, boolean deep) {
-		pw.print("catalog: ");
-		pw.println(catalog.getName());
-		pw.indent();
-			this.dumpSchemaContainerOn(catalog, pw, deep);
-		pw.undent();
-	}
-
-	protected void dumpSchemaContainerOn(SchemaContainer schemaContainer, IndentingPrintWriter pw, boolean deep) {
-		for (Schema schema : schemaContainer.getSchemata()) {
-			this.dumpSchemaOn(schema, pw, deep);
-		}
-	}
-
-	protected void dumpSchema(Schema schema) {
-		this.dumpSchema(schema, true);
-	}
-
-	protected void dumpSchema(Schema schema, boolean deep) {
-		IndentingPrintWriter pw = new IndentingPrintWriter(new OutputStreamWriter(System.out));
-		// synchronize the console so everything is contiguous
-		synchronized (System.out) {
-			this.dumpSchemaOn(schema, pw, deep);
-		}
-		pw.flush();
-	}
-
-	protected void dumpSchemaOn(Schema schema, IndentingPrintWriter pw, boolean deep) {
-		pw.print("schema: ");
-		pw.println(schema.getName());
-		if (deep) {
-			pw.indent();
-				for (Table table : schema.getTables()) {
-					this.dumpTableOn(table, pw);
-				}
-				for (Sequence sequence : schema.getSequences()) {
-					this.dumpSequenceOn(sequence, pw);
-				}
-			pw.undent();
-		}
-	}
-
-	protected void dumpTableOn(Table table, IndentingPrintWriter pw) {
-		pw.print("table: ");
-		pw.println(table.getName());
-		pw.indent();
-			for (Column column : table.getColumns()) {
-				this.dumpColumnOn(column, pw);
-			}
-			for (ForeignKey foreignKey : table.getForeignKeys()) {
-				this.dumpForeignKeyOn(foreignKey, pw);
-			}
-		pw.undent();
-	}
-
-	protected void dumpColumnOn(Column column, IndentingPrintWriter pw) {
-		pw.print("column: ");
-		pw.print(column.getName());
-		pw.print(" : ");
-		pw.print(column.getDataTypeName());
-		if (column.isPartOfPrimaryKey()) {
-			pw.print(" [primary key]");
-		}
-		pw.println();
-	}
-
-	protected void dumpForeignKeyOn(ForeignKey foreignKey, IndentingPrintWriter pw) {
-		pw.print("foreign key: ");
-		pw.print(foreignKey.getName());
-		pw.print("=>");
-		pw.print(foreignKey.getReferencedTable().getName());
-		pw.print(" (");
-		for (Iterator<ColumnPair> stream = foreignKey.getColumnPairs().iterator(); stream.hasNext(); ) {
-			ColumnPair cp = stream.next();
-			pw.print(cp.getBaseColumn().getName());
-			pw.print("=>");
-			pw.print(cp.getReferencedColumn().getName());
-			if (stream.hasNext()) {
-				pw.print(", ");
-			}
-		}
-		pw.print(')');
-		pw.println();
-	}
-
-	protected void dumpSequenceOn(Sequence sequence, IndentingPrintWriter pw) {
-		pw.print("sequence: ");
-		pw.println(sequence.getName());
-	}
-
-
-	// ********** dump JDBC metadata **********
-
-	protected void dumpJDBCCatalogs() throws SQLException {
-		IndentingPrintWriter pw = new IndentingPrintWriter(new OutputStreamWriter(System.out));
-		// synchronize the console so everything is contiguous
-		synchronized (System.out) {
-			this.dumpJDBCCatalogsOn(pw);
-		}
-		pw.flush();
-	}
-
-	protected void dumpJDBCCatalogsOn(IndentingPrintWriter pw) throws SQLException {
-		pw.println("JDBC catalogs: ");
-		pw.indent();
-			ArrayList<ArrayList<Object>> rows = this.buildRows(this.getDatabaseMetaData().getCatalogs());
-			for (Iterator<ArrayList<Object>> stream = rows.iterator(); stream.hasNext(); ) {
-				pw.println(stream.next().get(0));
-			}
-		pw.undent();
-	}
-
-	protected void dumpJDBCSchemata() throws SQLException {
-		IndentingPrintWriter pw = new IndentingPrintWriter(new OutputStreamWriter(System.out));
-		// synchronize the console so everything is contiguous
-		synchronized (System.out) {
-			this.dumpJDBCSchemataOn(pw);
-		}
-		pw.flush();
-	}
-
-	protected void dumpJDBCSchemataOn(IndentingPrintWriter pw) throws SQLException {
-		pw.println("JDBC schemata: ");
-		pw.indent();
-			ArrayList<ArrayList<Object>> rows = this.buildRows(this.getDatabaseMetaData().getSchemas());
-			for (ArrayList<Object> row : rows) {
-				if (row.size() == 2) {  // catalogs were added in jdk 1.4
-					Object catalog = row.get(1);
-					pw.print(catalog);
-					pw.print('.');
-				}
-				Object schema = row.get(0);
-				pw.println(schema);
-			}
-		pw.undent();
-	}
-
-
-	// ********** connection profile listener **********
-
-	protected static class TestConnectionProfileListener implements ConnectionProfileListener {
-		public String addedName;
-		public String removedName;
-		public String renamedOldName;
-		public String renamedNewName;
-
-		public void connectionProfileAdded(String name) {
-			this.addedName = name;
-		}
-		public void connectionProfileRemoved(String name) {
-			this.removedName = name;
-		}
-		public void connectionProfileRenamed(String oldName, String newName) {
-			this.renamedOldName = oldName;
-			this.renamedNewName = newName;
-		}
-		public void clear() {
-			this.addedName = null;
-			this.removedName = null;
-			this.renamedOldName = null;
-			this.renamedNewName = null;
-		}
-	}
-
-
-	// ********** connection listener **********
-
-	protected static class TestConnectionListener implements ConnectionListener {
-		public ConnectionProfile openedProfile;
-		public ConnectionProfile modifiedProfile;
-		public ConnectionProfile okToCloseProfile;
-		public ConnectionProfile aboutToCloseProfile;
-		public ConnectionProfile closedProfile;
-		public Database changedDatabase;
-		public Catalog changedCatalog;
-		public Schema changedSchema;
-		public Sequence changedSequence;
-		public Table changedTable;
-		public Column changedColumn;
-		public ForeignKey changedForeignKey;
-
-		public void opened(ConnectionProfile profile) {
-			this.openedProfile = profile;
-		}
-		public void modified(ConnectionProfile profile) {
-			this.modifiedProfile = profile;
-		}
-		public boolean okToClose(ConnectionProfile profile) {
-			this.okToCloseProfile = profile;
-			return true;
-		}
-		public void aboutToClose(ConnectionProfile profile) {
-			this.aboutToCloseProfile = profile;
-		}
-		public void closed(ConnectionProfile profile) {
-			this.closedProfile = profile;
-		}
-		public void databaseChanged(ConnectionProfile profile, Database database) {
-			this.changedDatabase = database;
-		}
-		public void catalogChanged(ConnectionProfile profile, Catalog catalog) {
-			this.changedCatalog = catalog;
-		}
-		public void schemaChanged(ConnectionProfile profile, Schema schema) {
-			this.changedSchema = schema;
-		}
-		public void sequenceChanged(ConnectionProfile profile, Sequence sequence) {
-			this.changedSequence = sequence;
-		}
-		public void tableChanged(ConnectionProfile profile, Table table) {
-			this.changedTable = table;
-		}
-		public void columnChanged(ConnectionProfile profile, Column column) {
-			this.changedColumn = column;
-		}
-		public void foreignKeyChanged(ConnectionProfile profile, ForeignKey foreignKey) {
-			this.changedForeignKey = foreignKey;
-		}
-		public void clear() {
-			this.openedProfile = null;
-			this.modifiedProfile = null;
-			this.okToCloseProfile = null;
-			this.aboutToCloseProfile = null;
-			this.closedProfile = null;
-			this.changedDatabase = null;
-			this.changedCatalog = null;
-			this.changedSchema = null;
-			this.changedSequence = null;
-			this.changedTable = null;
-			this.changedColumn = null;
-			this.changedForeignKey = null;
-		}
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/DerbyTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/DerbyTests.java
deleted file mode 100644
index 6ec1ba4..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/DerbyTests.java
+++ /dev/null
@@ -1,482 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObject;
-import org.eclipse.jpt.db.Column;
-import org.eclipse.jpt.db.ForeignKey;
-import org.eclipse.jpt.db.Schema;
-import org.eclipse.jpt.db.Table;
-
-@SuppressWarnings("nls")
-public class DerbyTests extends DTPPlatformTests {
-
-	public DerbyTests(String name) {
-		super(name);
-	}
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
-
-	@Override
-	protected String getPlatformPropertiesFileName() {
-		return "derby.properties";
-	}
-
-	@Override
-	protected String getDriverName() {
-		return "Derby Embedded JDBC Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionID() {
-		return "DriverDefn.Derby Embedded JDBC Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionType() {
-		return "org.eclipse.datatools.connectivity.db.derby101.genericDriverTemplate";
-	}
-
-	@Override
-	protected String getDatabaseVendor() {
-		return "Derby";
-	}
-
-	@Override
-	protected String getDatabaseVersion() {
-		return "10.1";
-	}
-
-	@Override
-	protected String getDriverClass() {
-		return "org.apache.derby.jdbc.EmbeddedDriver";
-	}
-
-	@Override
-	protected String getProfileName() {
-		return "Derby_10.1_Embedded";
-	}
-
-	@Override
-	protected String getProfileDescription() {
-		return "Derby 10.1 Embedded JDBC Profile [Test]";
-	}
-
-	@Override
-	protected String getProviderID() {
-		return "org.eclipse.datatools.connectivity.db.derby.embedded.connectionProfile";
-	}
-
-	@Override
-	protected boolean supportsCatalogs() {
-		return false;
-	}
-
-	@Override
-	protected boolean executeOfflineTests() {
-		return true;
-	}
-
-	public void testSchema() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropSchema("TEST1");
-		this.dropSchema("TEST2");
-
-		this.executeUpdate("CREATE SCHEMA TEST1");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema1 = this.getDatabase().getSchemaNamed("TEST1");
-		assertNotNull(schema1);
-
-		this.executeUpdate("CREATE SCHEMA TEST2");
-		Schema schema2 = this.getDatabase().getSchemaNamed("TEST2");
-		assertNull(schema2);  // should be null until refresh
-
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		assertSame(this.getDatabase(), listener.changedDatabase);
-
-		schema2 = this.getDatabase().getSchemaNamed("TEST2");
-		assertNotNull(schema2);
-		assertNotSame(schema1, this.getDatabase().getSchemaNamed("TEST1"));  // we should have a new schema after the refresh
-
-		this.dropSchema("TEST2");
-		this.dropSchema("TEST1");
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testSchemaLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropSchema("LOOKUP_TEST");
-		this.dropSchema("\"lookup_TEST\"");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		this.executeUpdate("CREATE SCHEMA LOOKUP_TEST");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		assertNotNull(this.getDatabase().getSchemaNamed("LOOKUP_TEST"));
-		assertNotNull(this.getDatabase().getSchemaForIdentifier("LOOKUP_TEST"));
-
-		assertNull(this.getDatabase().getSchemaNamed("lookup_test"));
-		assertNotNull(this.getDatabase().getSchemaForIdentifier("lookup_test"));
-
-		assertNull(this.getDatabase().getSchemaNamed("lookup_TEST"));
-		assertNotNull(this.getDatabase().getSchemaForIdentifier("lookup_TEST"));
-
-		assertNotNull(this.getDatabase().getSchemaForIdentifier("\"LOOKUP_TEST\""));
-		assertNull(this.getDatabase().getSchemaForIdentifier("\"lookup_TEST\""));
-
-		this.dropSchema("LOOKUP_TEST");
-
-		this.executeUpdate("CREATE SCHEMA \"lookup_TEST\"");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		assertNull(this.getDatabase().getSchemaNamed("LOOKUP_TEST"));
-		assertNull(this.getDatabase().getSchemaForIdentifier("LOOKUP_TEST"));
-
-		assertNull(this.getDatabase().getSchemaNamed("lookup_test"));
-		assertNull(this.getDatabase().getSchemaForIdentifier("lookup_test"));
-
-		assertNotNull(this.getDatabase().getSchemaNamed("lookup_TEST"));
-		assertNull(this.getDatabase().getSchemaForIdentifier("lookup_TEST"));
-
-		assertNull(this.getDatabase().getSchemaForIdentifier("\"LOOKUP_TEST\""));
-		assertNotNull(this.getDatabase().getSchemaForIdentifier("\"lookup_TEST\""));
-
-		this.dropSchema("\"lookup_TEST\"");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testSchemaIdentifier() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropSchema("LOOKUP_TEST");
-		this.dropSchema("\"lookup_TEST\"");
-
-		this.executeUpdate("CREATE SCHEMA lookup_test");  // this gets folded to uppercase
-		this.executeUpdate("CREATE SCHEMA \"lookup_TEST\"");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDatabase().getSchemaForIdentifier("LOOKUP_TEST");
-		assertEquals("LOOKUP_TEST", schema.getIdentifier());
-		assertEquals("LOOKUP_TEST", schema.getIdentifier("LookupTest"));
-		assertNull(schema.getIdentifier("Lookup_Test"));
-
-		schema = this.getDatabase().getSchemaForIdentifier("lookup_test");
-		assertEquals("LOOKUP_TEST", schema.getIdentifier());
-
-		schema = this.getDatabase().getSchemaForIdentifier("\"lookup_TEST\"");
-		assertEquals("\"lookup_TEST\"", schema.getIdentifier());
-		assertEquals("\"lookup_TEST\"", schema.getIdentifier("lookup_TEST"));
-
-		this.dropSchema("\"lookup_TEST\"");
-		this.dropSchema("LOOKUP_TEST");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testTable() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("TABLE_TEST", "FOO_BAZ");
-		this.dropTable("TABLE_TEST", "BAZ");
-		this.dropTable("TABLE_TEST", "FOO");
-		this.dropTable("TABLE_TEST", "BAR");
-		this.dropSchema("TABLE_TEST");
-
-		this.executeUpdate("CREATE SCHEMA TABLE_TEST");
-		this.executeUpdate("SET SCHEMA = TABLE_TEST");
-
-		this.executeUpdate(this.buildBarDDL());
-		this.executeUpdate(this.buildFooDDL());
-		this.executeUpdate(this.buildBazDDL());
-		this.executeUpdate(this.buildFooBazDDL());
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDatabase().getSchemaNamed("TABLE_TEST");
-
-		// FOO
-		Table fooTable = schema.getTableNamed("FOO");
-		assertEquals(4, fooTable.getColumnsSize());
-		assertEquals(1, fooTable.getPrimaryKeyColumnsSize());
-		assertEquals(1, fooTable.getForeignKeysSize());
-
-		Column pkColumn = fooTable.getPrimaryKeyColumn();
-		assertEquals("ID", pkColumn.getName());
-		Column idColumn = fooTable.getColumnNamed("ID");
-		assertSame(pkColumn, idColumn);
-		assertEquals("INTEGER", idColumn.getDataTypeName());
-		assertSame(fooTable, idColumn.getTable());
-		assertTrue(idColumn.isPartOfPrimaryKey());
-		assertFalse(idColumn.isPartOfForeignKey());
-		assertEquals("int", idColumn.getJavaTypeDeclaration());
-
-		Column nameColumn = fooTable.getColumnNamed("NAME");
-		assertEquals("VARCHAR", nameColumn.getDataTypeName());
-		assertEquals("java.lang.String", nameColumn.getJavaTypeDeclaration());
-		assertEquals(20, nameColumn.getLength());
-		assertFalse(nameColumn.isPartOfPrimaryKey());
-		assertFalse(nameColumn.isNumeric());
-		assertTrue(nameColumn.isNullable());
-
-		Column barColumn = fooTable.getColumnNamed("BAR_ID");
-		assertEquals("INTEGER", barColumn.getDataTypeName());
-		assertTrue(barColumn.isPartOfForeignKey());
-		assertFalse(barColumn.isPartOfPrimaryKey());
-
-		Column salaryColumn = fooTable.getColumnNamed("SALARY");
-		assertEquals("DECIMAL", salaryColumn.getDataTypeName());
-		assertTrue(salaryColumn.isNullable());
-		assertTrue(salaryColumn.isNumeric());
-		assertEquals(11, salaryColumn.getPrecision());
-		assertEquals(2, salaryColumn.getScale());
-		assertEquals(-1, salaryColumn.getLength());
-
-		ForeignKey barFK = fooTable.getForeignKeys().iterator().next();  // there should only be 1 foreign key
-		assertEquals(1, barFK.getColumnPairsSize());
-		assertEquals("BAR", barFK.getAttributeName());
-		assertNull(barFK.getJoinColumnAnnotationIdentifier("bar"));
-		assertEquals("BAR_ID", barFK.getJoinColumnAnnotationIdentifier("primaryBar"));
-		assertSame(fooTable, barFK.getBaseTable());
-
-		assertFalse(fooTable.isPossibleJoinTable());
-		assertSame(schema, fooTable.getSchema());
-
-		// BAR
-		Table barTable = schema.getTableNamed("BAR");
-		assertEquals(3, barTable.getColumnsSize());
-		assertEquals(1, barTable.getPrimaryKeyColumnsSize());
-		assertEquals(0, barTable.getForeignKeysSize());
-		assertEquals("ID", barTable.getPrimaryKeyColumn().getName());
-		assertFalse(barTable.isPossibleJoinTable());
-
-		Column id2Column = barTable.getColumnNamed("ID2");
-		assertEquals("INTEGER", id2Column.getDataTypeName());
-//		assertTrue(id2Column.isPartOfUniqueConstraint());  // doesn't work(?)
-		assertFalse(id2Column.isNullable());
-		assertTrue(id2Column.isNumeric());
-		assertEquals(0, id2Column.getPrecision());  // not sure what to expect here...
-		assertEquals(0, id2Column.getScale());  // not sure what to expect here either...
-		assertEquals("BLOB", barTable.getColumnNamed("CHUNK").getDataTypeName());
-		assertEquals("byte[]", barTable.getColumnNamed("CHUNK").getJavaTypeDeclaration());
-		assertTrue(barTable.getColumnNamed("CHUNK").isLOB());
-		assertSame(barTable, barFK.getReferencedTable());
-
-		// BAZ
-		Table bazTable = schema.getTableNamed("BAZ");
-		Column nicknameColumn = bazTable.getColumnNamed("NICKNAME");
-		assertEquals(20, nicknameColumn.getLength());
-//		assertTrue(nicknameColumn.isPartOfUniqueConstraint());  // doesn't work(?)
-
-		// FOO_BAZ
-		Table foo_bazTable = schema.getTableNamed("FOO_BAZ");
-		assertEquals(2, foo_bazTable.getColumnsSize());
-		assertEquals(0, foo_bazTable.getPrimaryKeyColumnsSize());
-		assertEquals(2, foo_bazTable.getForeignKeysSize());
-		assertTrue(foo_bazTable.isPossibleJoinTable());
-		assertTrue(foo_bazTable.joinTableNameIsDefault());
-		assertTrue(foo_bazTable.getColumnNamed("FOO_ID").isPartOfForeignKey());
-
-		this.dropTable("TABLE_TEST", "FOO_BAZ");
-		this.dropTable("TABLE_TEST", "BAZ");
-		this.dropTable("TABLE_TEST", "FOO");
-		this.dropTable("TABLE_TEST", "BAR");
-		this.dropSchema("TABLE_TEST");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private static final String CR = System.getProperty("line.separator");  //$NON-NLS-1$
-
-	private String buildBarDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE BAR (").append(CR);
-		sb.append("    ID INT PRIMARY KEY,").append(CR);
-		sb.append("    ID2 INT UNIQUE NOT NULL,").append(CR);
-		sb.append("    CHUNK BLOB(100K)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE FOO (").append(CR);
-		sb.append("    ID INT PRIMARY KEY,").append(CR);
-		sb.append("    NAME VARCHAR(20),").append(CR);
-		sb.append("    SALARY DECIMAL(11, 2),").append(CR);
-		sb.append("    BAR_ID INT REFERENCES BAR(ID)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE BAZ (").append(CR);
-		sb.append("    ID INT PRIMARY KEY,").append(CR);
-		sb.append("    NICKNAME VARCHAR(20) NOT NULL UNIQUE").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE FOO_BAZ (").append(CR);
-		sb.append("    FOO_ID INT REFERENCES FOO(ID),").append(CR);
-		sb.append("    BAZ_ID INT REFERENCES BAZ(ID)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	public void testColumnLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("COLUMN_TEST", "test");
-		this.dropSchema("COLUMN_TEST");
-
-		this.executeUpdate("CREATE SCHEMA COLUMN_TEST");
-		this.executeUpdate("SET SCHEMA = COLUMN_TEST");
-
-		// lowercase
-		this.executeUpdate("CREATE TABLE test (id INTEGER, name VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Table table = this.getDatabase().getSchemaNamed("COLUMN_TEST").getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("id"));
-		assertNotNull(table.getColumnForIdentifier("name"));
-
-		this.dropTable("COLUMN_TEST", "test");
-
-		// uppercase
-		this.executeUpdate("CREATE TABLE test (ID INTEGER, NAME VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDatabase().getSchemaNamed("COLUMN_TEST").getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("ID"));
-		assertNotNull(table.getColumnForIdentifier("NAME"));
-
-		this.dropTable("COLUMN_TEST", "test");
-
-		// mixed case
-		this.executeUpdate("CREATE TABLE test (Id INTEGER, Name VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDatabase().getSchemaNamed("COLUMN_TEST").getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("Id"));
-		assertNotNull(table.getColumnForIdentifier("Name"));
-
-		this.dropTable("COLUMN_TEST", "test");
-
-		// delimited
-		this.executeUpdate("CREATE TABLE test (\"Id\" INTEGER, \"Name\" VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDatabase().getSchemaNamed("COLUMN_TEST").getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("\"Id\""));
-		assertNotNull(table.getColumnForIdentifier("\"Name\""));
-
-		this.dropTable("COLUMN_TEST", "test");
-		this.dropSchema("COLUMN_TEST");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testCrossSchemaReference() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("XREF_TEST2", "EMP");
-		this.dropSchema("XREF_TEST2");
-		this.dropTable("XREF_TEST1", "ORG");
-		this.dropSchema("XREF_TEST1");
-
-		this.executeUpdate("CREATE SCHEMA XREF_TEST1");
-		this.executeUpdate("SET SCHEMA = XREF_TEST1");
-		this.executeUpdate("CREATE TABLE ORG (ID INTEGER PRIMARY KEY, NAME VARCHAR(20))");
-
-		this.executeUpdate("CREATE SCHEMA XREF_TEST2");
-		this.executeUpdate("SET SCHEMA = XREF_TEST2");
-		this.executeUpdate("CREATE TABLE EMP (ID INTEGER PRIMARY KEY, NAME VARCHAR(20), " +
-				"ORG_ID INTEGER REFERENCES XREF_TEST1.ORG(ID))");
-
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		Schema schema1 = this.getDatabase().getSchemaNamed("XREF_TEST1");
-		assertNotNull(schema1);
-		Table orgTable = schema1.getTableNamed("ORG");
-		assertNotNull(orgTable);
-
-		Schema schema2 = this.getDatabase().getSchemaNamed("XREF_TEST2");
-		assertNotNull(schema2);
-		Table empTable = schema2.getTableNamed("EMP");
-		assertNotNull(empTable);
-		assertEquals(1, empTable.getForeignKeysSize());
-		ForeignKey fk = empTable.getForeignKeys().iterator().next();
-		Table refTable = fk.getReferencedTable();
-		assertNotNull(refTable);
-		assertEquals("ORG", refTable.getName());
-		assertEquals(1, fk.getColumnPairsSize());
-		ForeignKey.ColumnPair cp = fk.getColumnPairs().iterator().next();
-		Column baseColumn = cp.getBaseColumn();
-		assertEquals("ORG_ID", baseColumn.getName());
-		Column refColumn = cp.getReferencedColumn();
-		assertEquals("ID", refColumn.getName());
-
-		this.dropTable("XREF_TEST2", "EMP");
-		this.dropSchema("XREF_TEST2");
-		this.dropTable("XREF_TEST1", "ORG");
-		this.dropSchema("XREF_TEST1");
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private void dropTable(String schemaName, String tableName) throws Exception {
-		Schema schema= this.getDatabase().getSchemaForIdentifier(schemaName);
-		if (schema != null) {
-			if (schema.getTableForIdentifier(tableName) != null) {
-				this.executeUpdate("DROP TABLE " + schemaName + '.' + tableName);
-			}
-		}
-	}
-
-	/**
-	 * NB: A Derby schema must be empty before it can be dropped.
-	 */
-	private void dropSchema(String name) throws Exception {
-		if (this.getDatabase().getSchemaForIdentifier(name) != null) {
-			this.executeUpdate("DROP SCHEMA " + name + " RESTRICT");
-		}
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/MySQLTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/MySQLTests.java
deleted file mode 100644
index 28c944e..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/MySQLTests.java
+++ /dev/null
@@ -1,404 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-import java.util.Properties;
-
-import org.eclipse.datatools.connectivity.drivers.jdbc.IJDBCDriverDefinitionConstants;
-import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObject;
-import org.eclipse.jpt.db.Column;
-import org.eclipse.jpt.db.ForeignKey;
-import org.eclipse.jpt.db.Schema;
-import org.eclipse.jpt.db.Table;
-
-/**
- * MySQL
- * 
- * Notes:
- * - We can only get database objects from the database associated with our
- *     connection profile.
- * - We can reference objects across multiple databases, so they are sorta like
- *     schemas....
- * - Foreign keys must be defined as table-level constraints; they cannot be
- *     defined as part of the column clause.
- * - Case-sensitivity and -folding is whacked on MySQL....
- */
-@SuppressWarnings("nls")
-public class MySQLTests extends DTPPlatformTests {
-
-	public MySQLTests( String name) {
-		super(name);
-	}
-
-	@Override
-	protected String getPlatformPropertiesFileName() {
-		return "mysql.properties";
-	}
-
-	@Override
-	protected String getDriverName() {
-		return "MySQL JDBC Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionID() {
-		return "DriverDefn.MySQL JDBC Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionType() {
-		return "org.eclipse.datatools.enablement.mysql.4_1.driverTemplate";
-	}
-
-	@Override
-	protected String getDatabaseVendor() {
-		return "MySql";
-	}
-
-	@Override
-	protected String getDatabaseVersion() {
-		return "4.1";
-	}
-
-	@Override
-	protected String getDriverClass() {
-		return "com.mysql.jdbc.Driver";
-	}
-
-	@Override
-	protected String getDefaultJDBCURL() {
-		return "jdbc:mysql://localhost:3306";
-	}
-
-	@Override
-	protected String getProfileName() {
-		return "MySQL_4.1";
-	}
-
-	@Override
-	protected String getProfileDescription() {
-		return "MySQL 4.1 JDBC Profile [Test]";
-	}
-
-	@Override
-	protected boolean supportsCatalogs() {
-		return false;
-	}
-
-	@Override
-	protected Properties buildDTPConnectionProfileProperties() {
-		Properties p = super.buildDTPConnectionProfileProperties();
-		p.setProperty(IJDBCDriverDefinitionConstants.DATABASE_NAME_PROP_ID, this.getDatabaseName());
-		return p;
-	}
-
-	private String getDatabaseName() {
-		return "dalitest";
-	}
-
-	@Override
-	protected boolean executeOfflineTests() {
-		return true;  // seems to work...
-	}
-
-	public void testDatabase() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		// DTP: MySQL has a single schema with the same name as the database
-		Schema schema = this.getDatabase().getSchemaNamed(this.getDatabaseName());
-		assertNotNull(schema);
-		assertSame(this.getDefaultSchema(), schema);
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testTable() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropDatabase(this.getDatabaseName());
-		this.executeUpdate("CREATE DATABASE " + this.getDatabaseName());
-		this.getJDBCConnection().setCatalog(this.getDatabaseName());
-
-		this.dropTable(this.getDatabaseName(), "foo_baz");
-		this.dropTable(this.getDatabaseName(), "baz");
-		this.dropTable(this.getDatabaseName(), "foo");
-		this.dropTable(this.getDatabaseName(), "bar");
-
-		this.executeUpdate(this.buildBarDDL());
-		this.executeUpdate(this.buildFooDDL());
-		this.executeUpdate(this.buildBazDDL());
-		this.executeUpdate(this.buildFooBazDDL());
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDefaultSchema();
-
-		// foo
-		Table fooTable = schema.getTableNamed("foo");
-		assertEquals(3, fooTable.getColumnsSize());
-		assertEquals(1, fooTable.getPrimaryKeyColumnsSize());
-		assertEquals(1, fooTable.getForeignKeysSize());
-
-		Column pkColumn = fooTable.getPrimaryKeyColumn();
-		assertEquals("id", pkColumn.getName());
-		Column idColumn = fooTable.getColumnNamed("id");
-		assertSame(pkColumn, idColumn);
-		assertEquals("INT", idColumn.getDataTypeName());
-		assertSame(fooTable, idColumn.getTable());
-		assertTrue(idColumn.isPartOfPrimaryKey());
-		assertFalse(idColumn.isPartOfForeignKey());
-		assertEquals("int", idColumn.getJavaTypeDeclaration());
-
-		Column nameColumn = fooTable.getColumnNamed("name");
-		assertEquals("VARCHAR", nameColumn.getDataTypeName());
-		assertEquals("java.lang.String", nameColumn.getJavaTypeDeclaration());
-		assertFalse(nameColumn.isPartOfPrimaryKey());
-
-		Column barColumn = fooTable.getColumnNamed("bar_id");
-		assertEquals("INT", barColumn.getDataTypeName());
-		assertTrue(barColumn.isPartOfForeignKey());
-		assertFalse(barColumn.isPartOfPrimaryKey());
-
-		ForeignKey barFK = fooTable.getForeignKeys().iterator().next();  // there should only be 1 foreign key
-		assertEquals(1, barFK.getColumnPairsSize());
-		assertEquals("bar", barFK.getAttributeName());
-		assertNull(barFK.getJoinColumnAnnotationIdentifier("bar"));
-		assertEquals("bar_id", barFK.getJoinColumnAnnotationIdentifier("primaryBar"));
-		assertSame(fooTable, barFK.getBaseTable());
-
-		assertFalse(fooTable.isPossibleJoinTable());
-		assertSame(schema, fooTable.getSchema());
-
-		// BAR
-		Table barTable = schema.getTableNamed("bar");
-		assertEquals(2, barTable.getColumnsSize());
-		assertEquals(1, barTable.getPrimaryKeyColumnsSize());
-		assertEquals(0, barTable.getForeignKeysSize());
-		assertEquals("id", barTable.getPrimaryKeyColumn().getName());
-		assertFalse(barTable.isPossibleJoinTable());
-		assertEquals("BLOB", barTable.getColumnNamed("chunk").getDataTypeName());
-		assertEquals("byte[]", barTable.getColumnNamed("chunk").getJavaTypeDeclaration());
-		assertTrue(barTable.getColumnNamed("chunk").isLOB());
-		assertSame(barTable, barFK.getReferencedTable());
-
-		// FOO_BAZ
-		Table foo_bazTable = schema.getTableNamed("foo_baz");
-		assertEquals(2, foo_bazTable.getColumnsSize());
-		assertEquals(0, foo_bazTable.getPrimaryKeyColumnsSize());
-		assertEquals(2, foo_bazTable.getForeignKeysSize());
-		assertTrue(foo_bazTable.isPossibleJoinTable());
-		assertTrue(foo_bazTable.joinTableNameIsDefault());
-		assertTrue(foo_bazTable.getColumnNamed("foo_id").isPartOfForeignKey());
-
-		this.dropTable(this.getDatabaseName(), "foo_baz");
-		this.dropTable(this.getDatabaseName(), "baz");
-		this.dropTable(this.getDatabaseName(), "foo");
-		this.dropTable(this.getDatabaseName(), "bar");
-
-		this.dropDatabase(this.getDatabaseName());
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private static final String CR = System.getProperty("line.separator");  //$NON-NLS-1$
-
-	private String buildBarDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE bar (").append(CR);
-		sb.append("    id INTEGER PRIMARY KEY,").append(CR);
-		sb.append("    chunk BLOB").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE foo (").append(CR);
-		sb.append("    id INTEGER PRIMARY KEY,").append(CR);
-		sb.append("    name VARCHAR(20),").append(CR);
-		sb.append("    bar_id INTEGER,").append(CR);
-		sb.append("    FOREIGN KEY (bar_id) REFERENCES bar(id)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE baz (").append(CR);
-		sb.append("    id INTEGER PRIMARY KEY,").append(CR);
-		sb.append("    name VARCHAR(20)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE foo_baz (").append(CR);
-		sb.append("    foo_id INT,").append(CR);
-		sb.append("    baz_id INT,").append(CR);
-		sb.append("    FOREIGN KEY (foo_id) REFERENCES foo(id),").append(CR);
-		sb.append("    FOREIGN KEY (baz_id) REFERENCES baz(id)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	/**
-	 * On Windows, table names get folded to lowercase by default;
-	 * even if the name is delimited (apparently).
-	 */
-	public void testTableLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropDatabase(this.getDatabaseName());
-		this.executeUpdate("CREATE DATABASE " + this.getDatabaseName());
-		this.getJDBCConnection().setCatalog(this.getDatabaseName());
-
-		this.dropTable(this.getDatabaseName(), "test1");
-		this.dropTable(this.getDatabaseName(), "TEST2");
-		this.dropTable(this.getDatabaseName(), "`TEST3`");
-
-		this.executeUpdate("CREATE TABLE test1 (id INTEGER, name VARCHAR(20))");
-		this.executeUpdate("CREATE TABLE TEST2 (id INTEGER, name VARCHAR(20))");
-		this.executeUpdate("CREATE TABLE `TEST3` (id INTEGER, name VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDefaultSchema();
-
-		Table test1Table = schema.getTableForIdentifier("test1");
-		assertNotNull(test1Table);
-
-		// this probably only works on Windows
-		Table test2Table = schema.getTableForIdentifier("test2");
-		assertNotNull(test2Table);
-
-		// this probably only works on Windows
-		Table test3Table = schema.getTableForIdentifier("`test3`");
-		assertNotNull(test3Table);
-
-		this.dropTable(this.getDatabaseName(), "test1");
-		this.dropTable(this.getDatabaseName(), "TEST2");
-		this.dropTable(this.getDatabaseName(), "`TEST3`");
-
-		this.dropDatabase(this.getDatabaseName());
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testColumnLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropDatabase(this.getDatabaseName());
-		this.executeUpdate("CREATE DATABASE " + this.getDatabaseName());
-		this.getJDBCConnection().setCatalog(this.getDatabaseName());
-
-		this.dropTable(this.getDatabaseName(), "test");
-
-		// lowercase
-		this.executeUpdate("CREATE TABLE test (id INTEGER, name VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Table table = this.getDefaultSchema().getTableNamed("test");
-		assertNotNull(table.getColumnNamed("id"));
-		assertNotNull(table.getColumnNamed("name"));
-
-		this.dropTable(this.getDatabaseName(), "test");
-
-		// uppercase
-		this.executeUpdate("CREATE TABLE test (ID INTEGER, NAME VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultSchema().getTableNamed("test");
-		assertNotNull(table.getColumnNamed("ID"));
-		assertNotNull(table.getColumnNamed("NAME"));
-
-		this.dropTable(this.getDatabaseName(), "test");
-
-		// mixed case
-		this.executeUpdate("CREATE TABLE test (Id INTEGER, Name VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultSchema().getTableNamed("test");
-		assertNotNull(table.getColumnNamed("Id"));
-		assertNotNull(table.getColumnNamed("Name"));
-
-		this.dropTable(this.getDatabaseName(), "test");
-
-		// delimited
-		this.executeUpdate("CREATE TABLE test (`Id` INTEGER, `Name` VARCHAR(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultSchema().getTableNamed("test");
-		assertNotNull(table.getColumnForIdentifier("`Id`"));
-		assertNotNull(table.getColumnForIdentifier("`Name`"));
-
-		this.dropTable(this.getDatabaseName(), "test");
-
-		this.dropDatabase(this.getDatabaseName());
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	/**
-	 * We can only get a single "schema" per connection via DTP,
-	 * so cross-schema references are not visible.
-	 */
-	public void testCrossSchemaReference() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropDatabase("xref_test2");
-		this.dropDatabase("xref_test1");
-
-		this.executeUpdate("CREATE DATABASE xref_test1");
-		this.getJDBCConnection().setCatalog("xref_test1");
-		this.executeUpdate("CREATE TABLE org (id INTEGER PRIMARY KEY, name VARCHAR(20))");
-
-		this.executeUpdate("CREATE DATABASE xref_test2");
-		this.getJDBCConnection().setCatalog("xref_test2");
-		this.executeUpdate("CREATE TABLE emp (id INTEGER PRIMARY KEY, name VARCHAR(20), " +
-				"org_id INTEGER, FOREIGN KEY (org_id) REFERENCES xref_test1.org(id))");
-
-		this.getJDBCConnection().setCatalog("xref_test2");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		Schema schema2 = this.getDefaultSchema();
-		assertNotNull(schema2);
-		Table empTable = schema2.getTableNamed("emp");
-		assertNotNull(empTable);
-		// no foreign keys
-		assertEquals(0, empTable.getForeignKeysSize());
-
-		this.dropDatabase("xref_test2");
-		this.dropDatabase("xref_test1");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private void dropTable(String dbName, String tableName) throws Exception {
-		this.executeUpdate("DROP TABLE IF EXISTS " + dbName + '.' + tableName);
-	}
-
-	private void dropDatabase(String name) throws Exception {
-		this.executeUpdate("DROP DATABASE IF EXISTS " + name);
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle10gTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle10gTests.java
deleted file mode 100644
index c70e343..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle10gTests.java
+++ /dev/null
@@ -1,397 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-import java.sql.SQLException;
-
-import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObject;
-import org.eclipse.jpt.db.Column;
-import org.eclipse.jpt.db.ForeignKey;
-import org.eclipse.jpt.db.Schema;
-import org.eclipse.jpt.db.Table;
-
-@SuppressWarnings("nls")
-public class Oracle10gTests extends DTPPlatformTests {
-
-	public Oracle10gTests( String name) {
-		super( name);
-	}
-
-	@Override
-	protected String getPlatformPropertiesFileName() {
-		return "oracle10g.properties";
-	}
-
-	@Override
-	protected String getDriverName() {
-		return "Oracle 10g Thin Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionID() {
-		return "DriverDefn.Oracle Thin Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionType() {
-		return "org.eclipse.datatools.enablement.oracle.10.driverTemplate";
-	}
-
-	@Override
-	protected String getDatabaseVendor() {
-		return "Oracle";
-	}
-
-	@Override
-	protected String getDatabaseVersion() {
-		return "10";
-	}
-
-	@Override
-	protected String getDriverClass() {
-		return "oracle.jdbc.OracleDriver";
-	}
-
-	@Override
-	protected String getProfileName() {
-		return "Oracle10g_10.1.0.4";
-	}
-
-	@Override
-	protected String getProfileDescription() {
-		return "Oracle10g (10.1.0.4) JDBC Profile [Test]";
-	}
-
-	@Override
-	protected boolean supportsCatalogs() {
-		return false;
-	}
-
-	@Override
-	protected boolean executeOfflineTests() {
-		// working offline is pretty ugly
-		return false;
-	}
-
-	public void testDatabase() throws Exception {
-		if (this.connectionProfile.getUserName().toUpperCase().equals("SYS")) {
-			System.out.println("skipped test: " + this.getClass() + '.' + this.getName());
-			return;  // SYS does not have a schema
-		}
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		// Oracle should have a schema with the same name as the user
-		Schema schema = this.getDatabase().getSchemaForIdentifier(this.getUserID());
-		assertNotNull(schema);
-		assertSame(this.getDefaultSchema(), schema);
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testTable() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("foo_baz");
-		this.dropTable("baz");
-		this.dropTable("foo");
-		this.dropTable("bar");
-
-		this.executeUpdate(this.buildBarDDL());
-		this.executeUpdate(this.buildFooDDL());
-		this.executeUpdate(this.buildBazDDL());
-		this.executeUpdate(this.buildFooBazDDL());
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDefaultSchema();
-
-		// foo
-		Table fooTable = schema.getTableForIdentifier("foo");
-		assertEquals(3, fooTable.getColumnsSize());
-		assertEquals(1, fooTable.getPrimaryKeyColumnsSize());
-		assertEquals(1, fooTable.getForeignKeysSize());
-
-		Column pkColumn = fooTable.getPrimaryKeyColumn();
-		assertEquals("ID", pkColumn.getName());
-		Column idColumn = fooTable.getColumnForIdentifier("id");
-		assertSame(pkColumn, idColumn);
-		assertEquals("NUMBER", idColumn.getDataTypeName());
-		assertSame(fooTable, idColumn.getTable());
-		assertTrue(idColumn.isPartOfPrimaryKey());
-		assertFalse(idColumn.isPartOfForeignKey());
-		assertEquals("java.math.BigDecimal", idColumn.getJavaTypeDeclaration());
-
-		Column nameColumn = fooTable.getColumnForIdentifier("name");
-		assertEquals("VARCHAR2", nameColumn.getDataTypeName());
-		assertEquals("java.lang.String", nameColumn.getJavaTypeDeclaration());
-		assertFalse(nameColumn.isPartOfPrimaryKey());
-
-		Column barColumn = fooTable.getColumnForIdentifier("bar_id");
-		assertEquals("NUMBER", barColumn.getDataTypeName());
-		assertTrue(barColumn.isPartOfForeignKey());
-		assertFalse(barColumn.isPartOfPrimaryKey());
-
-		ForeignKey barFK = fooTable.getForeignKeys().iterator().next();  // there should only be 1 foreign key
-		assertEquals(1, barFK.getColumnPairsSize());
-		assertEquals("BAR", barFK.getAttributeName());
-		assertNull(barFK.getJoinColumnAnnotationIdentifier("bar"));
-		assertEquals("BAR_ID", barFK.getJoinColumnAnnotationIdentifier("primaryBar"));
-		assertSame(fooTable, barFK.getBaseTable());
-
-		assertFalse(fooTable.isPossibleJoinTable());
-		assertSame(schema, fooTable.getSchema());
-
-		// BAR
-		Table barTable = schema.getTableForIdentifier("bar");
-		assertEquals(2, barTable.getColumnsSize());
-		assertEquals(1, barTable.getPrimaryKeyColumnsSize());
-		assertEquals(0, barTable.getForeignKeysSize());
-		assertEquals("ID", barTable.getPrimaryKeyColumn().getName());
-		assertFalse(barTable.isPossibleJoinTable());
-		assertEquals("BLOB", barTable.getColumnForIdentifier("chunk").getDataTypeName());
-		assertEquals("byte[]", barTable.getColumnForIdentifier("chunk").getJavaTypeDeclaration());
-		assertTrue(barTable.getColumnForIdentifier("chunk").isLOB());
-		assertSame(barTable, barFK.getReferencedTable());
-
-		// FOO_BAZ
-		Table foo_bazTable = schema.getTableForIdentifier("foo_baz");
-		assertEquals(2, foo_bazTable.getColumnsSize());
-		assertEquals(0, foo_bazTable.getPrimaryKeyColumnsSize());
-		assertEquals(2, foo_bazTable.getForeignKeysSize());
-		assertTrue(foo_bazTable.isPossibleJoinTable());
-		assertTrue(foo_bazTable.joinTableNameIsDefault());
-		assertTrue(foo_bazTable.getColumnForIdentifier("foo_id").isPartOfForeignKey());
-
-		this.dropTable("foo_baz");
-		this.dropTable("baz");
-		this.dropTable("foo");
-		this.dropTable("bar");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private static final String CR = System.getProperty("line.separator");  //$NON-NLS-1$
-
-	private String buildBarDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE bar (").append(CR);
-		sb.append("    id NUMBER(10) PRIMARY KEY,").append(CR);
-		sb.append("    chunk BLOB").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE foo (").append(CR);
-		sb.append("    id NUMBER(10) PRIMARY KEY,").append(CR);
-		sb.append("    name VARCHAR2(20),").append(CR);
-		sb.append("    bar_id REFERENCES bar(id)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE baz (").append(CR);
-		sb.append("    id NUMBER(10) PRIMARY KEY,").append(CR);
-		sb.append("    name VARCHAR2(20)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE foo_baz (").append(CR);
-		sb.append("    foo_id NUMBER(10) REFERENCES foo(id),").append(CR);
-		sb.append("    baz_id NUMBER(10) REFERENCES baz(id)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	public void testTableLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("test1");
-		this.dropTable("TEST2");
-		this.dropTable("\"test3\"");
-
-		this.executeUpdate("CREATE TABLE test1 (id NUMBER(10), name VARCHAR2(20))");
-		this.executeUpdate("CREATE TABLE TEST2 (id NUMBER(10), name VARCHAR2(20))");
-		this.executeUpdate("CREATE TABLE \"test3\" (id NUMBER(10), name VARCHAR2(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDefaultSchema();
-
-		Table test1Table = schema.getTableForIdentifier("test1");
-		assertNotNull(test1Table);
-		test1Table = schema.getTableForIdentifier("TEST1");
-		assertNotNull(test1Table);
-
-		Table test2Table = schema.getTableForIdentifier("test2");
-		assertNotNull(test2Table);
-		test2Table = schema.getTableForIdentifier("TEST2");
-		assertNotNull(test2Table);
-
-		Table test3Table = schema.getTableForIdentifier("\"test3\"");
-		assertNotNull(test3Table);
-		test3Table = schema.getTableForIdentifier("test3");
-		assertNull(test3Table);
-
-		this.dropTable("test1");
-		this.dropTable("TEST2");
-		this.dropTable("\"test3\"");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testColumnLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("test");
-
-		// lowercase
-		this.executeUpdate("CREATE TABLE test (id NUMBER(10), name VARCHAR2(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Table table = this.getDefaultSchema().getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("id"));
-		assertNotNull(table.getColumnForIdentifier("name"));
-
-		this.dropTable("test");
-
-		// uppercase
-		this.executeUpdate("CREATE TABLE test (ID NUMBER(10), NAME VARCHAR2(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultSchema().getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("ID"));
-		assertNotNull(table.getColumnForIdentifier("NAME"));
-
-		this.dropTable("test");
-
-		// mixed case
-		this.executeUpdate("CREATE TABLE test (Id NUMBER(10), Name VARCHAR2(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultSchema().getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("Id"));
-		assertNotNull(table.getColumnForIdentifier("Name"));
-
-		this.dropTable("test");
-
-		// delimited
-		this.executeUpdate("CREATE TABLE test (\"Id\" NUMBER(10), \"Name\" VARCHAR2(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultSchema().getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("\"Id\""));
-		assertNotNull(table.getColumnForIdentifier("\"Name\""));
-
-		this.dropTable("test");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testCrossSchemaReference() throws Exception {
-		if ( ! this.connectionProfile.getUserName().toUpperCase().equals("SYS")) {
-			System.out.println("skipped test: " + this.getClass() + '.' + this.getName());
-			return;  // SYS does not have a schema
-		}
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.executeUpdateIgnoreErrors("DROP USER XREF_TEST2 CASCADE");
-		this.executeUpdateIgnoreErrors("DROP USER XREF_TEST1 CASCADE");
-
-		this.executeUpdate("CREATE USER XREF_TEST1 IDENTIFIED BY foo");
-		this.executeUpdate("ALTER USER XREF_TEST1 QUOTA UNLIMITED ON USERS");
-		this.executeUpdate("CREATE TABLE XREF_TEST1.ORG (ID NUMBER(10) PRIMARY KEY, NAME VARCHAR2(20))");
-
-		this.executeUpdate("CREATE USER XREF_TEST2 IDENTIFIED BY foo");
-		this.executeUpdate("ALTER USER XREF_TEST2 QUOTA UNLIMITED ON USERS");
-		this.executeUpdate("GRANT ALL ON XREF_TEST1.ORG TO XREF_TEST2");
-		this.executeUpdate("CREATE TABLE XREF_TEST2.EMP (ID NUMBER(10) PRIMARY KEY, NAME VARCHAR2(20), " +
-				"ORG_ID NUMBER(10) REFERENCES XREF_TEST1.ORG(ID))");
-
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		Schema schema1 = this.getDatabase().getSchemaNamed("XREF_TEST1");
-		assertNotNull(schema1);
-		Table orgTable = schema1.getTableNamed("ORG");
-		assertNotNull(orgTable);
-
-		Schema schema2 = this.getDatabase().getSchemaNamed("XREF_TEST2");
-		assertNotNull(schema2);
-		Table empTable = schema2.getTableNamed("EMP");
-		assertNotNull(empTable);
-		assertEquals(1, empTable.getForeignKeysSize());
-		ForeignKey fk = empTable.getForeignKeys().iterator().next();
-		Table refTable = fk.getReferencedTable();
-		assertNotNull(refTable);
-		assertEquals("ORG", refTable.getName());
-		assertEquals(1, fk.getColumnPairsSize());
-		ForeignKey.ColumnPair cp = fk.getColumnPairs().iterator().next();
-		Column baseColumn = cp.getBaseColumn();
-		assertEquals("ORG_ID", baseColumn.getName());
-		Column refColumn = cp.getReferencedColumn();
-		assertEquals("ID", refColumn.getName());
-
-		this.executeUpdate("DROP USER XREF_TEST2 CASCADE");
-		this.executeUpdate("DROP USER XREF_TEST1 CASCADE");
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private void dropTable(String tableName) throws Exception {
-		this.executeUpdateIgnoreErrors("DROP TABLE " + tableName + " CASCADE CONSTRAINTS");
-	}
-
-// need Oracle enablement plug-in
-//	public void testSequence() throws Exception {
-//		this.connectionProfile.connect();
-//		TestConnectionListener listener = new TestConnectionListener();
-//		this.connectionProfile.addConnectionListener(listener);
-//
-//		this.dropSequence("FOO_SEQ");
-//
-//		this.executeUpdate("CREATE SEQUENCE FOO_SEQ");
-//		((ICatalogObject) this.getDTPDatabase()).refresh();
-//
-//		Sequence sequence = this.getDatabase().getDefaultSchema().getSequenceForIdentifier("FOO");
-//		assertNotNull(sequence);
-//		assertEquals("FOO_SEQ", sequence.getName());
-//
-//		this.dropSequence("FOO_SEQ");
-//
-//		this.connectionProfile.removeConnectionListener(listener);
-//		this.connectionProfile.disconnect();
-//	}
-//
-//	private void dropSequence(String sequenceName) throws Exception {
-//		this.executeUpdateIgnoreErrors("DROP SEQUENCE " + sequenceName);
-//	}
-//
-	protected void dumpUserObjects() throws SQLException {
-		this.dump("select * from user_objects");
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle10gXETests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle10gXETests.java
deleted file mode 100644
index 7f309f8..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle10gXETests.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-
-/**
- *  Oracle 10g Thin Driver Test
- */
-@SuppressWarnings("nls")
-public class Oracle10gXETests extends DTPPlatformTests {
-
-	public Oracle10gXETests( String name) {
-		super( name);
-	}
-
-	@Override
-	protected String getPlatformPropertiesFileName() {
-		return "oracle10gXE.properties";
-	}
-
-	@Override
-	protected String getDriverName() {
-		return "Oracle 10g Thin Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionID() {
-		return "DriverDefn.Oracle Thin Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionType() {
-		return "org.eclipse.datatools.enablement.oracle.10.driverTemplate";
-	}
-
-	@Override
-	protected String getDatabaseVendor() {
-		return "Oracle";
-	}
-
-	@Override
-	protected String getDatabaseVersion() {
-		return "10";
-	}
-
-	@Override
-	protected String getDriverClass() {
-		return "oracle.jdbc.OracleDriver";
-	}
-
-	@Override
-	protected String getProfileName() {
-		return "Oracle10g_XE";
-	}
-
-	@Override
-	protected String getProfileDescription() {
-		return "Oracle10g XE Release 2 (10.2) JDBC Profile [Test]";
-	}
-
-	@Override
-	protected boolean supportsCatalogs() {
-		return false;
-	}
-
-	@Override
-	protected boolean executeOfflineTests() {
-		// working offline is pretty ugly
-		return false;
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle9iTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle9iTests.java
deleted file mode 100644
index 9d1c474..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/Oracle9iTests.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-
-/**
- *  Oracle 9i Thin Driver Test
- */
-@SuppressWarnings("nls")
-public class Oracle9iTests extends DTPPlatformTests {
-
-	public Oracle9iTests( String name) {
-		super( name);
-	}
-
-	@Override
-	protected String getPlatformPropertiesFileName() {
-		return "oracle9i.properties";
-	}
-
-	@Override
-	protected String getDriverName() {
-		return "Oracle 9i Thin Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionID() {
-		return "DriverDefn.Oracle Thin Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionType() {
-		return "org.eclipse.datatools.enablement.oracle.9.driverTemplate";
-	}
-
-	@Override
-	protected String getDatabaseVendor() {
-		return "Oracle";
-	}
-
-	@Override
-	protected String getDatabaseVersion() {
-		return "9";
-	}
-
-	@Override
-	protected String getDriverClass() {
-		return "oracle.jdbc.OracleDriver";
-	}
-
-	@Override
-	protected String getProfileName() {
-		return "Oracle9i";
-	}
-
-	@Override
-	protected String getProfileDescription() {
-		return "Oracle9i JDBC Profile [Test]";
-	}
-
-	@Override
-	protected boolean supportsCatalogs() {
-		return false;
-	}
-
-	@Override
-	protected boolean executeOfflineTests() {
-		// working offline is pretty ugly
-		return false;
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/PostgreSQLTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/PostgreSQLTests.java
deleted file mode 100644
index 4b54bbf..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/PostgreSQLTests.java
+++ /dev/null
@@ -1,486 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObject;
-import org.eclipse.jpt.db.Column;
-import org.eclipse.jpt.db.ForeignKey;
-import org.eclipse.jpt.db.Schema;
-import org.eclipse.jpt.db.Table;
-
-@SuppressWarnings("nls")
-public class PostgreSQLTests extends DTPPlatformTests {
-
-	public PostgreSQLTests( String name) {
-		super( name);
-	}
-
-	@Override
-	protected String getPlatformPropertiesFileName() {
-		return "postgresql.properties";
-	}
-
-	@Override
-	protected String getDriverName() {
-		return "PostgreSQL JDBC Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionID() {
-		return "DriverDefn.PostgreSQL JDBC Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionType() {
-		return "org.eclipse.datatools.enablement.postgresql.postgresqlDriverTemplate";
-	}
-
-	@Override
-	protected String getDatabaseVendor() {
-		return "postgres";
-	}
-
-	@Override
-	protected String getDatabaseVersion() {
-		return "8.x";
-	}
-
-	@Override
-	protected String getDriverClass() {
-		return "org.postgresql.Driver";
-	}
-
-	@Override
-	protected String getDefaultJDBCURL() {
-		// using this URL will result in the DTP database containing a single
-		// catalog named "" - which, unfortunately, resembles the pseudo-catalog
-		// generated by DTP for databases that do not return any catalogs via
-		// JDBC metadata calls...
-		return "jdbc:postgresql";
-	}
-
-	@Override
-	protected String getProfileName() {
-		return "PostgreSQL";
-	}
-
-	@Override
-	protected String getProfileDescription() {
-		return "PostgreSQL 8.2 JDBC Profile [Test]";
-	}
-
-	@Override
-	protected boolean supportsCatalogs() {
-		return true;
-	}
-
-	@Override
-	protected boolean executeOfflineTests() {
-		// DTP does not support PostgreSQL off-line - see 226704/241558
-		return false;
-	}
-
-	public void testSchema() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropSchema("TEST1");
-		this.dropSchema("TEST2");
-
-		this.executeUpdate("CREATE SCHEMA TEST1");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema1 = this.getDefaultCatalog().getSchemaForIdentifier("TEST1");
-		assertNotNull(schema1);
-
-		this.executeUpdate("CREATE SCHEMA TEST2");
-		Schema schema2 = this.getDefaultCatalog().getSchemaForIdentifier("TEST2");
-		assertNull(schema2);  // should be null until refresh
-
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		assertSame(this.getDatabase(), listener.changedDatabase);
-
-		schema2 = this.getDefaultCatalog().getSchemaForIdentifier("TEST2");
-		assertNotNull(schema2);
-		assertNotSame(schema1, this.getDefaultCatalog().getSchemaForIdentifier("TEST1"));  // we should have a new schema after the refresh
-
-		this.dropSchema("TEST2");
-		this.dropSchema("TEST1");
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testSchemaLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropSchema("LOOKUP_TEST");
-		this.dropSchema("\"lookup_TEST\"");
-
-		this.executeUpdate("CREATE SCHEMA LOOKUP_TEST");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		assertNull(this.getDefaultCatalog().getSchemaNamed("LOOKUP_TEST"));
-		assertNotNull(this.getDefaultCatalog().getSchemaForIdentifier("LOOKUP_TEST"));
-
-		assertNotNull(this.getDefaultCatalog().getSchemaNamed("lookup_test"));
-		assertNotNull(this.getDefaultCatalog().getSchemaForIdentifier("lookup_test"));
-
-		assertNull(this.getDefaultCatalog().getSchemaNamed("lookup_TEST"));
-		assertNotNull(this.getDefaultCatalog().getSchemaForIdentifier("lookup_TEST"));
-
-		assertNotNull(this.getDefaultCatalog().getSchemaForIdentifier("\"lookup_test\""));
-		assertNull(this.getDefaultCatalog().getSchemaForIdentifier("\"lookup_TEST\""));
-		assertNull(this.getDefaultCatalog().getSchemaForIdentifier("\"LOOKUP_TEST\""));
-
-		this.dropSchema("LOOKUP_TEST");
-
-		this.executeUpdate("CREATE SCHEMA \"lookup_TEST\"");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		assertNull(this.getDefaultCatalog().getSchemaNamed("LOOKUP_TEST"));
-		assertNull(this.getDefaultCatalog().getSchemaForIdentifier("LOOKUP_TEST"));
-
-		assertNull(this.getDefaultCatalog().getSchemaNamed("lookup_test"));
-		assertNull(this.getDefaultCatalog().getSchemaForIdentifier("lookup_test"));
-
-		assertNotNull(this.getDefaultCatalog().getSchemaNamed("lookup_TEST"));
-		assertNull(this.getDefaultCatalog().getSchemaForIdentifier("lookup_TEST"));
-
-		assertNull(this.getDefaultCatalog().getSchemaForIdentifier("\"LOOKUP_TEST\""));
-		assertNotNull(this.getDefaultCatalog().getSchemaForIdentifier("\"lookup_TEST\""));
-
-		this.dropSchema("\"lookup_TEST\"");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testSchemaIdentifier() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropSchema("LOOKUP_TEST");
-		this.dropSchema("\"lookup_TEST\"");
-
-		this.executeUpdate("CREATE SCHEMA lookup_test");  // this gets folded to lowercase
-		this.executeUpdate("CREATE SCHEMA \"lookup_TEST\"");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDefaultCatalog().getSchemaForIdentifier("LOOKUP_TEST");
-		assertEquals("lookup_test", schema.getIdentifier());
-		assertEquals("lookup_test", schema.getIdentifier("LookupTest"));
-		assertNull(schema.getIdentifier("Lookup_Test"));
-
-		schema = this.getDefaultCatalog().getSchemaNamed("lookup_test");
-		assertEquals("lookup_test", schema.getIdentifier());
-
-		schema = this.getDefaultCatalog().getSchemaForIdentifier("\"lookup_TEST\"");
-		assertEquals("\"lookup_TEST\"", schema.getIdentifier());
-		assertEquals("\"lookup_TEST\"", schema.getIdentifier("lookup_TEST"));
-
-		this.dropSchema("\"lookup_TEST\"");
-		this.dropSchema("LOOKUP_TEST");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testTable() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("TABLE_TEST", "FOO_BAZ");
-		this.dropTable("TABLE_TEST", "BAZ");
-		this.dropTable("TABLE_TEST", "FOO");
-		this.dropTable("TABLE_TEST", "BAR");
-		this.dropSchema("TABLE_TEST");
-
-		this.executeUpdate("CREATE SCHEMA TABLE_TEST");
-		this.executeUpdate("SET search_path TO TABLE_TEST");
-
-		this.executeUpdate(this.buildBarDDL());
-		this.executeUpdate(this.buildFooDDL());
-		this.executeUpdate(this.buildBazDDL());
-		this.executeUpdate(this.buildFooBazDDL());
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDefaultCatalog().getSchemaForIdentifier("TABLE_TEST");
-
-		// FOO
-		Table fooTable = schema.getTableForIdentifier("FOO");
-		assertEquals(3, fooTable.getColumnsSize());
-		assertEquals(1, fooTable.getPrimaryKeyColumnsSize());
-		assertEquals(1, fooTable.getForeignKeysSize());
-
-		Column pkColumn = fooTable.getPrimaryKeyColumn();
-		assertEquals("id", pkColumn.getName());
-		Column idColumn = fooTable.getColumnForIdentifier("ID");
-		assertSame(pkColumn, idColumn);
-		assertEquals("INT4", idColumn.getDataTypeName());
-		assertSame(fooTable, idColumn.getTable());
-		assertTrue(idColumn.isPartOfPrimaryKey());
-		assertFalse(idColumn.isPartOfForeignKey());
-		assertEquals("java.lang.Integer", idColumn.getJavaTypeDeclaration());
-
-		Column nameColumn = fooTable.getColumnForIdentifier("NAME");
-		assertEquals("VARCHAR", nameColumn.getDataTypeName());
-		assertEquals("java.lang.String", nameColumn.getJavaTypeDeclaration());
-		assertFalse(nameColumn.isPartOfPrimaryKey());
-
-		Column barColumn = fooTable.getColumnForIdentifier("BAR_ID");
-		assertEquals("INT4", barColumn.getDataTypeName());
-		assertTrue(barColumn.isPartOfForeignKey());
-		assertFalse(barColumn.isPartOfPrimaryKey());
-
-		ForeignKey barFK = fooTable.getForeignKeys().iterator().next();  // there should only be 1 foreign key
-		assertEquals(1, barFK.getColumnPairsSize());
-		assertEquals("bar", barFK.getAttributeName());
-		assertNull(barFK.getJoinColumnAnnotationIdentifier("bar"));
-		assertEquals("bar_id", barFK.getJoinColumnAnnotationIdentifier("primaryBar"));
-		assertSame(fooTable, barFK.getBaseTable());
-
-		assertFalse(fooTable.isPossibleJoinTable());
-		assertSame(schema, fooTable.getSchema());
-
-		// BAR
-		Table barTable = schema.getTableForIdentifier("BAR");
-		assertEquals(2, barTable.getColumnsSize());
-		assertEquals(1, barTable.getPrimaryKeyColumnsSize());
-		assertEquals(0, barTable.getForeignKeysSize());
-		assertEquals("id", barTable.getPrimaryKeyColumn().getName());
-		assertFalse(barTable.isPossibleJoinTable());
-		assertEquals("BYTEA", barTable.getColumnForIdentifier("CHUNK").getDataTypeName());
-		assertEquals("byte[]", barTable.getColumnForIdentifier("CHUNK").getJavaTypeDeclaration());
-		// assertTrue(barTable.getColumnForIdentifier("CHUNK").dataTypeIsLOB());
-		assertSame(barTable, barFK.getReferencedTable());
-
-		// FOO_BAZ
-		Table foo_bazTable = schema.getTableForIdentifier("FOO_BAZ");
-		assertEquals(2, foo_bazTable.getColumnsSize());
-		assertEquals(0, foo_bazTable.getPrimaryKeyColumnsSize());
-		assertEquals(2, foo_bazTable.getForeignKeysSize());
-		assertTrue(foo_bazTable.isPossibleJoinTable());
-		assertTrue(foo_bazTable.joinTableNameIsDefault());
-		assertTrue(foo_bazTable.getColumnForIdentifier("FOO_ID").isPartOfForeignKey());
-
-		this.dropTable("TABLE_TEST", "FOO_BAZ");
-		this.dropTable("TABLE_TEST", "BAZ");
-		this.dropTable("TABLE_TEST", "FOO");
-		this.dropTable("TABLE_TEST", "BAR");
-		this.dropSchema("TABLE_TEST");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private static final String CR = System.getProperty("line.separator");  //$NON-NLS-1$
-
-	private String buildBarDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE BAR (").append(CR);
-		sb.append("    ID integer PRIMARY KEY,").append(CR);
-		sb.append("    CHUNK bytea").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE FOO (").append(CR);
-		sb.append("    ID integer PRIMARY KEY,").append(CR);
-		sb.append("    NAME varchar(20),").append(CR);
-		sb.append("    BAR_ID integer REFERENCES BAR(ID)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE BAZ (").append(CR);
-		sb.append("    ID integer PRIMARY KEY,").append(CR);
-		sb.append("    NAME varchar(20)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("CREATE TABLE FOO_BAZ (").append(CR);
-		sb.append("    FOO_ID int REFERENCES FOO(ID),").append(CR);
-		sb.append("    BAZ_ID int REFERENCES BAZ(ID)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	public void testColumnLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("TABLE_TEST", "test");
-		this.dropSchema("TABLE_TEST");
-
-		this.executeUpdate("CREATE SCHEMA TABLE_TEST");
-		this.executeUpdate("SET search_path TO TABLE_TEST");
-
-		// lowercase
-		this.executeUpdate("CREATE TABLE test (id int, name varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Table table = this.getDefaultCatalog().getSchemaForIdentifier("TABLE_TEST").getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("id"));
-		assertNotNull(table.getColumnForIdentifier("name"));
-
-		this.dropTable("TABLE_TEST", "test");
-
-		// uppercase
-		this.executeUpdate("CREATE TABLE test (ID int, NAME varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultCatalog().getSchemaForIdentifier("TABLE_TEST").getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("ID"));
-		assertNotNull(table.getColumnForIdentifier("NAME"));
-
-		this.dropTable("TABLE_TEST", "test");
-
-		// mixed case
-		this.executeUpdate("CREATE TABLE test (Id int, Name varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultCatalog().getSchemaForIdentifier("TABLE_TEST").getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("Id"));
-		assertNotNull(table.getColumnForIdentifier("Name"));
-
-		this.dropTable("TABLE_TEST", "test");
-
-		// delimited
-		this.executeUpdate("CREATE TABLE test (\"Id\" int, \"Name\" varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDefaultCatalog().getSchemaForIdentifier("TABLE_TEST").getTableForIdentifier("test");
-		assertNotNull(table.getColumnForIdentifier("\"Id\""));
-		assertNotNull(table.getColumnForIdentifier("\"Name\""));
-
-		this.dropTable("TABLE_TEST", "test");
-		this.dropSchema("TABLE_TEST");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testCrossSchemaReference() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.dropTable("XREF_TEST2", "EMP");
-		this.dropSchema("XREF_TEST2");
-		this.dropTable("XREF_TEST1", "ORG");
-		this.dropSchema("XREF_TEST1");
-
-		this.executeUpdate("CREATE SCHEMA XREF_TEST1");
-		this.executeUpdate("SET search_path TO XREF_TEST1");
-		this.executeUpdate("CREATE TABLE ORG (ID integer PRIMARY KEY, NAME varchar(20))");
-
-		this.executeUpdate("CREATE SCHEMA XREF_TEST2");
-		this.executeUpdate("SET search_path TO XREF_TEST2");
-		this.executeUpdate("CREATE TABLE EMP (ID integer PRIMARY KEY, NAME varchar(20), " +
-				"ORG_ID integer REFERENCES XREF_TEST1.ORG(ID))");
-
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		Schema schema1 = this.getDefaultCatalog().getSchemaNamed("xref_test1");
-		assertNotNull(schema1);
-		Table orgTable = schema1.getTableNamed("org");
-		assertNotNull(orgTable);
-
-		Schema schema2 = this.getDefaultCatalog().getSchemaNamed("xref_test2");
-		assertNotNull(schema2);
-		Table empTable = schema2.getTableNamed("emp");
-		assertNotNull(empTable);
-		assertEquals(1, empTable.getForeignKeysSize());
-		ForeignKey fk = empTable.getForeignKeys().iterator().next();
-		Table refTable = fk.getReferencedTable();
-		assertNotNull(refTable);
-		assertEquals("org", refTable.getName());
-		assertEquals(1, fk.getColumnPairsSize());
-		ForeignKey.ColumnPair cp = fk.getColumnPairs().iterator().next();
-		Column baseColumn = cp.getBaseColumn();
-		assertEquals("org_id", baseColumn.getName());
-		Column refColumn = cp.getReferencedColumn();
-		assertEquals("id", refColumn.getName());
-
-		this.dropTable("XREF_TEST2", "EMP");
-		this.dropSchema("XREF_TEST2");
-		this.dropTable("XREF_TEST1", "ORG");
-		this.dropSchema("XREF_TEST1");
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private void dropTable(String schemaName, String tableName) throws Exception {
-		Schema schema= this.getDefaultCatalog().getSchemaForIdentifier(schemaName);
-		if (schema != null) {
-			if (schema.getTableForIdentifier(tableName) != null) {
-				this.executeUpdate("DROP TABLE " + schemaName + '.' + tableName);
-			}
-		}
-	}
-
-	private void dropSchema(String name) throws Exception {
-		if (this.getDefaultCatalog().getSchemaForIdentifier(name) != null) {
-			this.executeUpdate("DROP SCHEMA " + name + " CASCADE");
-		}
-	}
-
-// see 241578/241557
-//	public void testSequence() throws Exception {
-//		this.connectionProfile.connect();
-//		TestConnectionListener listener = new TestConnectionListener();
-//		this.connectionProfile.addConnectionListener(listener);
-//
-//		this.dropSequence("SEQUENCE_TEST", "FOO");
-//		this.dropSchema("SEQUENCE_TEST");
-//
-//		this.executeUpdate("CREATE SCHEMA SEQUENCE_TEST");
-//		this.executeUpdate("SET search_path TO SEQUENCE_TEST");
-//
-//		this.executeUpdate(this.buildBarDDL());
-//		this.executeUpdate("CREATE SEQUENCE FOO START 1");
-////		List<Object[]> list = this.execute("SELECT nextval('foo')");
-////		System.out.println(list);
-//		((ICatalogObject) this.getDTPDatabase()).refresh();
-//
-//		Schema schema = this.getDefaultCatalog().getSchemaNamed("SEQUENCE_TEST");
-//		Sequence sequence = schema.getSequenceNamed("FOO");
-//		assertNotNull(sequence);
-//		assertEquals("foo_seq", sequence.getName());
-//
-//		this.dropSequence("SEQUENCE_TEST", "FOO");
-//		this.dropSchema("SEQUENCE_TEST");
-//
-//		this.connectionProfile.removeConnectionListener(listener);
-//		this.connectionProfile.disconnect();
-//	}
-//
-//	private void dropSequence(String schemaName, String sequenceName) throws Exception {
-//		Schema schema= this.getDefaultCatalog().getSchemaNamed(schemaName);
-//		if (schema != null) {
-//			if (schema.getSequenceNamed(sequenceName) != null) {
-//				this.executeUpdate("DROP SEQUENCE " + schemaName + '.' + sequenceName);
-//			}
-//		}
-//	}
-//
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/SQLServerTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/SQLServerTests.java
deleted file mode 100644
index cedde5d..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/SQLServerTests.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-
-/**
- *  SQL Server 2005 Driver Test
- */
-@SuppressWarnings("nls")
-public class SQLServerTests extends DTPPlatformTests {
-
-	public SQLServerTests( String name) {
-		super( name);
-	}
-
-	@Override
-	protected String getPlatformPropertiesFileName() {
-		return "sqlserver.properties";
-	}
-
-	@Override
-	protected String getDriverName() {
-		return "Microsoft SQL Server 2005 JDBC Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionID() {
-		return "DriverDefn.Microsoft SQL Server 2005 JDBC Driver";
-	}
-
-	@Override
-	protected String getDriverDefinitionType() {
-		return "org.eclipse.datatools.enablement.msft.sqlserver.2005.driverTemplate";
-	}
-
-	@Override
-	protected String getDatabaseVendor() {
-		return "SQLServer";
-	}
-
-	@Override
-	protected String getDatabaseVersion() {
-		return "2005";
-	}
-
-	@Override
-	protected String getDriverClass() {
-		return "com.microsoft.sqlserver.jdbc.SQLServerDriver";
-	}
-
-	@Override
-	protected String getProfileName() {
-		return "SQLServer_2005";
-	}
-
-	@Override
-	protected String getProfileDescription() {
-		return "Microsoft SQL Server 2005 JDBC Profile [Test]";
-	}
-
-	@Override
-	protected String getProviderID() {
-		return "org.eclipse.datatools.connectivity.db.generic.connectionProfile";
-	}
-
-	@Override
-	protected boolean supportsCatalogs() {
-		return true;
-	}
-
-	@Override
-	protected boolean executeOfflineTests() {
-		return true;  // haven't actually tried this yet...
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/SybaseTests.java b/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/SybaseTests.java
deleted file mode 100644
index 41cea99..0000000
--- a/jpa/tests/org.eclipse.jpt.db.tests/src/org/eclipse/jpt/db/tests/internal/platforms/SybaseTests.java
+++ /dev/null
@@ -1,443 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.db.tests.internal.platforms;
-
-import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObject;
-import org.eclipse.jpt.db.Catalog;
-import org.eclipse.jpt.db.Column;
-import org.eclipse.jpt.db.ForeignKey;
-import org.eclipse.jpt.db.Schema;
-import org.eclipse.jpt.db.Table;
-
-@SuppressWarnings("nls")
-public class SybaseTests extends DTPPlatformTests {
-
-	public SybaseTests( String name) {
-		super( name);
-	}
-
-	@Override
-	protected String getPlatformPropertiesFileName() {
-		return "sybase.properties";
-	}
-
-	@Override
-	protected String getDriverName() {
-		return "Sybase JDBC Driver for Sybase ASE 15.x";
-	}
-
-	@Override
-	protected String getDriverDefinitionID() {
-		return "DriverDefn.Sybase JDBC Driver for Sybase ASE 15.x";
-	}
-
-	@Override
-	protected String getDriverDefinitionType() {
-		return "org.eclipse.datatools.connectivity.db.sybase.ase.genericDriverTemplate_15";
-	}
-
-	@Override
-	protected String getDatabaseVendor() {
-		return "Sybase_ASE";
-	}
-
-	@Override
-	protected String getDatabaseVersion() {
-		return "15.x";
-	}
-
-	@Override
-	protected String getDriverClass() {
-		return "com.sybase.jdbc3.jdbc.SybDriver";
-	}
-
-	@Override
-	protected String getProfileName() {
-		return "Sybase_15";
-	}
-
-	@Override
-	protected String getProfileDescription() {
-		return "Sybase ASE 15 jConnect JDBC Profile [Test]";
-	}
-
-	@Override
-	protected boolean supportsCatalogs() {
-		return true;
-	}
-
-	@Override
-	protected boolean executeOfflineTests() {
-		// working offline is pretty ugly
-		return false;
-	}
-
-	/**
-	 * Sybase "databases" become DTP "catalogs"
-	 */
-	public void testCatalog() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdateIgnoreErrors("drop database test1");
-		this.executeUpdateIgnoreErrors("drop database test2");
-
-		this.executeUpdate("create database test1");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Catalog catalog1 = this.getDatabase().getCatalogNamed("test1");
-		assertNotNull(catalog1);
-		Schema schema1 = catalog1.getSchemaNamed("dbo");
-		assertNotNull(schema1);
-		assertSame(schema1, catalog1.getDefaultSchema());
-
-		this.executeUpdate("create database test2");
-		Catalog catalog2 = this.getDatabase().getCatalogNamed("test2");
-		assertNull(catalog2);  // should be null until refresh
-
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		assertSame(this.getDatabase(), listener.changedDatabase);
-
-		catalog2 = this.getDatabase().getCatalogNamed("test2");
-		assertNotNull(catalog2);
-		Schema schema2 = catalog2.getDefaultSchema();
-		assertNotNull(schema2);
-
-		assertNotSame(catalog1, this.getDatabase().getCatalogNamed("test1"));  // we should have a new catalog after the refresh
-		assertNotSame(schema1, this.getDatabase().getCatalogNamed("test1").getDefaultSchema());  // we should have a new schema after the refresh
-
-		this.executeUpdate("drop database test2");
-		this.executeUpdate("drop database test1");
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testTable() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdateIgnoreErrors("drop database table_test");
-		this.executeUpdate("create database table_test");
-		this.getJDBCConnection().setCatalog("table_test");
-
-		this.executeUpdate(this.buildBarDDL());
-		this.executeUpdate(this.buildFooDDL());
-		this.executeUpdate(this.buildBazDDL());
-		this.executeUpdate(this.buildFooBazDDL());
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDatabase().getCatalogNamed("table_test").getDefaultSchema();
-
-		// foo
-		Table fooTable = schema.getTableNamed("foo");
-		assertEquals(3, fooTable.getColumnsSize());
-		assertEquals(1, fooTable.getPrimaryKeyColumnsSize());
-		assertEquals(1, fooTable.getForeignKeysSize());
-
-		Column pkColumn = fooTable.getPrimaryKeyColumn();
-		assertEquals("id", pkColumn.getName());
-		Column idColumn = fooTable.getColumnNamed("id");
-		assertSame(fooTable, idColumn.getTable());
-		assertSame(pkColumn, idColumn);
-		assertTrue(idColumn.isPartOfPrimaryKey());
-		assertFalse(idColumn.isPartOfForeignKey());
-		assertTrue(idColumn.isPartOfUniqueConstraint());
-		assertFalse(idColumn.isNullable());
-
-		assertEquals("INT", idColumn.getDataTypeName());
-		assertTrue(idColumn.isNumeric());
-		assertEquals(0, idColumn.getPrecision());
-		assertEquals(0, idColumn.getScale());
-		assertEquals(-1, idColumn.getLength());
-		assertFalse(idColumn.isLOB());
-		assertEquals("int", idColumn.getJavaTypeDeclaration());
-
-		Column nameColumn = fooTable.getColumnNamed("name");
-		assertFalse(nameColumn.isPartOfPrimaryKey());
-		assertFalse(nameColumn.isPartOfForeignKey());
-		assertTrue(nameColumn.isPartOfUniqueConstraint());
-		assertFalse(nameColumn.isNullable());  // implied "NOT NULL" ?
-
-		assertEquals("VARCHAR", nameColumn.getDataTypeName());
-		assertFalse(nameColumn.isNumeric());
-		assertEquals(-1, nameColumn.getPrecision());
-		assertEquals(-1, nameColumn.getScale());
-		assertEquals(20, nameColumn.getLength());
-		assertFalse(nameColumn.isLOB());
-		assertEquals("java.lang.String", nameColumn.getJavaTypeDeclaration());
-
-		Column barColumn = fooTable.getColumnNamed("bar_id");
-		assertEquals("INT", barColumn.getDataTypeName());
-		assertTrue(barColumn.isPartOfForeignKey());
-		assertFalse(barColumn.isPartOfPrimaryKey());
-
-		ForeignKey barFK = fooTable.getForeignKeys().iterator().next();  // there should only be 1 foreign key
-		assertEquals(1, barFK.getColumnPairsSize());
-		assertEquals("bar", barFK.getAttributeName());
-		assertNull(barFK.getJoinColumnAnnotationIdentifier("bar"));
-		assertEquals("bar_id", barFK.getJoinColumnAnnotationIdentifier("primaryBar"));
-		assertSame(fooTable, barFK.getBaseTable());
-
-		assertFalse(fooTable.isPossibleJoinTable());
-		assertSame(schema, fooTable.getSchema());
-
-		// BAR
-		Table barTable = schema.getTableNamed("bar");
-		assertEquals(2, barTable.getColumnsSize());
-		assertEquals(1, barTable.getPrimaryKeyColumnsSize());
-		assertEquals(0, barTable.getForeignKeysSize());
-		assertEquals("id", barTable.getPrimaryKeyColumn().getName());
-		assertFalse(barTable.isPossibleJoinTable());
-		Column chunkColumn = barTable.getColumnNamed("chunk");
-		assertEquals("IMAGE", chunkColumn.getDataTypeName());
-		assertFalse(chunkColumn.isNumeric());
-		assertTrue(chunkColumn.isLOB());
-		assertEquals("byte[]", chunkColumn.getJavaTypeDeclaration());
-		assertSame(barTable, barFK.getReferencedTable());
-
-		// BAZ
-		Table bazTable = schema.getTableNamed("baz");
-		assertEquals(4, bazTable.getColumnsSize());
-		assertEquals(1, bazTable.getPrimaryKeyColumnsSize());
-		assertEquals(0, bazTable.getForeignKeysSize());
-
-		Column nicknameColumn = bazTable.getColumnNamed("nickname");
-		assertTrue(nicknameColumn.isNullable());
-
-		Column songColumn = bazTable.getColumnNamed("song");
-		assertFalse(songColumn.isNullable());
-
-		Column salaryColumn = bazTable.getColumnNamed("salary");
-		assertFalse(salaryColumn.isPartOfUniqueConstraint());
-		assertEquals("DECIMAL", salaryColumn.getDataTypeName());
-		assertTrue(salaryColumn.isNumeric());
-		assertEquals(10, salaryColumn.getPrecision());
-		assertEquals(2, salaryColumn.getScale());
-		assertEquals(-1, salaryColumn.getLength());
-		assertFalse(salaryColumn.isLOB());
-
-		// FOO_BAZ
-		Table foo_bazTable = schema.getTableNamed("foo_baz");
-		assertEquals(2, foo_bazTable.getColumnsSize());
-		assertEquals(0, foo_bazTable.getPrimaryKeyColumnsSize());
-		assertEquals(2, foo_bazTable.getForeignKeysSize());
-		assertTrue(foo_bazTable.isPossibleJoinTable());
-		assertTrue(foo_bazTable.joinTableNameIsDefault());
-		assertTrue(foo_bazTable.getColumnNamed("foo_id").isPartOfForeignKey());
-
-		this.executeUpdate("drop table foo_baz");
-		this.executeUpdate("drop table baz");
-		this.executeUpdate("drop table foo");
-		this.executeUpdate("drop table bar");
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdate("drop database table_test");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	private static final String CR = System.getProperty("line.separator");  //$NON-NLS-1$
-
-	private String buildBarDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("create table bar (").append(CR);
-		sb.append("    id integer primary key,").append(CR);
-		sb.append("    chunk image").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("create table foo (").append(CR);
-		sb.append("    id integer primary key,").append(CR);
-		sb.append("    name varchar(20) unique,").append(CR);
-		sb.append("    bar_id integer references bar(id)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("create table baz (").append(CR);
-		sb.append("    id integer primary key,").append(CR);
-		sb.append("    nickname varchar(20) null,").append(CR);
-		sb.append("    song varchar(20) not null,").append(CR);
-		sb.append("    salary decimal(10, 2)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	private String buildFooBazDDL() {
-		StringBuilder sb = new StringBuilder(200);
-		sb.append("create table foo_baz (").append(CR);
-		sb.append("    foo_id integer references foo(id),").append(CR);
-		sb.append("    baz_id integer references baz(id)").append(CR);
-		sb.append(")").append(CR);
-		return sb.toString();
-	}
-
-	public void testTableLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdateIgnoreErrors("drop database table_lookup_test");
-		this.executeUpdate("create database table_lookup_test");
-		this.getJDBCConnection().setCatalog("table_lookup_test");
-
-		this.executeUpdate("create table test1 (id integer, name varchar(20))");
-		this.executeUpdate("create table TEST2 (id integer, name varchar(20))");
-		this.executeUpdate("create table [Test3] (id integer, name varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Schema schema = this.getDatabase().getCatalogNamed("table_lookup_test").getDefaultSchema();
-
-		assertNotNull(schema.getTableNamed("test1"));
-		assertNotNull(schema.getTableForIdentifier("test1"));
-
-		assertNotNull(schema.getTableNamed("TEST2"));
-		assertNotNull(schema.getTableForIdentifier("TEST2"));
-
-		assertNotNull(schema.getTableForIdentifier("[Test3]"));
-
-		this.executeUpdate("drop table [Test3]");
-		this.executeUpdate("drop table TEST2");
-		this.executeUpdate("drop table test1");
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdate("drop database table_lookup_test");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testColumnLookup() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdateIgnoreErrors("drop database column_lookup_test");
-		this.executeUpdate("create database column_lookup_test");
-		this.getJDBCConnection().setCatalog("column_lookup_test");
-
-		// lowercase
-		this.executeUpdate("create table test (id integer, name varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		Table table = this.getDatabase().getCatalogNamed("column_lookup_test").getDefaultSchema().getTableNamed("test");
-		assertNotNull(table.getColumnNamed("id"));
-		assertNotNull(table.getColumnNamed("name"));
-
-		this.executeUpdate("drop table test");
-
-		// uppercase
-		this.executeUpdate("create table test (ID integer, NAME varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDatabase().getCatalogNamed("column_lookup_test").getDefaultSchema().getTableNamed("test");
-		assertNotNull(table.getColumnForIdentifier("ID"));
-		assertNotNull(table.getColumnForIdentifier("NAME"));
-
-		this.executeUpdate("drop table test");
-
-		// mixed case
-		this.executeUpdate("create table test (Id integer, Name varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDatabase().getCatalogNamed("column_lookup_test").getDefaultSchema().getTableNamed("test");
-		assertNotNull(table.getColumnForIdentifier("Id"));
-		assertNotNull(table.getColumnForIdentifier("Name"));
-
-		this.executeUpdate("drop table test");
-
-		// delimited
-		this.executeUpdate("create table test ([Id] integer, [Name] varchar(20))");
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-
-		table = this.getDatabase().getCatalogNamed("column_lookup_test").getDefaultSchema().getTableNamed("test");
-		assertNotNull(table.getColumnForIdentifier("[Id]"));
-		assertNotNull(table.getColumnForIdentifier("[Name]"));
-
-		this.executeUpdate("drop table test");
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdate("drop database column_lookup_test");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-	public void testCrossSchemaReference() throws Exception {
-		this.connectionProfile.connect();
-		TestConnectionListener listener = new TestConnectionListener();
-		this.connectionProfile.addConnectionListener(listener);
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdateIgnoreErrors("drop database xref_test2");
-		this.executeUpdateIgnoreErrors("drop database xref_test1");
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdate("create database xref_test1");
-		this.getJDBCConnection().setCatalog("xref_test1");
-		this.executeUpdate("create table org (id integer primary key, name varchar(20))");
-
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdate("create database xref_test2");
-		this.getJDBCConnection().setCatalog("xref_test2");
-		this.executeUpdate("create table emp (id integer primary key, name varchar(20), " +
-				"org_id integer references xref_test1..org(id))");
-
-		((ICatalogObject) this.getDTPDatabase()).refresh();
-		Catalog catalog1 = this.getDatabase().getCatalogNamed("xref_test1");
-		assertNotNull(catalog1);
-		Schema schema1 = catalog1.getSchemaNamed("dbo");
-		assertNotNull(schema1);
-		Table orgTable = schema1.getTableNamed("org");
-		assertNotNull(orgTable);
-
-		Catalog catalog2 = this.getDatabase().getCatalogNamed("xref_test2");
-		assertNotNull(catalog2);
-		Schema schema2 = catalog2.getSchemaNamed("dbo");
-		assertNotNull(schema2);
-		Table empTable = schema2.getTableNamed("emp");
-		assertNotNull(empTable);
-		assertEquals(1, empTable.getForeignKeysSize());
-		ForeignKey fk = empTable.getForeignKeys().iterator().next();
-		Table refTable = fk.getReferencedTable();
-		assertNotNull(refTable);
-		assertEquals("org", refTable.getName());
-		assertEquals(1, fk.getColumnPairsSize());
-		ForeignKey.ColumnPair cp = fk.getColumnPairs().iterator().next();
-		Column baseColumn = cp.getBaseColumn();
-		assertEquals("org_id", baseColumn.getName());
-		Column refColumn = cp.getReferencedColumn();
-		assertEquals("id", refColumn.getName());
-
-		this.getJDBCConnection().setCatalog("xref_test2");
-		this.executeUpdate("drop table emp");
-		this.getJDBCConnection().setCatalog("xref_test1");
-		this.executeUpdate("drop table org");
-		this.getJDBCConnection().setCatalog("master");
-		this.executeUpdate("drop database xref_test2");
-		this.executeUpdate("drop database xref_test1");
-
-		this.connectionProfile.removeConnectionListener(listener);
-		this.connectionProfile.disconnect();
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/.classpath b/jpa/tests/org.eclipse.jpt.gen.tests/.classpath
deleted file mode 100644
index 482a6d9..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/.classpath
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">
-		<accessrules>
-			<accessrule kind="accessible" pattern="org/eclipse/jpt/gen/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/.project b/jpa/tests/org.eclipse.jpt.gen.tests/.project
deleted file mode 100644
index 2159feb..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.gen.tests</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/.settings/org.eclipse.core.resources.prefs b/jpa/tests/org.eclipse.jpt.gen.tests/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 2c6dda4..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Tue Jan 15 11:12:14 EST 2008
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/.settings/org.eclipse.jdt.core.prefs b/jpa/tests/org.eclipse.jpt.gen.tests/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 8bab913..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,7 +0,0 @@
-#Mon Jul 07 20:13:24 EDT 2008
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/META-INF/MANIFEST.MF b/jpa/tests/org.eclipse.jpt.gen.tests/META-INF/MANIFEST.MF
deleted file mode 100644
index febf670..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,14 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-Vendor: %providerName
-Bundle-SymbolicName: org.eclipse.jpt.gen.tests
-Bundle-Version: 2.0.0
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Require-Bundle: org.eclipse.core.runtime;bundle-version="3.4.0",
- org.eclipse.jdt.core;bundle-version="3.4.0",
- org.eclipse.jpt.utility;bundle-version="1.2.0",
- org.eclipse.jpt.db;bundle-version="1.1.1",
- org.eclipse.jpt.gen;bundle-version="1.1.0",
- org.junit;bundle-version="3.8.0"
-Export-Package: org.eclipse.jpt.gen.tests.internal;x-internal:=true
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/about.html b/jpa/tests/org.eclipse.jpt.gen.tests/about.html
deleted file mode 100644
index be534ba..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/about.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<HTML>
-
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-
-<BODY lang="EN-US">
-
-<H3>About This Content</H3>
-
-<P>May 02, 2008</P>
-
-<H3>License</H3>
-
-<P>The Eclipse Foundation makes available all content in this plug-in 
-("Content"). Unless otherwise indicated below, the Content is provided to you 
-under the terms and conditions of the Eclipse Public License Version 1.0 
-("EPL"). A copy of the EPL is available at
-<A href="http://www.eclipse.org/org/documents/epl-v10.php">http://www.eclipse.org/org/documents/epl-v10.php</A>. 
-For purposes of the EPL, "Program" will mean the Content.</P>
-
-<P>If you did not receive this Content directly from the Eclipse Foundation, the 
-Content is being redistributed by another party ("Redistributor") and different 
-terms and conditions may apply to your use of any object code in the Content. 
-Check the Redistributor's license that was provided with the Content. If no such 
-license exists, contact the Redistributor. Unless otherwise indicated below, the 
-terms and conditions of the EPL still apply to any source code in the Content 
-and such source code may be obtained at
-<A href="http://www.eclipse.org/">http://www.eclipse.org/</A>.</P>
-
-</BODY>
-</HTML>
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/build.properties b/jpa/tests/org.eclipse.jpt.gen.tests/build.properties
deleted file mode 100644
index e68d4bf..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/build.properties
+++ /dev/null
@@ -1,18 +0,0 @@
-################################################################################
-# Copyright (c) 2008 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-javacSource = 1.5
-javacTarget = 1.5
-bin.includes = .,\
-               META-INF/,\
-               about.html,\
-               test.xml,\
-               plugin.properties
-source.. = src/
-output.. = bin/
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/plugin.properties b/jpa/tests/org.eclipse.jpt.gen.tests/plugin.properties
deleted file mode 100644
index f81a674..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/plugin.properties
+++ /dev/null
@@ -1,23 +0,0 @@
-################################################################################
-# Copyright (c) 2006, 2007 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-# ====================================================================
-# To code developer:
-#   Do NOT change the properties between this line and the
-#   "%%% END OF TRANSLATED PROPERTIES %%%" line.
-#   Make a new property name, append to the end of the file and change
-#   the code to use the new property.
-# ====================================================================
-
-# ====================================================================
-# %%% END OF TRANSLATED PROPERTIES %%%
-# ====================================================================
-
-pluginName=Java Persistence Tools Entity Generation Tests
-providerName=Eclipse.org
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/src/org/eclipse/jpt/gen/tests/internal/EntityGenToolsTests.java b/jpa/tests/org.eclipse.jpt.gen.tests/src/org/eclipse/jpt/gen/tests/internal/EntityGenToolsTests.java
deleted file mode 100644
index 944e9f4..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/src/org/eclipse/jpt/gen/tests/internal/EntityGenToolsTests.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.gen.tests.internal;
-
-import java.util.HashSet;
-import org.eclipse.jpt.gen.internal.util.EntityGenTools;
-
-import junit.framework.TestCase;
-
-/**
- * 
- */
-@SuppressWarnings("nls")
-public class EntityGenToolsTests extends TestCase {
-
-	public EntityGenToolsTests(String name) {
-		super(name);
-	}
-
-	public void testConvertToUniqueJavaStyleClassName1() {
-		HashSet<String> names = new HashSet<String>();
-		assertEquals("Foo", EntityGenTools.convertToUniqueJavaStyleClassName("Foo", names));
-		assertEquals("Foo", EntityGenTools.convertToUniqueJavaStyleClassName("foo", names));
-		assertEquals("Foo", EntityGenTools.convertToUniqueJavaStyleClassName("FOO", names));
-		assertEquals("Foo", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_", names));
-		assertEquals("Foo", EntityGenTools.convertToUniqueJavaStyleClassName("_FOO", names));
-		assertEquals("Foo_", EntityGenTools.convertToUniqueJavaStyleClassName("FOO*", names));
-		assertEquals("_oo", EntityGenTools.convertToUniqueJavaStyleClassName("5oo", names));
-	}
-
-	public void testConvertToUniqueJavaStyleClassName2() {
-		HashSet<String> names = new HashSet<String>();
-		names.add("Foo");
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("Foo", names));
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("foo", names));
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("FOO", names));
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_", names));
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("_FOO", names));
-		assertEquals("Foo_", EntityGenTools.convertToUniqueJavaStyleClassName("FOO*", names));
-		assertEquals("_oo", EntityGenTools.convertToUniqueJavaStyleClassName("5OO", names));
-	}
-
-	public void testConvertToUniqueJavaStyleClassName3() {
-		HashSet<String> names = new HashSet<String>();
-		names.add("foo");
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("Foo", names));
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("foo", names));
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("FOO", names));
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_", names));
-		assertEquals("Foo2", EntityGenTools.convertToUniqueJavaStyleClassName("_FOO", names));
-		assertEquals("Foo_", EntityGenTools.convertToUniqueJavaStyleClassName("FOO*", names));
-		assertEquals("_oo", EntityGenTools.convertToUniqueJavaStyleClassName("5OO", names));
-	}
-
-	public void testConvertToUniqueJavaStyleClassName4() {
-		HashSet<String> names = new HashSet<String>();
-		assertEquals("FooBar", EntityGenTools.convertToUniqueJavaStyleClassName("FooBar", names));
-		assertEquals("Foo_bar", EntityGenTools.convertToUniqueJavaStyleClassName("foo_bar", names));
-		assertEquals("FooBar", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_BAR", names));
-		assertEquals("FooBar", EntityGenTools.convertToUniqueJavaStyleClassName("_FOO_BAR", names));
-		assertEquals("FooBar", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_BAR_", names));
-		assertEquals("FooBar_", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_BAR_*", names));
-		assertEquals("_fooBar", EntityGenTools.convertToUniqueJavaStyleClassName("4FOO_BAR", names));
-	}
-
-	public void testConvertToUniqueJavaStyleClassName5() {
-		HashSet<String> names = new HashSet<String>();
-		names.add("FooBar");
-		assertEquals("FooBar2", EntityGenTools.convertToUniqueJavaStyleClassName("FooBar", names));
-		assertEquals("Foo_bar", EntityGenTools.convertToUniqueJavaStyleClassName("foo_bar", names));
-		assertEquals("FooBar2", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_BAR", names));
-		assertEquals("FooBar2", EntityGenTools.convertToUniqueJavaStyleClassName("_FOO_BAR", names));
-		assertEquals("FooBar2", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_BAR_", names));
-		assertEquals("FooBar_", EntityGenTools.convertToUniqueJavaStyleClassName("FOO_BAR_*", names));
-		assertEquals("_fooBar", EntityGenTools.convertToUniqueJavaStyleClassName("4FOO_BAR", names));
-	}
-
-	public void testConvertToUniqueJavaStyleAttributeName1() {
-		HashSet<String> names = new HashSet<String>();
-		assertEquals("foo", EntityGenTools.convertToUniqueJavaStyleAttributeName("Foo", names));
-		assertEquals("foo", EntityGenTools.convertToUniqueJavaStyleAttributeName("foo", names));
-		assertEquals("foo", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO", names));
-		assertEquals("foo", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_", names));
-		assertEquals("foo", EntityGenTools.convertToUniqueJavaStyleAttributeName("_FOO", names));
-		assertEquals("foo_", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO*", names));
-		assertEquals("_oo", EntityGenTools.convertToUniqueJavaStyleAttributeName("5oo", names));
-	}
-
-	public void testConvertToUniqueJavaStyleAttributeName2() {
-		HashSet<String> names = new HashSet<String>();
-		names.add("Foo");
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("Foo", names));
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("foo", names));
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO", names));
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_", names));
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("_FOO", names));
-		assertEquals("foo_", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO*", names));
-		assertEquals("_oo", EntityGenTools.convertToUniqueJavaStyleAttributeName("5OO", names));
-	}
-
-	public void testConvertToUniqueJavaStyleAttributeName3() {
-		HashSet<String> names = new HashSet<String>();
-		names.add("foo");
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("Foo", names));
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("foo", names));
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO", names));
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_", names));
-		assertEquals("foo2", EntityGenTools.convertToUniqueJavaStyleAttributeName("_FOO", names));
-		assertEquals("foo_", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO*", names));
-		assertEquals("_oo", EntityGenTools.convertToUniqueJavaStyleAttributeName("5OO", names));
-	}
-
-	public void testConvertToUniqueJavaStyleAttributeName4() {
-		HashSet<String> names = new HashSet<String>();
-		assertEquals("fooBar", EntityGenTools.convertToUniqueJavaStyleAttributeName("FooBar", names));
-		assertEquals("foo_bar", EntityGenTools.convertToUniqueJavaStyleAttributeName("foo_bar", names));
-		assertEquals("fooBar", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_BAR", names));
-		assertEquals("fooBar", EntityGenTools.convertToUniqueJavaStyleAttributeName("_FOO_BAR", names));
-		assertEquals("fooBar", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_BAR_", names));
-		assertEquals("fooBar_", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_BAR_*", names));
-		assertEquals("_fooBar", EntityGenTools.convertToUniqueJavaStyleAttributeName("4FOO_BAR", names));
-	}
-
-	public void testConvertToUniqueJavaStyleAttributeName5() {
-		HashSet<String> names = new HashSet<String>();
-		names.add("FooBar");
-		assertEquals("fooBar2", EntityGenTools.convertToUniqueJavaStyleAttributeName("FooBar", names));
-		assertEquals("foo_bar", EntityGenTools.convertToUniqueJavaStyleAttributeName("foo_bar", names));
-		assertEquals("fooBar2", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_BAR", names));
-		assertEquals("fooBar2", EntityGenTools.convertToUniqueJavaStyleAttributeName("_FOO_BAR", names));
-		assertEquals("fooBar2", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_BAR_", names));
-		assertEquals("fooBar_", EntityGenTools.convertToUniqueJavaStyleAttributeName("FOO_BAR_*", names));
-		assertEquals("_fooBar", EntityGenTools.convertToUniqueJavaStyleAttributeName("4FOO_BAR", names));
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/src/org/eclipse/jpt/gen/tests/internal/JptGenTests.java b/jpa/tests/org.eclipse.jpt.gen.tests/src/org/eclipse/jpt/gen/tests/internal/JptGenTests.java
deleted file mode 100644
index 1e79d7d..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/src/org/eclipse/jpt/gen/tests/internal/JptGenTests.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.gen.tests.internal;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import org.eclipse.jpt.gen.tests.internal.EntityGenToolsTests;
-
-/**
- * 
- */
-public class JptGenTests {
-
-	public static Test suite() {
-		TestSuite suite = new TestSuite("JPT Entity Generation Tests"); //$NON-NLS-1$
-		suite.addTestSuite(EntityGenToolsTests.class);
-		return suite;
-	}
-
-	private JptGenTests() {
-		super();
-		throw new UnsupportedOperationException();
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.gen.tests/test.xml b/jpa/tests/org.eclipse.jpt.gen.tests/test.xml
deleted file mode 100644
index 2b842d9..0000000
--- a/jpa/tests/org.eclipse.jpt.gen.tests/test.xml
+++ /dev/null
@@ -1,49 +0,0 @@
-<?xml version="1.0"?>
-<!--
-  Copyright (c) 2008, 2010 Oracle. 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:
-    Oracle - initial API and implementation
- -->
-<project name="testsuite" default="run" basedir=".">
-	<!-- The property ${eclipse-home} should be passed into this script -->
-	<!-- Set a meaningful default value for when it is not. -->
-	<echo message="basedir ${basedir}" />
-	<echo message="eclipse place ${eclipse-home}" />
-	<!-- sets the properties plugin-name -->
-	<property name="plugin-name" value="org.eclipse.jpt.gen.tests"/>
-
-	<!-- This target holds all initialization code that needs to be done for -->
-	<!-- all tests that are to be run. Initialization for individual tests -->
-	<!-- should be done within the body of the suite target. -->
-	<target name="init">
-		<tstamp/>
-		<delete>
-			<fileset dir="${eclipse-home}" includes="org*.xml"/>
-		</delete>
-	</target>
-
-	<!-- This target defines the tests that need to be run. -->
-	<target name="suite">
-		<ant target="gen-test" antfile="${library-file}" dir="${eclipse-home}">
-			<property name="plugin-name" value="${plugin-name}"/>
-			<property name="classname" value="org.eclipse.jpt.gen.tests.internal.JptGenTests" />
-			<property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/>
-			<property name="extraVMargs" value=""/>
-		</ant>
-	</target>
-
-	<!-- This target holds code to cleanup the testing environment after -->
-	<!-- after all of the tests have been run. You can use this target to -->
-	<!-- delete temporary files that have been created. -->
-	<target name="cleanup">
-	</target>
-
-	<!-- This target runs the test suite. Any actions that need to happen -->
-	<!-- after all the tests have been run should go here. -->
-	<target name="run" depends="init, suite, cleanup">
-	</target>
-</project>
\ No newline at end of file
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/.classpath b/jpa/tests/org.eclipse.jpt.ui.tests/.classpath
deleted file mode 100644
index 382639e..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/.classpath
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">
-		<accessrules>
-			<accessrule kind="accessible" pattern="org/eclipse/jpt/ui/**"/>
-			<accessrule kind="accessible" pattern="org/eclipse/jpt/core/**"/>
-			<accessrule kind="accessible" pattern="org/eclipse/jpt/utility/**"/>
-		</accessrules>
-	</classpathentry>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/.project b/jpa/tests/org.eclipse.jpt.ui.tests/.project
deleted file mode 100644
index 0240774..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jpt.ui.tests</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.ManifestBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.pde.SchemaBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.PluginNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/.settings/org.eclipse.core.resources.prefs b/jpa/tests/org.eclipse.jpt.ui.tests/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index d364a0f..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Mon Apr 07 14:27:16 EDT 2008
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/.settings/org.eclipse.jdt.core.prefs b/jpa/tests/org.eclipse.jpt.ui.tests/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index d909c10..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,7 +0,0 @@
-#Sun May 27 14:55:01 EDT 2007
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/META-INF/MANIFEST.MF b/jpa/tests/org.eclipse.jpt.ui.tests/META-INF/MANIFEST.MF
deleted file mode 100644
index 8a2119e..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,26 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-Vendor: %providerName
-Bundle-SymbolicName: org.eclipse.jpt.ui.tests
-Bundle-Version: 1.0.1
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Require-Bundle: 
- org.junit;bundle-version="4.3.1",
- org.eclipse.core.resources,
- org.eclipse.core.runtime,
- org.eclipse.jface,
- org.eclipse.jpt.core.tests,
- org.eclipse.jpt.core.tests.extension.resource,
- org.eclipse.jpt.utility,
- org.eclipse.jpt.core,
- org.eclipse.jpt.ui,
- org.eclipse.ui.navigator;bundle-version="3.4.0",
- org.eclipse.ui.forms;bundle-version="3.3.100",
- org.eclipse.ui.workbench;bundle-version="3.4.0"
-Export-Package: org.eclipse.jpt.ui.tests;x-internal:=true,
- org.eclipse.jpt.ui.tests.internal.jface;x-internal:=true,
- org.eclipse.jpt.ui.tests.internal.platform;x-internal:=true,
- org.eclipse.jpt.ui.tests.internal.swt;x-internal:=true,
- org.eclipse.jpt.ui.tests.internal.util;x-internal:=true,
- org.eclipse.jpt.ui.tests.internal.utility.swt;x-internal:=true
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/build.properties b/jpa/tests/org.eclipse.jpt.ui.tests/build.properties
deleted file mode 100644
index 50f0aa3..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-################################################################################
-# Copyright (c) 2007, 2010 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-source.. = src/
-output.. = bin/
-bin.includes = META-INF/,\
-               .
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/plugin.properties b/jpa/tests/org.eclipse.jpt.ui.tests/plugin.properties
deleted file mode 100644
index cd93615..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/plugin.properties
+++ /dev/null
@@ -1,23 +0,0 @@
-################################################################################
-# Copyright (c) 2006, 2007 Oracle. 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:
-#     Oracle - initial API and implementation
-################################################################################
-# ====================================================================
-# To code developer:
-#   Do NOT change the properties between this line and the
-#   "%%% END OF TRANSLATED PROPERTIES %%%" line.
-#   Make a new property name, append to the end of the file and change
-#   the code to use the new property.
-# ====================================================================
-
-# ====================================================================
-# %%% END OF TRANSLATED PROPERTIES %%%
-# ====================================================================
-
-pluginName=Java Persistence API UI Tests
-providerName=Eclipse.org
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/JptUiTests.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/JptUiTests.java
deleted file mode 100644
index 310abb7..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/JptUiTests.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import org.eclipse.jpt.ui.tests.internal.platform.JptUiPlatformTests;
-import org.eclipse.jpt.ui.tests.internal.swt.JptUiSWTTests;
-import org.eclipse.jpt.ui.tests.internal.util.JptUiUtilTests;
-
-/**
- * Runs all JPT UI Tests
- */
-public class JptUiTests {
-
-	public static Test suite() {
-		TestSuite suite = new TestSuite(JptUiTests.class.getPackage().getName());
-		suite.addTest(JptUiPlatformTests.suite());
-		suite.addTest(JptUiSWTTests.suite());
-		suite.addTest(JptUiUtilTests.suite());
-		return suite;
-	}
-
-	private JptUiTests() {
-		super();
-		throw new UnsupportedOperationException();
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/jface/DelegatingLabelProviderUiTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/jface/DelegatingLabelProviderUiTest.java
deleted file mode 100644
index 47e8fc2..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/jface/DelegatingLabelProviderUiTest.java
+++ /dev/null
@@ -1,602 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.jface;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.viewers.ArrayContentProvider;
-import org.eclipse.jface.viewers.BaseLabelProvider;
-import org.eclipse.jface.viewers.ComboViewer;
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.viewers.ISelectionChangedListener;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.viewers.SelectionChangedEvent;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jpt.ui.internal.jface.AbstractItemLabelProvider;
-import org.eclipse.jpt.ui.internal.jface.AbstractTreeItemContentProvider;
-import org.eclipse.jpt.ui.internal.jface.DelegatingTreeContentAndLabelProvider;
-import org.eclipse.jpt.ui.jface.DelegatingContentAndLabelProvider;
-import org.eclipse.jpt.ui.jface.ItemLabelProvider;
-import org.eclipse.jpt.ui.jface.ItemLabelProviderFactory;
-import org.eclipse.jpt.ui.jface.TreeItemContentProvider;
-import org.eclipse.jpt.ui.jface.TreeItemContentProviderFactory;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.NullCollectionValueModel;
-import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.internal.model.value.StaticCollectionValueModel;
-import org.eclipse.jpt.utility.internal.model.value.StaticPropertyValueModel;
-import org.eclipse.jpt.utility.model.event.PropertyChangeEvent;
-import org.eclipse.jpt.utility.model.listener.PropertyChangeListener;
-import org.eclipse.jpt.utility.model.value.CollectionValueModel;
-import org.eclipse.jpt.utility.model.value.PropertyValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionAdapter;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.graphics.ImageData;
-import org.eclipse.swt.graphics.PaletteData;
-import org.eclipse.swt.graphics.RGB;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Shell;
-
-public class DelegatingLabelProviderUiTest extends ApplicationWindow
-{
-	private TreeViewer tree;
-	
-	private WritablePropertyValueModel<Vehicle> selectedVehicle;
-	
-	
-	public static void main(String[] args) {
-		Window window = new DelegatingLabelProviderUiTest(args);
-		window.setBlockOnOpen(true);
-		window.open();
-		Display.getCurrent().dispose();
-		System.exit(0);
-	}
-	
-	
-	private DelegatingLabelProviderUiTest(String[] args) {
-		super(null);
-		this.selectedVehicle = new SimplePropertyValueModel<Vehicle>();
-	}
-	
-	
-	@Override
-	protected Control createContents(Composite parent) {
-		((Shell) parent).setText(this.getClass().getSimpleName());
-		parent.setSize(400, 400);
-		parent.setLayout(new GridLayout());
-		Composite mainPanel = new Composite(parent, SWT.NONE);
-		mainPanel.setLayoutData(new GridData(GridData.FILL_BOTH));
-		mainPanel.setLayout(new GridLayout());
-		buildTreePanel(mainPanel);
-		buildControlPanel(mainPanel);
-		return mainPanel;
-	}
-	
-	private void buildTreePanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayoutData(new GridData(GridData.FILL_BOTH));
-		panel.setLayout(new GridLayout());
-		
-		Label label = new Label(panel, SWT.NONE);
-		label.setLayoutData(new GridData(GridData.BEGINNING, GridData.CENTER, false, false));
-		label.setText("My Vehicles");
-		
-		tree = new TreeViewer(panel, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
-		tree.getTree().setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));
-		DelegatingContentAndLabelProvider contentAndLabelProvider = 
-			new DelegatingTreeContentAndLabelProvider(
-				new VehicleContentProviderFactory(),
-				new VehicleLabelProviderFactory());
-		tree.setContentProvider(contentAndLabelProvider);
-		tree.setLabelProvider(contentAndLabelProvider);
-		tree.setInput(new Root());
-		tree.addSelectionChangedListener(buildTreeSelectionChangedListener());
-	}
-	
-	private ISelectionChangedListener buildTreeSelectionChangedListener() {
-		return new ISelectionChangedListener() {
-			public void selectionChanged(SelectionChangedEvent event) {
-				selectedVehicle.setValue((Vehicle) ((IStructuredSelection) event.getSelection()).getFirstElement());
-			}
-		};
-	}
-	
-	private void buildControlPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
-		panel.setLayout(new GridLayout());
-		buildUpperControlPanel(panel);
-		buildLowerControlPanel(panel);
-	}
-	
-	private void buildUpperControlPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
-		panel.setLayout(new GridLayout(2, true));
-		buildVehicleCombo(panel);
-		buildColorCombo(panel);
-	}
-	
-	private void buildVehicleCombo(Composite parent) {
-		final ComboViewer combo = new ComboViewer(parent, SWT.READ_ONLY);
-		combo.getCombo().setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
-		combo.setContentProvider(new ArrayContentProvider());
-		combo.setLabelProvider(new VehicleTypeLabelProvider());
-		combo.setInput(
-			new VehicleType[] {
-				VehicleType.BICYCLE, VehicleType.CAR, 
-				VehicleType.TRUCK, VehicleType.BOAT
-			});
-		combo.getCombo().setEnabled(false);
-		combo.addSelectionChangedListener(
-			new ISelectionChangedListener() {
-				public void selectionChanged(SelectionChangedEvent event) {
-					selectedVehicle().setVehicleType((VehicleType) ((StructuredSelection) event.getSelection()).getFirstElement()); 
-				}
-			});
-		selectedVehicle.addPropertyChangeListener(
-			PropertyValueModel.VALUE, 
-			new PropertyChangeListener() {
-				public void propertyChanged(PropertyChangeEvent event) {
-					Vehicle vehicle = selectedVehicle();
-					combo.getCombo().setEnabled(vehicle != null);
-					combo.setSelection(new StructuredSelection((vehicle == null) ? null : vehicle.vehicleType()));
-				}
-			});
-	}
-	
-	private void buildColorCombo(Composite parent) {
-		final ComboViewer combo = new ComboViewer(parent, SWT.READ_ONLY);
-		combo.getCombo().setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
-		combo.setContentProvider(new ArrayContentProvider());
-		combo.setLabelProvider(new ColorLabelProvider());
-		combo.setInput(new Color[] {Color.RED, Color.BLUE, Color.YELLOW, Color.GREEN});
-		combo.addSelectionChangedListener(
-			new ISelectionChangedListener() {
-				public void selectionChanged(SelectionChangedEvent event) {
-					selectedVehicle().setColor((Color) ((StructuredSelection) event.getSelection()).getFirstElement()); 
-				}
-			});
-		selectedVehicle.addPropertyChangeListener(
-			PropertyValueModel.VALUE, 
-			new PropertyChangeListener() {
-				public void propertyChanged(PropertyChangeEvent event) {
-					Vehicle vehicle = selectedVehicle();
-					combo.getCombo().setEnabled(vehicle != null);
-					combo.setSelection(new StructuredSelection((vehicle == null) ? null : vehicle.color()));
-				}
-			});
-	}
-	
-	private void buildLowerControlPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
-		panel.setLayout(new GridLayout(3, false));
-		buildEffectsLabel(panel);
-		buildGreyedCheckBox(panel);
-		buildTranslucentCheckBox(panel);
-		buildActionPanel(panel);
-	}
-	
-	private void buildEffectsLabel(Composite parent) {
-		Label label = new Label(parent, SWT.LEFT);
-		label.setText("Color effects: ");
-		label.setLayoutData(new GridData(GridData.BEGINNING, GridData.CENTER, false, false, 3, 1));
-	}
-	
-	private void buildGreyedCheckBox(Composite parent) {
-		final Button button = new Button(parent, SWT.CHECK);
-		button.setLayoutData(new GridData(GridData.BEGINNING, GridData.CENTER, false, false));
-		button.setText("greyed");
-		button.setEnabled(false);
-		button.addSelectionListener(
-			new SelectionAdapter() {
-				@Override
-				public void widgetSelected(SelectionEvent e) {
-					selectedVehicle().setGreyed(button.getSelection());
-				}
-			});
-		selectedVehicle.addPropertyChangeListener(
-			PropertyValueModel.VALUE, 
-			new PropertyChangeListener() {
-				public void propertyChanged(PropertyChangeEvent event) {
-					Vehicle vehicle = selectedVehicle();
-					button.setEnabled(vehicle != null);
-					button.setSelection(vehicle != null && vehicle.isGreyed());
-				}
-			});
-	}
-	
-	private void buildTranslucentCheckBox(Composite parent) {
-		final Button button = new Button(parent, SWT.CHECK);
-		button.setLayoutData(new GridData(GridData.BEGINNING, GridData.CENTER, true, false));
-		button.setText("translucent");
-		button.setEnabled(false);
-		button.addSelectionListener(
-			new SelectionAdapter() {
-				@Override
-				public void widgetSelected(SelectionEvent e) {
-					selectedVehicle().setTranslucent(button.getSelection());
-				}
-			});
-		selectedVehicle.addPropertyChangeListener(
-			PropertyValueModel.VALUE, 
-			new PropertyChangeListener() {
-				public void propertyChanged(PropertyChangeEvent event) {
-					Vehicle vehicle = selectedVehicle();
-					button.setEnabled(vehicle != null);
-					button.setSelection(vehicle != null && vehicle.isTranslucent());
-				}
-			});
-	}
-	
-	private void buildActionPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayoutData(new GridData(GridData.END, GridData.FILL, false, false));
-		panel.setLayout(new GridLayout());
-		buildRefreshTreeACI().fill(panel);
-	}
-	
-	private ActionContributionItem buildRefreshTreeACI() {
-		Action action = new Action("Refresh tree", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				refreshTree();
-			}
-		};
-		action.setToolTipText("Refresh the tree's labels");
-		return new ActionContributionItem(action);
-	}
-	
-	void refreshTree() {
-		tree.refresh();
-	}
-	
-	private Vehicle selectedVehicle() {
-		return selectedVehicle.getValue();
-	}
-	
-	
-	private static class VehicleTypeLabelProvider extends BaseLabelProvider
-		implements ILabelProvider
-	{
-		public Image getImage(Object element) {
-			return null;
-		}
-		
-		public String getText(Object element) {
-			return ((VehicleType) element).description();
-		}
-	}
-	
-	
-	private static class ColorLabelProvider extends BaseLabelProvider
-		implements ILabelProvider
-	{
-		public Image getImage(Object element) {
-			return null;
-		}
-		
-		public String getText(Object element) {
-			return ((Color) element).description();
-		}
-	}
-	
-	
-	private static class VehicleContentProviderFactory
-		implements TreeItemContentProviderFactory
-	{
-		public TreeItemContentProvider buildItemContentProvider(Object item, DelegatingContentAndLabelProvider contentAndLabelProvider) {
-			if (item instanceof Root) {
-				return new RootContentProvider(
-					(Root) item, (DelegatingTreeContentAndLabelProvider) contentAndLabelProvider);
-			}
-			return new VehicleContentProvider(
-				(Vehicle) item, (DelegatingTreeContentAndLabelProvider) contentAndLabelProvider);
-		}
-	}
-	
-	
-	private static class RootContentProvider extends AbstractTreeItemContentProvider<Vehicle>
-	{
-		public RootContentProvider(Root item, DelegatingTreeContentAndLabelProvider contentAndLabelProvider) {
-			super(item, contentAndLabelProvider);
-		}
-		
-		@Override
-		public Root getModel() {
-			return (Root) super.getModel();
-		}
-		
-		@Override
-		public Object getParent() {
-			return null;
-		}
-		
-		@Override
-		protected CollectionValueModel<Vehicle> buildChildrenModel() {
-			return new StaticCollectionValueModel<Vehicle>(this.getModel().vehicles());
-		}
-	}
-	
-	@SuppressWarnings("unchecked")
-	private static class VehicleContentProvider extends AbstractTreeItemContentProvider
-	{
-		public VehicleContentProvider(Vehicle item, DelegatingTreeContentAndLabelProvider contentAndLabelProvider) {
-			super(item, contentAndLabelProvider);
-		}
-		
-		@Override
-		public Vehicle getModel() {
-			return (Vehicle) super.getModel();
-		}
-		
-		@Override
-		public Object getParent() {
-			return getModel().parent();
-		}
-		
-		@Override
-		protected CollectionValueModel buildChildrenModel() {
-			return new NullCollectionValueModel();
-		}
-	}
-	
-	
-	private static class VehicleLabelProviderFactory
-		implements ItemLabelProviderFactory
-	{
-		public ItemLabelProvider buildItemLabelProvider(Object element, DelegatingContentAndLabelProvider labelProvider) {
-			return new VehicleLabelProvider((Vehicle) element, labelProvider);
-		}
-	}
-	
-	
-	private static class VehicleLabelProvider extends AbstractItemLabelProvider
-	{
-		public VehicleLabelProvider(Vehicle vehicle, DelegatingContentAndLabelProvider labelProvider) {
-			super(vehicle, labelProvider);
-		}
-		
-		@Override
-		protected PropertyValueModel<Image> buildImageModel() {
-			return new PropertyAspectAdapter<Vehicle, Image>(
-					new StaticPropertyValueModel<Vehicle>((Vehicle) model()), 
-					Vehicle.COLOR_PROPERTY, Vehicle.GREYED_PROPERTY, Vehicle.TRANSLUCENT_PROPERTY) {
-				@Override
-				protected Image buildValue_() {
-					return subject.image();
-				}
-			};
-		}
-		
-		@Override
-		protected PropertyValueModel<String> buildTextModel() {
-			return new PropertyAspectAdapter<Vehicle, String>(
-					new StaticPropertyValueModel<Vehicle>((Vehicle) model()), 
-					Vehicle.VEHICLE_TYPE_PROPERTY, Vehicle.COLOR_PROPERTY) {
-				@Override
-				protected String buildValue_() {
-					return subject.color().description() + ' ' + subject.vehicleType().description();
-				}
-			};
-		}
-		
-		@Override
-		protected PropertyValueModel<String> buildDescriptionModel() {
-			return buildTextModel();
-		}
-	}
-	
-	
-	private static abstract class TreeNode extends AbstractModel
-	{
-		private TreeNode parent;
-		
-		
-		public TreeNode(TreeNode parent) {
-			this.parent = parent;
-		}
-		
-		
-		public TreeNode parent() {
-			return parent;
-		}
-	}
-	
-	
-	private static class Root extends TreeNode
-	{
-		protected final Vehicle[] vehicles;
-		
-		
-		public Root() {
-			super(null);
-			vehicles = new Vehicle[] {
-				new Vehicle(this, VehicleType.BICYCLE, Color.BLUE),
-				new Vehicle(this, VehicleType.CAR, Color.YELLOW),
-				new Vehicle(this, VehicleType.TRUCK, Color.RED),
-				new Vehicle(this, VehicleType.BOAT, Color.GREEN)};
-		}
-		
-		public Vehicle[] vehicles() {
-			return vehicles;
-		}
-	}
-	
-	
-	private static class Vehicle extends TreeNode
-	{
-		private VehicleType vehicleType;
-		public final static String VEHICLE_TYPE_PROPERTY = "vehicleType";
-		
-		private Color color;
-		public final static String COLOR_PROPERTY = "color";
-		
-		private boolean greyed = false;
-		public final static String GREYED_PROPERTY = "greyed";
-		
-		private boolean translucent = false;
-		public final static String TRANSLUCENT_PROPERTY = "translucent";
-		
-		private Image image;
-		
-			
-		public Vehicle(TreeNode parent, VehicleType vehicleType, Color color) {
-			super(parent);
-			this.vehicleType = vehicleType;
-			this.color = color;
-		}
-		
-		public VehicleType vehicleType() {
-			return vehicleType;
-		}
-		
-		public void setVehicleType(VehicleType newVehicleType) {
-			VehicleType oldVehicleType = vehicleType;
-			vehicleType = newVehicleType;
-			firePropertyChanged(VEHICLE_TYPE_PROPERTY, oldVehicleType, newVehicleType);
-		}
-		
-		public Color color() {
-			return color;
-		}
-		
-		public void setColor(Color newColor) {
-			Color oldColor = color;
-			color = newColor;
-			firePropertyChanged(COLOR_PROPERTY, oldColor, newColor);
-		}
-		
-		public boolean isGreyed() {
-			return greyed;
-		}
-		
-		public void setGreyed(boolean newGreyed) {
-			boolean oldGreyed = greyed;
-			greyed = newGreyed;
-			firePropertyChanged(GREYED_PROPERTY, oldGreyed, newGreyed);
-		}
-		
-		public boolean isTranslucent() {
-			return translucent;
-		}
-		
-		public void setTranslucent(boolean newTranslucent) {
-			boolean oldTranslucent = translucent;
-			translucent = newTranslucent;
-			firePropertyChanged(TRANSLUCENT_PROPERTY, oldTranslucent, newTranslucent);
-		}
-		
-		public Image image() {
-			if (image != null) {
-				image.dispose();
-			}
-			
-			return ImageFactory.image(color(), greyed, translucent);
-		}
-	}
-	
-	
-	private static enum VehicleType
-	{
-		BICYCLE("bicycle"),
-		CAR("car"),
-		TRUCK("truck"),
-		BOAT("boat");
-		
-		private final String description;
-		
-		private VehicleType(String description) {
-			this.description = description;
-		}
-		
-		public String description() {
-			return description;
-		}
-		
-		@Override
-		public String toString() {
-			return description();
-		}
-	}
-	
-	
-	private static enum Color
-	{
-		RED("red", new RGB(255, 0, 0)),
-		BLUE("blue", new RGB(0, 0, 255)),
-		YELLOW("yellow", new RGB(255, 255, 0)),
-		GREEN("green", new RGB(0, 255, 0));
-		
-		private final String description;
-		
-		private final RGB rgb;
-		
-		private Color(String description, RGB rgb) {
-			this.description = description;
-			this.rgb = rgb;
-		}
-		
-		public String description() {
-			return description;
-		}
-		
-		public RGB rgb() {
-			return rgb;
-		}
-		
-		@Override
-		public String toString() {
-			return description();
-		}
-	}
-	
-	
-	private static class ImageFactory
-	{
-		private static RGB rgb(Color color, boolean greyed, boolean translucent) {
-			RGB rgb = (greyed) ? new RGB(127, 127, 127) : color.rgb();
-			if (translucent) {
-				rgb = new RGB(translucify(rgb.red), translucify(rgb.green), translucify(rgb.blue));
-			}
-			return rgb;
-		}
-		
-		private static int translucify(int color) {
-			return 255 - (int) ((255 - color) * 0.3);
-		}
-		
-		public static Image image(Color color, boolean greyed, boolean translucent) {
-			PaletteData pd = new PaletteData(new RGB[] {rgb(color, greyed, translucent)});
-			ImageData id = new ImageData(20, 20, 1, pd);
-			for (int x = 0; x < 20; x ++) {
-				for (int y = 0; y < 20; y ++) {
-					id.setPixel(x, y, 0);
-				}
-			}
-			return new Image(Display.getCurrent(), id);
-		}
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/jface/DelegatingTreeContentProviderUiTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/jface/DelegatingTreeContentProviderUiTest.java
deleted file mode 100644
index 96460f5..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/jface/DelegatingTreeContentProviderUiTest.java
+++ /dev/null
@@ -1,566 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.jface;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.viewers.BaseLabelProvider;
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.viewers.ISelectionChangedListener;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.viewers.ITreeContentProvider;
-import org.eclipse.jface.viewers.SelectionChangedEvent;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jpt.ui.internal.jface.AbstractTreeItemContentProvider;
-import org.eclipse.jpt.ui.internal.jface.DelegatingTreeContentAndLabelProvider;
-import org.eclipse.jpt.ui.jface.DelegatingContentAndLabelProvider;
-import org.eclipse.jpt.ui.jface.TreeItemContentProvider;
-import org.eclipse.jpt.ui.jface.TreeItemContentProviderFactory;
-import org.eclipse.jpt.utility.internal.CollectionTools;
-import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
-import org.eclipse.jpt.utility.internal.iterators.ReadOnlyListIterator;
-import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.CompositeCollectionValueModel;
-import org.eclipse.jpt.utility.internal.model.value.ListAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.ListCollectionValueModelAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.internal.model.value.StaticCollectionValueModel;
-import org.eclipse.jpt.utility.model.event.PropertyChangeEvent;
-import org.eclipse.jpt.utility.model.listener.PropertyChangeListener;
-import org.eclipse.jpt.utility.model.value.CollectionValueModel;
-import org.eclipse.jpt.utility.model.value.PropertyValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.Text;
-
-@SuppressWarnings("nls")
-public class DelegatingTreeContentProviderUiTest extends ApplicationWindow
-{
-	private final Root root;
-
-	private WritablePropertyValueModel<TreeNode> selectedNode;
-
-	private TreeViewer controlTree;
-
-	private TreeViewer viewTree;
-
-	private Text nodeNameText;
-
-
-	public static void main(String[] args) {
-		Window window = new DelegatingTreeContentProviderUiTest(args);
-		window.setBlockOnOpen(true);
-		window.open();
-		Display.getCurrent().dispose();
-		System.exit(0);
-	}
-
-	private DelegatingTreeContentProviderUiTest(String[] args) {
-		super(null);
-		this.root = new Root();
-		this.root.addChild("Parent_1");
-		this.selectedNode = new SimplePropertyValueModel<TreeNode>(this.root);
-	}
-
-	@Override
-	protected Control createContents(Composite parent) {
-		((Shell) parent).setText(this.getClass().getSimpleName());
-		parent.setSize(800, 400);
-		parent.setLayout(new GridLayout());
-		Composite mainPanel = new Composite(parent, SWT.NONE);
-		mainPanel.setLayoutData(new GridData(GridData.FILL_BOTH));
-		mainPanel.setLayout(new GridLayout());
-		buildTreePanel(mainPanel);
-		buildControlPanel(mainPanel);
-		return mainPanel;
-	}
-
-	private void buildTreePanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayoutData(new GridData(GridData.FILL_BOTH));
-		panel.setLayout(new GridLayout(2, true));
-		buildControlTreePanel(panel);
-		buildViewTreePanel(panel);
-	}
-
-	private void buildControlTreePanel(Composite parent) {
-		controlTree = buildTreePanel(
-				parent, "Control tree",
-				new DelegatingTreeContentAndLabelProvider(new ControlTreeItemContentProviderFactory()),
-				new LabelProvider());
-		controlTree.addSelectionChangedListener(buildTreeSelectionChangedListener());
-		selectedNode.addPropertyChangeListener(
-				PropertyValueModel.VALUE,
-				new PropertyChangeListener() {
-					public void propertyChanged(PropertyChangeEvent event) {
-						controlTree.setSelection(new StructuredSelection(event.getNewValue()));
-					}
-				}
-			);
-	}
-
-	private void buildViewTreePanel(Composite parent) {
-		viewTree = buildTreePanel(
-				parent, "View tree",
-				new DelegatingTreeContentAndLabelProvider(new ViewTreeItemContentProviderFactory()),
-				new LabelProvider());
-	}
-
-	private TreeViewer buildTreePanel(Composite parent, String labelText, ITreeContentProvider contentProvider, ILabelProvider labelProvider) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayoutData(new GridData(GridData.FILL_BOTH));
-		panel.setLayout(new GridLayout());
-
-		Label label = new Label(panel, SWT.LEFT);
-		label.setLayoutData(new GridData(GridData.BEGINNING, GridData.CENTER, false, false));
-		label.setText(labelText);
-
-		final TreeViewer tree = new TreeViewer(panel, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
-		tree.getTree().setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));
-		tree.setContentProvider(contentProvider);
-		tree.setLabelProvider(labelProvider);
-		tree.setInput(root);
-
-		return tree;
-	}
-
-	private ISelectionChangedListener buildTreeSelectionChangedListener() {
-		return new ISelectionChangedListener() {
-			public void selectionChanged(SelectionChangedEvent event) {
-				TreeNode selection = (TreeNode) ((IStructuredSelection) event.getSelection()).getFirstElement();
-				selectedNode.setValue((selection == null) ? root : selection);
-			}
-		};
-	}
-
-	private void buildControlPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));
-		panel.setLayout(new GridLayout(6, false));
-		buildNodeNameText(panel);
-		buildAddChildACI().fill(panel);
-		buildAddNestedChildACI().fill(panel);
-		buildRemoveACI().fill(panel);
-		buildClearModelACI().fill(panel);
-		buildRestoreModelACI().fill(panel);
-	}
-
-	private void buildNodeNameText(Composite parent) {
-		nodeNameText = new Text(parent, SWT.SINGLE | SWT.BORDER);
-		nodeNameText.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
-	}
-
-	private ActionContributionItem buildAddChildACI() {
-		final Action action = new Action("Add child", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				addChild();
-			}
-		};
-		action.setToolTipText("Add a child with the given name");
-		selectedNode.addPropertyChangeListener(
-				PropertyValueModel.VALUE,
-				new PropertyChangeListener() {
-					public void propertyChanged(PropertyChangeEvent event) {
-						action.setEnabled(((TreeNode) event.getNewValue()).canHaveChildren());
-					}
-				}
-			);
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildAddNestedChildACI() {
-		final Action action = new Action("Add nested child", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				addNestedChild();
-			}
-		};
-		action.setToolTipText("Add a nested child with the given name");
-		action.setEnabled(false);
-		selectedNode.addPropertyChangeListener(
-				PropertyValueModel.VALUE,
-				new PropertyChangeListener() {
-					public void propertyChanged(PropertyChangeEvent event) {
-						action.setEnabled(((TreeNode) event.getNewValue()).canHaveNestedChildren());
-					}
-				}
-			);
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildRemoveACI() {
-		final Action action = new Action("Remove", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				remove();
-			}
-		};
-		action.setToolTipText("Remove the selected node");
-		action.setEnabled(false);
-		selectedNode.addPropertyChangeListener(
-				PropertyValueModel.VALUE,
-				new PropertyChangeListener() {
-					public void propertyChanged(PropertyChangeEvent event) {
-						action.setEnabled(event.getNewValue() != root);
-					}
-				}
-			);
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildClearModelACI() {
-		Action action = new Action("Clear model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				clearModel();
-			}
-		};
-		action.setToolTipText("Clear the model");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildRestoreModelACI() {
-		Action action = new Action("Restore model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				restoreModel();
-			}
-		};
-		action.setToolTipText("Restore the model");
-		return new ActionContributionItem(action);
-	}
-
-	void addChild() {
-		String nodeName = nodeNameText.getText();
-		if (nodeName.length() != 0) {
-			selectedNode.getValue().addChild(nodeName);
-		}
-	}
-
-	void addNestedChild() {
-		String nodeName = nodeNameText.getText();
-		if (nodeName.length() != 0) {
-			selectedNode.getValue().addNestedChild(nodeName);
-		}
-	}
-
-	void remove() {
-		TreeNode node = selectedNode.getValue();
-		node.parent().removeChild(node);
-	}
-
-	void clearModel() {
-		controlTree.setInput(null);
-		viewTree.setInput(null);
-	}
-
-	void restoreModel() {
-		controlTree.setInput(root);
-		viewTree.setInput(root);
-	}
-
-
-	static abstract class AbstractTreeItemContentProviderFactory
-		implements TreeItemContentProviderFactory
-	{
-		public TreeItemContentProvider buildItemContentProvider(
-			Object item, DelegatingContentAndLabelProvider contentAndLabelProvider) {
-			return new GenericTreeItemContentProvider(
-				(TreeNode) item, (DelegatingTreeContentAndLabelProvider) contentAndLabelProvider);
-		}
-	}
-
-
-	static class ControlTreeItemContentProviderFactory extends AbstractTreeItemContentProviderFactory
-	{
-
-	}
-
-
-	static class ViewTreeItemContentProviderFactory
-		extends AbstractTreeItemContentProviderFactory
-	{
-		@Override
-		public TreeItemContentProvider buildItemContentProvider(
-				Object item, DelegatingContentAndLabelProvider contentAndLabelProvider) {
-			if (item instanceof Parent) {
-				return new ViewTreeParentItemContentProvider(
-						(Parent) item, (DelegatingTreeContentAndLabelProvider) contentAndLabelProvider);
-			}
-			return super.buildItemContentProvider(item, contentAndLabelProvider);
-		}
-	}
-
-
-	static class GenericTreeItemContentProvider extends AbstractTreeItemContentProvider<TreeNode>
-	{
-		public GenericTreeItemContentProvider(
-				TreeNode treeNode, DelegatingTreeContentAndLabelProvider treeContentAndLabelProvider) {
-			super(treeNode, treeContentAndLabelProvider);
-		}
-
-		protected TreeNode treeNode() {
-			return (TreeNode) getModel();
-		}
-
-		@Override
-		public TreeNode getParent() {
-			return treeNode().parent();
-		}
-
-		@Override
-		protected CollectionValueModel<TreeNode> buildChildrenModel() {
-			return new ListCollectionValueModelAdapter<TreeNode>(
-			new ListAspectAdapter<TreeNode, TreeNode>(TreeNode.CHILDREN_LIST, treeNode()) {
-				@Override
-				protected ListIterator<TreeNode> listIterator_() {
-					return treeNode().children();
-				}
-			});
-		}
-	}
-
-	static class ViewTreeParentItemContentProvider extends GenericTreeItemContentProvider
-	{
-		public ViewTreeParentItemContentProvider(
-				TreeNode treeNode, DelegatingTreeContentAndLabelProvider treeContentAndLabelProvider) {
-			super(treeNode, treeContentAndLabelProvider);
-		}
-
-		@Override
-		public TreeNode getParent() {
-			TreeNode parent = super.getParent();
-			if (parent instanceof Nest) {
-				parent = parent.parent();
-			}
-			return parent;
-		}
-
-		@Override
-		protected CollectionValueModel<TreeNode> buildChildrenModel() {
-				return new CompositeCollectionValueModel<TreeNode, TreeNode>(super.buildChildrenModel()) {
-						@Override
-						protected CollectionValueModel<TreeNode> transform(TreeNode value) {
-							if (value instanceof Nest) {
-								final Nest nest = (Nest) value;
-								return new ListCollectionValueModelAdapter<TreeNode>(
-										new ListAspectAdapter<TreeNode, TreeNode>(TreeNode.CHILDREN_LIST, nest) {
-											@Override
-											protected ListIterator<TreeNode> listIterator_() {
-												return nest.children();
-											}
-										}
-									);
-							}
-							return new StaticCollectionValueModel<TreeNode>(CollectionTools.collection(value));
-						}
-					};
-		}
-	}
-
-
-	static class LabelProvider extends BaseLabelProvider
-		implements ILabelProvider
-	{
-		public Image getImage(Object element) {
-			return null;
-		}
-
-		public String getText(Object element) {
-			return ((TreeNode) element).getName();
-		}
-	}
-
-
-	static abstract class TreeNode extends AbstractModel
-	{
-		private TreeNode parent;
-
-		protected final List<TreeNode> children;
-		public final static String CHILDREN_LIST = "children";
-
-		protected String name;
-		public final static String NAME_PROPERTY = "name";
-
-
-		public TreeNode(TreeNode parent, String name) {
-			this.parent = parent;
-			this.children = new ArrayList<TreeNode>();
-			this.name = name;
-		}
-
-		public TreeNode parent() {
-			return parent;
-		}
-
-		public ListIterator<TreeNode> children() {
-			return new ReadOnlyListIterator<TreeNode>(children);
-		}
-
-		protected void addChild(TreeNode child) {
-			addItemToList(child, children, CHILDREN_LIST);
-		}
-
-		public void removeChild(TreeNode child) {
-			removeItemFromList(child, children, CHILDREN_LIST);
-		}
-
-		public void removeChild(int index) {
-			removeItemFromList(index, children, CHILDREN_LIST);
-		}
-
-		public String getName() {
-			return name;
-		}
-
-		public void setName(String newName) {
-			String oldName = name;
-			name = newName;
-			firePropertyChanged(NAME_PROPERTY, oldName, newName);
-		}
-
-		public boolean canHaveChildren() {
-			return false;
-		}
-
-		public void addChild(String name) {
-			throw new UnsupportedOperationException();
-		}
-
-		public boolean canHaveNestedChildren() {
-			return false;
-		}
-
-		public void addNestedChild(String name) {
-			throw new UnsupportedOperationException();
-		}
-
-		@Override
-		public void toString(StringBuilder sb) {
-			sb.append(getName());
-		}
-	}
-
-
-	static class Root extends TreeNode
-	{
-		public Root() {
-			super(null, null);
-		}
-
-		@Override
-		public boolean canHaveChildren() {
-			return true;
-		}
-
-		@Override
-		public void addChild(String name) {
-			addChild(new Parent(this, name));
-		}
-	}
-
-
-	static class Parent extends TreeNode
-	{
-		public Parent(TreeNode parent, String name) {
-			super(parent, name);
-		}
-
-		@Override
-		public boolean canHaveChildren() {
-			return true;
-		}
-
-		@Override
-		public void addChild(String name) {
-			addChild(new Child(this, name));
-		}
-
-		@Override
-		public boolean canHaveNestedChildren() {
-			return true;
-		}
-
-		@Override
-		public void addNestedChild(String name) {
-			TreeNode nest = new Nest(this);
-			addChild(nest);
-			nest.addChild(name);
-		}
-
-		public Iterator<Child> nestlessChildren() {
-			return new FilteringIterator<Child>(
-					new TransformationIterator<TreeNode, Child>(children()) {
-						@Override
-						protected Child transform(TreeNode next) {
-							if (next instanceof Nest) {
-								return ((Nest) next).child();
-							}
-							return (Child) next;
-						}
-					}) {
-				@Override
-				protected boolean accept(Child c) {
-					return c != null;
-				}
-			};
-		}
-	}
-
-
-	static class Nest extends TreeNode
-	{
-		public Nest(TreeNode parent) {
-			super(parent, "nest");
-		}
-
-		@Override
-		public boolean canHaveChildren() {
-			return children.size() == 0;
-		}
-
-		@Override
-		public void addChild(String name) {
-			addChild(new Child(this, name));
-		}
-
-		/* can only have one child */
-		public Child child() {
-			return (children.isEmpty()) ? null : (Child) children.get(0);
-		}
-	}
-
-
-	static class Child extends TreeNode
-	{
-		public Child(TreeNode parent, String name) {
-			super(parent, name);
-		}
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/platform/JpaPlatformUiExtensionTests.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/platform/JpaPlatformUiExtensionTests.java
deleted file mode 100644
index 91d7edc..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/platform/JpaPlatformUiExtensionTests.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*******************************************************************************
- *  Copyright (c) 2010  Oracle. 
- *  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: 
- *  	Oracle - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.platform;
-
-import junit.framework.TestCase;
-import org.eclipse.jpt.core.JpaProject;
-import org.eclipse.jpt.core.internal.JpaPlatformRegistry;
-import org.eclipse.jpt.core.tests.extension.resource.ExtensionTestPlugin;
-import org.eclipse.jpt.core.tests.extension.resource.TestJpaPlatformProvider;
-import org.eclipse.jpt.core.tests.internal.projects.TestJpaProject;
-
-@SuppressWarnings("nls")
-public class JpaPlatformUiExtensionTests extends TestCase
-{
-	protected TestJpaProject testProject;
-
-	protected static final String PROJECT_NAME = "ExtensionTestProject";
-	protected static final String PACKAGE_NAME = "extension.test";
-
-	public static final String TEST_PLUGIN_CLASS = ExtensionTestPlugin.class.getName();
-	public static final String TEST_PLUGIN_ID = ExtensionTestPlugin.PLUGIN_ID;
-
-	public static final String TEST_PLATFORM_ID = TestJpaPlatformProvider.ID;
-	public static final String TEST_PLATFORM_CLASS = TestJpaPlatformProvider.class.getName();
-	public static final String TEST_PLATFORM_LABEL = "Test Jpa Platform";
-
-	public static final String TEST_UI_PLATFORM_ID = TEST_PLATFORM_ID;
-
-	public JpaPlatformUiExtensionTests(String name) {
-		super(name);
-	}
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		this.testProject = this.buildJpaProject(PROJECT_NAME, false);  // false = no auto-build
-	}
-
-	protected TestJpaProject buildJpaProject(String projectName, boolean autoBuild) throws Exception {
-		return new TestJpaProject(projectName, autoBuild);  // false = no auto-build
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		this.testProject.getProject().delete(true, true, null);
-		this.testProject = null;
-		super.tearDown();
-	}
-
-	protected JpaProject jpaProject() {
-		return this.testProject.getJpaProject();
-	}
-
-	public void testJpaPlatform() {
-		assertNotNull(JpaPlatformRegistry.instance().getJpaPlatform(this.testProject.getProject()));
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/platform/JptUiPlatformTests.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/platform/JptUiPlatformTests.java
deleted file mode 100644
index 50bcc99..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/platform/JptUiPlatformTests.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.platform;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-public class JptUiPlatformTests
-{
-	public static Test suite() {
-		TestSuite suite = new TestSuite(JptUiPlatformTests.class.getPackage().getName());
-		suite.addTestSuite(JpaPlatformUiExtensionTests.class);
-		return suite;
-	}
-
-	private JptUiPlatformTests() {
-		super();
-		throw new UnsupportedOperationException();
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/AbstractComboModelAdapterTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/AbstractComboModelAdapterTest.java
deleted file mode 100644
index d6d12ea..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/AbstractComboModelAdapterTest.java
+++ /dev/null
@@ -1,773 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.swt;
-
-import static org.junit.Assert.*;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-import org.eclipse.jpt.ui.internal.swt.AbstractComboModelAdapter;
-import org.eclipse.jpt.ui.internal.swt.AbstractComboModelAdapter.SelectionChangeEvent;
-import org.eclipse.jpt.ui.internal.swt.AbstractComboModelAdapter.SelectionChangeListener;
-import org.eclipse.jpt.utility.internal.StringConverter;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.ListAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimpleListValueModel;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.internal.swing.SimpleDisplayable;
-import org.eclipse.jpt.utility.model.value.ListValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public abstract class AbstractComboModelAdapterTest {
-
-	private Model model;
-	private WritablePropertyValueModel<SimpleDisplayable> selectedItemHolder;
-	private Shell shell;
-	private WritablePropertyValueModel<Model> subjectHolder;
-
-	protected abstract AbstractComboModelAdapter<SimpleDisplayable> buildEditableComboModelAdapter();
-
-	protected final ListValueModel<SimpleDisplayable> buildEmptyListHolder() {
-		return new SimpleListValueModel<SimpleDisplayable>();
-	}
-
-	private List<SimpleDisplayable> buildList() {
-		List<SimpleDisplayable> list = new ArrayList<SimpleDisplayable>();
-		populateCollection(list);
-		return list;
-	}
-
-	protected final ListValueModel<SimpleDisplayable> buildListHolder() {
-		return new ListAspectAdapter<Model, SimpleDisplayable>(subjectHolder, Model.ITEMS_LIST) {
-			@Override
-			protected ListIterator<SimpleDisplayable> listIterator_() {
-				return subject.items();
-			}
-
-			@Override
-			protected int size_() {
-				return subject.itemsSize();
-			}
-		};
-	}
-
-	protected abstract AbstractComboModelAdapter<SimpleDisplayable> buildReadOnlyComboModelAdapter();
-
-	private SimpleDisplayable buildSelectedItem() {
-		return new SimpleDisplayable("baz");
-	}
-
-	private WritablePropertyValueModel<SimpleDisplayable> buildSelectedItemHolder() {
-		return new PropertyAspectAdapter<Model, SimpleDisplayable>(subjectHolder, Model.ITEM_PROPERTY) {
-			@Override
-			protected SimpleDisplayable buildValue_() {
-				return subject.getItem();
-			}
-
-			@Override
-			protected void setValue_(SimpleDisplayable value) {
-				subject.setItem(value);
-			}
-		};
-	}
-
-	protected final StringConverter<SimpleDisplayable> buildStringConverter() {
-		return new StringConverter<SimpleDisplayable>() {
-			public String convertToString(SimpleDisplayable value) {
-				return (value == null) ? "" : value.displayString();
-			}
-		};
-	}
-
-	private WritablePropertyValueModel<Model> buildSubjectHolder() {
-		return new SimplePropertyValueModel<Model>();
-	}
-
-	public abstract String comboSelectedItem();
-
-	protected abstract boolean emptyComboCanHaveSelectedValue();
-
-	protected abstract String itemAt(int index);
-
-	protected abstract int itemCounts();
-
-	private void populateCollection(Collection<SimpleDisplayable> c) {
-		c.add(new SimpleDisplayable("foo"));
-		c.add(new SimpleDisplayable("bar"));
-		c.add(new SimpleDisplayable("baz"));
-		c.add(new SimpleDisplayable("joo"));
-		c.add(new SimpleDisplayable("jar"));
-		c.add(new SimpleDisplayable("jaz"));
-	}
-
-	protected final WritablePropertyValueModel<SimpleDisplayable> selectedItemHolder() {
-		return selectedItemHolder;
-	}
-
-	@Before
-	public void setUp() throws Exception {
-
-		shell              = new Shell(Display.getCurrent());
-		model              = new Model();
-		subjectHolder      = buildSubjectHolder();
-		selectedItemHolder = buildSelectedItemHolder();
-	}
-
-	protected final Shell shell() {
-		return shell;
-	}
-
-	protected final WritablePropertyValueModel<Model> subjectHolder() {
-		return subjectHolder;
-	}
-
-	@After
-	public void tearDown() throws Exception {
-
-		if (!shell.isDisposed()) {
-			shell.dispose();
-		}
-
-		shell              = null;
-		subjectHolder      = null;
-		selectedItemHolder = null;
-	}
-
-	private void testItems() {
-
-		assertEquals(
-			"The count of items is not in sync with the model",
-			model.itemsSize(),
-			itemCounts()
-		);
-
-		for (int index = 0; index < model.itemsSize(); index++) {
-			assertEquals(
-				"The item at index " + index + " is not the same between the model and the combo",
-				model.itemAt(index).displayString(),
-				itemAt(index)
-			);
-		}
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_AddedAfter_ReadOnly() throws Exception {
-
-		buildReadOnlyComboModelAdapter();
-		testRemoveItems_AddedAfter();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_AddedAfter_RemoveItems_Editable() throws Exception {
-
-		buildEditableComboModelAdapter();
-		testRemoveItems_AddedAfter();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_AddedBefore_RemoveItems_Editable() throws Exception {
-
-		subjectHolder.setValue(model);
-		model.addItems(buildList());
-
-		buildEditableComboModelAdapter();
-		testSelectedItem(null);
-		testItems();
-
-		ArrayList<SimpleDisplayable> items = new ArrayList<SimpleDisplayable>();
-		items.add(model.itemAt(0));
-		items.add(model.itemAt(3));
-		model.removeItems(items.iterator());
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_AddedBefore_RemoveItems_ReadOnly() throws Exception {
-
-		subjectHolder.setValue(model);
-		model.addItems(buildList());
-
-		buildReadOnlyComboModelAdapter();
-		testSelectedItem(null);
-		testItems();
-
-		ArrayList<SimpleDisplayable> items = new ArrayList<SimpleDisplayable>();
-		items.add(model.itemAt(0));
-		items.add(model.itemAt(3));
-		model.removeItems(items.iterator());
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_NullSelectedItem_ItemsAfterAfter_Editable() throws Exception {
-
-		buildEditableComboModelAdapter();
-
-		subjectHolder.setValue(model);
-		model.addItems(buildList());
-
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_NullSelectedItem_ItemsAfterAfter_ReadOnly() throws Exception {
-
-		buildReadOnlyComboModelAdapter();
-
-		subjectHolder.setValue(model);
-		model.addItems(buildList());
-
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_NullSelectedItem_ItemsAfterBefore_Editable() throws Exception {
-
-		buildEditableComboModelAdapter();
-
-		model.addItems(buildList());
-		subjectHolder.setValue(model);
-
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_NullSelectedItem_ItemsAfterBefore_ReadOnly() throws Exception {
-
-		buildReadOnlyComboModelAdapter();
-
-		model.addItems(buildList());
-		subjectHolder.setValue(model);
-
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_NullSelectedItem_ItemsBefore_Editable() throws Exception {
-
-		model.addItems(buildList());
-		buildEditableComboModelAdapter();
-
-		subjectHolder.setValue(model);
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_NullSelectedItem_ItemsBefore_ReadOnly() throws Exception {
-
-		model.addItems(buildList());
-		buildReadOnlyComboModelAdapter();
-
-		subjectHolder.setValue(model);
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_NullSelectedItem_NoItems_Editable() throws Exception {
-
-		buildEditableComboModelAdapter();
-
-		subjectHolder.setValue(model);
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_NullSelectedItem_NoItems_ReadOnly() throws Exception {
-
-		buildReadOnlyComboModelAdapter();
-
-		subjectHolder.setValue(model);
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectAfter_SelectedItemChanged_ReadOnly() throws Exception {
-
-		subjectHolder.setValue(model);
-		model.addItems(buildList());
-
-		SimpleDisplayable selectedItem = model.itemAt(0);
-
-		AbstractComboModelAdapter<SimpleDisplayable> adapter = buildEditableComboModelAdapter();
-		SelectionListener selectionListener = new SelectionListener();
-		adapter.addSelectionChangeListener(selectionListener);
-
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-		testSelectedItem(null);
-
-		testSelectedItemChanged(selectedItem, selectionListener);
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NonNullSelectedItemAfter_Editable() throws Exception {
-
-		SimpleDisplayable selectedItem = buildSelectedItem();
-		subjectHolder.setValue(model);
-
-		buildEditableComboModelAdapter();
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-
-		testSelectedItem(selectedItem);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NonNullSelectedItemAfter_Items_Editable() throws Exception {
-
-		SimpleDisplayable selectedItem = buildSelectedItem();
-		subjectHolder.setValue(model);
-
-		buildEditableComboModelAdapter();
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-
-		testSelectedItem(selectedItem);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NonNullSelectedItemAfter_Items_ReadOnly() throws Exception {
-
-		List<SimpleDisplayable> list = buildList();
-		SimpleDisplayable selectedItem = list.get(0);
-		subjectHolder.setValue(model);
-
-		buildReadOnlyComboModelAdapter();
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-
-		testSelectedItem(selectedItem);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NonNullSelectedItemAfter_ReadOnly() throws Exception {
-
-		List<SimpleDisplayable> list = buildList();
-		SimpleDisplayable selectedItem = list.get(0);
-		subjectHolder.setValue(model);
-
-		buildReadOnlyComboModelAdapter();
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-
-		testSelectedItem(selectedItem);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NonNullSelectedItemBefore_Editable() throws Exception {
-
-		model.addItems(buildList());
-		SimpleDisplayable selectedItem = model.itemAt(0);
-		subjectHolder.setValue(model);
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-
-		model.clearItemCalledFlag();
-		buildEditableComboModelAdapter();
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-
-		testSelectedItem(selectedItem);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NonNullSelectedItemBefore_Items_Editable() throws Exception {
-
-		model.addItems(buildList());
-		SimpleDisplayable selectedItem = model.itemAt(0);
-		subjectHolder.setValue(model);
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-
-		model.clearItemCalledFlag();
-		buildEditableComboModelAdapter();
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-
-		testSelectedItem(selectedItem);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NonNullSelectedItemBefore_Items_ReadOnly() throws Exception {
-
-		List<SimpleDisplayable> list = buildList();
-		SimpleDisplayable selectedItem = list.get(0);
-		subjectHolder.setValue(model);
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-
-		model.clearItemCalledFlag();
-		buildReadOnlyComboModelAdapter();
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-
-		testSelectedItem(selectedItem);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NonNullSelectedItemBefore_ReadOnly() throws Exception {
-
-		List<SimpleDisplayable> list = buildList();
-		SimpleDisplayable selectedItem = list.get(0);
-		subjectHolder.setValue(model);
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-
-		model.clearItemCalledFlag();
-		buildReadOnlyComboModelAdapter();
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-
-		testSelectedItem(selectedItem);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NullSelectedItem_Items_Editable() throws Exception {
-
-		subjectHolder.setValue(model);
-
-		buildEditableComboModelAdapter();
-
-		assertFalse("The item wasn't supposed to be modified", model.isSetItemCalled());
-		assertNull("The selected item is supposed to remain null", model.getItem());
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NullSelectedItem_Items_ReadOnly() throws Exception {
-
-		subjectHolder.setValue(model);
-
-		buildEditableComboModelAdapter();
-
-		assertFalse("The item wasn't supposed to be modified", model.isSetItemCalled());
-		assertNull("The selected item is supposed to remain null", model.getItem());
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NullSelectedItem_NoItems_Editable() throws Exception {
-
-		subjectHolder.setValue(model);
-
-		buildEditableComboModelAdapter();
-
-		assertFalse("The item wasn't supposed to be modified", model.isSetItemCalled());
-		assertNull("The selected item is supposed to remain null", model.getItem());
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_NullSelectedItem_NoItems_ReadOnly() throws Exception {
-
-		subjectHolder.setValue(model);
-
-		buildEditableComboModelAdapter();
-
-		assertFalse("The item wasn't supposed to be modified", model.isSetItemCalled());
-		assertNull("The selected item is supposed to remain null", model.getItem());
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNonNullSubjectBefore_SelectedItemChanged_Editable() throws Exception {
-
-		model.addItems(buildList());
-
-		SimpleDisplayable selectedItem = model.itemAt(3);
-		subjectHolder.setValue(model);
-
-		AbstractComboModelAdapter<SimpleDisplayable> adapter = buildEditableComboModelAdapter();
-		SelectionListener selectionListener = new SelectionListener();
-		adapter.addSelectionChangeListener(selectionListener);
-
-		assertFalse("The selected item wasn't supposed to be modified", model.isSetItemCalled());
-		testSelectedItem(null);
-
-		testSelectedItemChanged(selectedItem, selectionListener);
-	}
-
-	private void testNullSubject() throws Exception {
-
-		assertNull("The selected item should be null", selectedItemHolder.getValue());
-
-		selectedItemHolder.setValue(buildSelectedItem());
-		assertFalse("The item wasn't supposed to be modified", model.isSetItemCalled());
-
-		// Null because the subject holder doesn't have the subject set
-		testSelectedItem(null);
-		testItems();
-	}
-
-	@Test
-	public void testNullSubject_NullSelectedItem_Items_Editable() throws Exception {
-		buildEditableComboModelAdapter();
-		testNullSubject();
-		testItems();
-		testSelectedItem(null);
-	}
-
-	@Test
-	public void testNullSubject_NullSelectedItem_Items_ReadOnly() throws Exception {
-		buildReadOnlyComboModelAdapter();
-		testNullSubject();
-		testItems();
-		testSelectedItem(null);
-	}
-
-	@Test
-	public void testNullSubject_NullSelectedItem_NoItems_Editable() throws Exception {
-		buildEditableComboModelAdapter();
-		testNullSubject();
-		testItems();
-		testSelectedItem(null);
-	}
-
-	@Test
-	public void testNullSubject_NullSelectedItem_NoItems_ReadOnly() throws Exception {
-		buildReadOnlyComboModelAdapter();
-		testNullSubject();
-		testItems();
-		testSelectedItem(null);
-	}
-
-	private void testRemoveItems_AddedAfter() {
-
-		subjectHolder.setValue(model);
-		model.addItems(buildList());
-
-		testSelectedItem(null);
-		testItems();
-		testSelectedItem(null);
-
-		ArrayList<SimpleDisplayable> items = new ArrayList<SimpleDisplayable>();
-		items.add(model.itemAt(0));
-		items.add(model.itemAt(3));
-		model.removeItems(items.iterator());
-
-		testItems();
-		testSelectedItem(null);
-	}
-
-	private void testSelectedItem(SimpleDisplayable selectedItem) {
-
-		if (selectedItem == null) {
-
-			assertNull(
-				"The selected item is supposed to be null",
-				model.getItem()
-			);
-
-			assertEquals(
-				"The combo's selected item should be null",
-				"",
-				comboSelectedItem()
-			);
-		}
-		else if (!emptyComboCanHaveSelectedValue()) {
-
-			assertEquals(
-				"The selected item wasn't set correctly",
-				selectedItem,
-				model.getItem()
-			);
-
-			assertEquals(
-				"The combo's selected item should be null",
-				"",
-				comboSelectedItem()
-			);
-		}
-		else {
-
-			assertEquals(
-				"The selected item wasn't set correctly",
-				selectedItem,
-				model.getItem()
-			);
-
-			assertEquals(
-				"The selected item wasn't set correctly",
-				selectedItem.displayString(),
-				comboSelectedItem()
-			);
-		}
-	}
-
-	private void testSelectedItemChanged(SimpleDisplayable selectedItem,
-	                                     SelectionListener selectionListener) {
-
-		// Test 1
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-		assertTrue("The SelectionListener was supposed to be notified", selectionListener.isListenerNotified());
-		assertSame("The SelectionListener was supposed to be notified", selectedItem, selectionListener.getItem());
-		testSelectedItem(selectedItem);
-
-		// Test 2
-		selectedItem = model.itemAt(1);
-		model.clearItemCalledFlag();
-		selectionListener.clearInfo();
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-		assertTrue("The SelectionListener was supposed to be notified", selectionListener.isListenerNotified());
-		assertSame("The SelectionListener was supposed to be notified", selectedItem, selectionListener.getItem());
-		testSelectedItem(selectedItem);
-
-		// Test 3
-		selectedItem = null;
-		model.clearItemCalledFlag();
-		selectionListener.clearInfo();
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertNull("The selected item wasn't set properly", model.getItem());
-		assertTrue("The SelectionListener was supposed to be notified", selectionListener.isListenerNotified());
-		assertSame("The SelectionListener was supposed to be notified", selectedItem, selectionListener.getItem());
-		testSelectedItem(selectedItem);
-
-		// Test 3
-		selectedItem = model.itemAt(2);
-		model.clearItemCalledFlag();
-		selectionListener.clearInfo();
-
-		model.setItem(selectedItem);
-		assertTrue("The selected item was supposed to be modified", model.isSetItemCalled());
-		assertSame("The selected item wasn't set properly", selectedItem, model.getItem());
-		assertTrue("The SelectionListener was supposed to be notified", selectionListener.isListenerNotified());
-		assertSame("The SelectionListener was supposed to be notified", selectedItem, selectionListener.getItem());
-		testSelectedItem(selectedItem);
-	}
-
-	private static class Model extends AbstractModel {
-
-		private SimpleDisplayable item;
-		private List<SimpleDisplayable> items = new ArrayList<SimpleDisplayable>();
-		private boolean setItemCalled;
-
-		static final String ITEM_PROPERTY = "item";
-		static final String ITEMS_LIST = "items";
-
-		void addItems(Iterator<SimpleDisplayable> items) {
-			addItemsToList(items, this.items, ITEMS_LIST);
-		}
-
-		void addItems(List<SimpleDisplayable> items) {
-			addItemsToList(items, this.items, ITEMS_LIST);
-		}
-
-		void clearItemCalledFlag() {
-			setItemCalled = false;
-		}
-
-		SimpleDisplayable getItem() {
-			return item;
-		}
-
-		boolean isSetItemCalled() {
-			return setItemCalled;
-		}
-
-		SimpleDisplayable itemAt(int index) {
-			return this.items.get(index);
-		}
-
-		ListIterator<SimpleDisplayable> items() {
-			return items.listIterator();
-		}
-
-		int itemsSize() {
-			return items.size();
-		}
-
-		void removeItems(Iterator<SimpleDisplayable> items) {
-			removeItemsFromList(items, this.items, ITEMS_LIST);
-		}
-
-		void setItem(SimpleDisplayable item) {
-			setItemCalled = true;
-
-			SimpleDisplayable oldItem = this.item;
-			this.item = item;
-			firePropertyChanged(ITEM_PROPERTY, oldItem, item);
-		}
-	}
-
-	private class SelectionListener implements SelectionChangeListener<SimpleDisplayable> {
-
-		private SimpleDisplayable item;
-		private boolean listenerNotified;
-
-		void clearInfo() {
-			this.listenerNotified = false;
-			this.item = null;
-		}
-
-		SimpleDisplayable getItem() {
-			return item;
-		}
-
-		public boolean isListenerNotified() {
-			return listenerNotified;
-		}
-
-		public void selectionChanged(SelectionChangeEvent<SimpleDisplayable> e) {
-			listenerNotified = true;
-			item = e.selectedItem();
-		}
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/CComboModelAdapterTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/CComboModelAdapterTest.java
deleted file mode 100644
index 4cf143e..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/CComboModelAdapterTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.swt;
-
-import org.eclipse.jpt.ui.internal.swt.AbstractComboModelAdapter;
-import org.eclipse.jpt.ui.internal.swt.CComboModelAdapter;
-import org.eclipse.jpt.utility.internal.swing.SimpleDisplayable;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.custom.CCombo;
-import org.junit.After;
-
-public class CComboModelAdapterTest extends AbstractComboModelAdapterTest {
-
-	private CCombo combo;
-
-	@Override
-	protected AbstractComboModelAdapter<SimpleDisplayable> buildEditableComboModelAdapter() {
-
-		combo = new CCombo(shell(), SWT.NULL);
-
-		return CComboModelAdapter.adapt(
-			buildListHolder(),
-			selectedItemHolder(),
-			combo,
-			buildStringConverter()
-		);
-	}
-
-	@Override
-	protected AbstractComboModelAdapter<SimpleDisplayable> buildReadOnlyComboModelAdapter() {
-
-		combo = new CCombo(shell(), SWT.READ_ONLY);
-
-		return CComboModelAdapter.adapt(
-			buildListHolder(),
-			selectedItemHolder(),
-			combo,
-			buildStringConverter()
-		);
-	}
-
-	@Override
-	public String comboSelectedItem() {
-		return combo.getText();
-	}
-
-	@Override
-	protected boolean emptyComboCanHaveSelectedValue() {
-		return true;
-	}
-
-	@Override
-	protected String itemAt(int index) {
-		return this.combo.getItem(index);
-	}
-
-	@Override
-	protected int itemCounts() {
-		return combo.getItemCount();
-	}
-
-	@After
-	@Override
-	public void tearDown() throws Exception {
-		super.tearDown();
-		combo = null;
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/ComboModelAdapterTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/ComboModelAdapterTest.java
deleted file mode 100644
index 0fb152a..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/ComboModelAdapterTest.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.swt;
-
-import org.eclipse.jpt.ui.internal.swt.AbstractComboModelAdapter;
-import org.eclipse.jpt.ui.internal.swt.ComboModelAdapter;
-import org.eclipse.jpt.utility.internal.swing.SimpleDisplayable;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Combo;
-import org.junit.After;
-
-public class ComboModelAdapterTest extends AbstractComboModelAdapterTest {
-
-	private Combo combo;
-	private boolean editable;
-
-	@Override
-	protected AbstractComboModelAdapter<SimpleDisplayable> buildEditableComboModelAdapter() {
-
-		combo = new Combo(shell(), SWT.NULL);
-		editable = true;
-
-		return ComboModelAdapter.adapt(
-			buildListHolder(),
-			selectedItemHolder(),
-			combo,
-			buildStringConverter()
-		);
-	}
-
-	@Override
-	protected AbstractComboModelAdapter<SimpleDisplayable> buildReadOnlyComboModelAdapter() {
-
-		combo = new Combo(shell(), SWT.READ_ONLY);
-		editable = false;
-
-		return ComboModelAdapter.adapt(
-			buildListHolder(),
-			selectedItemHolder(),
-			combo,
-			buildStringConverter()
-		);
-	}
-
-	@Override
-	public String comboSelectedItem() {
-		return combo.getText();
-	}
-
-	@Override
-	protected boolean emptyComboCanHaveSelectedValue() {
-		return editable;
-	}
-
-	@Override
-	protected String itemAt(int index) {
-		return this.combo.getItem(index);
-	}
-
-	@Override
-	protected int itemCounts() {
-		return combo.getItemCount();
-	}
-
-	@After
-	@Override
-	public void tearDown() throws Exception {
-		super.tearDown();
-		combo = null;
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/JptUiSWTTests.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/JptUiSWTTests.java
deleted file mode 100644
index 12a8c2f..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/JptUiSWTTests.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.swt;
-
-import junit.framework.JUnit4TestAdapter;
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import org.junit.runners.Suite.SuiteClasses;
-
-@SuiteClasses
-({
-	CComboModelAdapterTest.class,
-	ComboModelAdapterTest.class,
-	SpinnerModelAdapterTest.class,
-	TableModelAdapterTest.class
-})
-@RunWith(Suite.class)
-public final class JptUiSWTTests {
-
-	private JptUiSWTTests() {
-		super();
-		throw new UnsupportedOperationException();
-	}
-
-	public static Test suite() {
-		TestSuite suite = new TestSuite();
-		suite.addTest(new JUnit4TestAdapter(JptUiSWTTests.class));
-		return suite;
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/SpinnerModelAdapterTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/SpinnerModelAdapterTest.java
deleted file mode 100644
index cf1629f..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/SpinnerModelAdapterTest.java
+++ /dev/null
@@ -1,340 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.swt;
-
-import static org.junit.Assert.*;
-import org.eclipse.jpt.ui.internal.swt.SpinnerModelAdapter;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.Spinner;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public class SpinnerModelAdapterTest {
-
-	private Model model;
-	private Shell shell;
-	private WritablePropertyValueModel<Model> subjectHolder;
-
-	private WritablePropertyValueModel<Model> buildSubjectHolder() {
-		return new SimplePropertyValueModel<Model>();
-	}
-
-	private WritablePropertyValueModel<Integer> buildValueHolder() {
-		return new PropertyAspectAdapter<Model, Integer>(subjectHolder, Model.VALUE_PROPERTY) {
-			@Override
-			protected Integer buildValue_() {
-				return subject.getValue();
-			}
-
-			@Override
-			protected void setValue_(Integer value) {
-				subject.setValue(value);
-			}
-		};
-	}
-
-	@Before
-	public void setUp() throws Exception {
-
-		shell              = new Shell(Display.getCurrent());
-		model              = new Model();
-		subjectHolder      = buildSubjectHolder();
-	}
-
-	@After
-	public void tearDown() throws Exception {
-
-		if (!shell.isDisposed()) {
-			shell.dispose();
-		}
-
-		shell         = null;
-		subjectHolder = null;
-	}
-
-	@Test
-	public void testDisposed() {
-
-		int value = 2;
-		model.setValue(value);
-		model.clearSetValueCalledFlag();
-		subjectHolder.setValue(model);
-
-		Spinner spinner = new Spinner(shell, SWT.NULL);
-		WritablePropertyValueModel<Integer> numberHolder = buildValueHolder();
-		int defaultValue = 1;
-
-		SpinnerModelAdapter.adapt(
-			numberHolder,
-			spinner,
-			defaultValue
-		);
-
-		assertEquals(
-			"The spinner's value should be coming from the model",
-			value,
-			spinner.getSelection()
-		);
-
-		assertEquals(
-			"The number holder's value should be the model's value",
-			model.getValue(),
-			numberHolder.getValue()
-		);
-
-		assertFalse(
-			"The model should not have received the value during initialization",
-			model.isSetValueCalled()
-		);
-
-		// Change the value in the model
-		spinner.dispose();
-
-		value = 4;
-		model.setValue(value);
-
-		assertEquals(
-			"The model's value was somehow changed",
-			Integer.valueOf(value),
-			model.getValue()
-		);
-	}
-
-	@Test
-	public void testInitialization_1() {
-
-		Spinner spinner = new Spinner(shell, SWT.NULL);
-		WritablePropertyValueModel<Integer> numberHolder = new SimplePropertyValueModel<Integer>();
-		int defaultValue = 1;
-
-		SpinnerModelAdapter.adapt(
-			numberHolder,
-			spinner,
-			defaultValue
-		);
-
-		assertEquals(
-			"The spinner's value should be the default value",
-			defaultValue,
-			spinner.getSelection()
-		);
-
-		assertNull(
-			"The number holder's value should be null",
-			numberHolder.getValue()
-		);
-	}
-
-	@Test
-	public void testInitialization_2() {
-
-		Spinner spinner = new Spinner(shell, SWT.NULL);
-		WritablePropertyValueModel<Integer> numberHolder = buildValueHolder();
-		int defaultValue = 1;
-
-		SpinnerModelAdapter.adapt(
-			numberHolder,
-			spinner,
-			defaultValue
-		);
-
-		assertEquals(
-			"The spinner's value should be the default value",
-			defaultValue,
-			spinner.getSelection()
-		);
-
-		assertNull(
-			"The number holder's value should be null",
-			numberHolder.getValue()
-		);
-	}
-
-	@Test
-	public void testInitialization_3() {
-
-		subjectHolder.setValue(model);
-
-		Spinner spinner = new Spinner(shell, SWT.NULL);
-		WritablePropertyValueModel<Integer> numberHolder = buildValueHolder();
-		int defaultValue = 1;
-
-		SpinnerModelAdapter.adapt(
-			numberHolder,
-			spinner,
-			defaultValue
-		);
-
-		assertEquals(
-			"The spinner's value should be the default value",
-			defaultValue,
-			spinner.getSelection()
-		);
-
-		assertNull(
-			"The number holder's value should be null",
-			numberHolder.getValue()
-		);
-
-		assertFalse(
-			"The model should not have received the value during initialization",
-			model.isSetValueCalled()
-		);
-	}
-
-	@Test
-	public void testInitialization_4() {
-
-		int value = 2;
-		model.setValue(value);
-		model.clearSetValueCalledFlag();
-		subjectHolder.setValue(model);
-
-		Spinner spinner = new Spinner(shell, SWT.NULL);
-		WritablePropertyValueModel<Integer> numberHolder = buildValueHolder();
-		int defaultValue = 1;
-
-		SpinnerModelAdapter.adapt(
-			numberHolder,
-			spinner,
-			defaultValue
-		);
-
-		assertEquals(
-			"The spinner's value should be the value coming from the model",
-			value,
-			spinner.getSelection()
-		);
-
-		assertEquals(
-			"The number holder's value should be " + value,
-			Integer.valueOf(value),
-			numberHolder.getValue()
-		);
-
-		assertFalse(
-			"The model should not have received the value during initialization",
-			model.isSetValueCalled()
-		);
-	}
-
-	@Test
-	public void testValueChanged() {
-
-		int value = 2;
-		model.setValue(value);
-		model.clearSetValueCalledFlag();
-		subjectHolder.setValue(model);
-
-		Spinner spinner = new Spinner(shell, SWT.NULL);
-		WritablePropertyValueModel<Integer> numberHolder = buildValueHolder();
-		int defaultValue = 1;
-
-		SpinnerModelAdapter.adapt(
-			numberHolder,
-			spinner,
-			defaultValue
-		);
-
-		assertEquals(
-			"The spinner's value should be coming from the model",
-			value,
-			spinner.getSelection()
-		);
-
-		assertEquals(
-			"The number holder's value should be the model's value",
-			model.getValue(),
-			numberHolder.getValue()
-		);
-
-		assertFalse(
-			"The model should not have received the value during initialization",
-			model.isSetValueCalled()
-		);
-
-		// Change the value in the model
-		value = 4;
-		model.setValue(value);
-
-		assertEquals(
-			"The spinner's value should be coming from the model",
-			value,
-			spinner.getSelection()
-		);
-
-		assertEquals(
-			"The model's value was somehow changed",
-			Integer.valueOf(value),
-			model.getValue()
-		);
-
-		// Change the value from the spinner
-		value = 6;
-		spinner.setSelection(value);
-
-		assertEquals(
-			"The spinner's value should be the new value set",
-			value,
-			spinner.getSelection()
-		);
-
-		assertEquals(
-			"The model's value was supposed to be updated",
-			Integer.valueOf(value),
-			model.getValue()
-		);
-
-		// Disconnect from model
-		subjectHolder.setValue(null);
-
-		assertEquals(
-			"The spinner's value should be the default value",
-			defaultValue,
-			spinner.getSelection()
-		);
-	}
-
-	private static class Model extends AbstractModel {
-
-		private boolean setValueCalled;
-		private Integer value;
-
-		static final String VALUE_PROPERTY = "value";
-
-		void clearSetValueCalledFlag() {
-			setValueCalled = false;
-		}
-
-		Integer getValue() {
-			return value;
-		}
-
-		boolean isSetValueCalled() {
-			return setValueCalled;
-		}
-
-		void setValue(Integer value) {
-			setValueCalled = true;
-
-			Integer oldValue = this.value;
-			this.value = value;
-			firePropertyChanged(VALUE_PROPERTY, oldValue, value);
-		}
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/TableModelAdapterTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/TableModelAdapterTest.java
deleted file mode 100644
index 057b8b4..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/TableModelAdapterTest.java
+++ /dev/null
@@ -1,1203 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.swt;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.ListIterator;
-import org.eclipse.jface.viewers.ITableLabelProvider;
-import org.eclipse.jface.viewers.LabelProvider;
-import org.eclipse.jpt.ui.internal.swt.ColumnAdapter;
-import org.eclipse.jpt.ui.internal.swt.TableModelAdapter;
-import org.eclipse.jpt.ui.internal.swt.TableModelAdapter.SelectionChangeEvent;
-import org.eclipse.jpt.ui.internal.swt.TableModelAdapter.SelectionChangeListener;
-import org.eclipse.jpt.utility.internal.CollectionTools;
-import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.ListAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.PropertyCollectionValueModelAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimpleCollectionValueModel;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.model.value.CollectionValueModel;
-import org.eclipse.jpt.utility.model.value.ListValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.Table;
-import org.eclipse.swt.widgets.TableItem;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public class TableModelAdapterTest {
-
-	private Shell shell;
-	private WritablePropertyValueModel<Manager> subjectHolder;
-
-	private ColumnAdapter<Employee> buildColumnAdapter() {
-		return new TableColumnAdapter();
-	}
-
-	private WritablePropertyValueModel<Employee> buildEmployeeHolder() {
-		return new SimplePropertyValueModel<Employee>();
-	}
-
-	private SimpleCollectionValueModel<Employee> buildEmployeeHolders() {
-		return new SimpleCollectionValueModel<Employee>();
-	}
-
-	private ListValueModel<Employee> buildEmployeeListHolder() {
-		return new ListAspectAdapter<Manager, Employee>(subjectHolder, Manager.EMPLOYEES_LIST) {
-			@Override
-			protected ListIterator<Employee> listIterator_() {
-				return subject.employees();
-			}
-
-			@Override
-			protected int size_() {
-				return subject.employeesSize();
-			}
-		};
-	}
-
-	private ITableLabelProvider buildLabelProvider() {
-		return new TableLabelProvider();
-	}
-
-	private SelectionChangeListener<Employee> buildSelectionChangeListener(final Collection<Employee> employees) {
-		return new SelectionChangeListener<Employee>() {
-			public void selectionChanged(SelectionChangeEvent<Employee> e) {
-				employees.clear();
-				CollectionTools.addAll(employees, e.selection());
-			}
-		};
-	}
-
-	private WritablePropertyValueModel<Manager> buildSubjectHolder() {
-		return new SimplePropertyValueModel<Manager>();
-	}
-
-	@Before
-	public void setUp() throws Exception {
-
-		shell         = new Shell(Display.getCurrent());
-		subjectHolder = buildSubjectHolder();
-	}
-
-	@After
-	public void tearDown() throws Exception {
-
-		if (!shell.isDisposed()) {
-			shell.dispose();
-		}
-
-		shell         = null;
-		subjectHolder = null;
-	}
-
-	@Test
-	public void testChanged() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-
-		// Make sure the Table was populated
-		Assert.assertEquals("The number of TableItems should be 3", 3, table.getItemCount());
-
-		// Change the list of Employees
-		ArrayList<Employee> employees = new ArrayList<Employee>(3);
-		employees.add(employee3);
-		employees.add(employee2);
-		employees.add(employee1);
-		manager.changeEmployees(employees);
-
-		Assert.assertEquals("The number of TableItems should be 3", 3, table.getItemCount());
-
-		testTableItemProperties(table, 0, expectedName3, expectedManager3, expectedTitle3);
-		testTableItemProperties(table, 1, expectedName2, expectedManager2, expectedTitle2);
-		testTableItemProperties(table, 2, expectedName1, expectedManager1, expectedTitle1);
-	}
-
-	@Test
-	public void testCleared() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-
-		// Make sure the Table was populated
-		Assert.assertEquals("The number of TableItems should be 3", 3, table.getItemCount());
-
-		// Test removing them all
-		manager.removeAllEmployees();
-
-		Assert.assertEquals("The list holder should have been cleared", 0, listHolder.size());
-		Assert.assertEquals("The Table should have been cleared", 0, table.getItemCount());
-	}
-
-	@Test
-	public void testItemAdded() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create a new Employee
-		String expectedName    = "Dali";
-		String expectedManager = "WTP";
-		String expectedTitle   = "plug-in";
-
-		Employee employee = manager.addEmployee(expectedName, expectedTitle, expectedManager);
-		Assert.assertNotNull("The new Employee was not created", employee);
-
-		// Retrieve the TableItem representing the new Employee
-		int index = tableModel.indexOf(employee);
-		Assert.assertEquals("The new Employee was not added to the table model", 0, index);
-		Assert.assertEquals("The number of TableItem should be 1", 1, table.getItemCount());
-
-		testTableItemProperties(table, index, expectedName, expectedManager, expectedTitle);
-	}
-
-	@Test
-	public void testItemMoved() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-
-		// Make sure the Employees were added to the Table
-		Assert.assertEquals("The number of TableItem should be 3", 3, table.getItemCount());
-
-		// Move an Employee up the list
-		manager.moveEmployeeUp(employee2);
-
-		int index1 = tableModel.indexOf(employee1);
-		Assert.assertEquals("The Employee 1 was not moved in the table model", 1, index1);
-
-		int index2 = tableModel.indexOf(employee2);
-		Assert.assertEquals("The Employee 2 was not moved in the table model", 0, index2);
-
-		int index3 = tableModel.indexOf(employee3);
-		Assert.assertEquals("The Employee 3 should not have been moved in the table model", 2, index3);
-
-		testTableItemProperties(table, index1, expectedName1, expectedManager1, expectedTitle1);
-		testTableItemProperties(table, index2, expectedName2, expectedManager2, expectedTitle2);
-		testTableItemProperties(table, index3, expectedName3, expectedManager3, expectedTitle3);
-
-		// Move an Employee down the list
-		manager.moveEmployeeDown(employee1);
-
-		index1 = tableModel.indexOf(employee1);
-		Assert.assertEquals("The Employee 1 should not have been moved in the table model", 2, index1);
-
-		index2 = tableModel.indexOf(employee2);
-		Assert.assertEquals("The Employee 2 was not moved in the table model", 0, index2);
-
-		index3 = tableModel.indexOf(employee3);
-		Assert.assertEquals("The Employee 3 was not moved in the table model", 1, index3);
-
-		testTableItemProperties(table, index1, expectedName1, expectedManager1, expectedTitle1);
-		testTableItemProperties(table, index2, expectedName2, expectedManager2, expectedTitle2);
-		testTableItemProperties(table, index3, expectedName3, expectedManager3, expectedTitle3);
-	}
-
-	@Test
-	public void testItemRemoved() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create a new Employee
-		String expectedName    = "Dali";
-		String expectedManager = "WTP";
-		String expectedTitle   = "plug-in";
-
-		Employee employee = manager.addEmployee(expectedName, expectedTitle, expectedManager);
-		Assert.assertNotNull("The new Employee was not created", employee);
-		Assert.assertEquals("The number of TableItem should be 1", 1, table.getItemCount());
-
-		// Make sure it was added to the model
-		int index = tableModel.indexOf(employee);
-		Assert.assertEquals("The new Employee was not added to the table model", 0, index);
-		testTableItemProperties(table, index, expectedName, expectedManager, expectedTitle);
-
-		// Retrieve the TableItem representing the new Employee
-		TableItem tableItem = table.getItem(index);
-		Assert.assertNotNull("No TableItem was found for the new Employee", tableItem);
-
-		// Now test the item being removed
-		manager.removeEmployee(employee);
-		index = tableModel.indexOf(employee);
-		Assert.assertEquals("The Employee was not removed from the table model", -1, index);
-		Assert.assertEquals("The number of TableItem should be 0", 0, table.getItemCount());
-	}
-
-	@Test
-	public void testItemReplaced() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create a new Employee
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		Employee employee1 = manager.addEmployee(expectedName1, expectedTitle1, expectedManager1);
-		Assert.assertNotNull("The new Employee was not created", employee1);
-
-		// Make sure it was added to the model
-		int index1 = tableModel.indexOf(employee1);
-		Assert.assertEquals("The new Employee was not added to the table model", 0, index1);
-		Assert.assertEquals("The number of TableItem should be 1", 1, table.getItemCount());
-
-		// Retrieve the TableItem representing the new Employee
-		TableItem tableItem = table.getItem(index1);
-		Assert.assertNotNull("No TableItem was found for the new Employee", tableItem);
-
-		testTableItemProperties(table, index1, expectedName1, expectedManager1, expectedTitle1);
-
-		// Replace the Employee
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		manager.replace(employee1, employee2);
-
-		int index2 = tableModel.indexOf(employee2);
-		Assert.assertSame("The Employee that got replaced should be at index " + index1, index1, index2);
-		Assert.assertEquals("The number of TableItem should be 1", 1, table.getItemCount());
-
-		testTableItemProperties(table, index2, expectedName2, expectedManager2, expectedTitle2);
-	}
-
-	@Test
-	public void testItemsAdded() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-
-		// Retrieve the TableItems representing the employees
-		Assert.assertEquals("The number of TableItem should be 3", 3, table.getItemCount());
-
-		int index = tableModel.indexOf(employee1);
-		Assert.assertEquals("The Employee 1 was not added to the table model", 0, index);
-
-		index = tableModel.indexOf(employee2);
-		Assert.assertEquals("The Employee 2 was not added to the table model", 1, index);
-
-		index = tableModel.indexOf(employee3);
-		Assert.assertEquals("The Employee 3 was not added to the table model", 2, index);
-
-		// Make sure the TableItem was correctly populated
-		testTableItemProperties(table, 0, expectedName1, expectedManager1, expectedTitle1);
-		testTableItemProperties(table, 1, expectedName2, expectedManager2, expectedTitle2);
-		testTableItemProperties(table, 2, expectedName3, expectedManager3, expectedTitle3);
-	}
-
-	@Test
-	public void testItemsMoved() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		String expectedName4    = "Dali_4";
-		String expectedManager4 = "WTP_4";
-		String expectedTitle4   = "plug-in_4";
-
-		String expectedName5    = "Dali_5";
-		String expectedManager5 = "WTP_5";
-		String expectedTitle5   = "plug-in_5";
-
-		String expectedName6    = "Dali_6";
-		String expectedManager6 = "WTP_6";
-		String expectedTitle6   = "plug-in_6";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-		Employee employee4 = new Employee(expectedName4, expectedTitle4, expectedManager4);
-		Employee employee5 = new Employee(expectedName5, expectedTitle5, expectedManager5);
-		Employee employee6 = new Employee(expectedName6, expectedTitle6, expectedManager6);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-		manager.addEmployee(employee4);
-		manager.addEmployee(employee5);
-		manager.addEmployee(employee6);
-
-		// Make sure the Employees were added to the Table
-		Assert.assertEquals("The number of TableItem should be 6", 6, table.getItemCount());
-
-		// Move an Employee up the list
-		ArrayList<Employee> employees = new ArrayList<Employee>(3);
-		employees.add(employee3);
-		employees.add(employee4);
-		employees.add(employee5);
-		manager.moveEmployees(employees, 0);
-
-		int index1 = tableModel.indexOf(employee1);
-		int index2 = tableModel.indexOf(employee2);
-		int index3 = tableModel.indexOf(employee3);
-		int index4 = tableModel.indexOf(employee4);
-		int index5 = tableModel.indexOf(employee5);
-		int index6 = tableModel.indexOf(employee6);
-
-		Assert.assertEquals("The Employee 1 is not at the right index", 3, index1);
-		Assert.assertEquals("The Employee 2 is not at the right index", 4, index2);
-		Assert.assertEquals("The Employee 3 is not at the right index", 0, index3);
-		Assert.assertEquals("The Employee 4 is not at the right index", 1, index4);
-		Assert.assertEquals("The Employee 5 is not at the right index", 2, index5);
-		Assert.assertEquals("The Employee 6 is not at the right index", 5, index6);
-
-		testTableItemProperties(table, index1, expectedName1, expectedManager1, expectedTitle1);
-		testTableItemProperties(table, index2, expectedName2, expectedManager2, expectedTitle2);
-		testTableItemProperties(table, index3, expectedName3, expectedManager3, expectedTitle3);
-		testTableItemProperties(table, index4, expectedName4, expectedManager4, expectedTitle4);
-		testTableItemProperties(table, index5, expectedName5, expectedManager5, expectedTitle5);
-		testTableItemProperties(table, index6, expectedName6, expectedManager6, expectedTitle6);
-
-		// Move an Employee down the list
-		employees = new ArrayList<Employee>(2);
-		employees.add(employee1);
-		employees.add(employee2);
-		manager.moveEmployees(employees, 4);
-
-		index1 = tableModel.indexOf(employee1);
-		index2 = tableModel.indexOf(employee2);
-		index3 = tableModel.indexOf(employee3);
-		index4 = tableModel.indexOf(employee4);
-		index5 = tableModel.indexOf(employee5);
-		index6 = tableModel.indexOf(employee6);
-
-		Assert.assertEquals("The Employee 1 is not at the right index", 4, index1);
-		Assert.assertEquals("The Employee 2 is not at the right index", 5, index2);
-		Assert.assertEquals("The Employee 3 is not at the right index", 0, index3);
-		Assert.assertEquals("The Employee 4 is not at the right index", 1, index4);
-		Assert.assertEquals("The Employee 5 is not at the right index", 2, index5);
-		Assert.assertEquals("The Employee 6 is not at the right index", 3, index6);
-
-		testTableItemProperties(table, index1, expectedName1, expectedManager1, expectedTitle1);
-		testTableItemProperties(table, index2, expectedName2, expectedManager2, expectedTitle2);
-		testTableItemProperties(table, index3, expectedName3, expectedManager3, expectedTitle3);
-		testTableItemProperties(table, index4, expectedName4, expectedManager4, expectedTitle4);
-		testTableItemProperties(table, index5, expectedName5, expectedManager5, expectedTitle5);
-		testTableItemProperties(table, index6, expectedName6, expectedManager6, expectedTitle6);
-	}
-
-	@Test
-	public void testItemsRemoved() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-
-		// Retrieve the TableItems representing the employees
-		Assert.assertEquals("The number of TableItem should be 3", 3, table.getItemCount());
-
-		int index = tableModel.indexOf(employee1);
-		Assert.assertEquals("The Employee 1 was not added to the table model", 0, index);
-
-		index = tableModel.indexOf(employee2);
-		Assert.assertEquals("The Employee 2 was not added to the table model", 1, index);
-
-		index = tableModel.indexOf(employee3);
-		Assert.assertEquals("The Employee 3 was not added to the table model", 2, index);
-
-		// Remove 2 items
-		ArrayList<Employee> employees = new ArrayList<Employee>(2);
-		employees.add(employee1);
-		employees.add(employee3);
-		manager.removeEmployees(employees);
-
-		Assert.assertEquals("The number of TableItem should be 1", 1, table.getItemCount());
-	}
-
-	@Test
-	public void testPropertyChanged() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		WritablePropertyValueModel<Employee> selectedItemHolder = buildEmployeeHolder();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create a new Employee
-		String expectedName    = "Dali";
-		String expectedManager = "WTP";
-		String expectedTitle   = "plug-in";
-
-		Employee employee = manager.addEmployee(expectedName, expectedTitle, expectedManager);
-		Assert.assertNotNull("The new Employee was not created", employee);
-
-		// Make sure it was added to the model
-		int index = tableModel.indexOf(employee);
-		Assert.assertEquals("The new Employee was not added to the table model", 0, index);
-		Assert.assertEquals("The number of TableItem should be 1", 1, table.getItemCount());
-
-		// Retrieve the TableItem representing the new Employee
-		TableItem tableItem = table.getItem(index);
-		Assert.assertNotNull("No TableItem was found for the new Employee", tableItem);
-
-		// Name property
-		String actualName = tableItem.getText(TableColumnAdapter.NAME_COLUMN);
-		Assert.assertEquals("TableItem[NAME_COLUMN] was not set correctly", expectedName, actualName);
-
-		expectedName = "Jpt";
-		employee.setName(expectedName);
-
-		actualName = tableItem.getText(TableColumnAdapter.NAME_COLUMN);
-		Assert.assertEquals("TableItem[NAME_COLUMN] was not set correctly", expectedName, actualName);
-
-		// Manager property
-		String actualManager = tableItem.getText(TableColumnAdapter.MANAGER_COLUMN);
-		Assert.assertEquals("TableItem[MANAGER_COLUMN] was not set correctly", expectedManager, actualManager);
-
-		expectedManager = "boss";
-		employee.setManager(expectedManager);
-
-		actualManager = tableItem.getText(TableColumnAdapter.MANAGER_COLUMN);
-		Assert.assertEquals("TableItem[MANAGER_COLUMN] was not set correctly", expectedManager, actualManager);
-
-		// Title property
-		String actualTitle = tableItem.getText(TableColumnAdapter.TITLE_COLUMN);
-		Assert.assertEquals("TableItem[TITLE_COLUMN] was not set correctly", expectedTitle, actualTitle);
-
-		expectedTitle = "EclipseLink";
-		employee.setTitle(expectedTitle);
-
-		actualTitle = tableItem.getText(TableColumnAdapter.TITLE_COLUMN);
-		Assert.assertEquals("TableItem[TITLE_COLUMN] was not set correctly", expectedTitle, actualTitle);
-	}
-
-	@Test
-	public void testSelectedItemsAddedRemoved() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		SimpleCollectionValueModel<Employee> selectedItemsHolder = buildEmployeeHolders();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemsHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-
-		// Test adding selected items
-		ArrayList<Employee> employees = new ArrayList<Employee>(2);
-		employees.add(employee1);
-		employees.add(employee3);
-		selectedItemsHolder.addAll(employees);
-
-		Collection<Employee> actualEmployees = tableModel.selectedItems();
-		Assert.assertNotNull("The collection of selected items can't be null", actualEmployees);
-		Assert.assertEquals("The count of selected items should be 2", 2, actualEmployees.size());
-
-		actualEmployees.remove(employee1);
-		actualEmployees.remove(employee3);
-
-		Assert.assertTrue("The selected items was not retrieved correctly", actualEmployees.isEmpty());
-
-		// Test removing selected items
-		selectedItemsHolder.remove(employee1);
-
-		actualEmployees = tableModel.selectedItems();
-		Assert.assertNotNull("The collection of selected items can't be null", actualEmployees);
-		Assert.assertEquals("The count of selected items should be 1", 1, actualEmployees.size());
-
-		actualEmployees.remove(employee3);
-
-		Assert.assertTrue("The selected items was not retrieved correctly", actualEmployees.isEmpty());
-	}
-
-	@Test
-	public void testSelectedItemsCleared() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		ListValueModel<Employee> listHolder = buildEmployeeListHolder();
-		SimpleCollectionValueModel<Employee> selectedItemsHolder = buildEmployeeHolders();
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			listHolder,
-			selectedItemsHolder,
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-
-		// Test adding selected items
-		ArrayList<Employee> employees = new ArrayList<Employee>(2);
-		employees.add(employee1);
-		employees.add(employee3);
-		selectedItemsHolder.addAll(employees);
-
-		Collection<Employee> actualEmployees = tableModel.selectedItems();
-		Assert.assertNotNull("The collection of selected items can't be null", actualEmployees);
-		Assert.assertEquals("The count of selected items should be 2", 2, actualEmployees.size());
-
-		actualEmployees.remove(employee1);
-		actualEmployees.remove(employee3);
-		Assert.assertTrue("The selected items was not retrieved correctly", actualEmployees.isEmpty());
-
-		// Test removing selected items
-		selectedItemsHolder.clear();
-
-		actualEmployees = tableModel.selectedItems();
-		Assert.assertNotNull("The collection of selected items can't be null", actualEmployees);
-		Assert.assertEquals("The count of selected items should be ", 0, actualEmployees.size());
-	}
-
-	@Test
-	public void testSelectionChangeListener() {
-
-		Table table = new Table(shell, SWT.V_SCROLL | SWT.H_SCROLL | SWT.FULL_SELECTION | SWT.MULTI);
-
-		Manager manager = new Manager();
-		subjectHolder.setValue(manager);
-
-		TableModel tableModel = new TableModel(
-			buildEmployeeListHolder(),
-			buildEmployeeHolder(),
-			table,
-			buildColumnAdapter(),
-			buildLabelProvider()
-		);
-
-		Collection<Employee> employees = new ArrayList<Employee>();
-		tableModel.addSelectionChangeListener(buildSelectionChangeListener(employees));
-
-		// Create Employees
-		String expectedName1    = "Dali_1";
-		String expectedManager1 = "WTP_1";
-		String expectedTitle1   = "plug-in_1";
-
-		String expectedName2    = "Dali_2";
-		String expectedManager2 = "WTP_2";
-		String expectedTitle2   = "plug-in_2";
-
-		String expectedName3    = "Dali_3";
-		String expectedManager3 = "WTP_3";
-		String expectedTitle3   = "plug-in_3";
-
-		Employee employee1 = new Employee(expectedName1, expectedTitle1, expectedManager1);
-		Employee employee2 = new Employee(expectedName2, expectedTitle2, expectedManager2);
-		Employee employee3 = new Employee(expectedName3, expectedTitle3, expectedManager3);
-
-		manager.addEmployee(employee1);
-		manager.addEmployee(employee2);
-		manager.addEmployee(employee3);
-
-		// Test adding selected items
-		table.setSelection(new int[] { 0, 2 });
-
-		// It seems a manual selection doesn't send any selection event
-		tableModel.tableSelectionChanged(null);
-
-		Assert.assertNotNull("The collection of selected items can't be null", employees);
-		Assert.assertEquals("The count of selected items should be 2", 2, employees.size());
-
-		employees.remove(employee1);
-		employees.remove(employee3);
-		Assert.assertTrue("The selected items was not retrieved correctly", employees.isEmpty());
-
-		// Test adding selected items
-		employees.add(employee1);
-		employees.add(employee3);
-		table.deselectAll();
-
-		// It seems a manual selection doesn't send any selection event
-		tableModel.tableSelectionChanged(null);
-
-		Assert.assertNotNull("The collection of selected items can't be null", employees);
-		Assert.assertEquals("The count of selected items should be 0", 0, employees.size());
-	}
-
-	private void testTableItemProperties(Table table,
-	                                     int index,
-	                                     String expectedName,
-	                                     String expectedManager,
-	                                     String expectedTitle)
-	{
-		TableItem tableItem = table.getItem(index);
-		Assert.assertNotNull("No TableItem was found for the Employee", tableItem);
-
-		String actualName = tableItem.getText(TableColumnAdapter.NAME_COLUMN);
-		Assert.assertEquals("TableItem[NAME_COLUMN] was not set correctly", expectedName, actualName);
-
-		String actualTitle = tableItem.getText(TableColumnAdapter.TITLE_COLUMN);
-		Assert.assertEquals("TableItem[TITLE_COLUMN] was not set correctly", expectedTitle, actualTitle);
-
-		String actualManager = tableItem.getText(TableColumnAdapter.MANAGER_COLUMN);
-		Assert.assertEquals("TableItem[MANAGER_COLUMN] was not set correctly", expectedManager, actualManager);
-	}
-
-	private class Employee extends AbstractModel {
-
-		private String manager;
-		private String name;
-		private String title;
-
-		static final String MANAGER_PROPERTY = "manager";
-		static final String NAME_PROPERTY = "name";
-		static final String TITLE_PROPERTY = "title";
-
-		Employee(String name, String title, String manager) {
-			super();
-
-			this.name    = name;
-			this.title   = title;
-			this.manager = manager;
-		}
-
-		String getManager() {
-			return manager;
-		}
-
-		String getName() {
-			return name;
-		}
-
-		String getTitle() {
-			return title;
-		}
-
-		void setManager(String manager) {
-			String oldManager = this.manager;
-			this.manager = manager;
-			firePropertyChanged(MANAGER_PROPERTY, oldManager, manager);
-		}
-
-		void setName(String name) {
-			String oldName = this.name;
-			this.name = name;
-			firePropertyChanged(NAME_PROPERTY, oldName, name);
-		}
-
-		void setTitle(String title) {
-			String oldTitle = this.title;
-			this.title = title;
-			firePropertyChanged(TITLE_PROPERTY, oldTitle, title);
-		}
-	}
-
-	private class Manager extends AbstractModel {
-
-		private List<Employee> employees;
-
-		static final String EMPLOYEES_LIST = "employees";
-
-		Manager() {
-			super();
-			employees = new ArrayList<Employee>();
-		}
-
-		Employee addEmployee(Employee employee) {
-			addItemToList(employee, employees, EMPLOYEES_LIST);
-			return employee;
-		}
-
-		Employee addEmployee(String name, String title, String manager) {
-			Employee employee = new Employee(name, title, manager);
-			return addEmployee(employee);
-		}
-
-		void changeEmployees(List<Employee> employees) {
-			this.employees.clear();
-			this.employees.addAll(employees);
-			fireListChanged(EMPLOYEES_LIST, employees);
-		}
-
-		ListIterator<Employee> employees() {
-			return new CloneListIterator<Employee>(employees);
-		}
-
-		int employeesSize() {
-			return employees.size();
-		}
-
-		void moveEmployeeDown(Employee employee) {
-			int index = employees.indexOf(employee);
-			moveItemInList(index + 1, index, employees, EMPLOYEES_LIST);
-		}
-
-		void moveEmployees(Collection<Employee> employees, int targetIndex) {
-
-			int sourceIndex = Integer.MAX_VALUE;
-
-			for (Employee employee : employees) {
-				sourceIndex = Math.min(sourceIndex, this.employees.indexOf(employee));
-			}
-
-			moveItemsInList(
-				targetIndex,
-				sourceIndex,
-				employees.size(),
-				this.employees,
-				EMPLOYEES_LIST
-			);
-		}
-
-		void moveEmployeeUp(Employee employee) {
-			int index = employees.indexOf(employee);
-			moveItemInList(index - 1, index, employees, EMPLOYEES_LIST);
-		}
-
-		void removeAllEmployees() {
-			clearList(employees, EMPLOYEES_LIST);
-		}
-
-		void removeEmployee(Employee employee) {
-			removeItemFromList(employee, employees, EMPLOYEES_LIST);
-		}
-
-		void removeEmployees(Collection<Employee> employees) {
-			removeItemsFromList(employees.iterator(), this.employees, EMPLOYEES_LIST);
-		}
-
-		void replace(Employee oldEmployee, Employee newEmployee) {
-			replaceItemInList(oldEmployee, newEmployee, employees, EMPLOYEES_LIST);
-		}
-	}
-
-	private class TableColumnAdapter implements ColumnAdapter<Employee> {
-
-		static final int COLUMN_COUNT = 3;
-		static final int MANAGER_COLUMN = 2;
-		static final int NAME_COLUMN = 0;
-		static final int TITLE_COLUMN = 1;
-
-		private WritablePropertyValueModel<String> buildManagerHolder(Employee subject) {
-			return new PropertyAspectAdapter<Employee, String>(Employee.MANAGER_PROPERTY, subject) {
-				@Override
-				protected String buildValue_() {
-					return subject.getManager();
-				}
-
-				@Override
-				protected void setValue_(String value) {
-					subject.setManager(value);
-				}
-			};
-		}
-
-		private WritablePropertyValueModel<String> buildNameHolder(Employee subject) {
-			return new PropertyAspectAdapter<Employee, String>(Employee.NAME_PROPERTY, subject) {
-				@Override
-				protected String buildValue_() {
-					return subject.getName();
-				}
-
-				@Override
-				protected void setValue_(String value) {
-					subject.setName(value);
-				}
-			};
-		}
-
-		private WritablePropertyValueModel<String> buildTitleHolder(Employee subject) {
-			return new PropertyAspectAdapter<Employee, String>(Employee.TITLE_PROPERTY, subject) {
-				@Override
-				protected String buildValue_() {
-					return subject.getTitle();
-				}
-
-				@Override
-				protected void setValue_(String value) {
-					subject.setTitle(value);
-				}
-			};
-		}
-
-		public WritablePropertyValueModel<?>[] cellModels(Employee subject) {
-			WritablePropertyValueModel<?>[] holders = new WritablePropertyValueModel<?>[3];
-			holders[NAME_COLUMN] = buildNameHolder(subject);
-			holders[TITLE_COLUMN] = buildTitleHolder(subject);
-			holders[MANAGER_COLUMN] = buildManagerHolder(subject);
-			return holders;
-		}
-
-		public int columnCount() {
-			return COLUMN_COUNT;
-		}
-
-		public String columnName(int columnIndex) {
-			return String.valueOf(columnIndex);
-		}
-	}
-
-	private class TableLabelProvider extends LabelProvider
-	                                 implements ITableLabelProvider {
-
-
-		public Image getColumnImage(Object element, int columnIndex) {
-			return null;
-		}
-
-		public String getColumnText(Object element, int columnIndex) {
-			Employee employee = (Employee) element;
-
-			if (columnIndex == TableColumnAdapter.NAME_COLUMN) {
-				return employee.getName();
-			}
-
-			if (columnIndex == TableColumnAdapter.TITLE_COLUMN) {
-				return employee.getTitle();
-			}
-
-			return employee.getManager();
-		}
-	}
-
-	private class TableModel extends TableModelAdapter<Employee> {
-
-		TableModel(ListValueModel<Employee> listHolder,
-		           CollectionValueModel<Employee> selectedItemsHolder,
-		           Table table,
-		           ColumnAdapter<Employee> columnAdapter,
-		           ITableLabelProvider labelProvider) {
-
-			super(listHolder,
-			      selectedItemsHolder,
-			      table,
-			      columnAdapter,
-			      labelProvider);
-		}
-
-		TableModel(ListValueModel<Employee> listHolder,
-		           WritablePropertyValueModel<Employee> selectedItemHolder,
-		           Table table,
-		           ColumnAdapter<Employee> columnAdapter,
-		           ITableLabelProvider labelProvider) {
-
-			super(listHolder,
-					new PropertyCollectionValueModelAdapter<Employee>(selectedItemHolder),
-			      table,
-			      columnAdapter,
-			      labelProvider);
-		}
-
-		@Override
-		protected int indexOf(Employee item) {
-			return super.indexOf(item);
-		}
-
-		@Override
-		protected Collection<Employee> selectedItems() {
-			return super.selectedItems();
-		}
-
-		@Override
-		protected void tableSelectionChanged(SelectionEvent event) {
-			super.tableSelectionChanged(event);
-		}
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/TriStateCheckBoxModelAdapterUITest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/TriStateCheckBoxModelAdapterUITest.java
deleted file mode 100644
index 3993af3..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/swt/TriStateCheckBoxModelAdapterUITest.java
+++ /dev/null
@@ -1,319 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.swt;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jpt.ui.internal.swt.TriStateCheckBoxModelAdapter;
-import org.eclipse.jpt.ui.internal.widgets.DefaultWidgetFactory;
-import org.eclipse.jpt.ui.internal.widgets.TriStateCheckBox;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.model.value.PropertyValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.layout.FillLayout;
-import org.eclipse.swt.layout.FormAttachment;
-import org.eclipse.swt.layout.FormData;
-import org.eclipse.swt.layout.FormLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- * Play around with a set of tri-state check boxes.
- */
-public class TriStateCheckBoxModelAdapterUITest
-	extends ApplicationWindow
-{
-	private final TestModel testModel;
-	private final WritablePropertyValueModel<TestModel> testModelHolder;
-	private final WritablePropertyValueModel<Boolean> flag1Holder;
-	private final WritablePropertyValueModel<Boolean> flag2Holder;
-	private final WritablePropertyValueModel<Boolean> notFlag2Holder;
-
-	public static void main(String[] args) throws Exception {
-		Window window = new TriStateCheckBoxModelAdapterUITest(args);
-		window.setBlockOnOpen(true);
-		window.open();
-		Display.getCurrent().dispose();
-		System.exit(0);
-	}
-
-	private TriStateCheckBoxModelAdapterUITest(String[] args) {
-		super(null);
-		this.testModel = new TestModel(Boolean.TRUE, Boolean.FALSE);
-		this.testModelHolder = new SimplePropertyValueModel<TestModel>(this.testModel);
-		this.flag1Holder = this.buildFlag1Holder(this.testModelHolder);
-		this.flag2Holder = this.buildFlag2Holder(this.testModelHolder);
-		this.notFlag2Holder = this.buildNotFlag2Holder(this.testModelHolder);
-	}
-
-	private WritablePropertyValueModel<Boolean> buildFlag1Holder(PropertyValueModel<TestModel> subjectHolder) {
-		return new PropertyAspectAdapter<TestModel, Boolean>(subjectHolder, TestModel.FLAG1_PROPERTY) {
-			@Override
-			protected Boolean buildValue_() {
-				return this.subject.isFlag1();
-			}
-			@Override
-			protected void setValue_(Boolean value) {
-				this.subject.setFlag1(value);
-			}
-		};
-	}
-
-	private WritablePropertyValueModel<Boolean> buildFlag2Holder(PropertyValueModel<TestModel> subjectHolder) {
-		return new PropertyAspectAdapter<TestModel, Boolean>(subjectHolder, TestModel.FLAG2_PROPERTY) {
-			@Override
-			protected Boolean buildValue_() {
-				return this.subject.isFlag2();
-			}
-			@Override
-			protected void setValue_(Boolean value) {
-				this.subject.setFlag2(value);
-			}
-		};
-	}
-
-	private WritablePropertyValueModel<Boolean> buildNotFlag2Holder(PropertyValueModel<TestModel> subjectHolder) {
-		return new PropertyAspectAdapter<TestModel, Boolean>(subjectHolder, TestModel.NOT_FLAG2_PROPERTY) {
-			@Override
-			protected Boolean buildValue_() {
-				return this.subject.isNotFlag2();
-			}
-			@Override
-			protected void setValue_(Boolean value) {
-				this.subject.setNotFlag2(value);
-			}
-		};
-	}
-
-	@Override
-	protected Control createContents(Composite parent) {
-		((Shell) parent).setText(this.getClass().getSimpleName());
-		parent.setSize(400, 100);
-		Composite mainPanel = new Composite(parent, SWT.NONE);
-		mainPanel.setLayout(new FormLayout());
-		Control checkBoxPanel = this.buildCheckBoxPanel(mainPanel);
-		this.buildControlPanel(mainPanel, checkBoxPanel);
-		return mainPanel;
-	}
-
-	private Control buildCheckBoxPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100, -35);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildFlag1CheckBox(panel);
-		this.buildFlag2CheckBox(panel);
-		this.buildNotFlag2CheckBox(panel);
-		this.buildUnattachedCheckBox(panel);
-
-		return panel;
-	}
-
-	private void buildFlag1CheckBox(Composite parent) {
-		TriStateCheckBox checkBox = new TriStateCheckBox(parent, "flag 1", DefaultWidgetFactory.instance());
-		TriStateCheckBoxModelAdapter.adapt(this.flag1Holder, checkBox);
-	}
-
-	private void buildFlag2CheckBox(Composite parent) {
-		TriStateCheckBox checkBox = new TriStateCheckBox(parent, "flag 2", DefaultWidgetFactory.instance());
-		TriStateCheckBoxModelAdapter.adapt(this.flag2Holder, checkBox);
-	}
-
-	private void buildNotFlag2CheckBox(Composite parent) {
-		TriStateCheckBox checkBox = new TriStateCheckBox(parent, "next flag 2", DefaultWidgetFactory.instance());
-		TriStateCheckBoxModelAdapter.adapt(this.notFlag2Holder, checkBox);
-	}
-
-	private void buildUnattachedCheckBox(Composite parent) {
-		TriStateCheckBox checkBox = new TriStateCheckBox(parent, "unattached", DefaultWidgetFactory.instance());
-		checkBox.addSelectionListener(this.buildUnattachedSelectionListener());
-	}
-
-	private SelectionListener buildUnattachedSelectionListener() {
-		return new SelectionListener() {
-			public void widgetDefaultSelected(SelectionEvent e) {
-				System.out.println("unattached default selected: " + e);
-			}
-			public void widgetSelected(SelectionEvent e) {
-				System.out.println("unattached selected: " + e);
-			}
-		};
-	}
-
-	private void buildControlPanel(Composite parent, Control checkBoxPanel) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(checkBoxPanel);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildFlipFlag1Button(panel);
-		this.buildClearModelButton(panel);
-		this.buildRestoreModelButton(panel);
-		this.buildPrintModelButton(panel);
-	}
-
-	private void buildFlipFlag1Button(Composite parent) {
-		this.buildFlipFlag1ACI().fill(parent);
-	}
-
-	private ActionContributionItem buildFlipFlag1ACI() {
-		Action action = new Action("next flag 1", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				TriStateCheckBoxModelAdapterUITest.this.nextFlag1();
-			}
-		};
-		action.setToolTipText("next flag 1");
-		return new ActionContributionItem(action);
-	}
-
-	void nextFlag1() {
-		this.testModel.nextFlag1();
-	}
-
-	private void buildClearModelButton(Composite parent) {
-		this.buildClearModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildClearModelACI() {
-		Action action = new Action("clear model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				TriStateCheckBoxModelAdapterUITest.this.clearModel();
-			}
-		};
-		action.setToolTipText("clear model");
-		return new ActionContributionItem(action);
-	}
-
-	void clearModel() {
-		this.testModelHolder.setValue(null);
-	}
-
-	private void buildRestoreModelButton(Composite parent) {
-		this.buildRestoreModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildRestoreModelACI() {
-		Action action = new Action("restore model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				TriStateCheckBoxModelAdapterUITest.this.restoreModel();
-			}
-		};
-		action.setToolTipText("restore model");
-		return new ActionContributionItem(action);
-	}
-
-	void restoreModel() {
-		this.testModelHolder.setValue(this.testModel);
-	}
-
-	private void buildPrintModelButton(Composite parent) {
-		this.buildPrintModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildPrintModelACI() {
-		Action action = new Action("print model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				TriStateCheckBoxModelAdapterUITest.this.printModel();
-			}
-		};
-		action.setToolTipText("print model");
-		return new ActionContributionItem(action);
-	}
-
-	void printModel() {
-		System.out.println("flag 1: " + this.testModel.isFlag1());
-		System.out.println("flag 2: " + this.testModel.isFlag2());
-		System.out.println("not flag 2: " + this.testModel.isNotFlag2());
-		System.out.println("***");
-	}
-
-
-	private class TestModel extends AbstractModel {
-		private Boolean flag1;
-			public static final String FLAG1_PROPERTY = "flag1";
-		private Boolean flag2;
-			public static final String FLAG2_PROPERTY = "flag2";
-		private Boolean notFlag2;
-			public static final String NOT_FLAG2_PROPERTY = "notFlag2";
-	
-		public TestModel(Boolean flag1, Boolean flag2) {
-			this.flag1 = flag1;
-			this.flag2 = flag2;
-			this.notFlag2 = this.next(flag2);
-		}
-		private Boolean next(Boolean b) {
-			return (b == null) ? Boolean.TRUE : b.booleanValue() ? Boolean.FALSE : null;
-		}
-		public Boolean isFlag1() {
-			return this.flag1;
-		}
-		public void setFlag1(Boolean flag1) {
-			Boolean old = this.flag1;
-			this.flag1 = flag1;
-			this.firePropertyChanged(FLAG1_PROPERTY, old, flag1);
-		}
-		public void nextFlag1() {
-			this.setFlag1(this.next(this.flag1));
-		}
-		public Boolean isFlag2() {
-			return this.flag2;
-		}
-		public void setFlag2(Boolean flag2) {
-			Boolean old = this.flag2;
-			this.flag2 = flag2;
-			this.firePropertyChanged(FLAG2_PROPERTY, old, flag2);
-
-			old = this.notFlag2;
-			this.notFlag2 = this.next(flag2);
-			this.firePropertyChanged(NOT_FLAG2_PROPERTY, old, this.notFlag2);
-		}
-		public void nextFlag2() {
-			this.setFlag2(this.next(this.flag2));
-		}
-		public Boolean isNotFlag2() {
-			return this.notFlag2;
-		}
-		public void setNotFlag2(Boolean notFlag2) {
-			this.setFlag2(this.next(flag2));
-		}
-		public void nextNotFlag2() {
-			this.setNotFlag2(this.next(this.notFlag2));
-		}
-		@Override
-		public String toString() {
-			return "TestModel(" + this.isFlag1() + " - " + this.isFlag2() + ")";
-		}
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlAlignerTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlAlignerTest.java
deleted file mode 100644
index a031783..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlAlignerTest.java
+++ /dev/null
@@ -1,800 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.*;
-import org.eclipse.jface.dialogs.TitleAreaDialog;
-import org.eclipse.jpt.ui.internal.util.ControlAligner;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.jpt.utility.internal.ReflectionTools;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Layout;
-import org.eclipse.swt.widgets.Shell;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class ControlAlignerTest {
-
-	private ControlAligner controlAligner;
-	private Composite parent;
-	private Shell shell;
-
-	private Layout buildSpacerLayout() {
-		return new Layout() {
-			@Override
-			protected Point computeSize(Composite composite,
-			                            int widthHint,
-			                            int heightHint,
-			                            boolean flushCache) {
-
-				return new Point(widthHint, heightHint);
-			}
-
-			@Override
-			protected void layout(Composite composite, boolean flushCache) {
-				GridData data = (GridData) composite.getLayoutData();
-				composite.setBounds(0, 0, data.widthHint, data.heightHint);
-			}
-		};
-	}
-
-	@Before
-	public void setUp() {
-
-		controlAligner = new ControlAligner();
-
-		shell  = new Shell(Display.getCurrent());
-		shell.setLayout(new GridLayout(1, false));
-
-		parent = new Composite(shell, SWT.NONE);
-		parent.setLayout(new GridLayout(1, false));
-		parent.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING));
-	}
-
-	@After
-	public void tearDown() {
-
-		if (controlAligner != null) {
-			controlAligner.dispose();
-			controlAligner = null;
-		}
-
-		if (shell != null) {
-			shell.dispose();
-			shell = null;
-		}
-	}
-
-	@Test
-	public void testAddControl1() throws Exception {
-
-		Composite pane = new Composite(parent, SWT.NULL);
-		pane.setLayout(new GridLayout(3, false));
-		pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		Label label = new Label(pane, SWT.NULL);
-		updateGridData(label);
-
-		controlAligner.add(label);
-
-		assertEquals(
-			"The maximum width should be 0,",
-			0,
-			controlAligner.getMaximumWidth()
-		);
-
-		label.setText("This is a ControlAligner");
-//		parent.layout(true, true);
-
-		Point size = label.getSize();
-
-		assertEquals(
-			"The width should be " + size.x + ",",
-			size.x,
-			controlAligner.getMaximumWidth()
-		);
-	}
-
-	@Test
-	public void testAddControl2() throws Exception {
-
-		Composite pane = new Composite(parent, SWT.NULL);
-		pane.setLayout(new GridLayout(3, false));
-		pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		Button button = new Button(pane, SWT.NULL);
-		button.setText("This is a ControlAligner");
-		updateGridData(button);
-
-		controlAligner.add(button);
-		parent.layout(true, true);
-
-		Point size = button.getSize();
-
-		assertEquals(
-			"The width should be " + size.x + ",",
-			size.x,
-			controlAligner.getMaximumWidth()
-		);
-	}
-
-	@Test
-	public void testAddControl3() throws Exception {
-
-		Composite pane = new Composite(parent, SWT.NULL);
-		pane.setLayout(new GridLayout(3, false));
-		pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		Label label = new Label(pane, SWT.NULL);
-		label.setText("This is very long text");
-		updateGridData(label);
-
-		Button button = new Button(pane, SWT.NULL);
-		button.setText("Short text");
-		updateGridData(button);
-
-//		parent.layout(true, true);
-
-		controlAligner.add(label);
-		controlAligner.add(button);
-
-		Point labelSize  = label.getSize();
-		Point buttonSize = button.getSize();
-		int max = Math.max(labelSize.x, buttonSize.x);
-
-		assertEquals(
-			"The width should be " + max + ",",
-			max,
-			controlAligner.getMaximumWidth()
-		);
-	}
-
-	@Test
-	public void testAddControlAligner1() throws Exception {
-
-		Label label1 = new Label(parent, SWT.NULL);
-		Label label2 = new Label(parent, SWT.NULL);
-
-		updateGridData(label1);
-		updateGridData(label2);
-
-		controlAligner.add(label1);
-
-		ControlAligner controlAligner2 = new ControlAligner();
-		controlAligner.add(controlAligner2);
-		controlAligner2.add(label2);
-
-		label1.setText("This is a ControlAligner");
-		label2.setText("This is a very long ControlAligner");
-//		parent.layout(true, true);
-
-		Point size1 = label1.getSize();
-		Point size2 = label2.getSize();
-		int width = Math.max(size1.x, size2.x);
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner.getMaximumWidth()
-		);
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner2.getMaximumWidth()
-		);
-	}
-
-	@Test
-	public void testAddControlAligner2() throws Exception {
-
-		Label label1 = new Label(parent, SWT.NULL);
-		Label label2 = new Label(parent, SWT.NULL);
-
-		updateGridData(label1);
-		updateGridData(label2);
-
-		controlAligner.add(label1);
-
-		ControlAligner controlAligner2 = new ControlAligner();
-		controlAligner2.add(label2);
-
-		label1.setText("This is a ControlAligner");
-		label2.setText("This is a very long ControlAligner");
-
-		controlAligner.add(controlAligner2);
-//		parent.layout(true, true);
-
-		Point size1 = label1.getSize();
-		Point size2 = label2.getSize();
-		int width = Math.max(size1.x, size2.x);
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner.getMaximumWidth()
-		);
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner2.getMaximumWidth()
-		);
-	}
-
-	@Test(expected=IllegalArgumentException.class)
-	public void testAddControlAlignerToItself() throws Exception {
-		controlAligner.add(controlAligner);
-		fail("A ControlAligner can't be added to itself");
-	}
-
-	@Test
-	public void testDialog_AddControl1() throws Exception {
-
-		final int[] maximumWidth = new int[1];
-		final int[] size = new int[1];
-
-		TitleAreaDialog dialog = new TitleAreaDialog(SWTUtil.getShell()) {
-
-			private Label label;
-
-			@Override
-			protected Control createDialogArea(Composite parent) {
-
-				Composite pane = new Composite(parent, SWT.NULL);
-				pane.setLayout(new GridLayout(3, false));
-				pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-				label = new Label(pane, SWT.LEFT);
-				label.setText("This is a ControlAligner");
-				updateGridData(label);
-
-				controlAligner.add(label);
-
-				return parent;
-			}
-
-			@Override
-			protected void initializeBounds() {
-				super.initializeBounds();
-				size[0] = label.getSize().x;
-				maximumWidth[0] = controlAligner.getMaximumWidth();
-			}
-		};
-
-		dialog.create();
-		dialog.close();
-
-		assertEquals(
-			"The width should be " + size[0] + ",",
-			size[0],
-			maximumWidth[0]
-		);
-	}
-
-	@Test
-	public void testDialog_AddControl2() throws Exception {
-
-		final int[] maximumWidth = new int[1];
-		final int[] sizes = new int[2];
-
-		TitleAreaDialog dialog = new TitleAreaDialog(SWTUtil.getShell()) {
-
-			private Button button;
-			private Label label;
-
-			@Override
-			protected Control createDialogArea(Composite parent) {
-
-				Composite pane = new Composite(parent, SWT.NULL);
-				pane.setLayout(new GridLayout(3, false));
-				pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-				label = new Label(pane, SWT.NULL);
-				label.setText("This is a ControlAligner");
-				updateGridData(label);
-
-				controlAligner.add(label);
-
-				button = new Button(pane, SWT.NULL);
-				button.setText("Short text");
-				updateGridData(button);
-
-				controlAligner.add(button);
-
-				return parent;
-			}
-
-			@Override
-			protected void initializeBounds() {
-				super.initializeBounds();
-				sizes[0] = label.getSize().x;
-				sizes[1] = button.getSize().x;
-				maximumWidth[0] = controlAligner.getMaximumWidth();
-			}
-		};
-
-		dialog.create();
-		dialog.close();
-
-		int labelSize  = sizes[0];
-		int buttonSize = sizes[1];
-		int max = Math.max(labelSize, buttonSize);
-
-		assertEquals(
-			"The width should be " + max + ",",
-			max,
-			maximumWidth[0]
-		);
-	}
-
-	@Test
-	public void testDispose() throws Exception {
-
-		Composite pane = new Composite(parent, SWT.NULL);
-		pane.setLayout(new GridLayout(3, false));
-		pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		Label label = new Label(pane, SWT.NULL);
-		label.setText("This is very long text");
-		updateGridData(label);
-
-		Button button = new Button(pane, SWT.NULL);
-		button.setText("Short text");
-		updateGridData(button);
-
-		controlAligner.add(label);
-		controlAligner.add(button);
-
-		Point labelSize  = label.getSize();
-		Point buttonSize = button.getSize();
-		int max = Math.max(labelSize.x, buttonSize.x);
-
-		assertEquals(
-			"The width should be " + max + ",",
-			max,
-			controlAligner.getMaximumWidth()
-		);
-
-		label.dispose();
-
-		Point newButtonSize = button.getSize();
-
-		assertNotSame(
-			"The old max and new max should not be the same",
-			max,
-			newButtonSize.x
-		);
-
-		assertEquals(
-			"The ControlAligner doesn't have the right maximum width",
-			newButtonSize.x,
-			controlAligner.getMaximumWidth()
-		);
-	}
-
-	@Test
-	public void testHierarchyOfControlAligners() throws Exception {
-
-		// Aligner1
-		//  ^
-		//  |-Aligner2
-		//     ^
-		//     |-Aligner3
-		ControlAligner controlAligner2 = new ControlAligner();
-		controlAligner.add(controlAligner2);
-
-		ControlAligner controlAligner3 = new ControlAligner();
-		controlAligner2.add(controlAligner3);
-
-		// Test 1
-		Label label1 = new Label(parent, SWT.NULL);
-		label1.setText("This is a label widget");
-		parent.layout(true, true);
-
-		int labelWidth1 = label1.getSize().x;
-		controlAligner3.add(label1);
-
-		assertEquals(controlAligner3.getMaximumWidth(), labelWidth1);
-		assertEquals(controlAligner2.getMaximumWidth(), labelWidth1);
-		assertEquals(controlAligner.getMaximumWidth(), labelWidth1);
-
-		// Test 2
-		Label label2 = new Label(parent, SWT.NULL);
-		label2.setText("ShortLabel");
-		controlAligner2.add(label2);
-		parent.layout(true);
-
-		int newLabelWidth1 = label1.getSize().x;
-		int newLabelWidth2 = label2.getSize().x;
-
-		assertEquals(controlAligner3.getMaximumWidth(), controlAligner2.getMaximumWidth());
-		assertEquals(controlAligner2.getMaximumWidth(), controlAligner.getMaximumWidth());
-		assertEquals(newLabelWidth1, newLabelWidth2);
-		assertEquals(newLabelWidth1, controlAligner.getMaximumWidth());
-
-		// Test 3
-		Label label3 = new Label(parent, SWT.NULL);
-		label3.setText("A very long label that takes a lot of horizontal space");
-//		parent.layout(true);
-		controlAligner.add(label3);
-
-		newLabelWidth1 = label1.getSize().x;
-		newLabelWidth2 = label2.getSize().x;
-		int newLabelWidth3 = label3.getSize().x;
-
-		assertEquals(controlAligner3.getMaximumWidth(), controlAligner2.getMaximumWidth());
-		assertEquals(controlAligner2.getMaximumWidth(), controlAligner.getMaximumWidth());
-		assertEquals(newLabelWidth1, newLabelWidth2);
-		assertEquals(newLabelWidth2, newLabelWidth3);
-		assertEquals(newLabelWidth1, controlAligner.getMaximumWidth());
-
-		// Make sure all the locked are removed
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner, "locked"), Boolean.FALSE);
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner2, "locked"), Boolean.FALSE);
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner3, "locked"), Boolean.FALSE);
-
-		// Change the text of label2
-		label2.setText("mm");
-//		parent.layout(true);
-
-		newLabelWidth1 = label1.getSize().x;
-		newLabelWidth2 = label2.getSize().x;
-		newLabelWidth3 = label3.getSize().x;
-
-		assertEquals(controlAligner3.getMaximumWidth(), controlAligner2.getMaximumWidth());
-		assertEquals(controlAligner2.getMaximumWidth(), controlAligner.getMaximumWidth());
-		assertEquals(newLabelWidth1, newLabelWidth2);
-		assertEquals(newLabelWidth2, newLabelWidth3);
-		assertEquals(newLabelWidth1, controlAligner.getMaximumWidth());
-
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner, "locked"), Boolean.FALSE);
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner2, "locked"), Boolean.FALSE);
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner3, "locked"), Boolean.FALSE);
-
-		// Change the text of label1
-		label1.setText("a");
-//		parent.layout(true);
-
-		Composite parent1 = new Composite(SWTUtil.getShell(), SWT.NULL);
-		parent1.setLayout(new GridLayout());
-
-		Label tempLabel = new Label(parent1, SWT.NULL);
-		tempLabel.setText("a");
-//		parent1.layout(true);
-
-		int realWidth = tempLabel.getSize().x;
-
-		newLabelWidth1 = label1.getSize().x;
-		newLabelWidth2 = label2.getSize().x;
-		newLabelWidth3 = label3.getSize().x;
-
-		assertEquals(controlAligner3.getMaximumWidth(), controlAligner2.getMaximumWidth());
-		assertEquals(controlAligner2.getMaximumWidth(), controlAligner.getMaximumWidth());
-		assertEquals(newLabelWidth1, newLabelWidth2);
-		assertEquals(newLabelWidth2, newLabelWidth3);
-		assertEquals(newLabelWidth1, controlAligner.getMaximumWidth());
-		assertFalse(newLabelWidth1 == realWidth);
-
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner, "locked"), Boolean.FALSE);
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner2, "locked"), Boolean.FALSE);
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner3, "locked"), Boolean.FALSE);
-
-		// Change the text of label1
-		label1.setText("Yes another big long long text so that all the labels will have to take the size of this label to make sure ControlAligner works correctly");
-//		parent.layout(true);
-
-		// Weird: It seems no notification is sent, fire one manually
-		Event event  = new Event();
-		event.widget = label1;
-		event.type   = SWT.Resize;
-		label1.notifyListeners(SWT.Resize, event);
-
-		Composite parent2 = new Composite(SWTUtil.getShell(), SWT.NULL);
-		parent2.setLayout(new GridLayout());
-
-		tempLabel = new Label(parent2, SWT.NULL);
-		tempLabel.setText(label1.getText());
-		parent2.layout(true);
-
-		realWidth = tempLabel.getSize().x;
-
-		newLabelWidth1 = label1.getSize().x;
-		newLabelWidth2 = label2.getSize().x;
-		newLabelWidth3 = label3.getSize().x;
-
-		assertEquals(controlAligner3.getMaximumWidth(), controlAligner2.getMaximumWidth());
-		assertEquals(controlAligner2.getMaximumWidth(), controlAligner.getMaximumWidth());
-		assertEquals(newLabelWidth1, newLabelWidth2);
-		assertEquals(newLabelWidth2, newLabelWidth3);
-		assertEquals(controlAligner.getMaximumWidth(), newLabelWidth1);
-		assertEquals(realWidth, newLabelWidth1);
-
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner, "locked"), Boolean.FALSE);
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner2, "locked"), Boolean.FALSE);
-		assertEquals(ReflectionTools.getFieldValue_(controlAligner3, "locked"), Boolean.FALSE);
-	}
-
-	@Test
-	public void testRemoveControl1() throws Exception {
-
-		Composite pane = new Composite(parent, SWT.NULL);
-		pane.setLayout(new GridLayout(3, false));
-		pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		Button button = new Button(pane, SWT.NULL);
-		button.setText("This is a ControlAligner");
-		updateGridData(button);
-
-		controlAligner.add(button);
-		parent.layout(true, true);
-
-		Point size = button.getSize();
-
-		assertEquals(
-			"The width should be " + size.x + ",",
-			size.x,
-			controlAligner.getMaximumWidth()
-		);
-
-		controlAligner.remove(button);
-
-		assertEquals(
-			"The width should be 0, ",
-			0,
-			controlAligner.getMaximumWidth()
-		);
-	}
-
-	@Test
-	public void testRemoveControl2() throws Exception {
-
-		Composite pane = new Composite(parent, SWT.NULL);
-		pane.setLayout(new GridLayout(3, false));
-		pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		Label label = new Label(pane, SWT.NULL);
-		label.setText("This is very long text");
-		updateGridData(label);
-
-		Button button = new Button(pane, SWT.NULL);
-		button.setText("Short text");
-		updateGridData(button);
-//		parent.layout(true, true);
-
-		controlAligner.add(label);
-		controlAligner.add(button);
-
-		Point labelSize  = label.getSize();
-		Point buttonSize = button.getSize();
-		int max = Math.max(labelSize.x, buttonSize.x);
-
-		assertEquals(
-			"The width should be " + max + ",",
-			max,
-			controlAligner.getMaximumWidth()
-		);
-
-		controlAligner.remove(label);
-
-		Point newButtonSize = button.getSize();
-
-		assertNotSame(
-			"The old max and new max should not be the same",
-			max,
-			newButtonSize.x
-		);
-
-		assertEquals(
-			"The ControlAligner doesn't have the right maximum width",
-			newButtonSize.x,
-			controlAligner.getMaximumWidth()
-		);
-	}
-
-	@Test
-	public void testRemoveControl4() throws Exception {
-
-		Composite pane = new Composite(parent, SWT.NULL);
-		pane.setLayout(new GridLayout(3, false));
-		pane.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-		// Widget 1
-		Label label = new Label(pane, SWT.NULL);
-		label.setText("This is very long text");
-		updateGridData(label);
-		controlAligner.add(label);
-
-		// Widget 2
-		Composite spacer = new Composite(pane, SWT.NULL);
-		spacer.setLayout(buildSpacerLayout());
-		updateGridData(spacer);
-		controlAligner.add(spacer);
-
-		// Widget 3
-		Button button = new Button(pane, SWT.NULL);
-		button.setText("Short text");
-		updateGridData(button);
-		controlAligner.add(button);
-
-//		parent.layout(true, true);
-
-		// Make sure the 3 widgets have the same width
-		Point labelSize  = label.getSize();
-		Point spacerSize = spacer.getSize();
-		Point buttonSize = button.getSize();
-		int max = Math.max(labelSize.x, buttonSize.x);
-		max = Math.max(max, spacerSize.x);
-
-		assertEquals(
-			"The width should be " + max + ",",
-			max,
-			controlAligner.getMaximumWidth()
-		);
-
-		assertEquals(
-			"The spacer's width should be " + max + ",",
-			max,
-			spacerSize.x
-		);
-
-		// Remove the label (the widest widget) and make sure the width was
-		// correctly calculated
-		controlAligner.remove(label);
-
-		spacerSize = spacer.getSize();
-		buttonSize = button.getSize();
-		int max2 = Math.max(spacerSize.x, buttonSize.x);
-
-		assertNotSame(
-			"The old max and new max should not be the same",
-			max,
-			max2
-		);
-
-		assertEquals(
-			"The ControlAligner doesn't have the right maximum width",
-			max2,
-			controlAligner.getMaximumWidth()
-		);
-
-		assertEquals(
-			"The spacer's width should have been adjusted",
-			max2,
-			spacerSize.x
-		);
-	}
-
-	@Test
-	public void testRemoveControlAligner1() throws Exception {
-
-		Label label1 = new Label(parent, SWT.NULL);
-		Label label2 = new Label(parent, SWT.NULL);
-
-		updateGridData(label1);
-		updateGridData(label2);
-
-		controlAligner.add(label1);
-
-		ControlAligner controlAligner2 = new ControlAligner();
-		controlAligner.add(controlAligner2);
-		controlAligner2.add(label2);
-
-		label1.setText("This is a ControlAligner");
-		label2.setText("This is a very long ControlAligner");
-//		parent.layout(true, true);
-
-		Point size1 = label1.getSize();
-		Point size2 = label2.getSize();
-		int width = Math.max(size1.x, size2.x);
-
-		// Test 1
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner.getMaximumWidth()
-		);
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner2.getMaximumWidth()
-		);
-
-		// Test 2
-		controlAligner.remove(label1);
-
-		width = label2.getSize().x;
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner.getMaximumWidth()
-		);
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner2.getMaximumWidth()
-		);
-	}
-
-	@Test
-	public void testRemoveControlAligner2() throws Exception {
-
-		Label label1 = new Label(parent, SWT.NULL);
-		Label label2 = new Label(parent, SWT.NULL);
-
-		updateGridData(label1);
-		updateGridData(label2);
-
-		controlAligner.add(label1);
-
-		ControlAligner controlAligner2 = new ControlAligner();
-		controlAligner.add(controlAligner2);
-		controlAligner2.add(label2);
-
-		label1.setText("This is a ControlAligner");
-		label2.setText("This is a very long ControlAligner");
-//		parent.layout(true, true);
-
-		Point size1 = label1.getSize();
-		Point size2 = label2.getSize();
-		int width = Math.max(size1.x, size2.x);
-
-		// Test 1
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner.getMaximumWidth()
-		);
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner2.getMaximumWidth()
-		);
-
-		// Test 2
-		controlAligner2.remove(label2);
-
-		width = label1.getSize().x;
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner.getMaximumWidth()
-		);
-
-		assertEquals(
-			"The width should be " + width + ",",
-			width,
-			controlAligner2.getMaximumWidth()
-		);
-	}
-
-	private void updateGridData(Control control) {
-		GridData data = new GridData();
-		data.horizontalAlignment       = GridData.FILL;
-		data.grabExcessHorizontalSpace = false;
-		control.setLayoutData(data);
-	}
-}
\ No newline at end of file
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlEnablerTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlEnablerTest.java
deleted file mode 100644
index 88cb7f2..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlEnablerTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.*;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.jpt.ui.internal.utility.swt.SWTTools;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Combo;
-import org.eclipse.swt.widgets.Composite;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class ControlEnablerTest {
-	private Composite parent;
-
-	@Before
-	public void setUp() {
-		parent = new Composite(SWTUtil.getShell(), SWT.NONE);
-		parent.setLayout(new GridLayout());
-	}
-
-	@After
-	public void tearDown() {
-		if (parent != null) {
-			parent.dispose();
-		}
-	}
-
-	@Test
-	public void testSwitchState() {
-
-		SimplePropertyValueModel<Boolean> booleanHolder =
-			new SimplePropertyValueModel<Boolean>(true);
-
-		Combo combo = new Combo(parent, SWT.BORDER);
-
-		SWTTools.controlEnabledState(booleanHolder, combo);
-
-		assertTrue(
-			"The Combo should be enabled",
-			combo.isEnabled()
-		);
-
-		// Change state (null)
-		booleanHolder.setValue(null);
-
-		assertFalse(
-			"The Combo should not be enabled",
-			combo.isEnabled()
-		);
-
-		// Change state (true)
-		booleanHolder.setValue(true);
-
-		assertTrue(
-			"The Combo should be enabled",
-			combo.isEnabled()
-		);
-
-		// Change state (false)
-		booleanHolder.setValue(false);
-
-		assertFalse(
-			"The Combo should not be enabled",
-			combo.isEnabled()
-		);
-
-		// Dispose
-		combo.dispose();
-		booleanHolder.setValue(true);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlSwitcherTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlSwitcherTest.java
deleted file mode 100644
index c124f60..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlSwitcherTest.java
+++ /dev/null
@@ -1,187 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.*;
-import org.eclipse.jpt.ui.internal.util.ControlSwitcher;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.jpt.utility.internal.ReflectionTools;
-import org.eclipse.jpt.utility.internal.Transformer;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Combo;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.part.PageBook;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class ControlSwitcherTest {
-
-	private PageBook pageBook;
-	private Composite pane1;
-	private Composite pane2;
-	private Composite parent;
-
-	private Composite buildPane1() {
-
-		if (pane1 == null) {
-
-			pane1 = new Composite(pageBook, SWT.NULL);
-			pane1.setLayout(new GridLayout(2, false));
-
-			Label label = new Label(pane1, SWT.NULL);
-			label.setText("&Test2:");
-
-			Text text = new Text(pane1, SWT.BORDER);
-			text.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-
-			Combo combo = new Combo(pane1, SWT.BORDER);
-
-			GridData data = new GridData(GridData.FILL_HORIZONTAL);
-			data.horizontalSpan = 2;
-			combo.setLayoutData(data);
-		}
-
-		return pane1;
-	}
-
-	private Composite buildPane2() {
-
-		if (pane2 == null) {
-
-			pane2 = new Composite(pageBook, SWT.NULL);
-			pane2.setLayout(new GridLayout(2, false));
-
-			Label label = new Label(pane2, SWT.NULL);
-			label.setText("&Test1:");
-
-			Text text = new Text(pane2, SWT.BORDER);
-			text.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
-		}
-
-		return pane2;
-	}
-
-	private Transformer<Boolean, Control> buildTransformer() {
-		return new Transformer<Boolean, Control>() {
-			public Control transform(Boolean value) {
-				return (value == null) ? null : (value ? pane1 : pane2);
-			}
-		};
-	}
-
-	@Before
-	public void setUp() {
-		parent = new Composite(SWTUtil.getShell(), SWT.NONE);
-		parent.setLayout(new GridLayout());
-
-		pageBook = new PageBook(parent, SWT.NULL);
-		pageBook.setLayoutData(new GridData());
-	}
-
-	@After
-	public void tearDown() {
-
-		if (parent != null) {
-
-			parent.dispose();
-
-			parent   = null;
-			pageBook = null;
-		}
-	}
-
-	@Test
-	public void testSwitch() {
-
-		SimplePropertyValueModel<Boolean> switchHolder = new SimplePropertyValueModel<Boolean>();
-		Transformer<Boolean, Control> transformer = buildTransformer();
-
-		pane1 = buildPane1();
-		pane1.setVisible(false);
-
-		pane2 = buildPane2();
-		pane2.setVisible(false);
-
-		new ControlSwitcher(
-			switchHolder,
-			transformer,
-			pageBook
-		);
-
-		// Test 1
-		switchHolder.setValue(true);
-		Control control = (Control) ReflectionTools.getFieldValue(pageBook, "currentPage");
-
-		assertNotNull(
-			"The page book's page shouldn't be null",
-			control
-		);
-
-		assertSame(
-			"The current pane should be pane1",
-			pane1,
-			control
-		);
-
-		Point pane1Size = pane1.computeSize(SWT.DEFAULT, SWT.DEFAULT);
-		Point pageBookSize = pageBook.computeSize(SWT.DEFAULT, SWT.DEFAULT);
-
-		assertEquals(
-			"The width of the PageBook should be the same as the width of pane1",
-			pane1Size.x,
-			pageBookSize.x
-		);
-
-		assertEquals(
-			"The height of the PageBook should be the same as the height of pane1",
-			pane1Size.y,
-			pageBookSize.y
-		);
-
-		// Test 2
-		switchHolder.setValue(false);
-		control = (Control) ReflectionTools.getFieldValue(pageBook, "currentPage");
-
-		assertNotNull(
-			"The page book's page shouldn't be null",
-			control
-		);
-
-		assertSame(
-			"The current pane should be pane2",
-			pane2,
-			control
-		);
-
-		Point pane2Size = pane2.computeSize(SWT.DEFAULT, SWT.DEFAULT);
-		pageBookSize = pageBook.computeSize(SWT.DEFAULT, SWT.DEFAULT);
-
-		assertEquals(
-			"The width of the PageBook should be the same as the width of pane2",
-			pane2Size.x,
-			pageBookSize.x
-		);
-
-		assertEquals(
-			"The height of the PageBook should be the same as the height of pane2",
-			pane2Size.y,
-			pageBookSize.y
-		);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlVisibilityEnablerTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlVisibilityEnablerTest.java
deleted file mode 100644
index 3a702d5..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/ControlVisibilityEnablerTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.jpt.ui.internal.utility.swt.SWTTools;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Combo;
-import org.eclipse.swt.widgets.Composite;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class ControlVisibilityEnablerTest {
-	private Composite parent;
-
-	@Before
-	public void setUp() {
-		parent = new Composite(SWTUtil.getShell(), SWT.NONE);
-		parent.setLayout(new GridLayout());
-	}
-
-	@After
-	public void tearDown() {
-		if (parent != null) {
-			parent.dispose();
-		}
-	}
-
-	@Test
-	public void testSwitchState() {
-
-		SimplePropertyValueModel<Boolean> booleanHolder =
-			new SimplePropertyValueModel<Boolean>(true);
-
-		Combo combo = new Combo(parent, SWT.BORDER);
-
-		SWTTools.controlVisibleState(booleanHolder, combo);
-
-		assertTrue(
-			"The Combo should be visible",
-			combo.isVisible()
-		);
-
-		// Change state (null)
-		booleanHolder.setValue(null);
-
-		assertFalse(
-			"The Combo should not be visible",
-			combo.isVisible()
-		);
-
-		// Change state (true)
-		booleanHolder.setValue(true);
-
-		assertTrue(
-			"The Combo should be visible",
-			combo.isVisible()
-		);
-
-		// Change state (false)
-		booleanHolder.setValue(false);
-
-		assertFalse(
-			"The Combo should not be visible",
-			combo.isVisible()
-		);
-
-		// Dispose
-		combo.dispose();
-		booleanHolder.setValue(true);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/JptUiUtilTests.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/JptUiUtilTests.java
deleted file mode 100644
index 81cfb08..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/JptUiUtilTests.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import junit.framework.JUnit4TestAdapter;
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import org.junit.runners.Suite.SuiteClasses;
-
-@SuiteClasses
-({
-	ControlAlignerTest.class,
-	ControlSwitcherTest.class,
-	ControlEnablerTest.class,
-	ControlVisibilityEnablerTest.class,
-	LabeledButtonTest.class,
-	LabeledLabelTest.class,
-	LabeledControlUpdaterTest.class,
-	PaneEnablerTest.class,
-	PaneVisibilityEnablerTest.class,
-})
-@RunWith(Suite.class)
-public final class JptUiUtilTests {
-
-	private JptUiUtilTests() {
-		super();
-		throw new UnsupportedOperationException();
-	}
-
-	public static Test suite() {
-		TestSuite suite = new TestSuite();
-		suite.addTest(new JUnit4TestAdapter(JptUiUtilTests.class));
-		return suite;
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledButtonTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledButtonTest.java
deleted file mode 100644
index dde3031..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledButtonTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.assertEquals;
-import org.eclipse.core.runtime.AssertionFailedException;
-import org.eclipse.jpt.ui.internal.util.LabeledButton;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class LabeledButtonTest {
-
-	private Composite parent;
-
-	@Before
-	public void setUp() {
-		parent = new Composite(SWTUtil.getShell(), SWT.NONE);
-		parent.setLayout(new GridLayout());
-	}
-
-	@After
-	public void tearDown() {
-		if (parent != null) {
-			parent.dispose();
-			parent = null;
-		}
-	}
-
-	@Test
-	public void testLabeledButton1() {
-		Button button = new Button(parent, SWT.NULL);
-		new LabeledButton(button);
-	}
-
-	@Test(expected=AssertionFailedException.class)
-	public void testLabeledButton2() {
-		new LabeledButton(null);
-	}
-
-	@Test
-	public void testSetImage() {
-
-		Image expected = new Image(parent.getDisplay(), 16, 16);
-
-		try {
-			Button button = new Button(parent, SWT.NULL);
-			LabeledButton labeledButton = new LabeledButton(button);
-
-			labeledButton.setImage(expected);
-
-			assertEquals(
-				"The Button didn't receive the Image",
-				expected,
-				button.getImage()
-			);
-		}
-		finally {
-			expected.dispose();
-		}
-	}
-
-	@Test
-	public void testSetImageDispose() {
-
-		Image expected = new Image(parent.getDisplay(), 16, 16);
-
-		try {
-			Button button = new Button(parent, SWT.NULL);
-			LabeledButton labeledButton = new LabeledButton(button);
-
-			button.dispose();
-
-			// This should not fail but simply do nothing
-			labeledButton.setImage(expected);
-		}
-		finally {
-			expected.dispose();
-		}
-	}
-
-	@Test
-	public void testSetText() {
-		Button button = new Button(parent, SWT.NULL);
-		LabeledButton labeledButton = new LabeledButton(button);
-
-		String expected = "This is a test";
-		labeledButton.setText(expected);
-
-		assertEquals(
-			"The Button didn't receive the text",
-			expected,
-			button.getText()
-		);
-	}
-
-	@Test
-	public void testSetTextDispose() {
-		Button button = new Button(parent, SWT.NULL);
-		LabeledButton labeledButton = new LabeledButton(button);
-
-		button.dispose();
-
-		// This should not fail but simply do nothing
-		String expected = "This is a test";
-		labeledButton.setText(expected);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledControlUpdaterTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledControlUpdaterTest.java
deleted file mode 100644
index bd2ce50..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledControlUpdaterTest.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.assertEquals;
-import org.eclipse.jpt.ui.internal.util.LabeledControlUpdater;
-import org.eclipse.jpt.ui.internal.util.LabeledLabel;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Label;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class LabeledControlUpdaterTest {
-
-	private Composite parent;
-
-	@Before
-	public void setUp() {
-		parent = new Composite(SWTUtil.getShell(), SWT.NONE);
-		parent.setLayout(new GridLayout());
-	}
-
-	@After
-	public void tearDown() {
-		if (parent != null) {
-			parent.dispose();
-			parent = null;
-		}
-	}
-
-	@Test
-	public void testSetImage() {
-
-		Image expected = new Image(parent.getDisplay(), 16, 16);
-
-		try {
-			Label label = new Label(parent, SWT.NULL);
-			LabeledLabel labeledLabel = new LabeledLabel(label);
-
-			WritablePropertyValueModel<Image> imageHolder = new SimplePropertyValueModel<Image>();
-			new LabeledControlUpdater(labeledLabel, null, imageHolder);
-
-			labeledLabel.setImage(expected);
-
-			assertEquals(
-				"The Label didn't receive the Image",
-				expected,
-				label.getImage()
-			);
-		}
-		finally {
-			expected.dispose();
-		}
-	}
-
-	@Test
-	public void testSetImageDispose() {
-
-		Image expected = new Image(parent.getDisplay(), 16, 16);
-
-		try {
-			Label label = new Label(parent, SWT.NULL);
-			LabeledLabel labeledLabel = new LabeledLabel(label);
-
-			WritablePropertyValueModel<Image> imageHolder = new SimplePropertyValueModel<Image>();
-			new LabeledControlUpdater(labeledLabel, null, imageHolder);
-
-			label.dispose();
-			labeledLabel.setImage(expected);
-		}
-		finally {
-			expected.dispose();
-		}
-	}
-
-	@Test
-	public void testSetText() {
-
-		Label label = new Label(parent, SWT.NULL);
-		LabeledLabel labeledLabel = new LabeledLabel(label);
-
-		WritablePropertyValueModel<String> textHolder = new SimplePropertyValueModel<String>();
-		new LabeledControlUpdater(labeledLabel, textHolder);
-
-		String expected = "This is a test";
-		textHolder.setValue(expected);
-
-		assertEquals(
-			"The Label didn't receive the text",
-			expected,
-			label.getText()
-		);
-	}
-
-	@Test
-	public void testSetTextDispose() {
-
-		Label label = new Label(parent, SWT.NULL);
-		LabeledLabel labeledLabel = new LabeledLabel(label);
-
-		WritablePropertyValueModel<String> textHolder = new SimplePropertyValueModel<String>();
-		new LabeledControlUpdater(labeledLabel, textHolder);
-
-		label.dispose();
-
-		String expected = "This is a test";
-		textHolder.setValue(expected);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledLabelTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledLabelTest.java
deleted file mode 100644
index f962284..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/LabeledLabelTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.assertEquals;
-import org.eclipse.core.runtime.AssertionFailedException;
-import org.eclipse.jpt.ui.internal.util.LabeledLabel;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Label;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class LabeledLabelTest {
-
-	private Composite parent;
-
-	@Before
-	public void setUp() {
-		parent = new Composite(SWTUtil.getShell(), SWT.NONE);
-		parent.setLayout(new GridLayout());
-	}
-
-	@After
-	public void tearDown() {
-		if (parent != null) {
-			parent.dispose();
-			parent = null;
-		}
-	}
-
-	@Test
-	public void testLabeledButton1() {
-		Label label = new Label(parent, SWT.NULL);
-		new LabeledLabel(label);
-	}
-
-	@Test(expected=AssertionFailedException.class)
-	public void testLabeledButton2() {
-		new LabeledLabel(null);
-	}
-
-	@Test
-	public void testSetImage() {
-
-		Image expected = new Image(parent.getDisplay(), 16, 16);
-
-		try {
-			Label label = new Label(parent, SWT.NULL);
-			LabeledLabel labeledLabel = new LabeledLabel(label);
-
-			labeledLabel.setImage(expected);
-
-			assertEquals(
-				"The Label didn't receive the Image",
-				expected,
-				label.getImage()
-			);
-		}
-		finally {
-			expected.dispose();
-		}
-	}
-
-	@Test
-	public void testSetImageDispose() {
-
-		Image expected = new Image(parent.getDisplay(), 16, 16);
-
-		try {
-			Label label = new Label(parent, SWT.NULL);
-			LabeledLabel labeledLabel = new LabeledLabel(label);
-
-			label.dispose();
-
-			// This should not fail but simply do nothing
-			labeledLabel.setImage(expected);
-		}
-		finally {
-			expected.dispose();
-		}
-	}
-
-	@Test
-	public void testSetText() {
-		Label label = new Label(parent, SWT.NULL);
-		LabeledLabel labeledLabel = new LabeledLabel(label);
-
-		String expected = "This is a test";
-		labeledLabel.setText(expected);
-
-		assertEquals(
-			"The Label didn't receive the text",
-			expected,
-			label.getText()
-		);
-	}
-
-	@Test
-	public void testSetTextDispose() {
-		Label label = new Label(parent, SWT.NULL);
-		LabeledLabel labeledLabel = new LabeledLabel(label);
-
-		label.dispose();
-
-		// This should not fail but simply do nothing
-		String expected = "This is a test";
-		labeledLabel.setText(expected);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/PaneEnablerTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/PaneEnablerTest.java
deleted file mode 100644
index 5563e25..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/PaneEnablerTest.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.*;
-import org.eclipse.jpt.ui.internal.util.PaneEnabler;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.jpt.ui.internal.widgets.DialogPane;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.internal.node.Node;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class PaneEnablerTest {
-	private Composite parent;
-
-	@Before
-	public void setUp() {
-		parent = new Composite(SWTUtil.getShell(), SWT.NONE);
-		parent.setLayout(new GridLayout());
-	}
-
-	@After
-	public void tearDown() {
-		if (parent != null) {
-			parent.dispose();
-		}
-	}
-
-	@Test
-	public void testSwitchState() {
-
-		SimplePropertyValueModel<Boolean> booleanHolder =
-			new SimplePropertyValueModel<Boolean>(true);
-
-		DialogPane<Node> pane = new DialogPane<Node>(
-			new SimplePropertyValueModel<Node>(),
-			parent)
-		{
-			@Override
-			protected void initializeLayout(Composite container) {
-			}
-		};
-
-		new PaneEnabler(booleanHolder, pane);
-
-		assertTrue(
-			"The pane should be enabled",
-			pane.getControl().isEnabled()
-		);
-
-		// Change state (null)
-		booleanHolder.setValue(null);
-
-		assertFalse(
-			"The pane should not be enabled",
-			pane.getControl().isEnabled()
-		);
-
-		// Change state (true)
-		booleanHolder.setValue(true);
-
-		assertTrue(
-			"The pane should be enabled",
-			pane.getControl().isEnabled()
-		);
-
-		// Change state (false)
-		booleanHolder.setValue(false);
-
-		assertFalse(
-			"The pane should not be enabled",
-			pane.getControl().isEnabled()
-		);
-
-		// Dispose
-		pane.dispose();
-		booleanHolder.setValue(true);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/PaneVisibilityEnablerTest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/PaneVisibilityEnablerTest.java
deleted file mode 100644
index 361b4c2..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/util/PaneVisibilityEnablerTest.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2009 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.util;
-
-import static org.junit.Assert.*;
-import org.eclipse.jpt.ui.internal.util.PaneVisibilityEnabler;
-import org.eclipse.jpt.ui.internal.util.SWTUtil;
-import org.eclipse.jpt.ui.internal.widgets.DialogPane;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.internal.node.Node;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-@SuppressWarnings("nls")
-public final class PaneVisibilityEnablerTest {
-	private Composite parent;
-
-	@Before
-	public void setUp() {
-		parent = new Composite(SWTUtil.getShell(), SWT.NONE);
-		parent.setLayout(new GridLayout());
-	}
-
-	@After
-	public void tearDown() {
-		if (parent != null) {
-			parent.dispose();
-		}
-	}
-
-	@Test
-	public void testSwitchState() {
-
-		SimplePropertyValueModel<Boolean> booleanHolder =
-			new SimplePropertyValueModel<Boolean>(true);
-
-		DialogPane<Node> pane = new DialogPane<Node>(
-			new SimplePropertyValueModel<Node>(),
-			parent)
-		{
-			@Override
-			protected void initializeLayout(Composite container) {
-			}
-		};
-
-		new PaneVisibilityEnabler(booleanHolder, pane);
-
-		assertTrue(
-			"The pane should be visible",
-			pane.getControl().isVisible()
-		);
-
-		// Change state (null)
-		booleanHolder.setValue(null);
-
-		assertFalse(
-			"The pane should not be visible",
-			pane.getControl().isVisible()
-		);
-
-		// Change state (true)
-		booleanHolder.setValue(true);
-
-		assertTrue(
-			"The pane should be visible",
-			pane.getControl().isVisible()
-		);
-
-		// Change state (false)
-		booleanHolder.setValue(false);
-
-		assertFalse(
-			"The pane should not be visible",
-			pane.getControl().isVisible()
-		);
-
-		// Dispose
-		pane.dispose();
-		booleanHolder.setValue(true);
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/BooleanStateControllerUITest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/BooleanStateControllerUITest.java
deleted file mode 100644
index 9219810..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/BooleanStateControllerUITest.java
+++ /dev/null
@@ -1,278 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.utility.swt;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jpt.ui.internal.utility.swt.SWTTools;
-import org.eclipse.jpt.utility.internal.model.value.SimpleListValueModel;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.FillLayout;
-import org.eclipse.swt.layout.FormAttachment;
-import org.eclipse.swt.layout.FormData;
-import org.eclipse.swt.layout.FormLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Combo;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- * Play around with boolean state controllers ('enabled' and 'visible').
- * <p>
- * Note the behavior of composites:<ul>
- * <li>When a composite is disabled, its children are disabled but <em>not</em>
- *     grayed out.
- * <li>When a composite is made invisible, its children are also made
- *     invisible.
- * </ul>
- */
-@SuppressWarnings("nls")
-public class BooleanStateControllerUITest
-	extends ApplicationWindow
-{
-	private final WritablePropertyValueModel<Boolean> enabledHolder;
-	private final WritablePropertyValueModel<Boolean> visibleHolder;
-	private final SimpleListValueModel<String> listHolder;
-	private final WritablePropertyValueModel<String> listSelectionHolder;
-
-	public static void main(String[] args) throws Exception {
-		Window window = new BooleanStateControllerUITest(args);
-		window.setBlockOnOpen(true);
-		window.open();
-		Display.getCurrent().dispose();
-		System.exit(0);
-	}
-
-	private BooleanStateControllerUITest(@SuppressWarnings("unused") String[] args) {
-		super(null);
-		this.enabledHolder = new SimplePropertyValueModel<Boolean>(Boolean.TRUE);
-		this.visibleHolder = new SimplePropertyValueModel<Boolean>(Boolean.TRUE);
-		this.listHolder = this.buildListHolder();
-		this.listSelectionHolder = new SimplePropertyValueModel<String>(null);
-	}
-
-	private SimpleListValueModel<String> buildListHolder() {
-		SimpleListValueModel<String> result = new SimpleListValueModel<String>();
-		result.add("zero");
-		result.add("one");
-		result.add("two");
-		result.add("three");
-		result.add("four");
-		result.add("five");
-		result.add("six");
-		result.add("seven");
-		return result;
-	}
-
-	@Override
-	protected Control createContents(Composite parent) {
-		((Shell) parent).setText(this.getClass().getSimpleName());
-		parent.setSize(500, 150);
-		Composite mainPanel = new Composite(parent, SWT.NONE);
-		mainPanel.setLayout(new FormLayout());
-		Control widgetPanel = this.buildWidgetPanels(mainPanel);
-		this.buildControlPanel(mainPanel, widgetPanel);
-		return mainPanel;
-	}
-
-	private Control buildWidgetPanels(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100, -35);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout(SWT.VERTICAL));
-
-		this.buildWidgetPanel1(panel);
-		this.buildWidgetPanel2(panel);
-
-		return panel;
-	}
-
-	private void buildWidgetPanel1(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayout(new FillLayout(SWT.HORIZONTAL));
-
-		Button enabledComboBoxCheckBox = this.buildEnabledComboBoxCheckBox(panel);
-		SWTTools.bind(this.enabledHolder, enabledComboBoxCheckBox);
-
-		Button visibleComboBoxCheckBox = this.buildVisibleComboBoxCheckBox(panel);
-		SWTTools.bind(this.visibleHolder, visibleComboBoxCheckBox);
-
-		Label comboBoxLabel = this.buildComboBoxLabel(panel);
-		Combo comboBox = this.buildComboBox(panel);
-		SWTTools.bind(this.listHolder, this.listSelectionHolder, comboBox);
-		SWTTools.controlEnabledState(this.enabledHolder, comboBoxLabel, comboBox);
-		SWTTools.controlVisibleState(this.visibleHolder, comboBoxLabel, comboBox);
-	}
-
-	private Button buildEnabledComboBoxCheckBox(Composite parent) {
-		return this.buildCheckBox(parent, "enabled");
-	}
-
-	private Button buildVisibleComboBoxCheckBox(Composite parent) {
-		return this.buildCheckBox(parent, "visible");
-	}
-
-	private Button buildCheckBox(Composite parent, String text) {
-		Button checkBox = new Button(parent, SWT.CHECK);
-		checkBox.setText(text);
-		return checkBox;
-	}
-
-	private Label buildComboBoxLabel(Composite parent) {
-		Label label = new Label(parent, SWT.LEFT);
-		label.setText("list:");
-		return label;
-	}
-
-	private Combo buildComboBox(Composite parent) {
-		return new Combo(parent, SWT.READ_ONLY);
-	}
-
-	private void buildWidgetPanel2(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayout(new FillLayout(SWT.HORIZONTAL));
-
-		Button checkBox1 = this.buildCheckBox(panel, "one");
-		this.buildCheckBox(panel, "two");
-		this.buildCheckBox(panel, "three");
-		this.buildCheckBox(panel, "four");
-
-		SWTTools.controlEnabledState(this.enabledHolder, panel, checkBox1);
-		SWTTools.controlVisibleState(this.visibleHolder, panel);
-	}
-
-	private void buildControlPanel(Composite parent, Control widgetPanel) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(widgetPanel);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildClearEnabledModelButton(panel);
-		this.buildClearVisibleModelButton(panel);
-		this.buildNullSelectionModelButton(panel);
-		this.buildNextButton(panel);
-	}
-
-	private void buildClearEnabledModelButton(Composite parent) {
-		this.buildClearEnabledModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildClearEnabledModelACI() {
-		Action action = new Action("clear enabled model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				BooleanStateControllerUITest.this.clearEnabledModel();
-			}
-		};
-		action.setToolTipText("clear enabled model");
-		return new ActionContributionItem(action);
-	}
-
-	void clearEnabledModel() {
-		this.enabledHolder.setValue(null);
-	}
-
-	private void buildClearVisibleModelButton(Composite parent) {
-		this.buildClearVisibleModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildClearVisibleModelACI() {
-		Action action = new Action("clear visible model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				BooleanStateControllerUITest.this.clearVisibleModel();
-			}
-		};
-		action.setToolTipText("clear visible model");
-		return new ActionContributionItem(action);
-	}
-
-	void clearVisibleModel() {
-		this.visibleHolder.setValue(null);
-	}
-
-	private void buildNullSelectionModelButton(Composite parent) {
-		this.buildNullSelectionModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildNullSelectionModelACI() {
-		Action action = new Action("null selection model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				BooleanStateControllerUITest.this.setSelectionModelNull();
-			}
-		};
-		action.setToolTipText("null selection model");
-		return new ActionContributionItem(action);
-	}
-
-	void setSelectionModelNull() {
-		this.listSelectionHolder.setValue(null);
-	}
-
-	private void buildNextButton(Composite parent) {
-		this.buildNextACI().fill(parent);
-	}
-
-	private ActionContributionItem buildNextACI() {
-		Action action = new Action("next", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				BooleanStateControllerUITest.this.next();
-			}
-		};
-		action.setToolTipText("next");
-		return new ActionContributionItem(action);
-	}
-
-	void next() {
-		this.listSelectionHolder.setValue(this.getNextListSelection());
-	}
-
-	private String getNextListSelection() {
-		return this.listHolder.get(this.getNextListSelectionIndex());
-	}
-
-	private int getNextListSelectionIndex() {
-		int index = this.getListSelectionIndex();
-		if (index == -1) {
-			return 0;
-		}
-		index++;
-		return (index == this.listHolder.size()) ? 0 : index;
-	}
-
-	private int getListSelectionIndex() {
-		return this.listHolder.indexOf(this.getListSelection());
-	}
-
-	private String getListSelection() {
-		return this.listSelectionHolder.getValue();
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/CheckBoxModelBindingUITest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/CheckBoxModelBindingUITest.java
deleted file mode 100644
index e6f232c..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/CheckBoxModelBindingUITest.java
+++ /dev/null
@@ -1,318 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.utility.swt;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jpt.ui.internal.utility.swt.SWTTools;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.model.value.PropertyValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.layout.FillLayout;
-import org.eclipse.swt.layout.FormAttachment;
-import org.eclipse.swt.layout.FormData;
-import org.eclipse.swt.layout.FormLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- * Play around with a set of check boxes.
- */
-@SuppressWarnings("nls")
-public class CheckBoxModelBindingUITest
-	extends ApplicationWindow
-{
-	private final TestModel testModel;
-	private final WritablePropertyValueModel<TestModel> testModelHolder;
-	private final WritablePropertyValueModel<Boolean> flag1Holder;
-	private final WritablePropertyValueModel<Boolean> flag2Holder;
-	private final WritablePropertyValueModel<Boolean> notFlag2Holder;
-
-	public static void main(String[] args) throws Exception {
-		Window window = new CheckBoxModelBindingUITest(args);
-		window.setBlockOnOpen(true);
-		window.open();
-		Display.getCurrent().dispose();
-		System.exit(0);
-	}
-
-	private CheckBoxModelBindingUITest(@SuppressWarnings("unused") String[] args) {
-		super(null);
-		this.testModel = new TestModel(true, true);
-		this.testModelHolder = new SimplePropertyValueModel<TestModel>(this.testModel);
-		this.flag1Holder = this.buildFlag1Holder(this.testModelHolder);
-		this.flag2Holder = this.buildFlag2Holder(this.testModelHolder);
-		this.notFlag2Holder = this.buildNotFlag2Holder(this.testModelHolder);
-	}
-
-	private WritablePropertyValueModel<Boolean> buildFlag1Holder(PropertyValueModel<TestModel> subjectHolder) {
-		return new PropertyAspectAdapter<TestModel, Boolean>(subjectHolder, TestModel.FLAG1_PROPERTY) {
-			@Override
-			protected Boolean buildValue_() {
-				return Boolean.valueOf(this.subject.isFlag1());
-			}
-			@Override
-			protected void setValue_(Boolean value) {
-				this.subject.setFlag1(value.booleanValue());
-			}
-		};
-	}
-
-	private WritablePropertyValueModel<Boolean> buildFlag2Holder(PropertyValueModel<TestModel> subjectHolder) {
-		return new PropertyAspectAdapter<TestModel, Boolean>(subjectHolder, TestModel.FLAG2_PROPERTY) {
-			@Override
-			protected Boolean buildValue_() {
-				return Boolean.valueOf(this.subject.isFlag2());
-			}
-			@Override
-			protected void setValue_(Boolean value) {
-				this.subject.setFlag2(value.booleanValue());
-			}
-		};
-	}
-
-	private WritablePropertyValueModel<Boolean> buildNotFlag2Holder(PropertyValueModel<TestModel> subjectHolder) {
-		return new PropertyAspectAdapter<TestModel, Boolean>(subjectHolder, TestModel.NOT_FLAG2_PROPERTY) {
-			@Override
-			protected Boolean buildValue_() {
-				return Boolean.valueOf(this.subject.isNotFlag2());
-			}
-			@Override
-			protected void setValue_(Boolean value) {
-				this.subject.setNotFlag2(value.booleanValue());
-			}
-		};
-	}
-
-	@Override
-	protected Control createContents(Composite parent) {
-		((Shell) parent).setText(this.getClass().getSimpleName());
-		parent.setSize(400, 100);
-		Composite mainPanel = new Composite(parent, SWT.NONE);
-		mainPanel.setLayout(new FormLayout());
-		Control checkBoxPanel = this.buildCheckBoxPanel(mainPanel);
-		this.buildControlPanel(mainPanel, checkBoxPanel);
-		return mainPanel;
-	}
-
-	private Control buildCheckBoxPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100, -35);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildFlag1CheckBox(panel);
-		this.buildFlag2CheckBox(panel);
-		this.buildNotFlag2CheckBox(panel);
-		this.buildUnattachedCheckBox(panel);
-
-		return panel;
-	}
-
-	private void buildFlag1CheckBox(Composite parent) {
-		Button checkBox = new Button(parent, SWT.CHECK);
-		checkBox.setText("flag 1");
-		SWTTools.bind(this.flag1Holder, checkBox);
-	}
-
-	private void buildFlag2CheckBox(Composite parent) {
-		Button checkBox = new Button(parent, SWT.CHECK);
-		checkBox.setText("flag 2");
-		SWTTools.bind(this.flag2Holder, checkBox);
-	}
-
-	private void buildNotFlag2CheckBox(Composite parent) {
-		Button checkBox = new Button(parent, SWT.CHECK);
-		checkBox.setText("not flag 2");
-		SWTTools.bind(this.notFlag2Holder, checkBox);
-	}
-
-	private void buildUnattachedCheckBox(Composite parent) {
-		Button checkBox = new Button(parent, SWT.CHECK);
-		checkBox.setText("unattached");
-		checkBox.addSelectionListener(this.buildUnattachedSelectionListener());
-	}
-
-	private SelectionListener buildUnattachedSelectionListener() {
-		return new SelectionListener() {
-			public void widgetDefaultSelected(SelectionEvent e) {
-				System.out.println("unattached default selected: " + e);
-			}
-			public void widgetSelected(SelectionEvent e) {
-				System.out.println("unattached selected: " + e);
-			}
-		};
-	}
-
-	private void buildControlPanel(Composite parent, Control checkBoxPanel) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(checkBoxPanel);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildFlipFlag1Button(panel);
-		this.buildNotFlag2ToggleButton(panel);
-		this.buildClearModelButton(panel);
-		this.buildRestoreModelButton(panel);
-		this.buildPrintModelButton(panel);
-	}
-
-	private void buildFlipFlag1Button(Composite parent) {
-		this.buildFlipFlag1ACI().fill(parent);
-	}
-
-	private ActionContributionItem buildFlipFlag1ACI() {
-		Action action = new Action("flip flag 1", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				CheckBoxModelBindingUITest.this.flipFlag1();
-			}
-		};
-		action.setToolTipText("flip flag 1");
-		return new ActionContributionItem(action);
-	}
-
-	void flipFlag1() {
-		this.testModel.setFlag1( ! this.testModel.isFlag1());
-	}
-
-	private void buildNotFlag2ToggleButton(Composite parent) {
-		Button checkBox = new Button(parent, SWT.TOGGLE);
-		checkBox.setText("not flag 2");
-		SWTTools.bind(this.notFlag2Holder, checkBox);
-	}
-
-	private void buildClearModelButton(Composite parent) {
-		this.buildClearModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildClearModelACI() {
-		Action action = new Action("clear model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				CheckBoxModelBindingUITest.this.clearModel();
-			}
-		};
-		action.setToolTipText("clear model");
-		return new ActionContributionItem(action);
-	}
-
-	void clearModel() {
-		this.testModelHolder.setValue(null);
-	}
-
-	private void buildRestoreModelButton(Composite parent) {
-		this.buildRestoreModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildRestoreModelACI() {
-		Action action = new Action("restore model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				CheckBoxModelBindingUITest.this.restoreModel();
-			}
-		};
-		action.setToolTipText("restore model");
-		return new ActionContributionItem(action);
-	}
-
-	void restoreModel() {
-		this.testModelHolder.setValue(this.testModel);
-	}
-
-	private void buildPrintModelButton(Composite parent) {
-		this.buildPrintModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildPrintModelACI() {
-		Action action = new Action("print model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				CheckBoxModelBindingUITest.this.printModel();
-			}
-		};
-		action.setToolTipText("print model");
-		return new ActionContributionItem(action);
-	}
-
-	void printModel() {
-		System.out.println("flag 1: " + this.testModel.isFlag1());
-		System.out.println("flag 2: " + this.testModel.isFlag2());
-		System.out.println("not flag 2: " + this.testModel.isNotFlag2());
-		System.out.println("***");
-	}
-
-
-	public static class TestModel extends AbstractModel {
-		private boolean flag1;
-			public static final String FLAG1_PROPERTY = "flag1";
-		private boolean flag2;
-			public static final String FLAG2_PROPERTY = "flag2";
-		private boolean notFlag2;
-			public static final String NOT_FLAG2_PROPERTY = "notFlag2";
-	
-		public TestModel(boolean flag1, boolean flag2) {
-			this.flag1 = flag1;
-			this.flag2 = flag2;
-			this.notFlag2 = ! flag2;
-		}
-		public boolean isFlag1() {
-			return this.flag1;
-		}
-		public void setFlag1(boolean flag1) {
-			boolean old = this.flag1;
-			this.flag1 = flag1;
-			this.firePropertyChanged(FLAG1_PROPERTY, old, flag1);
-		}
-		public boolean isFlag2() {
-			return this.flag2;
-		}
-		public void setFlag2(boolean flag2) {
-			boolean old = this.flag2;
-			this.flag2 = flag2;
-			this.firePropertyChanged(FLAG2_PROPERTY, old, flag2);
-	
-			old = this.notFlag2;
-			this.notFlag2 = ! flag2;
-			this.firePropertyChanged(NOT_FLAG2_PROPERTY, old, this.notFlag2);
-		}
-		public boolean isNotFlag2() {
-			return this.notFlag2;
-		}
-		public void setNotFlag2(boolean notFlag2) {
-			this.setFlag2( ! notFlag2);
-		}
-		@Override
-		public String toString() {
-			return "TestModel(" + this.isFlag1() + " - " + this.isFlag2() + ")";
-		}
-	}
-
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/DropDownListBoxModelBindingUITest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/DropDownListBoxModelBindingUITest.java
deleted file mode 100644
index 15f31aa..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/DropDownListBoxModelBindingUITest.java
+++ /dev/null
@@ -1,678 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.utility.swt;
-
-import java.text.Collator;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jpt.ui.internal.utility.swt.SWTTools;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.ListAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.internal.model.value.SortedListValueModelWrapper;
-import org.eclipse.jpt.utility.model.Model;
-import org.eclipse.jpt.utility.model.value.ListValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.custom.CCombo;
-import org.eclipse.swt.layout.FillLayout;
-import org.eclipse.swt.layout.FormAttachment;
-import org.eclipse.swt.layout.FormData;
-import org.eclipse.swt.layout.FormLayout;
-import org.eclipse.swt.widgets.Combo;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.Text;
-
-/**
- * Play around with a set of read-only combo-boxes.
- */
-@SuppressWarnings("nls")
-public class DropDownListBoxModelBindingUITest
-	extends ApplicationWindow
-{
-	final TaskList taskList;
-	private final WritablePropertyValueModel<TaskList> taskListHolder;
-	private Text taskTextField;
-
-	public static void main(String[] args) throws Exception {
-		Window window = new DropDownListBoxModelBindingUITest(args);
-		window.setBlockOnOpen(true);
-		window.open();
-		Display.getCurrent().dispose();
-		System.exit(0);
-	}
-
-	private DropDownListBoxModelBindingUITest(@SuppressWarnings("unused") String[] args) {
-		super(null);
-		this.taskList = new TaskList();
-		this.taskListHolder = new SimplePropertyValueModel<TaskList>(this.taskList);
-		this.taskList.addTask("swim");
-		this.taskList.addTask("bike");
-		this.taskList.addTask("run");
-		Task rest = this.taskList.addTask("rest");
-		this.taskList.addTask("repeat");
-		this.taskList.setPriorityTask(rest);
-	}
-
-	@Override
-	protected Control createContents(Composite parent) {
-		((Shell) parent).setText(this.getClass().getSimpleName());
-		parent.setSize(800, 300);
-		Composite mainPanel = new Composite(parent, SWT.NONE);
-		mainPanel.setLayout(new FormLayout());
-		Control taskListPanel = this.buildTaskListPanel(mainPanel);
-		this.buildControlPanel(mainPanel, taskListPanel);
-		return mainPanel;
-	}
-
-	private Control buildTaskListPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100, -30);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FormLayout());
-		this.buildTaskListPanel(panel, false);  // false = native (Combo)
-		this.buildTaskListPanel(panel, true);  // true = custom (CCombo)
-
-		return panel;
-	}
-
-	private Control buildTaskListPanel(Composite parent, boolean custom) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(custom ? 50 : 0);
-			fd.bottom = new FormAttachment(custom ? 100 : 50);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FormLayout());
-		this.buildPrimitiveTaskListPanel(panel, custom);
-		this.buildObjectTaskListPanel(panel, custom);
-
-		return panel;
-	}
-
-	private void buildPrimitiveTaskListPanel(Composite parent, boolean custom) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(50);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildUnsortedPrimitiveListPanel(panel, custom);
-		this.buildStandardSortedPrimitiveListPanel(panel, custom);
-		this.buildCustomSortedPrimitiveListPanel(panel, custom);
-	}
-
-	private void buildObjectTaskListPanel(Composite parent, boolean custom) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(50);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildUnsortedObjectListPanel(panel, custom);
-		this.buildStandardSortedObjectListPanel(panel, custom);
-		this.buildCustomSortedObjectListPanel(panel, custom);
-	}
-
-	private void buildUnsortedPrimitiveListPanel(Composite parent, boolean custom) {
-		String label = "primitive unsorted";
-		if (custom) label += " (custom)";
-		this.buildComboBoxPanel(parent, label, this.buildUnsortedPrimitiveListModel(), this.buildPriorityTaskNameAdapter(), custom);
-	}
-
-	private void buildStandardSortedPrimitiveListPanel(Composite parent, boolean custom) {
-		String label = "primitive sorted";
-		if (custom) label += " (custom)";
-		this.buildComboBoxPanel(parent, label, this.buildStandardSortedPrimitiveListModel(), this.buildPriorityTaskNameAdapter(), custom);
-	}
-
-	private void buildCustomSortedPrimitiveListPanel(Composite parent, boolean custom) {
-		String label = "primitive reverse sorted";
-		if (custom) label += " (custom)";
-		this.buildComboBoxPanel(parent, label, this.buildCustomSortedPrimitiveListModel(), this.buildPriorityTaskNameAdapter(), custom);
-	}
-
-	private void buildUnsortedObjectListPanel(Composite parent, boolean custom) {
-		String label = "object unsorted";
-		if (custom) label += " (custom)";
-		this.buildComboBoxPanel(parent, label, this.buildUnsortedObjectListModel(), this.buildPriorityTaskAdapter(), custom);
-	}
-
-	private void buildStandardSortedObjectListPanel(Composite parent, boolean custom) {
-		String label = "object sorted";
-		if (custom) label += " (custom)";
-		this.buildComboBoxPanel(parent, label, this.buildStandardSortedObjectListModel(), this.buildPriorityTaskAdapter(), custom);
-	}
-
-	private void buildCustomSortedObjectListPanel(Composite parent, boolean custom) {
-		String label = "object reverse sorted";
-		if (custom) label += " (custom)";
-		this.buildComboBoxPanel(parent, label, this.buildCustomSortedObjectListModel(), this.buildPriorityTaskAdapter(), custom);
-	}
-
-	private ListValueModel<String> buildUnsortedPrimitiveListModel() {
-		return this.buildPrimitiveTaskListAdapter();
-	}
-
-	private ListValueModel<String> buildStandardSortedPrimitiveListModel() {
-		return new SortedListValueModelWrapper<String>(this.buildPrimitiveTaskListAdapter());
-	}
-
-	private ListValueModel<String> buildCustomSortedPrimitiveListModel() {
-		return new SortedListValueModelWrapper<String>(this.buildPrimitiveTaskListAdapter(), this.buildCustomStringComparator());
-	}
-
-	private ListValueModel<Task> buildUnsortedObjectListModel() {
-		return this.buildObjectTaskListAdapter();
-	}
-
-	private ListValueModel<Task> buildStandardSortedObjectListModel() {
-		return new SortedListValueModelWrapper<Task>(this.buildObjectTaskListAdapter());
-	}
-
-	private ListValueModel<Task> buildCustomSortedObjectListModel() {
-		return new SortedListValueModelWrapper<Task>(this.buildObjectTaskListAdapter(), this.buildCustomTaskComparator());
-	}
-
-	private <E> void buildComboBoxPanel(Composite parent, String label, ListValueModel<E> model, WritablePropertyValueModel<E> selectedItemModel, boolean custom) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayout(new FormLayout());
-
-		Label comboBoxLabel = new Label(panel, SWT.LEFT | SWT.VERTICAL);
-		comboBoxLabel.setText(label);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0, 3);
-			fd.bottom = new FormAttachment(0, 20);
-			fd.left = new FormAttachment(0, 5);
-			fd.right = new FormAttachment(100);
-		comboBoxLabel.setLayoutData(fd);
-
-		Control comboBox = this.buildComboBox(panel, custom);
-		fd = new FormData();
-			fd.top = new FormAttachment(comboBoxLabel);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		comboBox.setLayoutData(fd);
-		if (custom) {
-			SWTTools.bind(model, selectedItemModel, (CCombo) comboBox);  // use #toString()
-		} else {
-			SWTTools.bind(model, selectedItemModel, (Combo) comboBox);  // use #toString()
-		}
-	}
-
-	private Control buildComboBox(Composite parent, boolean custom) {
-		int style = SWT.READ_ONLY;
-		return custom ? new CCombo(parent, style) : new Combo(parent, style);
-	}
-
-	private Comparator<String> buildCustomStringComparator() {
-		return new Comparator<String>() {
-			public int compare(String s1, String s2) {
-				return s2.compareTo(s1);
-			}
-		};
-	}
-
-	private Comparator<Task> buildCustomTaskComparator() {
-		return new Comparator<Task>() {
-			public int compare(Task to1, Task to2) {
-				return to2.compareTo(to1);
-			}
-		};
-	}
-
-	private ListValueModel<String> buildPrimitiveTaskListAdapter() {
-		return new ListAspectAdapter<TaskList, String>(this.taskListHolder, TaskList.TASK_NAMES_LIST) {
-			@Override
-			protected ListIterator<String> listIterator_() {
-				return this.subject.taskNames();
-			}
-		};
-	}
-
-	private ListValueModel<Task> buildObjectTaskListAdapter() {
-		return new ListAspectAdapter<TaskList, Task>(this.taskListHolder, TaskList.TASKS_LIST) {
-			@Override
-			protected ListIterator<Task> listIterator_() {
-				return this.subject.tasks();
-			}
-		};
-	}
-
-	private WritablePropertyValueModel<Task> buildPriorityTaskAdapter() {
-		return new PriorityTaskAdapter(this.taskListHolder);
-	}
-
-	static class PriorityTaskAdapter
-		extends PropertyAspectAdapter<TaskList, Task>
-	{
-		PriorityTaskAdapter(WritablePropertyValueModel<TaskList> taskListHolder) {
-			super(taskListHolder, TaskList.PRIORITY_TASK_PROPERTY);
-		}
-		@Override
-		protected Task buildValue_() {
-			return this.subject.getPriorityTask();
-		}
-		@Override
-		protected void setValue_(Task value) {
-			this.subject.setPriorityTask(value);
-		}
-	}
-
-	private WritablePropertyValueModel<String> buildPriorityTaskNameAdapter() {
-		return new PriorityTaskNameAdapter(this.taskListHolder);
-	}
-
-	static class PriorityTaskNameAdapter
-		extends PropertyAspectAdapter<TaskList, String>
-	{
-		PriorityTaskNameAdapter(WritablePropertyValueModel<TaskList> taskListHolder) {
-			super(taskListHolder, TaskList.PRIORITY_TASK_NAME_PROPERTY);
-		}
-		@Override
-		protected String buildValue_() {
-			return this.subject.getPriorityTaskName();
-		}
-		@Override
-		protected void setValue_(String value) {
-			// ignore
-		}
-	}
-
-	private void buildControlPanel(Composite parent, Control taskListPanel) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(taskListPanel);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FormLayout());
-		Control misc = this.buildMiscTaskPanel(panel);
-		this.buildAddRemoveTaskPanel(panel, misc);
-	}
-
-	// is there a better way to associate an ACI with form data?
-	private Control buildMiscTaskPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(100, -400);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildClearListACI().fill(panel);
-		this.buildClearModelACI().fill(panel);
-		this.buildRestoreModelACI().fill(panel);
-		this.buildChangePriorityTaskACI().fill(panel);
-		this.buildClearPriorityTaskACI().fill(panel);
-		return panel;
-	}
-
-	private ActionContributionItem buildClearListACI() {
-		Action action = new Action("clear list", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				DropDownListBoxModelBindingUITest.this.clearTasks();
-			}
-		};
-		action.setToolTipText("clear all the tasks");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildClearModelACI() {
-		Action action = new Action("clear model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				DropDownListBoxModelBindingUITest.this.clearModel();
-			}
-		};
-		action.setToolTipText("clear the task list model");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildRestoreModelACI() {
-		Action action = new Action("restore model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				DropDownListBoxModelBindingUITest.this.restoreModel();
-			}
-		};
-		action.setToolTipText("restore the task list model");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildChangePriorityTaskACI() {
-		Action action = new Action("change priority", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				DropDownListBoxModelBindingUITest.this.changePriorityTask();
-			}
-		};
-		action.setToolTipText("change the priority task");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildClearPriorityTaskACI() {
-		Action action = new Action("clear priority", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				DropDownListBoxModelBindingUITest.this.clearPriorityTask();
-			}
-		};
-		action.setToolTipText("clear the priority task");
-		return new ActionContributionItem(action);
-	}
-
-	private void buildAddRemoveTaskPanel(Composite parent, Control clearButton) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(clearButton);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FormLayout());
-		Control addButton = this.buildAddButton(panel);
-		Control removeButton = this.buildRemoveButton(panel);
-		this.buildTaskTextField(panel, addButton, removeButton);
-	}
-
-	// is there a better way to associate an ACI with form data?
-	private Control buildAddButton(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(0, 50);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildAddACI().fill(panel);
-		return panel;
-	}
-
-	private ActionContributionItem buildAddACI() {
-		Action action = new Action("add", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				DropDownListBoxModelBindingUITest.this.addTask();
-			}
-		};
-		action.setToolTipText("add a task with the name in the entry field");
-		return new ActionContributionItem(action);
-	}
-
-	// is there a better way to associate an ACI with form data?
-	private Control buildRemoveButton(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(100, -50);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildRemoveACI().fill(panel);
-		return panel;
-	}
-
-	private ActionContributionItem buildRemoveACI() {
-		Action action = new Action("remove", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				DropDownListBoxModelBindingUITest.this.removeTask();
-			}
-		};
-		action.setToolTipText("remove the task with the name in the entry field");
-		return new ActionContributionItem(action);
-	}
-
-	private void buildTaskTextField(Composite parent, Control addButton, Control removeButton) {
-		this.taskTextField = new Text(parent, SWT.SINGLE | SWT.BORDER);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(addButton);
-			fd.right = new FormAttachment(removeButton);
-		this.taskTextField.setLayoutData(fd);
-	}
-
-	private String taskTextFieldText() {
-		return this.taskTextField.getText();
-	}
-
-	void addTask() {
-		String taskText = this.taskTextFieldText();
-		if (taskText.length() != 0) {
-			this.taskList.addTask(taskText);
-		}
-	}
-
-	void removeTask() {
-		String task = this.taskTextFieldText();
-		if (task.length() != 0) {
-			this.taskList.removeTask(task);
-		}
-	}
-
-	void clearTasks() {
-		this.taskList.clearTasks();
-	}
-
-	void clearModel() {
-		this.taskListHolder.setValue(null);
-	}
-
-	void restoreModel() {
-		this.taskListHolder.setValue(this.taskList);
-	}
-
-	void changePriorityTask() {
-		boolean found = false;
-		for (Task task : this.taskList.getTasks()) {
-			if (this.taskList.getPriorityTask() == task) {
-				found = true;
-			} else {
-				if (found) {
-					this.taskList.setPriorityTask(task);
-					return;
-				}
-			}
-		}
-		Iterator<Task> tasks = this.taskList.tasks();
-		if (tasks.hasNext()) {
-			this.taskList.setPriorityTask(tasks.next());
-		}
-	}
-
-	void clearPriorityTask() {
-		this.taskList.setPriorityTask(null);
-	}
-
-
-	// ********** TaskList **********
-
-	// note absence of validation...
-	public static class TaskList extends AbstractModel {
-		private final List<String> taskNames = new ArrayList<String>();
-			public static final String TASK_NAMES_LIST = "taskNames";
-		private final List<Task> tasks = new ArrayList<Task>();
-			public static final String TASKS_LIST = "tasks";
-		private String priorityTaskName = null;
-			public static final String PRIORITY_TASK_NAME_PROPERTY = "priorityTaskName";
-		private Task priorityTask = null;
-			public static final String PRIORITY_TASK_PROPERTY = "priorityTask";
-		public TaskList() {
-			super();
-		}
-		public ListIterator<String> taskNames() {
-			return this.taskNames.listIterator();
-		}
-		public Iterable<Task> getTasks() {
-			return this.tasks;
-		}
-		public ListIterator<Task> tasks() {
-			return this.tasks.listIterator();
-		}
-		public String getPriorityTaskName() {
-			return this.priorityTaskName;
-		}
-		public Task getPriorityTask() {
-			return this.priorityTask;
-		}
-		public Task addTask(String taskName) {
-			this.addItemToList(taskName, this.taskNames, TASK_NAMES_LIST);
-			Task task = new Task(taskName);
-			this.addItemToList(task, this.tasks, TASKS_LIST);
-			return task;
-		}		
-		public void removeTask(String taskName) {
-			int index = this.taskNames.indexOf(taskName);
-			if (index != -1) {
-				Task task = this.tasks.get(index);
-				if (task == this.priorityTask) {
-					this.setPriorityTask(null);
-				}
-				// assume the indexes match...
-				this.removeItemFromList(index, this.taskNames, TASK_NAMES_LIST);
-				this.removeItemFromList(index, this.tasks, TASKS_LIST);
-			}
-		}
-		public void clearTasks() {
-			this.setPriorityTask(null);
-			this.clearList(this.taskNames, TASK_NAMES_LIST);
-			this.clearList(this.tasks, TASKS_LIST);
-		}
-		private void setPriorityTaskName(String priorityTaskName) {
-			String old = this.priorityTaskName;
-			this.priorityTaskName = priorityTaskName;
-			this.firePropertyChanged(PRIORITY_TASK_NAME_PROPERTY, old, priorityTaskName);
-		}
-		public void setPriorityTask(Task priorityTask) {
-			Task old = this.priorityTask;
-			this.priorityTask = priorityTask;
-			this.firePropertyChanged(PRIORITY_TASK_PROPERTY, old, priorityTask);
-			this.setPriorityTaskName((priorityTask == null) ? null : priorityTask.getName());
-		}
-	}
-
-
-	// ********** Task **********
-
-	public static class Task extends AbstractModel implements Displayable {
-		private String name;
-		private int instanceCount;
-		private static int INSTANCE_COUNT = 1;
-		public Task(String name) {
-			this.name = name;
-			this.instanceCount = INSTANCE_COUNT++;
-		}
-		public String displayString() {
-			return this.name + ": " + this.instanceCount;
-		}
-		public int compareTo(Displayable o) {
-			return DEFAULT_COMPARATOR.compare(this, o);
-		}
-		public String getName() {
-			return this.name;
-		}
-		public void setName(String name) {
-			Object old = this.name;
-			this.name = name;
-			this.firePropertyChanged(DISPLAY_STRING_PROPERTY, old, name);
-		}
-		@Override
-		public String toString() {
-			return this.displayString();
-		}
-	}
-
-	public interface Displayable extends Model, Comparable<Displayable> {
-	
-		String displayString();
-			String DISPLAY_STRING_PROPERTY = "displayString";
-	
-	
-		// ********** helper implementations **********
-	
-		Collator DEFAULT_COLLATOR = Collator.getInstance();
-	
-		Comparator<Displayable> DEFAULT_COMPARATOR =
-			new Comparator<Displayable>() {
-				public int compare(Displayable d1, Displayable d2) {
-					// disallow duplicates based on object identity
-					if (d1 == d2) {
-						return 0;
-					}
-	
-					// first compare display strings using the default collator
-					int result = DEFAULT_COLLATOR.compare(d1.displayString(), d2.displayString());
-					if (result != 0) {
-						return result;
-					}
-	
-					// then compare using object-id
-					result = System.identityHashCode(d1) - System.identityHashCode(d2);
-					if (result != 0) {
-						return result;
-					}
-	
-					// It's unlikely that we get to this point; but, just in case, we will return -1.
-					// Unfortunately, this introduces some mild unpredictability to the sort order
-					// (unless the objects are always passed into this method in the same order).
-					return -1;		// if all else fails, indicate that o1 < o2
-				}
-				@Override
-				public String toString() {
-					return "Displayable.DEFAULT_COMPARATOR";
-				}
-			};
-	
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/ListBoxModelBindingUITest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/ListBoxModelBindingUITest.java
deleted file mode 100644
index ff19beb..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/ListBoxModelBindingUITest.java
+++ /dev/null
@@ -1,627 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.utility.swt;
-
-import java.text.Collator;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jpt.ui.internal.utility.swt.SWTTools;
-import org.eclipse.jpt.utility.internal.CollectionTools;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.CollectionAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.ListAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimpleCollectionValueModel;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.internal.model.value.SortedListValueModelWrapper;
-import org.eclipse.jpt.utility.model.Model;
-import org.eclipse.jpt.utility.model.value.ListValueModel;
-import org.eclipse.jpt.utility.model.value.WritableCollectionValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.FillLayout;
-import org.eclipse.swt.layout.FormAttachment;
-import org.eclipse.swt.layout.FormData;
-import org.eclipse.swt.layout.FormLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.Text;
-
-/**
- * Play around with a set of list boxes.
- */
-@SuppressWarnings("nls")
-public class ListBoxModelBindingUITest
-	extends ApplicationWindow
-{
-	final TaskList taskList;
-	private final WritablePropertyValueModel<TaskList> taskListHolder;
-	private Text taskTextField;
-
-	public static void main(String[] args) throws Exception {
-		Window window = new ListBoxModelBindingUITest(args);
-		window.setBlockOnOpen(true);
-		window.open();
-		Display.getCurrent().dispose();
-		System.exit(0);
-	}
-
-	private ListBoxModelBindingUITest(@SuppressWarnings("unused") String[] args) {
-		super(null);
-		this.taskList = new TaskList();
-		this.taskListHolder = new SimplePropertyValueModel<TaskList>(this.taskList);
-		this.taskList.addTask("swim");
-		this.taskList.addTask("bike");
-		this.taskList.addTask("run");
-		Task rest = this.taskList.addTask("rest");
-		this.taskList.addPriorityTask(rest);
-		Task repeat = this.taskList.addTask("repeat");
-		this.taskList.addPriorityTask(repeat);
-	}
-
-	@Override
-	protected Control createContents(Composite parent) {
-		((Shell) parent).setText(this.getClass().getSimpleName());
-		parent.setSize(800, 400);
-		Composite mainPanel = new Composite(parent, SWT.NONE);
-		mainPanel.setLayout(new FormLayout());
-		Control taskListPanel = this.buildTaskListPanel(mainPanel);
-		this.buildControlPanel(mainPanel, taskListPanel);
-		return mainPanel;
-	}
-
-	private Control buildTaskListPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100, -30);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FormLayout());
-		this.buildPrimitiveTaskListPanel(panel);
-		this.buildObjectTaskListPanel(panel);
-
-		return panel;
-	}
-
-	private void buildPrimitiveTaskListPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(50);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildUnsortedPrimitiveListPanel(panel);
-		this.buildStandardSortedPrimitiveListPanel(panel);
-		this.buildCustomSortedPrimitiveListPanel(panel);
-	}
-
-	private void buildObjectTaskListPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(50);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildUnsortedObjectListPanel(panel);
-		this.buildStandardSortedObjectListPanel(panel);
-		this.buildCustomSortedObjectListPanel(panel);
-	}
-
-	private void buildUnsortedPrimitiveListPanel(Composite parent) {
-		this.buildListPanel(parent, "primitive unsorted", this.buildUnsortedPrimitiveListModel(), new SimpleCollectionValueModel<String>());
-	}
-
-	private void buildStandardSortedPrimitiveListPanel(Composite parent) {
-		this.buildListPanel(parent, "primitive sorted", this.buildStandardSortedPrimitiveListModel(), new SimpleCollectionValueModel<String>());
-	}
-
-	private void buildCustomSortedPrimitiveListPanel(Composite parent) {
-		this.buildListPanel(parent, "primitive reverse sorted", this.buildCustomSortedPrimitiveListModel(), new SimpleCollectionValueModel<String>());
-	}
-
-	private void buildUnsortedObjectListPanel(Composite parent) {
-		this.buildListPanel(parent, "object unsorted", this.buildUnsortedObjectListModel(), this.buildPriorityTaskListAdapter());
-	}
-
-	private void buildStandardSortedObjectListPanel(Composite parent) {
-		this.buildListPanel(parent, "object sorted", this.buildStandardSortedObjectListModel(), this.buildPriorityTaskListAdapter());
-	}
-
-	private void buildCustomSortedObjectListPanel(Composite parent) {
-		this.buildListPanel(parent, "object reverse sorted", this.buildCustomSortedObjectListModel(), this.buildPriorityTaskListAdapter());
-	}
-
-	private ListValueModel<String> buildUnsortedPrimitiveListModel() {
-		return this.buildPrimitiveTaskListAdapter();
-	}
-
-	private ListValueModel<String> buildStandardSortedPrimitiveListModel() {
-		return new SortedListValueModelWrapper<String>(this.buildPrimitiveTaskListAdapter());
-	}
-
-	private ListValueModel<String> buildCustomSortedPrimitiveListModel() {
-		return new SortedListValueModelWrapper<String>(this.buildPrimitiveTaskListAdapter(), this.buildCustomStringComparator());
-	}
-
-	private ListValueModel<Task> buildUnsortedObjectListModel() {
-		return this.buildObjectTaskListAdapter();
-	}
-
-	private ListValueModel<Task> buildStandardSortedObjectListModel() {
-		return new SortedListValueModelWrapper<Task>(this.buildObjectTaskListAdapter());
-	}
-
-	private ListValueModel<Task> buildCustomSortedObjectListModel() {
-		return new SortedListValueModelWrapper<Task>(this.buildObjectTaskListAdapter(), this.buildCustomTaskComparator());
-	}
-
-	private <E> org.eclipse.swt.widgets.List buildListPanel(Composite parent, String label, ListValueModel<E> model, WritableCollectionValueModel<E> selectedItemsModel) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		panel.setLayout(new FormLayout());
-
-		Label listLabel = new Label(panel, SWT.LEFT | SWT.VERTICAL);
-		listLabel.setText(label);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0, 3);
-			fd.bottom = new FormAttachment(0, 20);
-			fd.left = new FormAttachment(0, 5);
-			fd.right = new FormAttachment(100);
-		listLabel.setLayoutData(fd);
-
-		org.eclipse.swt.widgets.List listBox = new org.eclipse.swt.widgets.List(panel, SWT.MULTI | SWT.BORDER);
-		fd = new FormData();
-			fd.top = new FormAttachment(listLabel);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		listBox.setLayoutData(fd);
-		SWTTools.bind(model, selectedItemsModel, listBox);  // use #toString()
-		return listBox;
-	}
-
-	private Comparator<String> buildCustomStringComparator() {
-		return new Comparator<String>() {
-			public int compare(String s1, String s2) {
-				return s2.compareTo(s1);
-			}
-		};
-	}
-
-	private Comparator<Task> buildCustomTaskComparator() {
-		return new Comparator<Task>() {
-			public int compare(Task to1, Task to2) {
-				return to2.compareTo(to1);
-			}
-		};
-	}
-
-	private ListValueModel<String> buildPrimitiveTaskListAdapter() {
-		return new ListAspectAdapter<TaskList, String>(this.taskListHolder, TaskList.TASK_NAMES_LIST) {
-			@Override
-			protected ListIterator<String> listIterator_() {
-				return this.subject.taskNames();
-			}
-		};
-	}
-
-	private ListValueModel<Task> buildObjectTaskListAdapter() {
-		return new ListAspectAdapter<TaskList, Task>(this.taskListHolder, TaskList.TASKS_LIST) {
-			@Override
-			protected ListIterator<Task> listIterator_() {
-				return this.subject.tasks();
-			}
-		};
-	}
-
-	private WritableCollectionValueModel<Task> buildPriorityTaskListAdapter() {
-		return new PriorityTaskListAdapter(this.taskListHolder);
-	}
-
-	static class PriorityTaskListAdapter
-		extends CollectionAspectAdapter<TaskList, Task>
-		implements WritableCollectionValueModel<Task>
-	{
-		PriorityTaskListAdapter(WritablePropertyValueModel<TaskList> taskListHolder) {
-			super(taskListHolder, TaskList.PRIORITY_TASKS_COLLECTION);
-		}
-		@Override
-		protected Iterator<Task> iterator_() {
-			return this.subject.priorityTasks();
-		}
-		public void setValues(Iterable<Task> values) {
-			this.subject.setPriorityTasks(values);
-		}
-	}
-
-	private void buildControlPanel(Composite parent, Control taskListPanel) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(taskListPanel);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FormLayout());
-		Control misc = this.buildMiscTaskPanel(panel);
-		this.buildAddRemoveTaskPanel(panel, misc);
-	}
-
-	// is there a better way to associate an ACI with form data?
-	private Control buildMiscTaskPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(100, -400);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildClearListACI().fill(panel);
-		this.buildClearModelACI().fill(panel);
-		this.buildRestoreModelACI().fill(panel);
-		this.buildAddPriorityTaskACI().fill(panel);
-		this.buildRemovePriorityTaskACI().fill(panel);
-		this.buildClearPriorityTasksACI().fill(panel);
-		return panel;
-	}
-
-	private ActionContributionItem buildClearListACI() {
-		Action action = new Action("clear list", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				ListBoxModelBindingUITest.this.clearTasks();
-			}
-		};
-		action.setToolTipText("clear all the tasks");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildClearModelACI() {
-		Action action = new Action("clear model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				ListBoxModelBindingUITest.this.clearModel();
-			}
-		};
-		action.setToolTipText("clear the task list model");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildRestoreModelACI() {
-		Action action = new Action("restore model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				ListBoxModelBindingUITest.this.restoreModel();
-			}
-		};
-		action.setToolTipText("restore the task list model");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildAddPriorityTaskACI() {
-		Action action = new Action("add priority", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				ListBoxModelBindingUITest.this.addPriorityTask();
-			}
-		};
-		action.setToolTipText("add a task to the priority tasks");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildRemovePriorityTaskACI() {
-		Action action = new Action("remove priority", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				ListBoxModelBindingUITest.this.removePriorityTask();
-			}
-		};
-		action.setToolTipText("remove a task from the priority tasks");
-		return new ActionContributionItem(action);
-	}
-
-	private ActionContributionItem buildClearPriorityTasksACI() {
-		Action action = new Action("clear priority", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				ListBoxModelBindingUITest.this.clearPriorityTasks();
-			}
-		};
-		action.setToolTipText("clear the priority tasks");
-		return new ActionContributionItem(action);
-	}
-
-	private void buildAddRemoveTaskPanel(Composite parent, Control clearButton) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(clearButton);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FormLayout());
-		Control addButton = this.buildAddButton(panel);
-		Control removeButton = this.buildRemoveButton(panel);
-		this.buildTaskTextField(panel, addButton, removeButton);
-	}
-
-	// is there a better way to associate an ACI with form data?
-	private Control buildAddButton(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(0, 50);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildAddACI().fill(panel);
-		return panel;
-	}
-
-	private ActionContributionItem buildAddACI() {
-		Action action = new Action("add", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				ListBoxModelBindingUITest.this.addTask();
-			}
-		};
-		action.setToolTipText("add a task with the name in the entry field");
-		return new ActionContributionItem(action);
-	}
-
-	// is there a better way to associate an ACI with form data?
-	private Control buildRemoveButton(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(100, -50);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildRemoveACI().fill(panel);
-		return panel;
-	}
-
-	private ActionContributionItem buildRemoveACI() {
-		Action action = new Action("remove", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				ListBoxModelBindingUITest.this.removeTask();
-			}
-		};
-		action.setToolTipText("remove the task with the name in the entry field");
-		return new ActionContributionItem(action);
-	}
-
-	private void buildTaskTextField(Composite parent, Control addButton, Control removeButton) {
-		this.taskTextField = new Text(parent, SWT.SINGLE | SWT.BORDER);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(addButton);
-			fd.right = new FormAttachment(removeButton);
-		this.taskTextField.setLayoutData(fd);
-	}
-
-	private String taskTextFieldText() {
-		return this.taskTextField.getText();
-	}
-
-	void addTask() {
-		String taskText = this.taskTextFieldText();
-		if (taskText.length() != 0) {
-			this.taskList.addTask(taskText);
-		}
-	}
-
-	void removeTask() {
-		String task = this.taskTextFieldText();
-		if (task.length() != 0) {
-			this.taskList.removeTask(task);
-		}
-	}
-
-	void clearTasks() {
-		this.taskList.clearTasks();
-	}
-
-	void clearModel() {
-		this.taskListHolder.setValue(null);
-	}
-
-	void restoreModel() {
-		this.taskListHolder.setValue(this.taskList);
-	}
-
-	void addPriorityTask() {
-		Iterator<Task> tasks = this.taskList.tasks();
-		while (tasks.hasNext()) {
-			if (this.taskList.addPriorityTask(tasks.next())) {
-				return;
-			}
-		}
-	}
-
-	void removePriorityTask() {
-		Iterator<Task> pTasks = this.taskList.priorityTasks();
-		if (pTasks.hasNext()) {
-			this.taskList.removePriorityTask(pTasks.next());
-		}
-	}
-
-	void clearPriorityTasks() {
-		this.taskList.clearPriorityTasks();
-	}
-
-
-	// ********** TaskList **********
-
-	// note absence of validation...
-	public static class TaskList extends AbstractModel {
-		private final List<String> taskNames = new ArrayList<String>();
-			public static final String TASK_NAMES_LIST = "taskNames";
-		private final List<Task> tasks = new ArrayList<Task>();
-			public static final String TASKS_LIST = "tasks";
-		private final Collection<Task> priorityTasks = new HashSet<Task>();
-			public static final String PRIORITY_TASKS_COLLECTION = "priorityTasks";
-		public TaskList() {
-			super();
-		}
-		public ListIterator<String> taskNames() {
-			return this.taskNames.listIterator();
-		}
-		public ListIterator<Task> tasks() {
-			return this.tasks.listIterator();
-		}
-		public Iterator<Task> priorityTasks() {
-			return this.priorityTasks.iterator();
-		}
-		public Task addTask(String taskName) {
-			this.addItemToList(taskName, this.taskNames, TASK_NAMES_LIST);
-			Task task = new Task(taskName);
-			this.addItemToList(task, this.tasks, TASKS_LIST);
-			return task;
-		}		
-		public void removeTask(String taskName) {
-			int index = this.taskNames.indexOf(taskName);
-			if (index != -1) {
-				this.removeItemFromList(index, this.taskNames, TASK_NAMES_LIST);
-				// assume the indexes match...
-				Task removedTask = this.removeItemFromList(index, this.tasks, TASKS_LIST);
-				this.removeItemFromCollection(removedTask, this.priorityTasks, PRIORITY_TASKS_COLLECTION);
-			}
-		}
-		public void clearTasks() {
-			this.clearCollection(this.priorityTasks, PRIORITY_TASKS_COLLECTION);
-			this.clearList(this.taskNames, TASK_NAMES_LIST);
-			this.clearList(this.tasks, TASKS_LIST);
-		}
-		public boolean addPriorityTask(Task task) {
-			return this.addItemToCollection(task, this.priorityTasks, PRIORITY_TASKS_COLLECTION);
-		}		
-		public void removePriorityTask(Task task) {
-			this.removeItemFromCollection(task, this.priorityTasks, PRIORITY_TASKS_COLLECTION);
-		}
-		public void clearPriorityTasks() {
-			this.clearCollection(this.priorityTasks, PRIORITY_TASKS_COLLECTION);
-		}
-		public void setPriorityTasks(Iterable<Task> tasks) {
-			this.priorityTasks.clear();
-			CollectionTools.addAll(this.priorityTasks, tasks);
-			this.fireCollectionChanged(PRIORITY_TASKS_COLLECTION, this.priorityTasks);
-		}
-	}
-
-
-	// ********** Task **********
-
-	public static class Task extends AbstractModel implements Displayable {
-		private String name;
-		private int instanceCount;
-		private static int INSTANCE_COUNT = 1;
-		public Task(String name) {
-			this.name = name;
-			this.instanceCount = INSTANCE_COUNT++;
-		}
-		public String displayString() {
-			return this.name + ": " + this.instanceCount;
-		}
-		public int compareTo(Displayable o) {
-			return DEFAULT_COMPARATOR.compare(this, o);
-		}
-		public String getName() {
-			return this.name;
-		}
-		public void setName(String name) {
-			Object old = this.name;
-			this.name = name;
-			this.firePropertyChanged(DISPLAY_STRING_PROPERTY, old, name);
-		}
-		@Override
-		public String toString() {
-			return this.displayString();
-		}
-	}
-
-	public interface Displayable extends Model, Comparable<Displayable> {
-	
-		String displayString();
-			String DISPLAY_STRING_PROPERTY = "displayString";
-	
-	
-		// ********** helper implementations **********
-	
-		Collator DEFAULT_COLLATOR = Collator.getInstance();
-	
-		Comparator<Displayable> DEFAULT_COMPARATOR =
-			new Comparator<Displayable>() {
-				public int compare(Displayable d1, Displayable d2) {
-					// disallow duplicates based on object identity
-					if (d1 == d2) {
-						return 0;
-					}
-	
-					// first compare display strings using the default collator
-					int result = DEFAULT_COLLATOR.compare(d1.displayString(), d2.displayString());
-					if (result != 0) {
-						return result;
-					}
-	
-					// then compare using object-id
-					result = System.identityHashCode(d1) - System.identityHashCode(d2);
-					if (result != 0) {
-						return result;
-					}
-	
-					// It's unlikely that we get to this point; but, just in case, we will return -1.
-					// Unfortunately, this introduces some mild unpredictability to the sort order
-					// (unless the objects are always passed into this method in the same order).
-					return -1;		// if all else fails, indicate that o1 < o2
-				}
-				@Override
-				public String toString() {
-					return "Displayable.DEFAULT_COMPARATOR";
-				}
-			};
-	
-	}
-}
diff --git a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/TextFieldModelBindingUITest.java b/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/TextFieldModelBindingUITest.java
deleted file mode 100644
index 4b3cb04..0000000
--- a/jpa/tests/org.eclipse.jpt.ui.tests/src/org/eclipse/jpt/ui/tests/internal/utility/swt/TextFieldModelBindingUITest.java
+++ /dev/null
@@ -1,252 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2010 Oracle. 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:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.ui.tests.internal.utility.swt;
-
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.action.ActionContributionItem;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jpt.ui.internal.utility.swt.SWTTools;
-import org.eclipse.jpt.utility.internal.model.AbstractModel;
-import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
-import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
-import org.eclipse.jpt.utility.model.value.PropertyValueModel;
-import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.FillLayout;
-import org.eclipse.swt.layout.FormAttachment;
-import org.eclipse.swt.layout.FormData;
-import org.eclipse.swt.layout.FormLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.Text;
-
-/**
- * Play around with a set of entry fields.
- */
-@SuppressWarnings("nls")
-public class TextFieldModelBindingUITest
-	extends ApplicationWindow
-{
-	private final TestModel testModel;
-		private static final String DEFAULT_NAME = "Scooby Doo";
-	private final WritablePropertyValueModel<TestModel> testModelHolder;
-	private final WritablePropertyValueModel<String> nameHolder;
-	private final WritablePropertyValueModel<String> allCapsNameHolder;
-
-
-	public static void main(String[] args) throws Exception {
-		Window window = new TextFieldModelBindingUITest();
-		window.setBlockOnOpen(true);
-		window.open();
-		Display.getCurrent().dispose();
-		System.exit(0);
-	}
-
-	private TextFieldModelBindingUITest() {
-		super(null);
-		this.testModel = new TestModel(DEFAULT_NAME);
-		this.testModelHolder = new SimplePropertyValueModel<TestModel>(this.testModel);
-		this.nameHolder = this.buildNameHolder(this.testModelHolder);
-		this.allCapsNameHolder = this.buildAllCapsNameHolder(this.testModelHolder);
-	}
-
-	private WritablePropertyValueModel<String> buildNameHolder(PropertyValueModel<TestModel> vm) {
-		return new PropertyAspectAdapter<TestModel, String>(vm, TestModel.NAME_PROPERTY) {
-			@Override
-			protected String buildValue_() {
-				return this.subject.name();
-			}
-			@Override
-			protected void setValue_(String value) {
-				this.subject.setName(value);
-			}
-		};
-	}
-
-	private WritablePropertyValueModel<String> buildAllCapsNameHolder(PropertyValueModel<TestModel> vm) {
-		return new PropertyAspectAdapter<TestModel, String>(vm, TestModel.NAME_PROPERTY) {
-			@Override
-			protected String buildValue_() {
-				return this.subject.name().toUpperCase();
-			}
-			@Override
-			protected void setValue_(String value) {
-				// do nothing
-			}
-		};
-	}
-
-	@Override
-	protected Control createContents(Composite parent) {
-		((Shell) parent).setText(this.getClass().getSimpleName());
-		parent.setSize(400, 100);
-		Composite mainPanel = new Composite(parent, SWT.NONE);
-		mainPanel.setLayout(new FormLayout());
-		Control textFieldPanel = this.buildTextFieldPanel(mainPanel);
-		this.buildControlPanel(mainPanel, textFieldPanel);
-		return mainPanel;
-	}
-
-	private Control buildTextFieldPanel(Composite parent) {
-		Composite panel = new Composite(parent, SWT.NONE);
-
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(0);
-			fd.bottom = new FormAttachment(100, -35);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildNameTextField(panel);
-		this.buildReadOnlyNameTextField(panel);
-		this.buildAllCapsNameTextField(panel);
-
-		return panel;
-	}
-
-	private void buildNameTextField(Composite parent) {
-		Text textField = new Text(parent, SWT.SINGLE);
-		SWTTools.bind(this.nameHolder, textField);
-	}
-
-	private void buildReadOnlyNameTextField(Composite parent) {
-		Text textField = new Text(parent, SWT.SINGLE);
-		textField.setEnabled(false);
-		SWTTools.bind(this.nameHolder, textField);
-	}
-
-	private void buildAllCapsNameTextField(Composite parent) {
-		Text textField = new Text(parent, SWT.SINGLE);
-		textField.setEnabled(false);
-		SWTTools.bind(this.allCapsNameHolder, textField);
-	}
-
-	private void buildControlPanel(Composite parent, Control checkBoxPanel) {
-		Composite panel = new Composite(parent, SWT.NONE);
-		FormData fd = new FormData();
-			fd.top = new FormAttachment(checkBoxPanel);
-			fd.bottom = new FormAttachment(100);
-			fd.left = new FormAttachment(0);
-			fd.right = new FormAttachment(100);
-		panel.setLayoutData(fd);
-
-		panel.setLayout(new FillLayout());
-		this.buildResetNameButton(panel);
-		this.buildClearModelButton(panel);
-		this.buildRestoreModelButton(panel);
-		this.buildPrintModelButton(panel);
-	}
-
-	private void buildResetNameButton(Composite parent) {
-		this.buildResetNameACI().fill(parent);
-	}
-
-	private ActionContributionItem buildResetNameACI() {
-		Action action = new Action("reset name", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				TextFieldModelBindingUITest.this.resetName();
-			}
-		};
-		action.setToolTipText("reset name");
-		return new ActionContributionItem(action);
-	}
-
-	void resetName() {
-		this.testModel.setName(DEFAULT_NAME);
-	}
-
-	private void buildClearModelButton(Composite parent) {
-		this.buildClearModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildClearModelACI() {
-		Action action = new Action("clear model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				TextFieldModelBindingUITest.this.clearModel();
-			}
-		};
-		action.setToolTipText("clear model");
-		return new ActionContributionItem(action);
-	}
-
-	void clearModel() {
-		this.testModelHolder.setValue(null);
-	}
-
-	private void buildRestoreModelButton(Composite parent) {
-		this.buildRestoreModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildRestoreModelACI() {
-		Action action = new Action("restore model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				TextFieldModelBindingUITest.this.restoreModel();
-			}
-		};
-		action.setToolTipText("restore model");
-		return new ActionContributionItem(action);
-	}
-
-	void restoreModel() {
-		this.testModelHolder.setValue(this.testModel);
-	}
-
-	private void buildPrintModelButton(Composite parent) {
-		this.buildPrintModelACI().fill(parent);
-	}
-
-	private ActionContributionItem buildPrintModelACI() {
-		Action action = new Action("print model", IAction.AS_PUSH_BUTTON) {
-			@Override
-			public void run() {
-				TextFieldModelBindingUITest.this.printModel();
-			}
-		};
-		action.setToolTipText("print model");
-		return new ActionContributionItem(action);
-	}
-
-	void printModel() {
-		System.out.println("name: " + this.testModel.name());
-	}
-
-
-	// ********** model class **********
-
-	class TestModel extends AbstractModel {
-		private String name;
-			public static final String NAME_PROPERTY = "name";
-
-		public TestModel(String name) {
-			this.name = name;
-		}
-		public String name() {
-			return this.name;
-		}
-		public void setName(String name) {
-			Object old = this.name;
-			this.name = name;
-			this.firePropertyChanged(NAME_PROPERTY, old, name);
-		}
-		@Override
-		public String toString() {
-			return "TestModel(" + this.name + ")";
-		}
-	}
-
-}
